MjAyNSBNdXN0LUhhdmUgcGVyIGkgcHJpbmNpcGlhbnRpIG5lZ2xpIGFzc2V0IGNyeXB0bzogQ29zYSBzb25vIExheWVyIDAsIExheWVyIDEgZSBMYXllciAyPw==

2021-11-24, 03:44

<p><img src="https://gimg2.gateimg.com/image/6202506061330523020188472.webp" alt="">
</p><h2 id="h2-Ultimi20sviluppi20nel20202558920"><a name="Ultimi sviluppi nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultimi sviluppi nel 2025</h2><p>Nel 2025, l’architettura a strati della blockchain è significativamente evoluta grazie a nuovi progressi nelle soluzioni Layer 0, Layer 1 e Layer 2:</p>
<ul>
<li><p>Integrazione Layer 0: Importanti protocolli infrastrutturali come <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> e Cosmos hanno raggiunto un’interoperabilità senza soluzione di continuità tra blockchain eterogenee, con oltre 200 parachain ora operative in più ecosistemi.</p>
</li><li><p>Efficienza del Layer 1: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha completato con successo l’upgrade Surge, aumentando la capacità di transazione di 100 volte mantenendo i principi di decentralizzazione.</p>
</li><li><p>Maturità del Layer 2: La tecnologia Rollup è stata standardizzata, gli ZK-rollup gestiscono l’85% delle transazioni di Ethereum e i costi sono diminuiti del 98% rispetto ai livelli del 2023.</p>
</li></ul>
<p>Il mercato ha risposto positivamente a questi sviluppi:</p>
<table>
<thead>
<tr>
<th>Tipo di strato</th>
<th>Crescita del TVL (rispetto al 2023)</th>
<th>Utenti Attivi</th>
<th>Costo medio della transazione</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 0</td>
<td>+350%</td>
<td>oltre 15 milioni</td>
<td>$0,005</td>
</tr>
<tr>
<td>Layer 1</td>
<td>+210%</td>
<td>110 milioni+</td>
<td>$0.05</td>
</tr>
<tr>
<td>Layer 2</td>
<td>+800%</td>
<td>250 milioni+</td>
<td>$0.001</td>
</tr>
</tbody>
</table>
<p>Le soluzioni cross-layer sono diventate lo standard del settore, consentendo alle applicazioni di funzionare senza problemi attraverso più livelli. I dati della piattaforma mostrano che gli utenti stanno migrando verso soluzioni integrate che sfruttano la sicurezza del Layer 1 e i vantaggi in termini di prestazioni del Layer 2.</p>
<p>La sfida del triangolo impossibile ha superato le discussioni teoriche, con implementazioni pratiche che mostrano un equilibrio senza precedenti tra sicurezza, decentralizzazione e scalabilità attraverso un approccio ibrido che combina i vantaggi di vari strati.</p>
<h2 id="h2-Una20lettura20obbligatoria20per20i20neofiti20del20mondo20degli20asset20crypto20Cosa20sono20Layer20020Layer20120e20Layer202550334"><a name="Una lettura obbligatoria per i neofiti del mondo degli asset crypto: Cosa sono Layer 0, Layer 1 e Layer 2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Una lettura obbligatoria per i neofiti del mondo degli asset crypto: Cosa sono Layer 0, Layer 1 e Layer 2</h2><p>[TL; DR]</p>
<ol>
<li>La blockchain ha un’architettura a sei livelli: livello dei dati, livello di rete, livello di consenso, livello di incentivo, livello di contratto e livello di applicazione.</li><li>Il livello dei dati e il livello di rete sono l’architettura fondamentale della blockchain e rappresentano anche il livello più basso dell’intero sistema blockchain.</li><li>Oltre all’architettura di base, il layer di consenso, il layer di incentivazione, il layer dei contratti e il layer delle applicazioni costituiscono insieme la parte protocollo della blockchain.</li><li>Il Layer 0, noto anche come il livello di trasmissione dei dati, corrisponde al livello più basso del modello OSI e riguarda principalmente le questioni di integrazione tra blockchain e reti tradizionali.</li><li>Le soluzioni di scalabilità di Layer 1, conosciute anche come scalabilità on-chain, si riferiscono a soluzioni di scalabilità implementate sul protocollo di base della blockchain.</li><li>Le soluzioni di scaling di Layer 2, note anche come scaling off-chain, si riferiscono all’aumento della velocità di elaborazione delle transazioni attraverso metodi come i canali di stato e le sidechain senza modificare il protocollo blockchain sottostante e le regole fondamentali.</li></ol>
<p>Nel notiziario sugli asset crypto, scalabilità, Layer 0/1/2 sono senza dubbio una serie di termini frequentemente menzionati. Quindi, quali sono il Layer 0, il Layer 1 e il Layer 2 della blockchain, e quali sono le diverse caratteristiche e utilizzi di questi tre strati?</p>
<h2 id="h2-A20partire20dallarchitettura20a20sei20strati20della20blockchain456799"><a name="A partire dall’architettura a sei strati della blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>A partire dall’architettura a sei strati della blockchain</h2><p>Nel gennaio 2009, il misterioso geek Satoshi Nakamoto generò il blocco di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> su un server situato a Helsinki. Attualmente, Bitcoin si è evoluto in un sistema massiccio con decine di migliaia di nodi a livello globale e un valore di mercato totale che supera i 1 trilione di dollari. Bitcoin risolve perfettamente il problema della rappresentazione del valore nel mondo digitale e ha portato la tecnologia blockchain all’umanità. Se analizziamo attentamente la struttura del sistema Bitcoin, possiamo dividerlo in cinque livelli in base alla funzionalità: il livello dei dati, il livello di rete, il livello di consenso, il livello di incentivazione e il livello applicativo. Successivamente, Ethereum, che è rapidamente emerso grazie ai contratti intelligenti, ha stabilito un nuovo paradigma per i sistemi blockchain aggiungendo un livello di contratto tra il livello di incentivazione e il livello applicativo. Spieghiamo questo in dettaglio dal basso verso l’alto.</p>
<p>Il layer dei dati e il layer di rete sono l’architettura fondamentale della blockchain e sono anche il livello più basso dell’intero sistema blockchain.</p>
<p>Il Data Layer include le strutture dati di ciascun blocco, come l’albero di Merkle, oltre a come i diversi blocchi sono connessi end-to-end per formare una catena. Inoltre, il Data Layer comprende anche gli algoritmi di crittografia hash e gli algoritmi di crittografia asimmetrica utilizzati per garantire l’immutabilità della blockchain. Il data layer della blockchain può essere visto come un database con caratteristiche distribuite e immutabilità. Questo database distribuito deve essere mantenuto collettivamente da tutti i nodi del sistema, il che porta al layer di rete della blockchain.</p>
<p>Il livello di rete (Network Layer) descrive un enorme network P2P composto da tutti i nodi nella blockchain. In questa rete distribuita e punto a punto, una volta che un nodo crea un nuovo blocco, trasmette le informazioni a diversi nodi vicini attraverso un meccanismo di broadcast (Transmission Mechanism). Altri nodi, dopo aver completato la verifica del blocco (Authentication Mechanism), trasmetteranno nuovamente i dati ad altri nodi. Alla fine, dopo che la maggior parte dei nodi dell’intero sistema completa la verifica del blocco, il blocco è ufficialmente connesso alla blockchain.</p>
<p>Sopra l’architettura di base, il layer di consenso, il layer di incentivo, il layer di contratto e il layer di applicazione insieme formano la parte del protocollo della blockchain.</p>
<p>Il Livello di Consenso include principalmente gli algoritmi dei meccanismi di consenso della blockchain. In una rete blockchain, molti nodi che inizialmente erano non correlati raggiungono l’unità attraverso gli algoritmi di consenso, mantenendo la coerenza del livello dati. Attualmente, i meccanismi di consenso più comuni includono il Proof of Work (PoW) utilizzato da Bitcoin e il Proof of Stake (PoS) utilizzato da Ethereum 2.0. <a href="https://www.gate/cn/trade/EOS_USDT?ch=ann357" rel="nofollow noopener noreferrer" target="_blank">EOS</a> Il proof of stake delegato (Delegated Proof of Stake, DPoS) impiegato, ecc. Il meccanismo di consenso è una delle innovazioni fondamentali della tecnologia blockchain, che influisce significativamente sulla sicurezza del sistema e sull’efficienza operativa. Inoltre, gli algoritmi di consenso sono anche i principali mezzi di governance della comunità nella blockchain.</p>
<p>Lo strato di attuazione comprende principalmente il meccanismo di emissione e il meccanismo di distribuzione della blockchain. Attraverso la progettazione del meccanismo di incentivazione, i nodi del sistema manterranno volontariamente la sicurezza dell’intera rete blockchain. Ad esempio, nel meccanismo PoW di Bitcoin, i nuovi bitcoin emessi vengono distribuiti ai miner dei nodi di imballaggio. Il consenso viene raggiunto in un modo che si avvicina a “più lavori, più guadagni”; i nodi con maggiore potenza di calcolo hanno maggiori probabilità di imballare con successo i blocchi e quindi guadagnare il diritto di contabilizzazione. In alcuni meccanismi di incentivazione, i nodi che abusano del loro potere possono anche essere puniti dal sistema.</p>
<p>Il Bitcoin integra creativamente meccanismi di incentivo economico negli algoritmi, consentendo ai miner di competere per i diritti di contabilità attraverso la potenza di calcolo. Questo non solo mantiene il sistema di transazioni, ma emette anche nuovi token, che vengono successivamente distribuiti come incentivi ai miner, creando così un ciclo chiuso stabile e sicuro. In questo processo, si realizza anche la funzionalità del Bitcoin come denaro elettronico. Continuiamo a progredire verso il livello superiore.</p>
<p>Il livello del contratto include principalmente vari codici script, algoritmi e smart contract, ed è la base per l’implementazione di molte funzioni avanzate nella blockchain. Nella blockchain, realizza veramente il cosiddetto “il codice è legge”; una volta attivato l’algoritmo del contratto, eseguirà inevitabilmente secondo le impostazioni originali senza alcun intervento o promozione da parte di terzi. Inoltre, a causa della completezza di Turing degli smart contract, il livello del contratto possiede anche programmabilità, il che conferisce all’intera rete blockchain una natura simile a quella di una macchina virtuale.</p>
<p>Il Livello Applicativo è il livello superiore dell’intero sistema blockchain, che comprende vari scenari applicativi di quella blockchain. Per la blockchain di Bitcoin, l’emissione completa, il trasferimento e le funzioni contabili del sistema di denaro elettronico Bitcoin costituiscono il suo “Livello Applicativo”; mentre per una blockchain programmabile come Ethereum, molte funzionalità avanzate e numerosi DApp formano insieme il suo livello applicativo.</p>
<h2 id="h2-Layer20020Layer20120e20Layer202308561"><a name="Layer 0, Layer 1 e Layer 2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Layer 0, Layer 1 e Layer 2</h2><p>I sei livelli del sistema blockchain sono strettamente interconnessi nella struttura, realizzando collettivamente le funzioni della blockchain. Ritornando al problema della scalabilità menzionato all’inizio di questo articolo, l’industria si riferisce generalmente al Modello di Riferimento per l’Interconnessione Aperta (OSI) nel campo delle comunicazioni, riclassificando i sei livelli del sistema blockchain in tre strati, ovvero Strato 0, Strato 1 e Strato 2, dal basso verso l’alto.</p>
<p>Tra questi, il Layer 0, noto anche come il layer di trasmissione dei dati, corrisponde al livello più basso del modello OSI e riguarda principalmente le questioni di integrazione tra blockchain e reti tradizionali. Le soluzioni di espansione del Layer 0 corrispondenti si riferiscono a soluzioni di miglioramento delle prestazioni che non alterano la struttura della blockchain e mantengono le sue regole ecologiche originali. Poiché non influiscono sulla blockchain stessa, le soluzioni di espansione del Layer 0 hanno una forte versatilità. Allo stesso tempo, le soluzioni di espansione del Layer 0 sono anche compatibili con Layer 1⁄2soluzioni di espansione, lavorando insieme per migliorare esponenzialmente le prestazioni delle reti blockchain. Nei protocolli di rete sottostanti, ci sono ancora molti problemi legati alle prestazioni che meritano di essere ottimizzati. Attualmente, le direzioni tecnologiche di espansione Layer 0 esistenti includono BDN (Distributed Network), protocollo QUIC UDP, ecc.</p>
<p>Inoltre, Polkadot è spesso definito un blockchain di Layer 0. Questo perché il mainnet di Polkadot, in quanto relay chain, serve solo a fornire sicurezza e interoperabilità tra vari parachain. Sopra Polkadot, è possibile collegare blockchain di Layer 1 simili a Ethereum tramite slot, come la catena Moonbeam, che supporta anche il linguaggio Solidity.</p>
<p>Il Layer 1 corrisponde al layer dei dati, layer di rete, layer di consenso e layer di incentivazione nel modello a sei strati. Per la maggior parte delle Crypto Assets, il Layer 1 è l’unica catena pubblica e tutti i regolamenti delle transazioni avvengono su di esso. Le soluzioni di scaling del Layer 1, note anche come scaling on-chain, si riferiscono a soluzioni di scaling implementate sul protocollo di base della blockchain. In generale, richiede la modifica di proprietà intrinseche come la capacità dei blocchi, il tempo di generazione dei blocchi e il meccanismo di consenso per migliorare la capacità di transazione. In particolare, l’aggiornamento delle dimensioni dei blocchi di Bitcoin aumenta la capacità di ogni blocco di Bitcoin, consentendo di accogliere più transazioni; Bitcoin SegWit riduce lo spazio occupato dalla singola transazione media, consentendo a ciascun blocco di contenere un numero maggiore di transazioni; l’aggiornamento a DPoS può anche ottenere prestazioni migliori a scapito di un certo grado di decentralizzazione e sicurezza. Tuttavia, a causa di vincoli fisici ed economici, l’efficienza dello scaling del Layer 1 ha i suoi limiti.</p>
<p>Per i principi e i limiti della scalabilità di Layer 1, si prega di fare riferimento al nostro precedente post sul blog:</p>
<p><a href="https://www.gate/blog_detail/86/dogecoin-
why-is-vitalik-buterin-against-it-will-scaling-increase-its-popularity" rel="nofollow noopener noreferrer" target="_blank">Cosa ha detto V God nel suo articolo contro Musk? Può la scalabilità rendere Dogecoin la “moneta del popolo”?</a></p>
<p>Il Layer 2 corrisponde al layer dei contratti e al layer delle applicazioni della blockchain. Le soluzioni di scaling Layer 2, conosciute anche come scaling off-chain, si riferiscono al miglioramento della velocità di elaborazione delle transazioni senza modificare i protocolli sottostanti e le regole fondamentali della blockchain, attraverso soluzioni come i canali di stato e le sidechain. Il Layer 2 si espande esternamente alla catena principale e ha una relazione complementare con il Layer 1; cioè, il Layer 2 è l’infrastruttura costruita sopra la blockchain sottostante, fornendo una migliore scalabilità, usabilità e privacy per la blockchain. Rispetto al Layer 1, che persegue sicurezza e decentralizzazione, il Layer 2 mira a un’efficienza e prestazioni ottimali. Attualmente, le soluzioni comuni del Layer 2 includono Side Chain, Plasma, canali di stato e Rollup.</p>
<p>Per le comuni soluzioni Layer 2 su Ethereum, si prega di fare riferimento al nostro precedente post sul blog: <a href="https://www.gate/blog_detail/77/ethereum-layer-2-an-
upgrade-of-scalability" rel="nofollow noopener noreferrer" target="_blank">Come giocare con Ethereum Layer 2? Comprendere l’upgrade di scalabilità di Ethereum in un articolo.</a></p>
<h2 id="h2-Conclusione824796"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Dallo sviluppo rapido di Bitcoin ed Ethereum, la questione delle prestazioni insufficienti è sempre stata una nube oscura che aleggia sulle blockchain pubbliche consolidate. Come rompere il “triangolo impossibile” e raggiungere la soluzione ottimale tra scalabilità, decentralizzazione e sicurezza è considerato anche il “Santo Graal” nel campo della blockchain.</p>
<p>Negli articoli seguenti, introdurremo specificamente varie soluzioni di espansione della blockchain, mentre seguiremo l’avanguardia del settore e riporteremo i più recenti progressi nella tecnologia di scalabilità. Rimanete sintonizzati.</p>
<div class="blog-details-info"><br>  <div>Autore: Team del Blog<br>  <div class="info-tips"><em>Questo contenuto non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti 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 tutti o parte dei suoi servizi dalle aree ristrette. Si prega di leggere il contratto utente per ulteriori informazioni, link:<a  rel="nofollow noopener noreferrer"  href="https://www.gate/zh/user-agreement。" data-index="4"></a><a  rel="nofollow noopener noreferrer"  href="https://www.gate/zh/user-agreement" data-index="5">https://www.gate/zh/user-agreement</a>.<br><p></p><br></em></div></div></div>