SWwgbW90b3JlIERlRmkgZGVsbFwnZWNvc2lzdGVtYSBTb2xhbmE6IGNvbWUgUmF5ZGl1bSBzdGEgZ3VpZGFuZG8gbFwnaW5ub3ZhemlvbmUgREVYIGUgbFwnZWNvbm9taWEgZGVsIGNyZWF0b3Jl

2025-06-25, 03:00

<p><img src="https://gimg2.gateimg.com/image/radyieum202506251059206634259881.png" alt="">
</p><p>Nel 2021, quando Raydium agisce come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Quando è nato il primo Automated Market Maker (AMM), ha portato con sé un’ambizione: aggregare la liquidità frammentata, rendendo il trading decentralizzato più veloce, più economico e più efficiente.</p>
<p>Quattro anni dopo, Raydium è diventata un’infrastruttura di liquidità inattaccabile nel <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosistema, con un volume di trading mensile che ha superato quello del tradizionale DEX di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in un certo momento, catturando il 60,7% del volume di trading totale nel <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> DEX.</p>
<h2 id="h2-AMM2020Order20Book20linnovazione20principale20di20Raydium235637"><a name="AMM + Order Book: l’innovazione principale di Raydium" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AMM + Order Book: l’innovazione principale di Raydium</h2><p>Il team fondatore di Raydium è composto da un gruppo di veterani del trading quantitativo di Wall Street e sviluppatori di blockchain. Il fondatore, conosciuto come AlphaRay, ha evidenziato i punti critici di DeFi dell’epoca in un’intervista: commissioni di transazione elevate, liquidità frammentata e funzionalità singole.</p>
<p>La loro soluzione è rivoluzionaria - costruire un modello AMM ibrido su Solana. Raydium non solo fornisce i propri pool di liquidità, ma si integra anche profondamente con il central limit order book di Serum (ora OpenBook).</p>
<p>Questo significa che le operazioni degli utenti possono accedere contemporaneamente alla liquidità del pool AMM e al libro degli ordini, ottenendo prezzi migliori e slippage inferiore. Anche i fondi dei fornitori di liquidità non sono inattivi, poiché il sistema li converte automaticamente in ordini limite sul libro degli ordini, migliorando l’efficienza del capitale.</p>
<p>Nonostante l’alta volatilità degli asset a lunga coda come le monete Meme, Raydium ha temporaneamente disabilitato la condivisione della liquidità con il libro degli ordini. Tuttavia, il suo quadro tecnico ha gettato le basi per uno scambio efficiente di token su Solana.</p>
<h2 id="h2-Crescere20Insieme20a20Solana20Beneficiari20e20Promotori20di20un20Ecosistema20Prospero121070"><a name="Crescere Insieme a Solana: Beneficiari e Promotori di un Ecosistema Prospero" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crescere Insieme a Solana: Beneficiari e Promotori di un Ecosistema Prospero</h2><p>Il 2024 è l’anno dell’epidemia di Solana. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Prezzo SOL</a> Con un aumento fino al 680%, il numero di indirizzi attivi on-chain e il volume di trading giornaliero hanno superato altre catene pubbliche mainstream. Raydium è al centro di questa crescita.</p>
<p>Come protocollo di trading sottostante, il volume di trading di Raydium è strettamente legato alla prosperità dell’ecosistema Solana:</p>
<ul>
<li>I bassi costi delle transazioni di Solana e l’alto throughput (65.000 TPS, tempo di blocco di 400 ms) forniscono un terreno fertile per interazioni DeFi ad alta frequenza</li><li>I progetti ecologici esplodono: da Drift (Perp DEX), Jito (mining di liquidità) a Jupiter (aggregatore), il valore di mercato di diversi token di protocollo ha superato 1 miliardo di dollari statunitensi</li><li>Il TVL è salito al terzo posto sulla catena pubblica: il valore totale bloccato di Solana è aumentato da 427 milioni di dollari a novembre 2023 a 8,4 miliardi di dollari, rappresentando il 7,04% del valore di mercato totale del mercato delle criptovalute.</li></ul>
<p>Raydium soddisfa diverse esigenze di trading con il suo design multi-pool (standard AMM / prodotto costante CPMM / liquidità concentrata CLMM), che va dalle coppie di valute principali alle long-tail Meme coins, con una profondità di liquidità che si classifica al primo posto tra i DEX di Solana.</p>
<p>Follia delle criptovalute meme: la legge della potenza di Raydium</p>
<p>All’inizio del 2024, la frenesia delle meme coin su Solana ha portato un motore di crescita senza precedenti a Raydium. Il principale fattore trainante è stata una partnership strategica con la piattaforma di lancio pump.fun.</p>
<p>Quando il valore di mercato del token emesso su pump.fun raggiunge $69.000, la piattaforma inietterà automaticamente $12.000 di liquidità in Raydium. Questo meccanismo ha portato ad un ciclo virtuoso:</p>
<p>creazione di pool Raydium → attrarre trader → più opzioni di progetto per l’emissione → ulteriore potenziamento della liquidità di Raydium.</p>
<p>I dati rivelano una realtà sorprendente: oltre il 90% dei token generati da pump.fun viene scambiato su Raydium, rendendolo indubbiamente il centro di scambio di meme coin su Solana.</p>
<p>Ma Raydium non è stata ‘sequestrata’ dalle monete Meme. Tra il suo volume di scambi, coppie di scambio mainstream come SOL-USDC rappresentano oltre il 50%, mentre i ‘token nativi’ (non monete Meme) contribuiscono a oltre il 70% della quota di scambio. Ciò riflette la sua diversificazione della liquidità e la resilienza alla volatilità.</p>
<h2 id="h2-Economia20dei20token20meccanismo20di20cattura20del20valore20di20RAY927240"><a name="Economia dei token: meccanismo di cattura del valore di RAY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia dei token: meccanismo di cattura del valore di RAY</h2><p>RAY, come token di governance nativo di Raydium, ha un’offerta totale costante di 5,55 miliardi di monete, con la sua distribuzione che bilancia incentivi a lungo termine e sviluppo del protocollo:</p>
<ul>
<li>Il 34% è allocato per gli incentivi alla mining di liquidità (rilasciati gradualmente per 36 mesi)</li><li>30% investimento nel fondo di sviluppo ecologico</li><li>20% allocati al team principale (bloccati per tre anni)</li><li>8% per la costruzione iniziale della liquidità</li></ul>
<p>Il protocollo ha progettato un chiaro meccanismo di feedback del valore: il 12% di ciascuna commissione di transazione è utilizzato per il riacquisto dei token RAY, aumentando direttamente la scarsità dei token. Inoltre, gli utenti possono ottenere diritti di governance e redditi aggiuntivi depositando RAY (il tasso di interesse annuo attuale è di circa il 4,45%).</p>
<h2 id="h2-LaunchLab20Ridisegnare20leconomia20dei20creatori20di20Solana625017"><a name="LaunchLab: Ridisegnare l’economia dei creatori di Solana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LaunchLab: Ridisegnare l’economia dei creatori di Solana</h2><p>Il 23 giugno 2025, Raydium ha annunciato il lancio di LaunchLab - una piattaforma di emissione di token senza codice, segnando la sua trasformazione strategica da protocollo di trading a piattaforma ecosistemica multidimensionale.</p>
<p>LaunchLab risolve le barriere tecniche all’emissione tradizionale di token, consentendo ai creatori di realizzarla senza programmazione:</p>
<ul>
<li>Personalizzare l’offerta di token e i parametri di raccolta fondi</li><li>Impostazione del periodo di vesting e del meccanismo di blocco dei token</li><li>Abilita il modello di condivisione delle commissioni ‘Burn &amp; Earn’</li><li>Restituire il 10% delle commissioni di trading agli utenti precoci</li></ul>
<p>Il suo modello economico è particolarmente sofisticato, adottando una commissione di transazione fissa dell’1% divisa in tre parti: il 50% restituito ai creatori e commercianti, il 25% riacquistato RAY, il 25% a supporto delle operazioni della piattaforma. Questa struttura lega profondamente gli interessi dei creatori, degli utenti e del protocollo.</p>
<p>LaunchLab è considerato una forte risposta da Raydium al nuovo PumpSwap di pump.fun, mirando a riconquistare il dominio del mercato secondario di Solana.</p>
<h2 id="h2-Aggiornamenti20tecnici20e20sfide20levoluzione20della20V3809705"><a name="Aggiornamenti tecnici e sfide: l’evoluzione della V3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamenti tecnici e sfide: l’evoluzione della V3</h2><p>Per far fronte all’aumento del numero di utenti e delle esigenze di trading, Raydium continua a ottimizzare la sua architettura tecnica. La versione V3 lanciata nel 2024 porta significativi miglioramenti:</p>
<ul>
<li>Riduzione significativa dei costi di creazione del pool: da 0,4 SOL in V2 a 0,15-0,2 SOL</li><li>Presentazione di un pool di protocollo CPMM più efficiente</li><li>Semplifica il processo operativo e diventa l’interfaccia di trading predefinita sul sito ufficiale</li></ul>
<p>Tuttavia, esistono ancora sfide. Nelle fasi iniziali di V3, c’erano problemi con ritardi nelle transazioni (fino a 40 minuti) e problemi di indicizzazione (difficoltà nella visualizzazione su piattaforme come DexScreener), che hanno influenzato l’esperienza dell’utente e la volontà di partecipazione dei trader. Questo riflette la complessità di costruire un’infrastruttura robusta su catene pubbliche in rapido sviluppo.</p>
<h2 id="h2-Prospettive20future20espansione20multichain20e20integrazione20dellecosistema893587"><a name="Prospettive future: espansione multi-chain e integrazione dell’ecosistema" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future: espansione multi-chain e integrazione dell’ecosistema</h2><p>Con Solana che si sta affermando come una catena pubblica di alto livello, la crescita futura di Raydium si concentrerà su due dimensioni:</p>
<ul>
<li>Approfondire l’integrazione interna di Solana: Espandere la cooperazione con i progetti NFT e GameFi, potenziare gli scenari di applicazione di RAY all’interno dell’ecosistema</li><li>Esplora la liquidità cross-chain: pur essendo attualmente fortemente dipendente da Solana, la funzionalità cross-chain potrebbe aprire un mercato più ampio per Raydium.</li><li>Espansione dell’ecosistema degli sviluppatori: Attirare team di sviluppatori di terze parti a unirsi al proprio ecosistema attraverso API aperte e moduli di LaunchLab</li></ul>
<p>Il fondatore di Raydium, AlphaRay, ha sottolineato una volta: “Il nostro obiettivo è quello di collegare tutte le piattaforme e la liquidità, diventando la scelta preferita per i progetti che emettono monete su Solana.” Questa visione si sta gradualmente realizzando attraverso il miglioramento della matrice di prodotti.</p>
<p>Con il lancio di LaunchLab, piattaforma di emissione no-code ieri, Raydium non è più soddisfatta di essere solo il più grande ‘centro commerciale di token’ su Solana. Si sta trasformando nel motore di un’economia creativa, consentendo a chiunque di emettere token con la stessa facilità con cui si crea un account sui social media.</p>
<p>Dal partner di liquidità di Serum, al motore di monete Meme di pump.fun, fino alla piattaforma no-code di LaunchLab, la strategia di Raydium è sempre stata chiara: diventare un “venditore di pala” indispensabile in ogni ondata dell’ecosistema Solana.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Squadra del blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un parere professionale indipendente prima di prendere decisioni di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o parte dei Servizi dalle Posizioni Restritte. Per ulteriori informazioni, si prega di leggere l'Accordo dell'Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="4">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>