RGUgRGVGaS1lbmdpbmUgdmFuIGhldCBTb2xhbmEtZWNvc3lzdGVlbTogSG9lIFJheWRpdW0gdm9vcm9wIGxvb3B0IGluIERFWC1pbm5vdmF0aWUgZW4gZGUgQ3JlYXRvci1lY29ub21pZQ==

2025-06-25, 03:00

<p><img src="https://gimg2.gateimg.com/image/radyieum202506251059206634259881.png" alt="">
</p><p>In 2021, wanneer Raydium optreedt als <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Toen de eerste Automated Market Maker (AMM) werd geboren, droeg het een ambitie met zich mee: het aggregeren van gefragmenteerde liquiditeit, waardoor gedecentraliseerde handel sneller, goedkoper en efficiënter wordt.</p>
<p>Vier jaar later is Raydium een onwankelbare liquiditeitsinfrastructuur geworden in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem, met een maandelijkse handelsvolume dat op een gegeven moment dat van de traditionele DEX van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> overstijgt, waarbij 60,7% van het totale handelsvolume in <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> DEX wordt vastgelegd.</p>
<h2 id="h2-AMM2020Order20Book20de20kerninnovatie20van20Raydium782597"><a name="AMM + Order Book: de kerninnovatie van Raydium" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AMM + Order Book: de kerninnovatie van Raydium</h2><p>Het oprichtingsteam van Raydium bestaat uit een groep veteranen van Wall Street quantitative trading en blockchain-ontwikkelaars. De oprichter, bekend als AlphaRay, wees in een interview op de pijnpunten van DeFi op dat moment: hoge transactiekosten, gefragmenteerde liquiditeit en enkele functionaliteit.</p>
<p>Hun oplossing is baanbrekend - het bouwen van een hybride model AMM op Solana. Raydium biedt niet alleen zijn eigen liquiditeitspools aan, maar integreert ook diep met Serum (nu OpenBook)’s centrale limietorderboek.</p>
<p>Dit betekent dat gebruikers’ transacties tegelijkertijd toegang kunnen krijgen tot de liquiditeit van het AMM-zwembad en het orderboek, waardoor ze betere prijzen en lagere slippen kunnen verkrijgen. De fondsen van liquiditeitsverschaffers zijn ook niet inactief, aangezien het systeem ze automatisch omzet in limietorders op het orderboek, waardoor de kapitaalefficiëntie verbetert.</p>
<p>Ondanks de hoge volatiliteit van long-tail activa zoals Meme coins, heeft Raydium tijdelijk de liquiditeitsdeling met het orderboek uitgeschakeld. De technische structuur heeft echter de basis gelegd voor efficiënte tokenuitwisseling op Solana.</p>
<h2 id="h2-Samen20groeien20met20Solana20Begunstigden20en20Promotors20van20een20Bloeiend20Ecosysteem135907"><a name="Samen groeien met Solana: Begunstigden en Promotors van een Bloeiend Ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samen groeien met Solana: Begunstigden en Promotors van een Bloeiend Ecosysteem</h2><p>2024 is het jaar van de uitbraak van Solana. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">SOL Prijs</a> Met een stijging tot 680% hebben het aantal actieve on-chain adressen en het dagelijkse handelsvolume andere belangrijke openbare ketens overtroffen. Raydium staat aan de kern van deze groei.</p>
<p>Als een onderliggend handelsprotocol is het handelsvolume van Raydium diep verbonden met de welvaart van het Solana-ecosysteem:</p>
<ul>
<li>Solana’s lage transactiekosten en hoge throughput (65.000 TPS, 400 ms bloktijd) bieden een vruchtbare bodem voor high-frequency DeFi-interacties</li><li>Ecologische projecten exploderen: van Drift (Perp DEX), Jito (liquiditeitsmining) tot Jupiter (aggregator), de marktwaarde van meerdere protocoltokens heeft de 1 miljard Amerikaanse dollars overschreden</li><li>TVL sprong naar de derde plaats op de publieke keten: De totale vergrendelde waarde van Solana steeg van $427 miljoen in november 2023 tot $8,4 miljard, wat 7,04% van de totale marktwaarde van de cryptocurrency-markt vertegenwoordigt.</li></ul>
<p>Raydium voldoet aan diverse handelsbehoeften met zijn multi-pool ontwerp (standaard AMM / constant product CPMM / geconcentreerde liquiditeit CLMM), variërend van mainstream valutaparen tot long-tail Meme munten, met liquiditeitsdiepte die op de eerste plaats staat onder Solana DEX.</p>
<h2 id="h2-Meme20Coin20Craze20Raydiums20Power20Law952676"><a name="Meme Coin Craze: Raydium’s Power Law" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meme Coin Craze: Raydium’s Power Law</h2><p>Begin 2024 bracht de meme coin-gekte op Solana een ongekende groeimotor naar Raydium. De belangrijkste drijfveer was een strategisch partnerschap met het launchpad-platform pump.fun.</p>
<p>Wanneer de token marktwaarde uitgegeven op pump.fun $69,000 bereikt, zal het platform automatisch $12,000 liquiditeit injecteren in Raydium. Dit mechanisme heeft een deugdzame cyclus teweeggebracht:</p>
<p>pump.fun-uitgifte → Raydium-poolcreatie → handelaren aantrekken → meer projectopties voor uitgifte → verdere verbetering van Raydium-liquiditeit.</p>
<p>De gegevens onthullen een verbluffende realiteit: meer dan 90% van de tokens gegenereerd door pump.fun worden verhandeld op Raydium, waardoor het ongetwijfeld het meme coin handelscentrum op Solana is.</p>
<p>Maar Raydium is niet ‘gekidnapt’ door Meme munten. Onder zijn handelsvolume vertegenwoordigen mainstream handelsparen zoals SOL-USDC meer dan 50%, terwijl ‘native tokens’ (niet-Meme munten) meer dan 70% van het handelsaandeel bijdragen. Dit weerspiegelt de liquiditeitsdiversificatie en veerkracht tegen volatiliteit.</p>
<h2 id="h2-Token20Economie20RAYs20Waarde20Vangmechanisme803839"><a name="Token Economie: RAY’s Waarde Vangmechanisme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token Economie: RAY’s Waarde Vangmechanisme</h2><p>RAY, als de inheemse governance-token van Raydium, heeft een constante totale voorraad van 5,55 miljard munten, waarbij de verdeling een balans vormt tussen langetermijnprikkels en protocolontwikkeling:</p>
<ul>
<li>34% wordt toegewezen voor liquiditeitsminingincentives (geleidelijk vrijgegeven over 36 maanden)</li><li>30% investering in ecologisch ontwikkelingsfonds</li><li>20% toegewezen aan het kernteam (vergrendeld voor drie jaar)</li><li>8% voor initiële liquiditeitsopbouw</li></ul>
<p>Het protocol heeft een duidelijk waarde terugkoppeling mechanisme ontworpen: 12% van elke transactiekosten wordt gebruikt om RAY tokens terug te kopen, waardoor de schaarste van tokens rechtstreeks toeneemt. Bovendien kunnen gebruikers bestuursrechten en extra inkomsten verkrijgen door RAY te staken (huidige jaarlijkse percentageopbrengst is ongeveer 4,45%).</p>
<h2 id="h2-LaunchLab20Het20hervormen20van20de20Solanamakerseconomie512551"><a name="LaunchLab: Het hervormen van de Solana-makerseconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LaunchLab: Het hervormen van de Solana-makerseconomie</h2><p>Op 23 juni 2025 kondigde Raydium de lancering aan van LaunchLab - een platform voor het uitgeven van tokens zonder code, wat de strategische transformatie markeert van een handelsprotocol naar een multidimensionaal ecosysteemplatform.</p>
<p>LaunchLab lost de technische barrières voor traditionele tokenuitgifte op, waardoor makers het kunnen bereiken zonder programmeren:</p>
<ul>
<li>Pas tokenvoorraad en financieringsparameters aan</li><li>Het instellen van de uitoefeningsperiode en het token lock-up mechanisme</li><li>Activeer het ‘Burn &amp; Earn’ kosten delen model</li><li>Geef 10% van de handelskosten terug aan vroege gebruikers</li></ul>
<p>Het economische modelontwerp is bijzonder geavanceerd, waarbij een vast transactietarief van 1% wordt aangenomen dat in drie delen is verdeeld: 50% wordt teruggegeven aan makers en handelaren, 25% wordt teruggekocht RAY, 25% ondersteunt platformoperaties. Deze structuur bindt de belangen van makers, gebruikers en het protocol diep.</p>
<p>LaunchLab wordt gezien als een krachtige reactie van Raydium op de nieuwe PumpSwap van pump.fun, met als doel de dominantie van de secundaire markt van Solana te herwinnen.</p>
<h2 id="h2-Technische20Upgrades20en20Uitdagingen20De20Evolutie20van20V3589949"><a name="Technische Upgrades en Uitdagingen: De Evolutie van V3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technische Upgrades en Uitdagingen: De Evolutie van V3</h2><p>Om te kunnen omgaan met het toenemende aantal gebruikers en handelsvereisten, blijft Raydium zijn technische architectuur optimaliseren. De V3-versie die in 2024 is gelanceerd, brengt aanzienlijke verbeteringen:</p>
<ul>
<li>Aanzienlijk verminder de kosten voor het aanmaken van een pool: van 0.4 SOL in V2 naar 0.15-0.2 SOL</li><li>Introductie van een meer efficiënt CPMM-protocol zwembad</li><li>Vereenvoudig het bedieningsproces en wordt de standaard handelsinterface op de officiële website</li></ul>
<p>Er zijn echter nog steeds uitdagingen. In de vroege stadia van V3 waren er problemen met transactievertragingen (tot 40 minuten) en indexatieproblemen (moeilijkheden bij weergave op platforms zoals DexScreener), wat de gebruikerservaring en de bereidheid van handelaren om deel te nemen beïnvloedde. Dit weerspiegelt de complexiteit van het bouwen van een robuuste infrastructuur op snel ontwikkelende publieke ketens.</p>
<h2 id="h2-Toekomstperspectief20Uitbreiding20van20multichain20en20integratie20van20het20ecosysteem935651"><a name="Toekomstperspectief: Uitbreiding van multi-chain en integratie van het ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectief: Uitbreiding van multi-chain en integratie van het ecosysteem</h2><p>Met Solana die zijn positie als top-tier publieke keten vestigt, zal de toekomstige groei van Raydium zich richten op twee dimensies:</p>
<ul>
<li>Verdiep interne integratie van Solana: Breid de samenwerking uit met NFT- en GameFi-projecten, verbeter de toepassingsscenario’s van RAY binnen het ecosysteem</li><li>Verken Cross-chain Liquiditeit: Hoewel momenteel sterk afhankelijk van Solana, kan cross-chain functionaliteit een bredere markt openen voor Raydium.</li><li>Uitbreiding van het ontwikkelaarsecosysteem: Trek derde partij ontwikkelingsteams aan om zich aan te sluiten bij het ecosysteem via LaunchLab open API’s en modules</li></ul>
<p>Oprichter AlphaRay van Raydium benadrukte ooit: “Ons doel is om alle platforms en liquiditeit met elkaar te verbinden en de voorkeurskeuze te worden voor projecten om munten op Solana uit te geven.” Deze visie wordt geleidelijk gerealiseerd door de verbetering van de productmatrix.</p>
<p>Met de lancering van het LaunchLab no-code-uitgifteplatform gisteren is Raydium niet langer tevreden met alleen de grootste ‘token shopping center’ op Solana te zijn. Het verandert in de motor van een makerseconomie, waardoor iedereen tokens kan uitgeven net zo eenvoudig als het maken van een sociaal media-account.</p>
<p>Van de liquiditeitspartner van Serum, tot de Meme coin engine van pump.fun, en nu naar het no-code platform van LaunchLab - de strategie van Raydium is altijd duidelijk geweest: om een onmisbare ‘schop verkoper’ te worden in elke golf van het Solana ecosysteem.</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 enige investeringsbeslissing 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="4">https://www.gate.com/legal/gebruikersovereenkomst</a>.<br><p></p><br></em></div></div></div>