RXNzZW56aWFsaSBwZXIgaSBwcmluY2lwaWFudGkgZGkgY3JpcHRvOiBDb3Mnw6ggTGF5ZXIgMCwgTGF5ZXIgMSBlIExheWVyIDI/

2021-11-24, 03:44

<p><img src="https://gimg.gateimg.com/image/article/1637724520blog_WhatIsLayer0Layer1andLayer2.jpg" alt=""></p>
<p><strong>[TL; DR]</strong></p>
<ol>
<li><p>Ci sono sei livelli nell’architettura logica della blockchain: livello dei dati, livello di rete, livello di consenso, livello di attivazione, livello del contratto e livello dell’applicazione.</p>
</li><li><p>I livelli di dati e di rete fanno parte dell’architettura di base della blockchain e costituiscono anche il livello più basso dell’intero sistema blockchain.</p>
</li><li><p>Sulla base dell’architettura fondamentale, il livello di consenso, il livello di attivazione, il livello dei contratti e il livello delle applicazioni lavorano insieme per costituire il livello di protocollo della blockchain.</p>
</li></ol>
<p>Il livello 0, noto anche come livello di trasferimento dati, è il livello inferiore del modello OSI e coinvolge principalmente l’integrazione tra blockchain e reti tradizionali.</p>
<ol>
<li>Layer 1, o scaling on-chain, si riferisce a una soluzione di scaling implementata sopra il protocollo di base della blockchain.</li></ol>
<p>Il livello 2 è anche conosciuto come scalabilità off-chain in cui i protocolli sottostanti e le regole fondamentali della blockchain non verranno cambiate e la velocità di elaborazione delle transazioni verrà aumentata attraverso canali di stato, sidechain e altre soluzioni.</p>
<p>Scalabilità e Layer 0/1/2 sono termini che vengono spesso menzionati nelle notizie sulle criptovalute. Quindi, cos’è Layer 0, Layer 1 e Layer 2 nella blockchain? E quali sono le loro rispettive caratteristiche e utilizzi?</p>
<h2 id="h2-Cominciamo20con20sei20livelli20della20tecnologia20blockchain895500"><a name="Cominciamo con sei livelli della tecnologia blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cominciamo con sei livelli della tecnologia blockchain</h2><p>Nel gennaio 2009, Satoshi Nakamoto ha minato il primo blocco di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> su un server situato a Helsinki. Per ora, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> è cresciuto in un sistema enorme con decine di migliaia di nodi in tutto il mondo e una capitalizzazione di mercato totale di oltre 1 trilione di dollari. Ha risolto perfettamente il problema della rappresentazione del valore nel mondo digitale ed ha anche avanzato la tecnologia blockchain. Se la struttura del <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il sistema viene attentamente analizzato, può essere suddiviso in cinque livelli in base alla sua funzione: il livello dei dati, il livello di rete, il livello di consenso, il livello di attivazione e il livello dell’applicazione. In seguito, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è rapidamente salito all’attenzione con i contratti intelligenti e ha stabilito un nuovo paradigma per il sistema blockchain aggiungendo uno strato contrattuale tra il livello di attivazione e il livello dell’applicazione. Diamo un’occhiata più da vicino.</p>
<p>I livelli di dati e rete sono l’architettura di base della blockchain e anche i livelli più bassi dell’intero sistema blockchain.</p>
<p>Il livello dei dati agisce come la struttura dei dati del blockchain (ad esempio, l’albero di Merkle) ed è composto da due elementi: puntatori e una lista collegata. I puntatori sono variabili che si riferiscono alla posizione di un’altra variabile, e una lista collegata è una lista di blocchi concatenati con dati e puntatori al blocco precedente. Inoltre, il livello dei dati coinvolge un algoritmo di hash e la crittografia asimmetrica utilizzata per garantire la natura antimanomissione del blockchain. Il livello può anche essere considerato come un database distribuito e resistente alle manipolazioni che deve essere mantenuto da tutti i nodi del sistema, il che porta al livello di rete del blockchain.</p>
<p>Il livello di rete si riferisce a una vasta rete P2P che coinvolge tutti i nodi della blockchain. In questa rete P2P distribuita, una volta che un nodo ha creato un nuovo blocco, trasmette le informazioni a diversi nodi vicini attraverso un meccanismo di trasmissione. Dopo che gli altri nodi hanno autenticato il blocco, trasmetteranno nuovamente i dati agli altri nodi. Alla fine, il blocco viene ufficialmente collegato alla blockchain una volta che la maggior parte dei nodi del sistema ha autenticato il blocco.</p>
<p>Basandosi sull’architettura fondamentale, il livello di consenso, il livello di attivazione, il livello contrattuale e il livello delle applicazioni lavorano insieme per costituire il livello di protocollo della blockchain.</p>
<p>Nella blockchain, il livello di consenso include principalmente meccanismi di algoritmo di consenso, che sono utilizzati per unificare i nodi non correlati tra loro nell’intera rete e mantenere la coerenza dei dati al livello dei dati. Finora, i meccanismi di consenso comuni sono la prova di lavoro (POW) di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, la prova del palo (POS) di Ethereum e la prova delegata del palo (DPoS) di <a href="https://www.gate.io/trade/EOS_USDT" target="_blank">EOS</a> Come una delle tecnologie principali della blockchain, il meccanismo di consenso svolge un ruolo significativo nella sicurezza e nell’efficienza operativa delle reti. Inoltre, è uno dei meccanismi di governance cruciali della comunità blockchain.</p>
<p>Il livello di attivazione include il meccanismo di emissione e i meccanismi di distribuzione della blockchain. Attraverso il meccanismo di incentivi, i nodi nel sistema manterranno spontaneamente la sicurezza di tutta la rete blockchain. Ad esempio, nel meccanismo di consenso PoW, appena emessi <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> I token vengono distribuiti ai minatori che includono e convalidano le transazioni. E sembra raggiungere un consenso che più lavoro paga di più. I nodi con più potenza di calcolo hanno più probabilità di imballare con successo i blocchi e ottenere i diritti di contabilità. In alcuni casi, i nodi che utilizzano la loro potenza per il male come barare verrebbero puniti dal sistema. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> integra in modo creativo incentivi economici nel suo algoritmo, risultando in minatori che competono per i diritti di tenuta dei conti attraverso la potenza di calcolo. Questo meccanismo mantiene il sistema di transazioni mentre emette nuovi token, che a loro volta diventano un incentivo per la distribuzione ai minatori, creando così un sistema stabile e sicuro. Nel processo, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> La sua funzione di denaro elettronico è anche soddisfatta.</p>
<p>Il livello del contratto comprende principalmente vari , algoritmi e smart contract. È la base della programmazione sofisticata della blockchain. Nella blockchain, è una vera implementazione di ciò che è noto come ‘il codice è legge’, in cui l’algoritmo del contratto, una volta attivato, seguirà inevitabilmente le sue impostazioni originali senza intervento o facilitazione di terzi. Inoltre, grazie alla completezza di Turing dei contratti intelligenti, il livello del contratto è anche programmabile, il che conferisce all’intera rete blockchain una natura simile a una macchina virtuale.</p>
<p>Il livello dell’applicazione è il livello superiore del sistema blockchain e contiene i vari scenari di applicazione della blockchain. Per la <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> La blockchain, il sistema di denaro elettronico con funzioni complete di emissione, trasferimento e contabilità, costituisce il livello di applicazione, mentre per una blockchain programmabile come Ethereum, varie funzionalità avanzate e DApps lavorano insieme per comporre il livello di applicazione.</p>
<p><img src="https://gimg.gateimg.com/image/article/16377247831.png" alt=""></p>
<h2 id="h2-Layer20020Layer20120e20Layer202511176"><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 strutturalmente inseparabili e realizzano congiuntamente le funzioni della blockchain. Tornando alla scalabilità menzionata all’inizio di questo articolo, il settore si riferisce generalmente al Modello di riferimento per l’interconnessione di sistemi aperti (OSI) delle comunicazioni e ridivide i sei livelli in tre Livelli, con il fondo in alto che è il Livello 0, il Livello 1 e il Livello 2.</p>
<p>Il livello 0, noto anche come livello di trasferimento dati, è il livello inferiore del modello OSI e coinvolge principalmente l’integrazione tra blockchain e reti tradizionali. Le soluzioni di scalabilità del livello 0 sono quelle che non modificano la struttura della blockchain e mantengono le sue regole originali dell’ecosistema per il miglioramento delle prestazioni. La soluzione del livello 0 è altamente versatile in quanto non influenza la blockchain stessa ed è anche compatibile con le soluzioni di scalabilità dei livelli 1 e 2. Lavorano insieme per moltiplicare le prestazioni della rete blockchain. Ci sono ancora numerosi problemi che influenzano le prestazioni nei protocolli di rete sottostanti da ottimizzare. Le tecnologie di scalabilità del livello 0 esistenti includono BDN (blockchain distribution network), QUIC e UDP.</p>
<p>Polkadot è spesso definito come un blockchain di Livello 0 poiché la sua mainnet funge da catena di rilancio e serve solo per fornire sicurezza e interoperabilità tra le principali parachains. E su Polkadot, alcune reti possono connettersi ai blockchain di Livello 1 come Ethereum attraverso slot, come la catena <a href="/price/moonbeam-glmr" target="_blank" class="blog_inner_link">Moonbeam</a> che supporta il linguaggio di programmazione.</p>
<p>Il livello 1 corrisponde al livello dei dati, al livello di rete, al livello di consenso e al livello di attivazione nell’architettura logica della blockchain. La maggior parte delle criptovalute ha una catena pubblica indipendente e unica, cioè il livello 1, su cui tutte le transazioni vengono regolate. Il livello 1, anche conosciuto come On-Chain Scaling, si riferisce a una soluzione di scalabilità implementata sopra il protocollo di base della blockchain. Generalmente richiede la modifica della capacità del blocco, del tempo di generazione del blocco, del meccanismo di consenso e di altre proprietà intrinseche della blockchain per aumentare la capacità di trading. In particolare, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> L’aggiornamento della scalabilità sta aumentando la capacità di ciascun blocco in modo che più transazioni possano essere gestite, mentre SegWit riduce lo spazio medio occupato da una singola transazione, consentendo di ospitare più transazioni per blocco. L’aggiornamento a DPoS consente anche una migliore prestazione a spese di un certo grado di decentralizzazione e sicurezza. Tuttavia, l’efficienza della scalabilità del Layer 1 è suscettibile a fattori fisici ed economici.</p>
<p>Per maggiori informazioni sui principi e le limitazioni della scalabilità di Layer 1, leggi di più <a href="https://www.gate.io/blog_detail/86" target="_blank">Dogecoin: Perché Vitalik Buterin è contrario? Aumenterà la scalabilità la sua popolarità?</a></p>
<p>Il livello 2 corrisponde al livello del contratto e al livello dell’applicazione della blockchain. È anche conosciuto come scalabilità off-chain in cui i protocolli sottostanti e le regole di base della blockchain non verranno modificati, e la velocità di elaborazione delle transazioni verrà aumentata attraverso canali di stato, sidechain e altre soluzioni. Il livello 2 è una soluzione alle prestazioni che scala al di fuori della catena principale. È complementare al Livello 1, cioè il Livello 2 è un’infrastruttura costruita sopra la blockchain sottostante per fornire una migliore scalabilità, disponibilità e privacy per la blockchain. Rispetto al Livello 1, che cerca sicurezza e decentramento, il Livello 2 cerca l’efficienza e le prestazioni finali. I tipi comuni di soluzioni di Livello 2 sono side chain, Plasma, Canali di Stato, Rollup e così via.</p>
<p>Per informazioni sulle comuni soluzioni di Layer 2 su Ethereum, si prega di leggere <a href="https://www.gate.io/blog_detail/77" target="_blank">Ethereum Layer 2: Un miglioramento della scalabilità</a></p>
<h2 id="h2-Conclusione746845"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Dal rapido sviluppo di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Con <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ethereum, il problema della performance insufficiente si sta aggirando su queste ben note catene pubbliche. Come craccare il “triangolo impossibile” e raggiungere una soluzione ottimale tra scalabilità, decentralizzazione e sicurezza è considerato una delle cause più significative nel campo delle blockchain. È il “santo graal” delle blockchain. Nei successivi articoli, ti presenteremo le soluzioni di scalabilità su importanti blockchain e le ultime avanzate tecnologiche di scalabilità, oltre ad aiutarti a tenere traccia del cutting edge dell’industria. Resta sintonizzato!</p>
<div class="blog-details-info"><br><div>Autore:<strong> Ashley. H</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>