TWV0IGRlIHRvdGFsZSB2b29ycmFhZCB2YW4gWFJQIGluZ2VzdGVsZCBvcCAxMDAgbWlsamFyZCwgaG9ldmVlbCB6b3UgaGV0IGluIGRlIHRvZWtvbXN0IHdhYXJkIGt1bm5lbiB6aWpuPw==

2025-05-28, 10:06

<p><img src="https://gimg2.gateimg.com/image/xrp202505281801017696295896.png" alt="">
</p><p>In de volatiele wereld van cryptocurrency, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> heeft altijd een unieke zekerheid gehandhaafd: de totale voorraad is constant 100 miljard. Dit voorzieningsmechanisme is sinds 2012 constant gebleven <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Vanaf de oprichting van de Ledger (XRPL) werden alle tokens in één keer gegenereerd in het genesisblok, waarbij het traditionele miningmodel volledig werd verlaten. Dit ontwerp legde een onveranderlijke basis voor het XRP-economische model en werd een kernpunt van het waarde debat.</p>
<h2 id="h2-XRP20aanbodstructuur568109"><a name="XRP aanbodstructuur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP aanbodstructuur</h2><p>Vanaf mei 2025 blijkt uit gegevens dat de circulatie van <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> ongeveer 58,5 miljard bedraagt, wat overeenkomt met 58,5% van het totale aanbod. De bestemming van de overgebleven tokens onthult de strategische lay-out van Ripple:</p>
<ol>
<li>550 miljard XRP is vergrendeld in escrow-contracten, met een maximale maandelijkse vrijgave van maximaal 1 miljard tokens, en elk ongebruikt deel zal opnieuw worden vergrendeld;</li><li>Ripple houdt rechtstreeks meerdere ‘walvisadressen’ aan, waarbij twee hoofdportefeuilles gezamenlijk meer dan 3,4 miljard XRP controleren;</li><li>Oprichter Chris Larsen bezit persoonlijk meer dan 5 miljard XRP, en zijn geleidelijke vermindering in de afgelopen jaren heeft vaak marktschommelingen veroorzaakt (zoals een enkele overdracht van 50 miljoen munten in 2024, ter waarde van $29 miljoen).</li></ol>
<p>Deze gecentraliseerde verdeling heeft controverse veroorzaakt: de top 10 adressen controleren 20,2% van de circulatie, terwijl de top 50 adressen maar liefst 48,7% vertegenwoordigen. Ter vergelijking, de top 10 adressen van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> accounteert slechts 5,3%, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> voor 6,4%, waarbij de uniekheid van de machtsstructuur van XRP wordt benadrukt.</p>
<h2 id="h2-Het20markteffect20van20een20vaste20aanbod20schaarste20en20waarde20logica324707"><a name="Het markteffect van een vaste aanbod: schaarste en waarde logica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het markteffect van een vaste aanbod: schaarste en waarde logica</h2><p>In tegenstelling tot traditionele fiatvaluta of inflatoire tokens, versterkt het nuluitgiftemechanisme van XRP de schaarste ervan. Tijdens de wereldwijde volatiliteit op de aandelenmarkt in 2025 (zoals een daling van 2,3% op één dag in de S&amp;P 500), groeide het on-chain transactievolume van XRP met 18% tegen de trend in, met een prijsstijging van 5,2% op één dag. Analyse suggereert dat de transparantie van de voorraad een belangrijke drijfveer is geworden voor fondshedge.</p>
<p>Echter is een vaste voorraad ook een tweesnijdend zwaard:</p>
<ul>
<li>Voordelen: Elimineer zorgen over inflatie en bied een duidelijk anker voor langetermijnwaardering;</li><li>Uitdaging: het vrijkomen van Ripple’s escrow en de druk van het uitvoerend verkopen kunnen de prijzen tijdelijk onderdrukken. Bijvoorbeeld, in 2021 bereikten de institutionele verkopen van Ripple 1,5 miljard Amerikaanse dollars, samenvallend met <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP-prijs</a> Terugbeltermijn.</li></ul>
<h2 id="h2-Het20meningsverschil20tussen20de20aanbodlimiet20en20prijsvoorspelling5528"><a name="Het meningsverschil tussen de aanbodlimiet en prijsvoorspelling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het meningsverschil tussen de aanbodlimiet en prijsvoorspelling</h2><p>Ondanks het totale bedrag dat vergrendeld is, variëren de marktverwachtingen voor XRP sterk, wat wijst op een cognitieve kloof in zijn nut en speculatie.</p>
<h3 id="h3-Korte20termijn20202520202026338622"><a name="Korte termijn (2025 - 2026)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Korte termijn (2025 - 2026)</h3><ul>
<li>CoinCodex is bearish op $1.51, terwijl Cryptomus bullish is op $4.56;</li><li>Technische indicatoren tonen aan dat het belangrijke ondersteuningsgebied tussen 2,00 en 2,20 Amerikaanse dollars ligt. Als dit wordt vastgehouden, kan het omhoog getest worden naar 3,00 Amerikaanse dollars.</li></ul>
<h3 id="h3-Lange20termijn20203020202050569600"><a name="Lange termijn (2030 - 2050)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lange termijn (2030 - 2050)</h3><ul>
<li>Conservatieve voorspelling: Het Plisio-model suggereert dat het tegen 2030 $50 zou kunnen bereiken;</li><li>Gedurfde voorspelling: Als het de hoeksteen van wereldwijde betalingen wordt, kan de prijs tegen 2050 $2000 - $5000 bereiken, maar dit doel vereist een marktwaarde groei van tienduizenden keren, de haalbaarheid ervan is twijfelachtig.</li></ul>
<h2 id="h2-XRPgebruik20inspectie210639"><a name="XRP-gebruik inspectie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP-gebruik inspectie</h2><p>Het kernverhaal van XRP draait altijd om efficiëntie bij grensoverschrijdende betalingen. Het voordeel van een afwikkeling van 3-5 seconden en een transactiekosten van minder dan $0.01 vereist theoretisch een enorme fonds <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> om zijn waarde te ondersteunen. Echter, on-chain data onthult de kloof tussen ideaal en werkelijkheid:</p>
<ul>
<li>Het gemiddelde dagelijkse afwikkelingsbedrag bedraagt ongeveer 3-10 miljard Amerikaanse dollars, met een piek van 22,8 miljard na de herverkiezing van Trump in 2024;</li><li>Gedurende dezelfde periode bedroeg de dagelijkse gemiddelde afwikkeling van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> 640,3 miljard. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> 56,7 miljard, waarbij de achterstand van XRP in adoptiesnelheid wordt benadrukt.</li></ul>
<p>Ondanks dat RippleNet verbonden is met 300 financiële instellingen (zoals Santander, American Express, etc.) en de USD-stablecoin RLUSD heeft gelanceerd in 2024 om het ecosysteem aan te vullen, moet XRP nog steeds doorbreken op het gebied van daadwerkelijke doorvoer in betalingsscenario’s om de logica van een marktwaarde van een biljoen dollar te rechtvaardigen.</p>
<h2 id="h2-Conclusie724068"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De vaste voorraad van 100 miljard XRP is een van de meest gedurfde economische experimenten in de geschiedenis van de cryptografie. Het verleent de token de schaarse eigenschap van weerstand tegen inflatie, maar vertrouwt ook op ecosysteemuitbreiding om de druk van bewaring vrij te geven te verwerken. Met de afwikkeling van de rechtszaak Ripple vs. SEC in maart 2025 (eindigend met een boete van $50 miljoen) en de lancering van XRP-futures op CME, verdwijnen regelgevende en technologische barrières geleidelijk.</p>
<p>De toekomstige waarde van XRP zal afhangen van of Ripple bankpartnerschappen kan omzetten in on-chain liquiditeit. De aanbodlimiet is zowel een gracht voor waarde als een groeiplafond in dit proces.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hiervan vormt geen enkel aanbod, verzoek of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten van Beperkte Locaties kan beperken of verbieden. Voor meer informatie kunt u de Gebruiksovereenkomst lezen via <a href="https://www.gate.com/legal/user-agreement" data-index="8">https://www.gate.com/legal/gebruikersovereenkomst</a>.<br><p></p><br></em></div></div></div>