SWwgVFZMIGRpIFNvbGFuYSByYWdnaXVuZ2UgdW4gbnVvdm8gcGljY28gYW5udWFsZQ==

2023-11-09, 06:20

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR685888"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 22 ottobre <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha raggiunto un nuovo massimo annuale di TVL di $350 milioni.</p>
<p>Mentre il TVL di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> è aumentato a ottobre, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e il valore totale bloccato di Binance Smart Chain è diminuito.</p>
<p>Entro la fine dell’anno il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Solana</a> potrebbe oscillare tra $34 e $38.</p>
<h2 id="h2-Introduzione651847"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molte criptovalute hanno avuto una performance migliore rispetto al passato durante ottobre a seguito delle aspettative del mercato sull’approvazione da parte della SEC dello spot. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fondi negoziati in borsa (ETF). XTZ, ADA, AVAX, TRX e Solana sono esempi di altcoin che hanno ottenuto risultati notevoli.</p>
<p>Il recente rally di Solana gli ha permesso di diventare la settima criptovaluta per capitalizzazione di mercato, superando <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> e <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> nel processo.</p>
<p>Il post di oggi valuta le performance del prezzo di Solana e le ragioni dietro il rally. Confronteremo anche l’attività della blockchain di Solana con i suoi principali concorrenti, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e BSC Chain.</p>
<h2 id="h2-Il20valore20totale20bloccato20TVL20di20Solana20raggiunge20un20nuovo20massimo20annuale224569"><a name="Il valore totale bloccato (TVL) di Solana raggiunge un nuovo massimo annuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il valore totale bloccato (TVL) di Solana raggiunge un nuovo massimo annuale</h2><p>La blockchain Solana ha raggiunto un nuovo massimo annuale di TVL di $350 milioni sullo sfondo di una forte performance dei prezzi nelle ultime settimane. Secondo i dati disponibili su Defillama, l’aggregatore di dati criptovalutari, il TVL di Solana ha raggiunto i $350 il 22 ottobre.</p>
<p>La crescita di Solana di circa $20 milioni, che rappresenta un aumento del 12,2% nel periodo di 24 ore che va dal 21 al 22 ottobre, ha determinato l’aumento del TVL. La notevole performance del prezzo di Solana gli ha permesso di essere uno dei migliori performer durante quel periodo. Il grafico seguente riassume le statistiche di crescita di Solana.<br><img src="https://gimg2.gateimg.com/image/article/169951037613721699510298_.pic.jpg" alt=""><br>Solana DeFi TVL - DeFillama</p>
<p>La crescita della blockchain Solana, indicata nel diagramma sopra, non è stata uno sviluppo isolato. È stata un’estensione della sua massiccia espansione che ha portato ad un aumento del 40% del TVL dall’1 gennaio di quest’anno. L’ampio afflusso di investitori e l’aumentata domanda per i suoi servizi hanno portato a tale crescita.</p>
<h2 id="h2-Solana20supera20Ethereum20e20Binance20Smart20Chain875999"><a name="Solana supera Ethereum e Binance Smart Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana supera Ethereum e Binance Smart Chain</h2><p>In termini di crescita del TVL, Solana ha superato sia Ethereum che Binance Smart Chain, che sono classificati al secondo e terzo posto nell’intero mercato crittografico. La blockchain ha anche ottenuto ottimi risultati in altre aree.</p>
<p>Come esempio, ha mantenuto una percentuale di uptime media del 100% negli ultimi 6 mesi. Come mostra Messari, alla fine del solo terzo trimestre, Solana era rimasta senza interruzioni di rete per 234 giorni come indica il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/169951041313731699510311_.pic.jpg" alt=""><br>Prestazioni della rete Solana: Messari</p>
<p>In realtà, l’interruzione precedente della rete di Solana è avvenuta il 25 febbraio 2023.</p>
<p>Pertanto, in termini di crescita del TVL, Solana ha superato diverse importanti blockchain, tra cui Binance Smart Chain (BSC) ed Ethereum. Le impressionanti performance di prezzo del SOL e la sua crescita della rete sono degne di nota considerando che la blockchain ha subito diversi tempi di inattività e sfruttamenti durante il 2022.</p>
<p>Con un TVL di circa $209.25 milioni all’inizio dell’anno, Solana ha registrato un aumento del 217% arrivando a $664 milioni. La cosa sorprendente è che mentre Solana ha registrato una crescita del genere a settembre, le altre blockchain come Binance Smart Chain, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> e Ethereum hanno registrato significativi cali del 6%, 10% e 13%, rispettivamente. L’immagine qui sotto mostra la dominanza di Solana nel terzo trimestre.<br><img src="https://gimg2.gateimg.com/image/article/169951044313741699510327_.pic.jpg" alt=""><br>Dominanza criptovalute Q3 Dominanza relativa - Coingecko</p>
<p>Come mostra l’immagine, Solana è stata una delle reti dominanti durante il Q3 del 2023.</p>
<h2 id="h2-Prestazioni20del20prezzo20di20SOL683320"><a name="Prestazioni del prezzo di SOL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni del prezzo di SOL</h2><p>La sorprendente performance di prezzo di SOL non si è limitata a pochi mesi, avendo registrato un guadagno del 95,5% dall’inizio dell’anno, cosa che poche criptovalute hanno raggiunto.</p>
<p>Per la maggior parte dell’anno, il prezzo di Solana è oscillato tra $19,50 e $25. Tuttavia, le riprese del prezzo di Solana non sono riuscite a raggiungere il massimo storico di $260 raggiunto nel novembre 2021. Infatti, è circa il 92,5% inferiore a quel picco.</p>
<h2 id="h2-Recenti20miglioramenti20della20blockchain20di20Solana123311"><a name="Recenti miglioramenti della blockchain di Solana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti miglioramenti della blockchain di Solana</h2><p>Oltre alle migliorie delle prestazioni e della crescita dei prezzi, Solana ha ottenuto anche molto sin dall’inizio dell’anno. Anche i suoi ricavi sono aumentati durante il periodo. Secondo Solscan, le commissioni di rete imposte sulle transazioni non votate sono aumentate a 53,06 SOL il 2 agosto. Di conseguenza, i ricavi di Solana sono cresciuti del 21% su base annua.</p>
<p>La capitalizzazione di mercato della blockchain è aumentata significativamente anche durante il Q3 2023. Messari, una piattaforma di intelligence di mercato Crypto, ha riferito che la capitalizzazione di mercato di Solana ha registrato una crescita del 17% trimestre su trimestre, chiudendo il Q3 a $8.4 miliardi.</p>
<p>La blockchain ha anche registrato un aumento dei token SOL in staking durante lo stesso periodo. L’importo di SOL in staking è aumentato del 2% nel Q3 per raggiungere i 404,9 milioni, un importo vicino alle cifre registrate prima dell’implosione di FTX un anno fa. In termini di token totali in staking, solo Ethereum supera il suo volume in staking. Il diagramma seguente fornisce le statistiche.<br><img src="https://gimg2.gateimg.com/image/article/169951070213751699510341_.pic.jpg" alt=""><br>Statistiche di rete Solana - Messari</p>
<p>Come mostra l’immagine sopra, Solana si è anche comportata in modo eccezionale in altre aree. Ad esempio, durante il terzo trimestre il numero di validatori è aumentato del 5,5%, dimostrando un miglioramento delle sue misure di sicurezza. Anche se il 29% dei validatori si trova negli Stati Uniti, sono distribuiti in 34 paesi diversi.</p>
<p>Un altro fattore che ha portato all’impennata del prezzo di SOL è stato l’aumento della sua adozione sancito da diverse collaborazioni. Ad esempio, nel terzo trimestre Shopify ha integrato Solana Pay nel suo sistema di pagamento. Attualmente, i suoi commercianti possono accettare pagamenti in USDC. Poiché Shopify rappresenta circa il 10% dell’e-commerce degli Stati Uniti, l’integrazione di Solana Pay è un grande traguardo per il settore delle criptovalute.</p>
<p>Inoltre, Solana si è anche alleata con VISA che mira a integrare il suo servizio di pagamento. Il team di VISA ha dichiarato di aver scelto Solana a causa delle sue varie caratteristiche chiave e attributi come transazioni veloci e una struttura di commissioni prevedibile.</p>
<p>Inoltre, Solana si è affermata come una blockchain preferita per i giochi <a href="/web3" target="_blank" class="blog_inner_link">web3</a> e i protocolli dei social media. Ad esempio, DSCVR, una piattaforma di social media e di costruzione della comunità Web3, ha annunciato di lanciare i suoi prodotti sulla blockchain Solana.</p>
<h2 id="h2-Le20sfide20che20la20rete20Solana20sta20affrontando732101"><a name="Le sfide che la rete Solana sta affrontando" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le sfide che la rete Solana sta affrontando</h2><p>Le impressionanti prestazioni di prezzo e di rete di SOL non implicano che tutto sia perfetto con la blockchain. Come molte altre reti, Solana ha la sua giusta dose di problemi.</p>
<p>In primo luogo, nelle sue azioni legali contro importanti exchange di criptovalute con sede negli Stati Uniti come Binance e Coinbase, la SEC degli Stati Uniti ha elencato il SOL di Solana come sicurezza crittografica.</p>
<p>Il prezzo di Solana potrebbe essere negativamente influenzato in futuro poiché FTX e Alameda Research detengono grandi quantità di SOL. Se il tribunale ordina loro di disfarsene, il prezzo di SOL potrebbe crollare.</p>
<h2 id="h2-Conclusion58274"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Solana ha superato sia Ethereum che Binance Smart Chain in termini di aumento del TVL. Mentre Solana ha registrato un aumento del 40% del TVL, quello di Ethereum e Binance Smart Chain è diminuito a settembre. Durante gli ultimi mesi, invece, il TVL di Solana è in costante crescita. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana cripto</a> il prezzo è aumentato notevolmente.</p>
<h2 id="h2-Domande20frequenti20su20Solana766372"><a name="Domande frequenti su Solana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Solana</h2><h3 id="h3-Solana20pu20raggiungere20i20500781826"><a name="Solana può raggiungere i $500?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana può raggiungere i $500?</h3><p>Sulla base dei suoi attuali movimenti di prezzo, è probabile che Solana raggiunga i 500 dollari entro il 2025. I suoi fondamentali stanno influenzando le attuali variazioni di prezzo. Man mano che sempre più investitori lo adottano, il suo prezzo potrebbe continuare a salire.</p>
<h3 id="h3-Pu20Solana20raggiungere201000770320"><a name="Può Solana raggiungere $1,000?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può Solana raggiungere $1,000?</h3><p>Solana ha il potenziale per raggiungere un prezzo di $1,000. Tuttavia, non possiamo prevedere con precisione quando raggiungerà quel prezzo in quanto dipende da vari fattori come le condizioni macroeconomiche globali, la chiarezza normativa e la sua importanza nello spazio blockchain.</p>
<h3 id="h3-E20previsto20un20aumento20di20Solana44285"><a name="E’ previsto un aumento di Solana?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>E’ previsto un aumento di Solana?</h3><p>Si prevede che il prezzo di Solana aumenterà nel breve e nel lungo periodo. Si noti che il suo valore è aumentato gradualmente nel corso del 2023 e ci aspettiamo che questo slancio continui nel 2024 e oltre.</p>
<h3 id="h3-Quanto20coster20SOL20nel202025209278"><a name="Quanto costerà SOL nel 2025?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto costerà SOL nel 2025?</h3><p>Il prezzo di SOL probabilmente oscillerà tra $300 e $500 nel 2025. Tuttavia, molti fattori come l’adozione globale, le innovazioni e la chiarezza normativa influenzeranno la variazione del prezzo nei prossimi due anni.</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 venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>