Q29zJ8OoIGlsIExheWVyIDMgY2hlIHN0YSBkaXZlbnRhbmRvIHNlbXByZSBwacO5IHBvcG9sYXJlPw==

2024-04-12, 09:56

<p><img src="https://gimg2.gateimg.com/image/article/1692587569kepu.jpeg" alt=""></p>
<h2 id="h2-TLDR583153"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>La popolarità di Degen Chain e di altri ha portato il Layer 3 nella visione delle persone, e l’emergere di questa tecnologia porterà una maggiore scalabilità e interoperabilità alle reti blockchain, fornendo soluzioni personalizzate per diversi scenari di applicazione.</p>
<p>Tra i casi d’uso emergenti del Layer 3, Arbitrum Orbit e Starknet hanno mostrato le prestazioni più eccezionali e potrebbero brillare in campi come Game e DeFi.</p>
<p>Se Layer 3 vuole fare una svolta, deve continuare a migliorare la propria tecnologia e cercare applicazioni di adozione su larga scala per supportare la sua svolta.</p>
<h2 id="h2-Introduzione808914"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il giorno prima del Pesce d’aprile di quest’anno, alcuni progetti di crittografia hanno approfittato dei temi del Livello 4 e Livello 5 per creare scherzi umoristici. Tra questi, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> Ha anche scherzato sul contenuto di “la nuova versione verrà costruita sopra L4”, il che ha persino indotto alcuni media a diffonderla come una notizia vera.</p>
<p>E questo scherzo è naturalmente basato sull’aumentare della popolarità del Livello 3. Per quanto riguarda il Livello 3, ciò di cui tutti sono generalmente interessati è se si tratti di una bambola russa inter-catenaria o di un’estensione personalizzata, e se abbia il potenziale per la scalabilità. Questo articolo si concentrerà su questa controversia per intrattenere i lettori.</p>
<h2 id="h2-Il20livello20320ha20guadagnato20popolarit20e20ha20scatenato20intensi20dibattiti20nella20comunit286120"><a name="Il livello 3 ha guadagnato popolarità e ha scatenato intensi dibattiti nella comunità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il livello 3 ha guadagnato popolarità e ha scatenato intensi dibattiti nella comunità</h2><p>Recentemente, la popolarità del Livello 3 è aumentata significativamente, attirando molta attenzione.</p>
<p>In particolare, la performance eccezionale dei token di Layer 3 come Degen Chain, come l’aumento a breve termine di oltre il 150% di DEGEN, e il massimo storico dei prezzi di GHST dopo la trasformazione di Aavegotchi in Base Series Layer 3, mettono ulteriormente in evidenza il potenziale di Layer 3.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17129156241.jpg" alt=""><br>Origine: degen.tips</p>
<p>Nella definizione tradizionale, Layer 2 è la rete di regolamento sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La mainnet e ha scalabilità. Il Layer 3, d’altra parte, è costruito sopra il Layer 2 e si basa su di esso per la liquidazione, fornendo una rete più scalabile.</p>
<p>Il concetto di Layer 3 è stato inizialmente proposto dal team di Starknet (allora StarkWare) nell’articolo “Fractal Scaling: From L2 to L3.” Nella visione di Starknet, la macchina virtuale di Livello 2 funge da strato di calcolo universale decentralizzato, mantenendo un alto grado di componibilità. Al contrario, il Livello 3 dovrebbe fungere da catena specifica dell’applicazione, soddisfacendo in modo flessibile le esigenze uniche delle varie applicazioni. La completezza di Turing fornisce una solida base per questa struttura gerarchica. In teoria, finché è presente la completezza di Turing, è possibile costruire qualsiasi possibile applicazione.</p>
<p>Lo sfondo per proporre questa idea è che Starknet ha sviluppato il linguaggio Cairo e la Cairo VM per generare prove in modo più efficiente, ma questi non erano pienamente compatibili con Ethereum. In questo momento, le catene di Livello 3 possono svolgere il loro ruolo e fornire le garanzie di sicurezza necessarie per queste applicazioni. Attraverso questo approccio, il Livello 3 è diventato un mezzo efficace per superare le limitazioni del Livello 2, promuovendo ulteriormente lo sviluppo della tecnologia blockchain.</p>
<p>Da un punto di vista tecnico, il Livello 3 supera le attuali soluzioni L1 e L2 ancorando le reti blockchain a L2, ottenendo una maggiore sicurezza e potenzialmente portando vantaggi di scalabilità esponenziale. Tuttavia, poiché sia il Livello 2 che il Livello 3 si basano sulla rete principale per il regolamento, i loro meccanismi di compressione e sincronizzazione dei dati sono diventati il focus della discussione.</p>
<p>Nel contesto del livello 2, i dati delle transazioni vengono confezionati, compressi e sincronizzati con la rete Ethereum. Allo stesso modo, il Livello 3 adotterà un meccanismo simile per comprimere e sincronizzare i suoi dati di transazione alla rete Livello 2.</p>
<p>Tuttavia, questo approccio, simile all’applicazione di Rollup nuovamente su Rollup, è stato messo in discussione e criticato. Poiché se continuiamo a immaginare reti di livello superiore come Layer 4 e Layer 5 con questa architettura, affronteremo il problema limite della compressione dei dati, poiché i dati non possono essere compressi continuamente all’infinito.</p>
<p>Ad esempio, alcune istituzioni come <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> I laboratori hanno esplicitamente dichiarato che non svilupperanno il Layer 3, mentre <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> deride persino le idee fantasiose del Layer 3 creando il Layer 4. Anche Vitalik ha recentemente dichiarato che il Layer 3 non migliora magicamente la potenza di elaborazione. Queste voci riflettono l’atteggiamento cauto dell’industria nei confronti della fattibilità e praticità della tecnologia del Layer 3.<img src="https://gimg2.gateimg.com/image/article/17129156642.jpg" alt=""><br>Origine: @VitalikButerin</p>
<h2 id="h2-Inventario20di20quei20progetti20di20istanza20di20livello203968417"><a name="Inventario di quei progetti di istanza di livello 3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inventario di quei progetti di istanza di livello 3</h2><p>Il Livello 3 mira ad affrontare i problemi di interoperabilità tra le blockchain e soddisfare le esigenze personalizzate degli sviluppatori, rendendo facile per il pubblico utilizzare e implementare, compresi i meccanismi di governance, le regole e le funzioni. Attraverso il trattamento off-chain delle transazioni, il Livello 3 può ulteriormente ridurre la congestione di rete e i costi delle transazioni basati sul Livello 2, migliorando l’efficienza dei costi.</p>
<p>Attualmente, tra i casi d’uso emergenti di Layer 3, Arbitrum Orbit e Starknet hanno mostrato le performance più eccezionali e potrebbero brillare in campi come Giochi e DeFi.</p>
<h3 id="h3-Arbitrum20Orbit634955"><a name="Arbitrum Orbit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arbitrum Orbit</h3><p>Nel 2023, la Fondazione Arbitrum ha lanciato una nuova funzionalità - Arbitrum Orbit, una blockchain di livello 3 costruita sulla piattaforma Arbitrum Nitro. Oltre a fornire costi di transazione più bassi e maggiore scalabilità, Arbitrum Orbit consente agli sviluppatori di creare blockchain dedicate autogestite su Arbitrum Nitro.</p>
<h3 id="h3-Stack20Starknet438451"><a name="Stack Starknet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stack Starknet</h3><p>In contrasto con il semplice metodo di impilamento, Starknet assegna diverse responsabilità a L2 e L3 nel nuovo framework L3. Sottolinea che L3 dovrebbe concentrarsi sulla fornitura di funzionalità personalizzate come la protezione della privacy o l’ottimizzazione specifica dell’applicazione anziché perseguire semplicemente la scalabilità.<br><img src="https://gimg2.gateimg.com/image/article/17129157033.jpg" alt=""><br>Origine: Starknet</p>
<p>A febbraio di quest’anno, Starknet ha annunciato ufficialmente una partnership con Celestia per costruire congiuntamente una rete Layer 3 ad alta velocità. Tuttavia, dato che Starknet utilizza una tecnologia unica di prova zk STARK, attualmente ancora relativamente immatura, ci vorrà ancora del tempo prima che Starknet Stack venga lanciato.</p>
<h3 id="h3-Orbs96485"><a name="Orbs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Orbs</h3><p>Orbs, come una nuova blockchain di Layer 3, mira a risolvere i problemi di scalabilità di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e lavorare in collaborazione con i protocolli esistenti di Layer 1 e Layer 2.</p>
<p>Orbs Layer 3 è un livello di “esecuzione avanzata” che consente agli sviluppatori di eseguire e sviluppare contratti intelligenti su un server cloud decentralizzato. Ciò significa che gli sviluppatori possono concentrarsi sulla scrittura e l’implementazione di contratti intelligenti senza preoccuparsi dell’infrastruttura di rete sottostante o della manutenzione dei server fisici.</p>
<p>Attualmente, Orbs supporta l’utilizzo di molteplici protocolli di Layer 1 e Layer 2 come Ethereum, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, Polygon, ecc.</p>
<h3 id="h3-zkSync20Hyperchains296319"><a name="zkSync Hyperchains" class="reference-link"></a><span class="header-link octicon octicon-link"></span>zkSync Hyperchains</h3><p>Un’altra tecnologia degna di nota è la zkSync Hyperchains lanciata dal team zkSync, che può essere considerata come Layer 3 e utilizzata per il regolamento tramite Layer 2.</p>
<p>Queste Hyperchain sono guidate dallo stesso motore zkEVM sullo ZK Stack, garantendo coerenza in tutti i circuiti ZKP sulla piattaforma e ereditando la sicurezza del Layer 1.</p>
<p>Un vantaggio significativo di questa architettura è che consente un passaggio più rapido dei messaggi tra il livello 3 stabilito sullo stesso livello 2 e promuove l’interoperabilità in un ecosistema più ampio.</p>
<h2 id="h2-Per20riassumere453635"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h2><p>Il Livello 3 risolve principalmente la scalabilità, il supporto di dApp complesse, l’interoperabilità blockchain, la personalizzazione, l’alta redditività e l’accessibilità blockchain.</p>
<p>Non solo migliora la scalabilità della blockchain e supporta lo sviluppo di dApp complesse, ma funge anche da ponte tra diverse blockchain, raggiungendo la compatibilità tra piattaforme. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> di transazioni e dati. Nel frattempo, il Layer 3 consente la personalizzazione in base alle esigenze degli sviluppatori, riducendo i costi delle transazioni, migliorando la redditività e rendendo la tecnologia blockchain più accessibile al pubblico.</p>
<p>Tuttavia, dall’evoluzione della tecnologia di crittografia, il Livello 3 non può raggiungere salti di prestazioni solo attraverso una semplice sovrapposizione. Anche se la personalizzazione può portare vantaggi specifici, la perdita di universalità limita la fattibilità della sua sovrapposizione.<img src="https://gimg2.gateimg.com/image/article/17129157504.jpg" alt=""><br>Origine: LK Venture</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl 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 suggerimenti 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></div>