SWwgZm9uZGF0b3JlIGRpIFNvbGFuYSBzb3N0aWVuZSB1bmEgc2FuYSByaXZhbGl0w6AgY29uIEV0aGVyZXVt

2023-12-25, 07:54

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR34353"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Diversi <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Le dApps basate hanno integrato con il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain che mostra l’essenza dell’interoperabilità piuttosto che la competizione.</p>
<p>Il prezzo di Sol è aumentato di oltre il 600% solo nel 2023.</p>
<p>L’aggiornamento della blockchain di Ethereum, danksharding, probabilmente aumenterà la sua collaborazione con altre blockchain come Solana.</p>
<h2 id="h2-Introduzione683182"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La concorrenza è un aspetto comune in diversi settori dell’economia, con la maggior parte delle aziende che mirano ad avere vantaggi competitivi rispetto ai loro rivali. Di solito, le imprese competono per avere grandi quote di mercato, generando così molte entrate per sostenere le proprie operazioni. La stessa situazione esiste nel settore delle blockchain, dove vari progetti di criptovalute lottano per superare gli altri.</p>
<p>Diverse blockchain come Solana, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>, <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> catena intelligente e <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Sono stati soprannominati killer di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> perché competono con quella blockchain. Tuttavia, il fondatore di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> mette in discussione l’idea che Solana debba essere un killer di Ethereum.</p>
<p>In questa analisi ci concentreremo sulla percezione del fondatore di Solana, Anatoly Yakovenko, che <a href="https://www.gate.io/learn/articles/whatissolana/43" target="_blank">Solana dovrebbe lavorare insieme</a> altri blockchain come Ethereum, piuttosto che essere il loro concorrente.</p>
<h2 id="h2-Solana20vs20Ethereum20Il20successo20di20Solana2020indipendente20da20Ethereum213728"><a name="Solana vs. Ethereum: Il successo di Solana è indipendente da Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana vs. Ethereum: Il successo di Solana è indipendente da Ethereum</h2><p>Yakovenko è contrario alla narrazione secondo cui la blockchain di Solana è un killer di Ethereum, una dichiarazione che implica che la blockchain mira a superare Ethereum e a farlo uscire dal mercato.</p>
<p>Il CEO di Solana ritiene che invece di sostituire Ethereum, altre blockchain come Solana dovrebbero utilizzare la loro tecnologia per coesistere con la piattaforma di contratti intelligenti numero uno al mondo. Ha recentemente affermato di non percepire un futuro blockchain in cui Solana prospererà mentre Ethereum “morirà”.</p>
<p><a href="https://iq.wiki/wiki/anatoly-yakovenko#cite-id-1lzefa5rwi4" rel="nofollow noopener noreferrer" target="_blank">Yakovenko ha detto</a>“Non riproponete l’ultimo ‘killer eth’ del ciclo. È banale. Le tecnologie a efficienza di Pareto possono avere funzionalità sovrapposte e competere, ma va tutto bene. Non vedo un futuro in cui Solana prospera e in qualche modo eth muore.”</p>
<p>Il fondatore di Solana prevede un futuro in cui entrambe le blockchain prosperano. Tuttavia, affinché ciò accada, le loro tecnologie dovrebbero evolversi e scalare per soddisfare le esigenze emergenti. Per lui, la concorrenza indica la natura dinamica del settore delle blockchain. Pertanto, affinché le blockchain coesistano, dovrebbero creare innovazioni adatte.</p>
<h2 id="h2-Il20blockchain20di20Solana20e20il20futuro20multichain4057"><a name="Il blockchain di Solana e il futuro multi-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il blockchain di Solana e il futuro multi-chain</h2><p>Yakovenko ha affermato che l’interoperabilità offre un futuro migliore per gli sviluppatori e i costruttori di web3. Pertanto, gli aggiornamenti futuri di Ethereum che includono danksharding creeranno una migliore opportunità per le due blockchain di interagire.</p>
<p>A questo <a href="https://iq.wiki/wiki/ethereum" rel="nofollow noopener noreferrer" target="_blank">Yakovenko ha detto</a>“Sono certo che alla fine danksharding avrà abbastanza larghezza di banda per tutti i dati di Solana.” Fin dal suo inizio, Ethereum si è comportato molto bene nei suoi prodotti DeFi e NFT, il che dimostra l’importanza della cooperazione tra Solana ed Ethereum piuttosto che una competizione diretta.</p>
<h2 id="h2-La20compatibilit20di20Solana20convivere20con20altre20blockchain25154"><a name="La compatibilità di Solana: convivere con altre blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La compatibilità di Solana: convivere con altre blockchain</h2><p>Ci sono diverse piattaforme che esistono <a href="https://www.gate.io/learn/articles/a-deep-dive-on-solana-a-high-performance-blockchain-network/914" target="_blank">sulla blockchain Solana</a> come NeonEVM che hanno funzionalità che permettono loro di sovrapporsi alla blockchain di Ethereum.</p>
<p>In effetti, NeonEVM, lanciato nel 2023, può portare la potenza di elaborazione di Solana sulla blockchain di Ethereum, offrendo agli sviluppatori di applicazioni decentralizzate (dApp) l’opportunità di trarre vantaggio dai due protocolli, migliorando l’interoperabilità. Con tale sviluppo, la tecnologia blockchain può offrire soluzioni diverse ai problemi che incontrano diversi smart contract come dApp.</p>
<p>Attualmente, ci sono diverse dApps di Solana che hanno adottato l’integrazione multichain per accedere a molti utenti, in particolare creatori e collezionisti di NFT. Ad esempio, ExchangeArt, un mercato di arte digitale, e Aurory, una franchigia di giochi, hanno integrato il supporto per Arbitrum ed Ethereum.</p>
<p>Quindi, i contratti intelligenti di Aurory e ExchangeArt possono comunicare con Ethereum. Alla fine, le dApps basate su Solana che si integrano con la blockchain di Ethereum possono offrire ai loro utenti una maggiore esposizione ad altri prodotti come l’esperienza di gioco.</p>
<p>Aurory e ExchangeArt non sono le uniche applicazioni decentralizzate basate su Solana ad integrarsi con Ethereum. Nel dicembre 2022, DeGods e y00ts hanno annunciato di integrarsi con Ethereum e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Tali mosse mostrano un futuro multi-chain in cui Solana ed Ethereum possono coesistere.</p>
<h2 id="h2-La20notevole20performance20di20Solana20aumenta20quasi20del2060020da20inizio20anno20superando20le20altre20principali20criptovalute273583"><a name="La notevole performance di Solana: aumenta quasi del 600% da inizio anno, superando le altre principali criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La notevole performance di Solana: aumenta quasi del 600% da inizio anno, superando le altre principali criptovalute</h2><p>Il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">crypto Solana</a> ha avuto un’ottima performance, aumentando del 600% soltanto quest’anno, impresa raggiunta da poche criptovalute. In sostanza, SOL ha sfidato le aspettative di alcuni analisti che prevedevano che avrebbe ottenuto risultati inferiori dopo il crollo dello scambio FTX. Il motivo è che FTX e la sua azienda controllata Alameda Research detengono grandi quantità della criptovaluta Solana.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1346/exploring-solanas-nfts-marketplace-magic-eden" target="_blank">Esplorare il Marketplace NFT di Solana: Magic Eden</a></p>
<p>L’ultimo impennata nell’attività della blockchain di Solana e il suo aggiornamento tecnologico hanno spinto il suo valore al rialzo. Al momento della stesura, il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Solana</a> è di $ 78,26 dopo aver raggiunto un aumento del 7% nelle ultime 24 ore.<br><img src="https://gimg2.gateimg.com/image/article/1703490772img_v3_026f_4e00ac2c-941f-428d-bb77-4fc8527e06ix.jpg" alt=""><br>Aumento del prezzo di Sol - Solana</p>
<p>Come mostra il diagramma, il <a href="https://www.gate.io/blog_detail/3500" target="_blank">Il prezzo di SOL è in un trend al rialzo</a> dopo aver superato il livello chiave di resistenza di $71. Attualmente, il prezzo di SOL si sta dirigendo verso il livello di $80, il che potrebbe dargli slancio per salire sopra i $90. Gli investitori di criptovalute che hanno messo i loro fondi nella criptovaluta Solana all’inizio dell’anno hanno guadagnato molto.</p>
<p>Anche il prezzo dell’ETH è aumentato durante l’anno. Solo a dicembre, il valore dell’ETH è aumentato dell’8% e sta mostrando una traiettoria ascendente sostenuta come mostra il prossimo grafico.<br><img src="https://gimg2.gateimg.com/image/article/1703490806img_v3_026f_350f64a6-3291-4c63-a98a-896821e974ix.jpg" alt=""><br>Aumento del prezzo di ETH - CoinDCX</p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> indica che il prezzo di ETH è aumentato significativamente da metà ottobre 2023. ETH, attualmente scambiato a $2.266,39, sta ora puntando a $2.350, che coincide con il livello R3 del punto di inversione di Fibonacci. Tuttavia, a confronto, il prezzo di Solana ha avuto una performance migliore di ETH quest’anno.</p>
<h2 id="h2-Conclusion136323"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Anatoly Yakovenko ha invitato il settore crypto a smettere di considerare Solana come un killer di Ethereum. Questo perché c’è spazio per la coesistenza e la condivisione di servizi vitali tra le due blockchain. Per il CEO di Solana, non c’è modo in cui la blockchain di Solana prospererà mentre quella di Ethereum “morirà”. Nel frattempo, il <a href="https://www.gate.io/how-to-buy/solana-sol" target="_blank">Il prezzo di Solana è aumentato di oltre il 600%</a> dal inizio del 2023.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, Ricercatore di 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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>