TGUgdHJhbnNhemlvbmkgZ2lvcm5hbGllcmUgZGkgTGF5ZXIgMiBkaSBPcHRpbWlzbSBzdXBlcmFubyBxdWVsbGUgZGkgQXJiaXRydW0=

2023-08-08, 07:52

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-Introduzione339492"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> e Arbitrum sono le due principali blockchain di livello 2 basate sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> network. I due forniscono una soluzione di scalabilità alla blockchain di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> poiché ha una capacità transazionale limitata. C’è stata molta comparazione tra i due utilizzando la loro attività di rete. Questa analisi confronta le attuali prestazioni di Ottimismo <a href="https://www.gate.io/learn/articles/a-deep-dive-into-arbitrum/487" target="_blank">e Arbitrum</a>.</p>
<h2 id="h2-Lottimismo20supera20Arbitrum689910"><a name="L’ottimismo supera Arbitrum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ottimismo supera Arbitrum</h2><p>I dati on-chain mostrano che le transazioni giornaliere di <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> hanno superato quelle di Arbitrum nell’ultima settimana di luglio. Il mercato deve ancora scoprire se questa tendenza continuerà in futuro. Il 27 luglio Artemis, una piattaforma di analisi blockchain, ha pubblicato dati che indicano che Optimism ha registrato un volume di transazioni superiore ad Arbitrum durante l’ultima settimana di luglio.</p>
<p>È importante notare che sia Optimism che Arbitrum utilizzano la tecnologia di rollup ottimistico per comprimere e raggruppare le transazioni in batch prima di inviarle alla mainnet di Ethereum, una mossa che ha contribuito a ridurre la congestione e diminuire le commissioni gas sulla rete.</p>
<p>Secondo Artemis, entrambe le blockchain di livello 2 hanno avuto livelli simili di attività transazionale tra agosto e dicembre 2022. Tuttavia, a dicembre Optimism ha registrato un aumento <a href="https://www.gate.io/learn/articles/what-is-arbitrum/204" target="_blank">volume di transazioni rispetto ad Arbitrum</a> ma è stato di breve durata. Nel gennaio 2023, Arbitrum ha superato di nuovo Optimism in termini di transazioni giornaliere.</p>
<p>Secondo Artemis, il volume delle transazioni di Optimism ha superato quello di Arbitrum a dicembre a causa della sua funzione “quest” utilizzata per ricompensare gli utenti per varie attività svolte sulla blockchain.</p>
<p>In una svolta degli eventi, Arbitrum ha registrato un volume superiore rispetto a Optimism a marzo quando <a href="https://www.gate.io/blog_detail/1065/tgf5zxigmibqcm9qzwn0ifrvdxi6iehvdyb0bybqcmvwyxjligzvcibbcmjpdhj1bsbbaxjkcm9w" target="_blank">ha lanciato il suo airdrop</a>. Il grafico seguente riassume le prestazioni delle due blockchain tra luglio 2022 e luglio 2023.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/optimism-op" target="_blank">OP Previsione del prezzo e previsione per il 2023, 2025, 2030</a><img src="https://gimg2.gateimg.com/image/article/16914810291.png" alt=""><br>Transazioni giornaliere per Optimism e Arbitrum - Artemis</p>
<p>Come osservato nel diagramma, Arbitrum ha avuto transazioni giornaliere più alte di Optimism tra gennaio e luglio di quest’anno. Tuttavia, pochi giorni prima della fine di luglio, le transazioni giornaliere di Optimism hanno superato quelle di Arbitrum.</p>
<h2 id="h2-Motivi20per20limpennata20delle20transazioni20giornaliere20su20Optimism695198"><a name="Motivi per l’impennata delle transazioni giornaliere su Optimism" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivi per l’impennata delle transazioni giornaliere su Optimism</h2><p>Ci sono diverse ragioni per cui la transazione giornaliera di Optimism ha superato quella di Arbitrum. In primo luogo, a giugno Optimism ha lanciato il suo Bedrock Upgrade come misura per abbassare le sue commissioni di transazione. Quell’aggiornamento ha portato a un aumento del 67% delle sue transazioni, anche se non è stato sufficiente a superare quelle di Arbitrum.</p>
<p>Inoltre, tra il 23 e il 26 luglio il volume delle transazioni su Optimism è aumentato del 65%, passando da 490.500 a 809.070, superando Arbitrum. Il lancio di Worldcoin, una criptovaluta legata a Sam Altman, creatore di ChatGPT e co-fondatore di OpenAI, su Optimism il 25 luglio ha ulteriormente aumentato l’attività della sua rete.</p>
<p>In effetti, dal momento in cui gli sviluppatori di Worldcoin hanno introdotto gli account utente su Optimism all’inizio di giugno, si è registrato un notevole aumento dell’attività. Ad esempio, il 1° giugno le transazioni giornaliere sono aumentate di circa il 240%, passando da 277.000 a 944.000. Al contrario, le transazioni giornaliere su Arbitrum sono diminuite da 745.000 a 660.000 nello stesso periodo.</p>
<p>Non c’è dubbio che il lancio di Worldcoin su Optimism abbia cambiato la scala a suo favore. Il grafico seguente mostra l’aumento dei portafogli di WorldApp.<br><img src="https://gimg2.gateimg.com/image/article/16914810612.png" alt=""><br>Portafogli WorldApp- Dune</p>
<p>Come mostra il diagramma, c’è stato un aumento astronomico nel numero di detentori di Worldcoin. Al momento della stesura, ci sono 1.100.857 portafogli che detengono Worldcoin. È essenziale notare che la maggior parte di questi utenti si è trasferita a Optimism.</p>
<p>Un altro fattore che potrebbe aver influenzato positivamente le metriche di Optimism è l’atteso lancio della rete Base di Coinbase, che i developer hanno detto che sarà collegata ad Optimism. Ciò potrebbe aver contribuito ad aumentare la fiducia degli investitori nel… <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Cripto di ottimismo</a>.</p>
<p>Sono state apportate anche diverse modifiche alle statistiche di Optimism. Ad esempio, l’aumento delle transazioni giornaliere è stato accompagnato da un aumento delle commissioni di transazione e dei ricavi. Inoltre, secondo Santiment, c’è stato anche un aumento dell’attività delle balene su Optimism. Tuttavia, l’attività delle balene su Arbitrum è diminuita.</p>
<p>Tuttavia, la dominanza sociale del token Arbitrum (ARB) e di Optimism (OP) è rimasta elevata durante quel periodo. Tale dominanza mostra che entrambe le criptovalute sono ancora popolari nel mercato cripto.</p>
<p>Sebbene le statistiche sopra sembrino indicare che Optimism abbia superato Arbitrum sotto tutti gli aspetti, non è così. Arbitrum ha guidato in alcuni aspetti. Ad esempio, Arbitrum aveva un valore totale bloccato superiore rispetto a Optimism.</p>
<p>Secondo DeFiLlama, Arbitrum ha avuto un valore totale bloccato di 5,9 miliardi, con una quota di mercato del 57,8%, nonostante una recente diminuzione. D’altra parte, Optimism ha raggiunto un valore totale bloccato di $2,8 miliardi, il più alto di sempre, dopo aver registrato un aumento del 30% rispetto a quello di giugno.</p>
<p>Entro quel momento, aveva una quota di mercato del 27,3%. Inoltre, i dati on-chain mostrano che Arbitrum aveva più utenti attivi giornalieri rispetto a Optimism dal momento che ne aveva 123.000 rispetto ai 89.000 di Optimism. È anche importante notare che l’attività totale in queste due blockchain L2 rappresenta l’85% dell’intero ecosistema Ethereum L2.</p>
<h2 id="h2-Prospettive20del20mercato20dei20token20OP20e20Arbitrum932680"><a name="Prospettive del mercato dei token OP e Arbitrum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive del mercato dei token OP e Arbitrum</h2><p>Al momento della scrittura, il <a href="https://www.gate.io/price/arbitrum-arb" target="_blank">Prezzo ARB</a> è di $1,14, avendo perso lo 0,71% e il 3,40% nelle ultime 24 ore e 7 giorni rispettivamente. Ancora una volta, questo token, con un’offerta circolante di 1,3 miliardi e una capitalizzazione di mercato di $1.447.076.710, ha un volume di scambio di 24 ore di $112.736.709.</p>
<p>D’altra parte, il <a href="https://www.gate.io/price/optimism-op" target="_blank">Prezzo dell’ottimismo</a> è $1.69 dopo aver guadagnato l’1,58% e il 6,39% rispettivamente nelle ultime 24 ore e 7 giorni. Ha un’offerta circolante di 720 milioni, una capitalizzazione di mercato di $1,209,553,877 e un volume di scambi di 24 ore di $90,792,622.09.</p>
<h2 id="h2-Dove20acquistare20OP20e20ARB212029"><a name="Dove acquistare OP e ARB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove acquistare OP e ARB</h2><p>Puoi acquistare i token OP e ARB su importanti borse criptovalute, tra cui Gate.io, nota per i suoi elevati standard di sicurezza ed efficienza. Per iniziare a fare trading di OP <a href="https://www.gate.io/uk/price-prediction/arbitrum-arb" target="_blank">e ARB su Gate.io</a> dovresti avere un account verificato. Puoi anche convertire qualsiasi criptovaluta principale come ETH, USDT o BTC che possiedi nel tuo account Gate.io in OP e ARB.</p>
<h2 id="h2-Conclusione84301"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Recentemente, Optimism ha superato Arbitrum in vari indicatori come le transazioni giornaliere. Tuttavia, Arbitrum rimane il leader in termini di valore totale bloccato. Le due blockchain Ethereum L2 rappresentano l’85% dell’intero ecosistema L2. Il prezzo attuale mostra che OP ha guadagnato mentre il token ARB ha perso valore nelle ultime 24 ore. Singoli individui e istituzioni possono acquistare ARB e OP sulla piattaforma di scambio centralizzata Gate.io.</p>
<h2 id="h2-Domande20frequenti20su20blockchain20di20livello20220Optimism20e20Arbitrum21209"><a name="Domande frequenti su blockchain di livello 2 Optimism e Arbitrum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su blockchain di livello 2 Optimism e Arbitrum</h2><h3 id="h3-Cos20la20moneta20Optimism790900"><a name="Cos’è la moneta Optimism?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la moneta Optimism?</h3><p>Optimism coin è la criptovaluta nativa per la blockchain layer-2 Optimism che esiste sulla blockchain di Ethereum. La blockchain Optimism offre una soluzione di scalabilità alla rete Ethereum.</p>
<h3 id="h3-Cos20Arbitrum752035"><a name="Cos’è Arbitrum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Arbitrum?</h3><p>Arbitrum è una blockchain di livello 2 che esiste sulla blockchain Ethereum. La funzione principale di Arbitrum è fornire una soluzione di scalabilità alla blockchain Ethereum che aiuta a ridurre la congestione e le commissioni di transazione.</p>
<h3 id="h3-Quali20sono20le20somiglianze20e20le20differenze20tra20Optimism20e20Arbitrum103582"><a name="Quali sono le somiglianze e le differenze tra Optimism e Arbitrum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono le somiglianze e le differenze tra Optimism e Arbitrum?</h3><p>Sia Optimism che Arbitrum sono blockchain di livello 2 che offrono soluzioni di scalabilità alla blockchain Ethereum. Entrambi utilizzano rollup per elaborare le transazioni off-chain e raggrupparle prima di trasmetterle alla mainnet di Ethereum. La principale differenza tra di loro è che Optimism utilizza prove a singolo round mentre Arbitrum utilizza prove a multi-round.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Gate.io Ricercatore<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 ripubblicare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>