RmF0dG9yaSBjaGUgZ3VpZGFubyBpbCByYWxseSBkZWwgcHJlenpvIGRpIFNPTA==

2023-11-29, 02:29

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR770473"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> La rete è una blockchain di scelta tra gli investitori di criptovalute grazie alla sua scalabilità, velocità e commissioni di transazione basse.</p>
<p>Di recente, Cathie Wood, CEO di ARK Invest, ha elogiato <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> per la sua efficienza.</p>
<p>Il rally di Solana che è iniziato a metà ottobre ha contribuito a spingere il valore di Grayscale’s Solana Trust (GSOL) in alto.</p>
<h2 id="h2-Introduzione96318"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La criptovaluta nativa della blockchain Solana, SOL, è in rialzo dal medio ottobre. Ci sono momenti in cui la domanda di SOL diventa molto alta poiché la blockchain, classificata al sesto posto per capitalizzazione di mercato, è la seconda rete più grande associata alle applicazioni decentralizzate (dApp).</p>
<p>A proposito, Solana è il più grande concorrente per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. Oggi discutiamo dei fattori che guidano l’impennata del prezzo di SOL e delle sue prospettive future.</p>
<h2 id="h2-Solana20Crypto20ha20brevemente20toccato20il20livello20dei206020a20novembre954242"><a name="Solana Crypto ha brevemente toccato il livello dei $60 a novembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana Crypto ha brevemente toccato il livello dei $60 a novembre</h2><p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana crypto</a> è stato performante fin dall’inizio dell’anno. Finora, il suo valore è aumentato di oltre il 550%. Ha ottenuto il maggior guadagno a ottobre, quando è salito di circa il 200%. Anche se il suo momentum rialzista è diminuito a novembre, il mercato si aspetta che continui a salire man mano che ci avviciniamo alla fine dell’anno.</p>
<p>Mentre Solana ha guadagnato più del 550% quest’anno, le altre principali criptovalute non hanno eguagliato il suo slancio. Il prezzo di Ether (ETH) è aumentato di circa il 70% nello stesso periodo. Allo stesso modo, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> guadagnato circa il 127%.</p>
<p>Durante la recente ascesa dei prezzi, il valore di SOL è salito brevemente sopra i 60 dollari. La pressione rialzista attuale è iniziata il 24 ottobre quando la maggior parte delle criptovalute è aumentata. Al contrario, intorno a questo periodo nel 2022 il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Prezzo Solana</a> stava oscillando intorno a $10 a seguito del crollo di FTX.</p>
<p>Di fatto, il valore di Solana è aumentato di oltre il 500% da quando la Securities and Exchange Commission degli Stati Uniti lo ha designato come un titolo di sicurezza insieme a <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>, Matic, Algo e MANA File coin (FIL), tra gli altri. Fondamentalmente, la corsa di Solana è iniziata il 10 luglio, la data in cui la SEC l’ha etichettata come una criptovaluta sicura.</p>
<h2 id="h2-Solana20sta20facendo20davvero20bene2020CEO20di20ARK20Invest20Cuthie20Wood885804"><a name="“Solana sta facendo davvero bene” - CEO di ARK Invest, Cuthie Wood" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Solana sta facendo davvero bene” - CEO di ARK Invest, Cuthie Wood</h2><p>Recentemente, c’è stato un fattore unico che ha spinto il prezzo di Solana verso l’alto, anche se per un breve periodo. Si tratta del commento di Cathie Wood, CEO di ARK Invest, sull’efficienza della blockchain e sui bassi costi delle transazioni.</p>
<p>Infatti, il 15 novembre, <a href="https://www.youtube.com/watch?v=kj95_DAc-Ao" rel="nofollow noopener noreferrer" target="_blank">in un’intervista con CNBC</a>, Wood ha elogiato la blockchain Solana per la sua infrastruttura unica che porta a scalabilità, velocità di transazione, alta sicurezza ed efficienza, tra gli altri. Secondo Wood, la blockchain è un attore principale nel settore delle criptovalute.</p>
<p>Durante l’intervista ha detto: ‘Solana sta facendo davvero un ottimo lavoro. Ether era più veloce e più economico di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> [indietro] ai tempi - ecco come abbiamo ottenuto ether. Solana è ancora più veloce e [più] conveniente di ether.’</p>
<p>Ha persino aggiunto che le piace davvero Solana. Tuttavia, Wood ha anche evidenziato una delle maggiori debolezze di Solana, il suo tempo di inattività costante durante la manutenzione e le interruzioni.</p>
<p>Lei ritiene che il tempo di inattività di Solana sia maggiore rispetto a quello della blockchain di Ethereum. Tuttavia, secondo lei, ciò non impedisce agli investitori di utilizzare la rete.</p>
<p>Ha aggiunto: “Le persone sono disposte ad accettare questo perché forse le dimensioni delle transazioni non sono così grandi o per qualche motivo non così importanti, vogliono solo velocità e costo come loro priorità assoluta. Ciascuna di [le reti] avrà un posto.”</p>
<h2 id="h2-Fattori20che20contribuiscono20al20movimento20al20rialzo20del20prezzo20di20SOL266355"><a name="Fattori che contribuiscono al movimento al rialzo del prezzo di SOL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fattori che contribuiscono al movimento al rialzo del prezzo di SOL</h2><p>Ci sono altri fattori chiave che hanno contribuito all’andamento al rialzo di Solana. Questo perché gli investitori non si limitano solo <a href="/how-to-buy/solana-sol" rel="nofollow noopener noreferrer" target="_blank">acquistare Solana</a> senza forti motivi.</p>
<p>Ad esempio, Solana ha visto un aumento di nuovi utenti, qualcosa che ha creato fiducia nella criptovaluta. Ciò ha anche attirato istituzioni finanziarie tradizionali come Grayscale ad investire in SOL.</p>
<p>Naturalmente, c’è stato un aumento del numero di applicazioni decentralizzate che operano sulla blockchain, il che ha portato a un aumento della domanda di SOL e, in definitiva, al suo prezzo. Il diagramma seguente mostra l’ultimo picco del prezzo di Solana.<br><img src="https://gimg2.gateimg.com/image/article/170122489115561701224598_.pic.jpg" alt=""><br>Prezzo dell’anno solare di Solana - TradingView</p>
<p>Come si nota dal diagramma, a partire dalla metà di ottobre il prezzo di Solana è aumentato significativamente. Questo slancio rialzista ha attirato molti investitori ad acquistare grandi quantità di SOL, creando un futuro più luminoso per Solana che mai prima d’ora.</p>
<p>Gli scambi decentralizzati che esistono sulla blockchain Solana influenzano il momento rialzista di SOL. Nel complesso, il volume di trading di questi scambi ha superato i 2 miliardi di dollari entro 12 giorni, intorno a metà novembre.</p>
<p>Molti trader di criptovalute amano scambiare Solana per la sua convenienza e velocità delle transazioni. A causa della forte domanda, gli investitori detengono anche Solana, aumentandone il valore totale bloccato (TVL). Attualmente, il TVL di Solana supera i $500 milioni e è destinato a crescere con l’acquisto e il mantenimento di SOL da parte di ulteriori investitori.</p>
<p>Questi fattori hanno avuto un effetto positivo sul valore del Grayscale’s Solana Trust (GSOL) le cui azioni sono scambiate con un premio che supera l’800%. Ad esempio, il 10 novembre, le azioni secondarie SOL hanno raggiunto un valore di $202 come mostra l’immagine successiva.<br><img src="https://gimg2.gateimg.com/image/article/170122491915571701224612_.pic.jpg" alt=""><br>Trust Solana di Grayscale - Grayscale</p>
<p>L’aumento del valore delle azioni di Grayscale Solana Trust ha aumentato l’interesse degli investitori per l’attività. Per contesto, Grayscale Solana Trust (GSOL) è un fondo negoziato in borsa di Alternative Digital Assets (ETF).</p>
<h2 id="h2-Conclusione157312"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Solana ha vissuto un forte rally da metà ottobre, superando per un breve periodo il valore di $60. Molti trader preferiscono Solana alla rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> per via della sua natura economica, della rapida finalità delle transazioni e dell’efficienza. Il movimento positivo del prezzo di SOL ha portato ad un aumento del valore di Grayscale Solana Trust.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita 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>