TGEgdGVuZGVuemEgZGVpIEwyIFN0YWNrcyDDqCBpbiBjcmVzY2l0YSwgY2hpIHZpbmNlcsOgIHRyYSBBUkIgZSBPUD8=

2023-09-12, 03:01
<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-Cos20uno20stack20software343216"><a name="Cos’è uno stack software?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è uno stack software?</h2><p>L’applicazione blockchain sta entrando nell’era del Rollup, e il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La mainnet sta gradualmente diventando un ruolo centrale responsabile della sicurezza del sistema e del livello di regolamento finale. Di fronte a una situazione di alto Gas, basso TPS e bassa libertà di programmazione, gli sviluppatori <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> dovranno affrontare le seguenti soluzioni:</p>
<p>-Alla ricerca di altri concorrenti elevati e L1 sicuro<br>-Migrazione a L2 con maggiore scalabilità<br>-Alla ricerca di soluzioni Stack L3 personalizzabili</p>
<p>La prima soluzione sembrava fattibile nella precedente fase di guerra delle catene pubbliche, ma con la crescita di L2, il traffico migrerà a L2. Tuttavia, la seconda soluzione continua a porre gli sviluppatori in una dipendenza da specifici ecosistemi. Pertanto, utilizzando L2 <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> creare soluzioni scalabili e personalizzabili diventerà una opzione importante per gli sviluppatori.</p>
<p>La società madre di StarkNet, StarkWare, ha proposto per la prima volta L3 già alla fine del 2021, che si riferisce a una gerarchia altamente scalabile costruita su L2. Possiamo comprendere che si tratti di aggiungere un potenziamento su L2, che teoricamente eredita la sicurezza della rete principale di Ethereum, pur avendo anche un’efficace interoperabilità tra le catene e costi di interazione inferiori rispetto a L2.</p>
<p>Sebbene il settore non abbia ancora fornito una definizione chiara di L3, non si può negare che il SuperChain di OP Stacks, L3 di Arbitrum Orbit e Hyperchain e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> I CDK di zkSync hanno scatenato una guerra di software stack basata sull’architettura L3.<br><img src="https://gimg2.gateimg.com/image/article/16944875248931694487448_.pic.jpg" alt=""><br>Fonte da: Twitter@ <a href="/price/0x-zrx" rel="nofollow noopener noreferrer" target="_blank">0x</a> Ning 0x</p>
<h2 id="h2-OP20Stack20Adozione20istituzionale20e20prosperit20dellecosistema508754"><a name="OP Stack: Adozione istituzionale e prosperità dell’ecosistema" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OP Stack: Adozione istituzionale e prosperità dell’ecosistema</h2><p>Già nell’ottobre 2022, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> ha proposto il concetto di OP Stack. Fornisce ai programmatori componenti di modulo open source standardizzati, consentendo loro di costruire blockchain L2 con le loro esigenze specifiche su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> senza una licenza utilizzando Optimistic Rollups.</p>
<p>Lo stack OP è composto da quattro componenti principali:</p>
<p>Uno è il mainnet. OP Mainnet è una rete Layer2 Ethereum economica e veloce compatibile con la macchina virtuale Ethereum EVM.</p>
<p>Il secondo è il contratto. Un contratto intelligente che implementa la logica centrale e le funzioni dello Stack OP. I contratti OP includono i Sistemi di Transizione di Stato (STS), i Provers di Frode (FP), le Catene di Impegno di Stato (SCC) e le Catene di Transazioni Canoniche (CTC).</p>
<p>Il terzo è il servizio. Può fornire disponibilità dei dati, sincronizzazione dei dati e servizi di comunicazione tra Layer1 e Layer2.</p>
<p>Il quarto sono gli strumenti. Utilizzato per promuovere lo sviluppo, il test, l’implementazione, il monitoraggio e il debug della blockchain basata su OP Stack.</p>
<p>In poche parole, OP Stack consente agli sviluppatori di costruire facilmente ed efficacemente la propria blockchain per soddisfare le esigenze di scenari specifici. OP Stack è progettato per migliorare l’interoperabilità all’interno della comunità Ethereum, segnando la fase iniziale di rapida crescita in Layer2 e Layer3 altamente compatibili, collettivamente definiti come op-chains nell’ecosistema di Optimism.</p>
<p>Secondo il punto di vista ufficiale di OP, il confine tra le op-chains scomparirà, formando una Superchain unificata (Superchain). Superchain è una rete decentralizzata composta da catene OP, che integra in modo trasparente più catene operative per condividere sicurezza, livello di comunicazione e stack tecnologico open source (stack OP).<br><img src="https://gimg2.gateimg.com/image/article/16944875788941694487491_.pic.jpg" alt=""><br>Fonte da: internet</p>
<p>Grazie all’architettura modulare altamente aperta alle sorgenti e ai vantaggi dell’adozione istituzionale del lato B, OP Stack è molto avanti per quanto riguarda la libertà, l’apertura e la prosperità ecologica. La TVL on-chain costruita utilizzando OP Stack ha accumulato quasi 3 miliardi di dollari.</p>
<p>Ad esempio, la Base Chain lanciata da Coinbase, la Rete Zora focalizzata sul protocollo NFT, la piattaforma di trading di opzioni decentralizzata Aevo e la Rete di Beni Pubblici sviluppata da <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> sono tutti stati implementati e lanciati basati su OP Stack. Inoltre, la catena L2 di BNBd, opBNB, blockchain verde <a href="/price/celo-celo" rel="nofollow noopener noreferrer" target="_blank">Celo</a>, e la piattaforma di trading decentralizzata UniDex Exchange sono anche in fase di costruzione e test basati su OP Stack.</p>
<h2 id="h2-Arbitrum20Orbit20Nuovo20Dominatore20del20Game20Track2428"><a name="Arbitrum Orbit: Nuovo Dominatore del Game Track" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arbitrum Orbit: Nuovo Dominatore del Game Track</h2><p>Arbitum Orbit è uno dei quattro prodotti principali di Arbitum ed è una soluzione scalabile basata sul livello di regolamento Arbitum Rollup lanciato dalla Fondazione Arbitum a marzo di quest’anno.</p>
<p>Il dilemma di ARB è che, anche se ha lanciato lo stack Orbiter L3, che compete con lo stack OP, oltre alla forte base L2 dell’Orbitrum one business data e all’Orbitrum nova ad alte prestazioni, non ci sono molti progetti di grandi dimensioni disposti a definirsi come L3 e utilizzare l’Orbitrum one come loro livello DA durante la fase di fioritura di L2. I progetti con buone risorse industriali (utenti, sviluppatori, contenuti IP) tendono spesso a costruire L2, il che significa un soffitto di valutazione più alto e un’orientamento utente più ampio.</p>
<p>Gli sviluppatori possono costruire catene di applicazioni esclusive basate sulle catene Arbitum L2 esistenti (One, Nova, Test Goerli), con scelte flessibili nei meccanismi di consenso, nelle modalità di governance, nei token di commissioni, nella privacy, ecc. Rispetto a OP Stack, offre agli sviluppatori modelli economici altamente autonomi e altre opzioni.<br><img src="https://gimg2.gateimg.com/image/article/16944876198951694487505_.pic.jpg" alt=""><br>Fonte da: Materiali pubblici su Internet</p>
<p>Recentemente, Sanko GameCorp, Layer 3 blockchain Xai e altri focalizzati sul gioco, sono diventati i primi partner di Arbitrum Orbit. Anche il progetto di espansione Ethereum AltLayer ha annunciato il supporto per il Layer 3 blockchain Arbitrum Orbit. Syndr, una piattaforma di trading di derivati, ha annunciato il lancio di un testnet basato su Arbitrum Orbit, diventando il primo protocollo DeFi dell’ecosistema Chain di Arbitrum Orbit.</p>
<p>Arbitrum, che domina i settori sociali e del gioco, non ha un layout più lento rispetto a OP Stack nella catena Orbit, ma ha anche i suoi problemi. Il livello di dati disponibile di Arbitrum Orbit è limitato ad Arbitrum One, e l’uso commerciale richiede l’approvazione dalla Fondazione Arbitrum o DAO. La catena Orbit di Arbitrum non è una rete blockchain completamente isolata, e le funzioni di interoperabilità non sono ancora state aperte, non è così amichevole e aperta per gli sviluppatori come OP Stack.</p>
<h2 id="h2-Conclusion3304"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La competizione per i componenti modulari del lancio a catena “One Click Chain Launch” è appena iniziata. OP Stack, grazie ai suoi vantaggi nell’intervento precoce e nelle comunità di collaborazione istituzionale, ha occupato una grande quota di mercato, classificandosi al primo posto in termini di libertà ecologica, prosperità e dimensioni. Tuttavia, l’Orbitrum Orbit è altamente personalizzabile e particolarmente adatto per casi d’uso ad alta capacità come giochi e social media. Con il suo enorme effetto di rete L2, potrebbe sbloccare più nuovi gameplay.</p>
<p>Nel frattempo, soluzioni alternative come <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> CDK, che eccelle nel marketing e nell’integrazione delle risorse, e ZK Stack, che si concentra sull’efficienza e la sicurezza, si sono gradualmente unite al campo di battaglia. Non è chiaro chi vinca o perda. Tuttavia, L2 Stack, che mantiene continuamente l’innovazione e l’iterazione, l’apertura e la trasparenza e aderisce alla decentralizzazione, guadagnerà un vantaggio competitivo sostenibile. Se la prosperità dell’ecosistema può potenziare i token di governance esistenti, è ancora necessaria un’osservazione a lungo termine.</p>
<p>Scopri di più su Web3: <a href="https://www.gate.io/web3" target="_blank">https://www.gate.io/web3</a></p>
<div class="blog-details-info"><br><div>Autore:<strong>Peter L.</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.<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 a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards