Q29zXCfDqCBNb25hZCBMYWJzPw==

2025-06-13, 02:19

<p><img src="https://gimg2.gateimg.com/image/monad202506131018070306105587.jpg" alt="">
</p><p>Nel panorama delle blockchain pubbliche Layer 1 del 2024, un progetto chiamato Monad Labs ha sconvolto il mondo delle criptovalute con un finanziamento straordinario di 225 milioni di dollari, guidato dalla principale società di venture capital Paradigm, stabilendo un record per il più grande finanziamento nel settore delle criptovalute di quell’anno. Questa azienda emergente, fondata da ex membri chiave di Jump Trading, sta cercando di ridefinire i limiti delle prestazioni delle catene compatibili con <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> con una soluzione tecnologica chiamata “Parallel EVM.”</p>
<h2 id="h2-Nucleo20Tecnico20Quando20lEVM20Impara20il20Multithreading403556"><a name="Nucleo Tecnico: Quando l’EVM Impara il “Multithreading”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nucleo Tecnico: Quando l’EVM Impara il “Multithreading”</h2><p>Il collo di bottiglia del tradizionale <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sta nella sua meccanismo di esecuzione sequenziale delle transazioni—come un casello autostradale a corsia singola, inevitabilmente diventa congestionato durante le ore di punta. Il punto di svolta di Monad risiede nell’introduzione della tecnologia di elaborazione parallela:</p>
<ul>
<li>Algoritmo di esecuzione parallela ottimistica: Raggruppa le transazioni per l’elaborazione simultanea e rileva i conflitti tracciando input e output. Se si verifica un conflitto, il sistema riesegue automaticamente le transazioni interessate, utilizzando la memorizzazione nella cache per garantire l’efficienza.</li><li>Architettura di esecuzione ritardata: separare consenso ed esecuzione in pipeline indipendenti per liberare più tempo di blocco per il reale processamento delle transazioni;</li><li>MonadDB database di stato: memorizza direttamente la struttura dell’albero di Merkle su SSD, riducendo significativamente gli effetti di amplificazione della lettura e accelerando l’accesso allo stato.</li><li>Meccanismo di consenso MonadBFT: Ottimizza l’algoritmo HotStuff, con complessità di comunicazione lineare che supporta una sincronizzazione efficiente tra centinaia di nodi a livello globale.</li></ul>
<p>Questa serie di innovazioni consente a Monad di raggiungere una capacità di 10.000 TPS e un tempo di blocco di 1 secondo, con prestazioni superiori a quelle di Ethereum di mille volte.</p>
<h2 id="h2-Team20e20background20Il20trapianto20di20geni20di20trading20ad20alta20frequenza696998"><a name="Team e background: Il trapianto di geni di trading ad alta frequenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Team e background: Il trapianto di geni di trading ad alta frequenza</h2><p>La fondazione di Monad nasce dalle esperienze pratiche dei fondatori Keone Hon e James Hunsaker presso Jump Trading. In quanto parte centrale del team di trading ad alta frequenza, gestivano migliaia di operazioni al secondo, con un volume di trading nominale annuale superiore a 10 trilioni di dollari. Questa esperienza ha dato loro una profonda comprensione dell’impatto dei ritardi di microsecondi sui sistemi, spingendo i due a fondare Monad nel 2022, introducendo soluzioni di ottimizzazione delle prestazioni dal settore finanziario tradizionale alla blockchain.<br>Il background del team ha guadagnato loro alta fiducia da parte del capitale: nel 2023, hanno completato un round di finanziamento seed da 19 milioni di dollari (guidato da Dragonfly), e nel 2024, hanno assicurato altri 225 milioni di dollari guidati da Paradigm, portando il finanziamento totale a 244 milioni di dollari, con una valutazione superiore a 3 miliardi di dollari.
</p><h2 id="h2-Compatibilit20Migrazione20senza20soluzione20di20continuit20nellecosistema20Ethereum487117"><a name="Compatibilità: “Migrazione senza soluzione di continuità” nell’ecosistema Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Compatibilità: “Migrazione senza soluzione di continuità” nell’ecosistema Ethereum</h2><p>Monad si posiziona come “Ethereum e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> la cristallizzazione tecnologica, alla ricerca di un equilibrio tra compatibilità e prestazioni:</p>
<ul>
<li>Completamente compatibile con il bytecode EVM: i contratti Ethereum possono essere distribuiti senza modifiche;</li><li>Supporto dell’API RPC di Ethereum: Strumenti come MetaMask ed Etherscan possono essere utilizzati direttamente;</li><li>Costi di migrazione zero per gli sviluppatori: Kit di sviluppo come Hardhat e Foundry si adattano senza problemi.</li></ul>
<p>Questa compatibilità abbassa significativamente la soglia di migrazione ecologica e attualmente oltre 60 progetti hanno annunciato che saranno costruiti su Monad.</p>
<h2 id="h2-Strategia20della20comunit20Meme20Addictivi20e20Tempesta20Viola351446"><a name="Strategia della comunità: Meme Addictivi e “Tempesta Viola”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Strategia della comunità: Meme Addictivi e “Tempesta Viola”</h2><p>Le operazioni comunitarie di Monad sono altamente riconoscibili:</p>
<ul>
<li>Post creativi quotidiani “gmonad” saluti di buongiorno sulla piattaforma X;</li><li>Continuando a tenere concorsi di meme (ora nella 27ª settimana), incoraggiando gli utenti a creare emoticon divertenti a tema viola.</li><li>Incentivare i primi contributori attraverso i ruoli di Discord (come Nads, OG).</li></ul>
<p>Questo stile è paragonato alla strategia di comunicazione di base di Solana, mirata a costruire una cultura comunitaria molto coinvolgente.</p>
<h2 id="h2-Progressi20e20Sfide20Lancio20della20Rete20di20Test20e20Soglie20dei20Nod989538"><a name="Progressi e Sfide: Lancio della Rete di Test e Soglie dei Nod" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Progressi e Sfide: Lancio della Rete di Test e Soglie dei Nod</h2><p>Nel febbraio 2025, la rete di test Monad è ufficialmente stata attivata, segnando un passo importante in avanti. Tuttavia, il suo design presenta anche sfide reali:</p>
<ul>
<li>Elevati requisiti hardware per i nodi: si consiglia di configurare un SSD da 2 TB, CPU a 16 core, 32 GB di RAM, il che potrebbe influenzare il grado di decentralizzazione.</li><li>Incubazione dell’ecosistema in corso: Il protocollo di liquidità Elixir ha aperto le sue interazioni testnet, consentendo agli utenti di mettere in staking ETH per partecipare allo sviluppo precoce.</li></ul>
<h2 id="h2-Conclusione340404"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Monad Labs rappresenta un nuovo percorso nell’evoluzione dell’EVM—non facendo affidamento sullo sharding di Layer 2 ma raggiungendo la scalabilità a singolo livello attraverso una ricostruzione sottostante. La sua visione è quella di diventare un super layer che supporta applicazioni complesse come DeFi ad alta frequenza e RWA, e persino fornisce un layer di regolamento per la finanza tradizionale. Con il testnet in funzione e i progetti ecologici che vengono lanciati gradualmente, se questa “rivoluzione parallela” possa sconvolgere il panorama dell’L1 si sta svolgendo sulla catena.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Si dovrebbe sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso totale o parziale dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere l'Accordo Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>