TCdlY29zaXN0ZW1hIFNvbmljIMOoIGluIHBpZW5vIGJvb20sIHF1YWxpIHNvbm8gbGUgb3Bwb3J0dW5pdMOgIGRpIHRlbmRlbnphPw==

<p><img src="https://gimg2.gateimg.com/image/article/1742955270HOTSPOT.png" alt=""></p>
<h2 id="h2-TLDR505410"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Recentemente, il TVL sulla catena Sonic è aumentato da $26 milioni a $1.3 miliardi, con un tasso di crescita molto superiore a quello delle catene pubbliche mainstream come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e Base. Il prezzo del token S è rimbalzato da $0.4 a $0.6, un aumento di più del 50%.</p>
<p>Entro la fine del 2024, Andre Cronje (AC) ha guidato il team per completare la ricostruzione dell’architettura tecnica e l’innovazione dell’ecosistema di Gate. <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> Il passaggio di ’ a Sonic, consentendo a Sonic di avere sia un’alta performance Layer 1 che compatibilità con EVM, e attirando la partecipazione di sviluppatori e utenti attraverso la ricostruzione economica dei token.</p>
<p>I primi cinque protocolli di Sonic rappresentano l’83% del TVL. La ricostruzione della fiducia nelle stablecoin algoritmiche, la liquidità dei progetti long-tail e l’ambiente complessivamente pessimistico del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> rimangono potenziali rischi per Sonic (S).</p>
<h2 id="h2-Introduzione593251"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La catena pubblica più conosciuta con le prestazioni più eccezionali degli ultimi tempi è Sonic. Come nuova catena pubblica ad alte prestazioni aggiornata da <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a>, Sonic ha ottenuto un aumento del TVL di oltre 40 volte quest’anno. Mentre BTC si stabilizza gradualmente, il prezzo di Sonic (S) è anche aumentato rapidamente, e il suo recente aumento ha portato il fronte di Layer1.</p>
<p>Questo articolo analizzerà approfonditamente i fattori trainanti dell’esplosione dell’ecosistema di Sonic, svelerà i suoi vantaggi tecnici, il modello economico, l’innovazione del progetto e le opportunità di mercato, e fornirà agli investitori spunti di tendenza e suggerimenti di partecipazione. Diamo un’occhiata.</p>
<h2 id="h2-TVL20Soars20La20Tecnologia20Sonic20Empodera20e20Ecosistema20Esplode524947"><a name="TVL Soars, La Tecnologia Sonic Empodera e, Ecosistema Esplode" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TVL Soars, La Tecnologia Sonic Empodera e, Ecosistema Esplode</h2><p>Dopo che il recente mercato delle criptovalute è caduto in una recessione macroeconomica, riserve strategiche sfavorevoli di criptovalute e una serie di ribassi, ha finalmente visto un nuovo punto luminoso - il TVL dell’ecosistema Sonic è passato da $26 milioni all’inizio dell’anno a $1,37 miliardi oggi, classificandosi al 12° posto tra le catene pubbliche di Livello 1. Una serie di protocolli DeFi popolari stanno entrando sul mercato uno dopo l’altro, facendo così crescere rapidamente l’ecosistema Sonic, attirando l’attenzione dei fondi speculativi e offrendo ricche opportunità di partecipazione per gli sviluppatori, i produttori di rendite e gli utenti ordinari.<img src="https://gimg2.gateimg.com/image/article/17429555841.jpeg" alt=""><br>Origine: DefiLlama</p>
<p>Come rispecchiato nel prezzo della moneta, Sonic (S) ha anche subito un calo passivo da marzo a causa del mercato complessivo lento. Tuttavia, dopo che BTC si è stabilizzato con successo sopra gli 80.000 dollari, abbiamo notato che Sonic (S), con un rapporto TVL/capitalizzazione di mercato di soli 1,9, si trovava in una zona di bassa valutazione. Dopo che il crollo e il fallimento del mercato sono stati gradualmente riparati, S ha preso il comando nel rimbalzare, salendo costantemente da un minimo di 0,4 a 0,6 dollari, un aumento di oltre il 50%, diventando il token che rimbalza più velocemente nel settore Layer1.<img src="https://gimg2.gateimg.com/image/article/17429556102.jpeg" alt=""><br>Source: Gate.io</p>
<p>L’ascesa di Sonic non è casuale. La sua architettura tecnica fornisce il supporto alla base dell’esplosione dell’ecosistema. Essendo la prima catena pubblica a ottenere una conferma in meno di un secondo (entro 1 secondo) e un throughput di 10.000 TPS, Sonic utilizza la tecnologia di eliminazione dei dati in tempo reale e una struttura di database a due livelli (LiveDB e ArchiveDB) per ridurre significativamente i costi di archiviazione garantendo al contempo la sicurezza. Questo vantaggio in termini di prestazioni risolve completamente i punti deboli di “alta latenza e costi elevati” nell’era Fantom.</p>
<p>Top protocol come Gate <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> V3 e Pendle dall’originale <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> l’ecosistema ha implementato la catena. Il primo, attraverso un piano incentivi congiunto da $15,8 milioni, ha fatto sì che il tasso di interesse annuo (APY) del deposito USDC raggiungesse il 19% in un momento; il secondo, in collaborazione con Rings Protocol, ha lanciato una soluzione di tokenizzazione del rendimento che ha attirato $43 milioni di depositi entro 24 ore dal suo lancio, e l’APY dei prodotti a tasso fisso ha superato il 40%.<img src="https://gimg2.gateimg.com/image/article/17429556293.jpeg" alt=""><br>Fonte: Messari</p>
<p>L’evento Meme Mania guidato dalla comunità ha infiammato l’entusiasmo degli investitori al dettaglio. Tra gli otto recenti ingressi, due meme coin, GOGLZ, hanno replicato l’effetto di ricchezza iniziale di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> con un volume di trading giornaliero di $8 milioni e un aumento settimanale del 200% in THC. Anche se il volume di trading e l’effetto popolare sono ancora limitati, c’è finalmente un momento di ripresa. Il modello di incentivi per gli sviluppatori FeeM (rimborso del 90% delle commissioni di gas) e il piano di distribuzione aerea di 190 milioni di token S hanno aumentato il numero di protocolli dell’ecosistema da 62 a 312, formando una matrice completa di Prestiti, DEX, Perp e NFT.</p>
<h2 id="h2-Da20Fantom20a20Sonic20Aggiornamenti20Tecnologici20Ripristinano20la20Fiducia20del20Mercato411710"><a name="Da Fantom a Sonic, Aggiornamenti Tecnologici Ripristinano la Fiducia del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Da <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> a Sonic, Aggiornamenti Tecnologici Ripristinano la Fiducia del Mercato</h2><p>Fantom ha lanciato la sua mainnet nel 2018, costruendo una catena pubblica ad alta capacità basata sul protocollo di consenso Lachesis. Tuttavia, non ha avuto uno sviluppo regolare a causa del collo di bottiglia dell’efficienza del framework tecnico iniziale. Dopo il mercato ribassista delle criptovalute nel 2022, l’ecosistema di Fantom è incappato in difficoltà a causa dell’abbandono del fondatore Andre Cronje e non è riuscito a fare alcuna svolta.</p>
<p>Nel 2023, il team ha annunciato il piano di aggiornamento Sonic, che mira a ricostruire completamente l’architettura sottostante. Nel quarto trimestre del 2023 è stato lanciato il testnet Sonic, utilizzando un meccanismo di consenso asincrono ottimizzato per raggiungere una velocità di conferma inferiore al secondo e oltre 2.000 transazioni al secondo, e ha introdotto FVM (Fantom Virtual Machine) per migliorare l’efficienza dell’esecuzione del contratto intelligente. Entro il 2024, la proposta si concentrerà sull’incremento dell’interoperabilità cross-chain e sulle capacità native di archiviazione dei dati attraverso aggiornamenti graduati dello strato core.</p>
<p>Entro la fine del 2024, Andre Cronje (AC) guiderà il team per completare la ricostruzione dell’architettura tecnica e l’innovazione dell’ecosistema del passaggio di Fantom a Sonic, che include principalmente tre dimensioni di aggiornamento:</p>
<p>Macchina virtuale FVM: Attraverso l’esecuzione parallela e l’ottimizzazione dell’insieme di istruzioni, supera il collo di bottiglia di StateDB di EVM (che rappresenta l’84% del tempo di elaborazione), aumenta la velocità delle transazioni di 8,1 volte e riduce i requisiti di archiviazione del 98%. Questo cambiamento riduce la soglia del nodo di verifica di Sonic da 2.000GB a 300GB, espande il numero di nodi completi da 7 a 21 e migliora significativamente il grado di decentralizzazione.</p>
<p>Sistema di archiviazione Carmen: utilizza la tecnologia di riduzione dinamica dei dati per mantenere solo lo stato del protocollo DeFi frequentemente accessato, comprimere e sigillare i dati storici e migliorare l’utilizzo delle risorse on-chain al vertice del settore.</p>
<p>Ponte cross-chain Sonic Gateway: nativamente integrato con <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>, arrivo veloce in 10 minuti (1 ora per il ritorno), meccanismo di protezione dei guasti integrato di 14 giorni. Rispetto al periodo di sfida di 7 giorni di Optimistic Rollup, la sua “finalità istantanea” e la naturalezza degli asset (senza necessità di incapsulamento) sono diventate il nucleo attrattivo della migrazione di capitale cross-chain.</p>
<p>Questo aggiornamento consente a Sonic di avere prestazioni elevate a livello 1 e compatibilità con EVM, fornendo supporto sottostante per DeFi, Giochi e altri scenari, attirando la partecipazione di sviluppatori e utenti attraverso la ricostruzione economica dei token.<img src="https://gimg2.gateimg.com/image/article/17429557224.jpeg" alt=""><br>Origine: Artemis</p>
<p>Ad esempio, <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> V3 ha attirato $15.8 milioni di liquidità nel primo giorno del suo lancio su Sonic, con APY del deposito che ha raggiunto il 19% in un momento, grazie all’esecuzione efficiente e ai vantaggi a basso costo di FVM. Questo deployment convalida l’appeal di Sonic verso i migliori protocolli DeFi.</p>
<h2 id="h2-La20Logica20della20Crescita20e20le20Preoccupazioni20Future20il20Gioco20tra20Efficienza20Sonica20e20Rischio522083"><a name="La Logica della Crescita e le Preoccupazioni Future, il Gioco tra Efficienza Sonica e Rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Logica della Crescita e le Preoccupazioni Future, il Gioco tra Efficienza Sonica e Rischio</h2><p>Sonic non solo continua a lavorare sodo sulla performance e sulla decentralizzazione, ma attiva anche l’ecosistema con grandi distribuzioni aeree fino al 6% e il programma di incentivi per sviluppatori Sonic Boom.</p>
<p>In particolare, Sonic restituisce il 90% delle commissioni di gas agli sviluppatori di dApp attraverso il modello FeeM, il che stimola notevolmente l’entusiasmo nello sviluppo in termini di costo, mentre la compatibilità e gli strumenti di debugging di FVM abbassano la soglia per gli sviluppatori che vogliono partecipare in termini di difficoltà tecnica. Di conseguenza, il numero di protocolli dell’ecosistema Sonic è aumentato da 62 a 312, un aumento di più di 4 volte.<img src="https://gimg2.gateimg.com/image/article/17429557805.jpeg" alt=""><br>Fonte: Defillma</p>
<p>I progetti dell’ecosistema Sonic coprono aree come il prestito, il DEX e lo staking di liquidità, e stanno emergendo meccanismi innovativi con elevati rendimenti in un flusso infinito, come:</p>
<p>Exchange Shadow: Con il supporto di FeeM, il design del protocollo è stato ottimizzato e TVL è aumentato da 0 a $125 milioni, formando un loop di feedback positivo tra fondi e utenti. Il prezzo del token è aumentato di più del 500% in una settimana dopo il lancio.</p>
<p>Beets.fi: TVL raggiunge $187 milioni. Gli utenti puntano S per ottenere certificati stS e il meccanismo di capitalizzazione automatica fornisce un rendimento annualizzato del 23%.</p>
<p>Finanza delle Uova: La capitalizzazione di mercato del token EGGS è di $12.7 milioni e l’APY a breve termine del pool EGGS/S arriva fino al 1800%, attirando i primi speculatori.</p>
<p>Pendle × Rings: Attratto $43 milioni in depositi in 24 ore, gli utenti dividono i diritti principali e di reddito, bloccando un APY fisso del 40%+ o reddito leva.</p>
<p>Dopo aver parlato della serie di ecosistemi e del progresso tecnologico di Sonic, parliamo delle preoccupazioni nascoste che influenzano il prezzo delle monete. La sfida principale è ricostruire la fiducia negli stablecoin algoritmici. Di recente, Sonic Labs ha lanciato un nuovo stablecoin algoritmico che offre un tasso di interesse annuo fino al 23%, cercando di evitare la tragedia della “spirale della morte” di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Il crollo di attraverso aggiornamenti tecnologici e aggiustamenti dinamici dei rendimenti. Tuttavia, il modello di stablecoin collegato a S ha ancora bisogno di tempo per essere verificato e l’accettazione della comunità deve essere lentamente coltivata.</p>
<p>Inoltre, l’83% del TVL su Sonic è concentrato nei primi cinque protocolli. La mancanza di liquidità dei progetti long-tail potrebbe esacerbare la fuga di capitali. Questo fenomeno di eccessiva concentrazione del traffico e la mancanza di sufficienti vantaggi tecnici rispetto ad altri Layer1 evidenziano la fragilità dell’attuale ecosistema di Sonic. Inoltre, il mercato crittografico non si è ancora completamente ripreso dal crollo di marzo, proprio come quando il mercato azionario statunitense e BTC sono crollati a febbraio, il tasso di crescita del TVL di Sonic si è brevemente rallentato.<img src="https://gimg2.gateimg.com/image/article/17429558626.jpeg" alt=""><br>Fonte: @arndxt_xo</p>
<p>In generale, l’esplosione dell’ecosistema Sonic deriva dagli sforzi congiunti di innovazione tecnologica, afflusso di capitale e impulso della comunità. Dal aumento di 28 volte del TVL, al potenziale del token S, all’innovazione diversificata del progetto, Sonic ha dimostrato una competitività unica nella traccia Layer 1. Ma la storia ci dice che non c’è mai stato un vincitore permanente nella guerra delle catene pubbliche - la crisi di frammentazione della liquidità di Ethereum, la centralizzazione di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> e la controversia PVP, e <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> Il ‘narrative bubble’ sono tutte le lezioni del passato. Se Sonic può superare il divario tra i picchi a breve termine e il mantenimento a lungo termine dipende dalla verifica continua della sicurezza tecnica, dal miglioramento dell’adesione delle applicazioni dell’ecosistema e dal controllo della direzione del ciclo macro. Gli investitori devono ancora partecipare in modo razionale.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>