U29sYW5hIChTT0wpIHZvbGEgb2x0cmUgaSAyMDAgZG9sbGFyaSBtZW50cmUgUGFudGVyYSBDYXBpdGFsIG9mZnJlIHVuJ29mZmVydGEgZGkgTWVtZWNvaW4gZSBsJ2F0dGl2aXTDoCBkaSBEQXBwIGF1bWVudGE=

2024-03-20, 02:51

<p><img src="https://gimg2.gateimg.com/image/article/1710902420rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR59411"><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> I volumi di trading elevati delle piattaforme DeFi sono stati il principale motore dell’attuale impennata dei prezzi di SOL.</p>
<p>Pantera Capital sta pianificando di acquistare token SOL del valore di $250 milioni da FTX Estate.</p>
<p>SOL, attualmente in negoziazione a $200 potrebbe raggiungere $621.51 entro aprile .</p>
<p><strong>Parole chiave</strong>: prezzo del token SOL, <a href="/how-to-buy/solana-sol" rel="nofollow noopener noreferrer" target="_blank">acquista Solana</a> token, elenco delle DApp di Solana, miglior <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> DEX, Solana <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a>, progetti di memecoin Solana, investire in token SOL, Dapps blockchain Solana, piattaforme Solana DeFi, grafico dei prezzi SOL, token dell’ecosistema Solana, notizie sulla criptovaluta Solana, crescita della rete Solana, trading di token SOL, nuovi memecoin Solana, smart contract Solana, analisi della blockchain Solana, futuro di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Solana</a></p>
<h2 id="h2-Introduzione933357"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Sebbene il blackout della rete Solana del 6 febbraio abbia creato il panico tra gli investitori SOL, la fiducia è presto tornata al mercato poiché il prezzo è rimbalzato dal momentum bearish che è iniziato a gennaio di quest’anno. Ci sono diverse ragioni per l’aumento del prezzo, tra cui l’aumento dell’attività dApp sulla rete.</p>
<p>L’obiettivo di questo articolo è esplorare i fattori che potrebbero aver contribuito al <a href="https://www.gate.io/blog_detail/3883/why-solana-sol-is-the-best-choice-in-a-bull-run" target="_blank">recente trend rialzista della criptovaluta Solana</a>. In particolare, ci concentreremo molto sulle attività dell’attività dApp della blockchain Solana e sull’effetto delle nuove memecoin Solana sul prezzo di SOL.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/solana-s-economic-eco-a-comprehensive-analysis/2083" target="_blank">L’ecosistema economico di Solana: un’analisi completa</a></p>
<h3 id="h3-Il20piano20di20investimento20di20Pantera20Capital20crea20un20momento20rialzista20per20SOL661258"><a name="Il piano di investimento di Pantera Capital crea un momento rialzista per SOL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il piano di investimento di Pantera Capital crea un momento rialzista per SOL</h3><p>Tra il 5 e il 7 marzo i piani di investimento di Pantera Capital hanno influenzato il prezzo del token SOL, facendolo aumentare del 19,5% fino a raggiungere i $200. Tuttavia, altri fattori come le prestazioni dei memecoin, i token funzionali SPL e l’attività delle DApps potrebbero aver contribuito all’aumento del volume di trading del token SOL. <a href="https://www.gate.io/learn/articles/a-deep-dive-on-solana-a-high-performance-blockchain-network/914" target="_blank">e la crescita della rete Solana</a>.</p>
<p>Fondamentalmente, la diffusione del <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Criptovaluta Solana</a> La notizia sull’intenzione di Pantera Capital di acquisire token SOL del valore di circa $250 milioni dall’eredità FTX ha fatto aumentare il suo prezzo. L’aspetto principale delle notizie criptate che hanno creato l’entusiasmo è stata la previsione del prezzo secondo cui SOL guadagnerebbe del 47% entro due settimane per superare la soglia dei $200.</p>
<p>Ultime notizie: <a href="https://www.gate.io/blog_detail/3876/volatility-in-solana-s-gamestop-meme-coin-70-plummet-followed-by-thursday-rebound" target="_blank">Volatilità nella GameStop Meme Coin di Solana: 70% di crollo seguito da un rimbalzo giovedì</a></p>
<p>Già, Pantera Capital, un gestore di attività focalizzato su cripto, ha lanciato una campagna di raccolta fondi per generare i fondi necessari. L’iniziativa, chiamata Pantera Solana Fund, darà agli investitori la possibilità di investire in token SOL. Secondo un recente articolo di Bloomberg, gli investitori che raccolgono i loro fondi attraverso Pantera Capital sono probabilmente <a href="https://www.gate.io/how-to-buy/solana-sol" target="_blank">acquista token Solana</a> al 39% di sconto.</p>
<p>Tuttavia, ci sarà un periodo di vestizione fino a quattro anni. La ragione per il lungo periodo di vestizione è consentire ai liquidatori di FTX, guidati da John J. Ray III, di rilasciare i token SOL ai creditori a un tasso basso per evitare di esercitare troppa pressione venditrice sul token. Tutto il resto uguale, una mossa del genere garantisce che il futuro dei prezzi di Solana rimanga brillante.</p>
<p>Attualmente, l’FTX possiede circa 41,1 milioni di token SOL, del valore di circa 5,4 miliardi di dollari. Inoltre, in base all’analisi della blockchain di Solana, tale importo costituisce approssimativamente il 10% dell’offerta totale di token SOL. Tuttavia, una delle condizioni del Pantera Solana Fund è che un investitore dovrebbe contribuire almeno 25 milioni di dollari.</p>
<h3 id="h3-Lattivit20di20Solana20DEX20raggiunge20quota20record20durante20il20rally20dei20Memecoin20Esplorando20il20momento20rialzista326306"><a name="L’attività di Solana DEX raggiunge quota record durante il rally dei Memecoin: Esplorando il momento rialzista" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’attività di Solana DEX raggiunge quota record durante il rally dei Memecoin: Esplorando il momento rialzista</h3><p>Poiché la quantità di token SOL che Pantera può acquisire attraverso il suo fondo costituisce solo il 10% dell’offerta di SOL, tale sviluppo potrebbe avere un’influenza limitata sul suo prezzo. Ciò significa che altri fattori potrebbero aver influito sul prezzo del token SOL.</p>
<p>In sostanza, fattori come l’entusiasmo per le memecoin Solana SPL e l’attività delle dApp potrebbero aver influenzato i cambiamenti di prezzo passati e presenti. Abbiamo una lunga lista di dApp Solana, composta da progetti criptati come Jupiter, <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Elio</a> e Raydium, le cui attività hanno un impatto sul <a href="https://www.gate.io/learn/articles/whatissolana/43" target="_blank">Prezzo della criptovaluta Solana</a>.</p>
<p>Ad esempio, l’aumento della domanda di token crypto delle piattaforme Solana DeFi, inclusi Jupiter (JUP) e Raydium (RAY) e Magic Eden, ha contribuito a spingere il valore di SOL verso l’alto.</p>
<p>Ad esempio, il 6 marzo alcuni token dell’ecosistema Solana ispirati a diverse celebrità come Jeo Boden, Spooderman e Juses Crust hanno registrato volumi di trading molto elevati.</p>
<p>Tali volumi di trading elevati e le prestazioni delle dApps sulla blockchain di Solana hanno portato ad un aumento del valore del token SOL. In effetti, durante quel periodo il volume delle dApps di Solana è aumentato di oltre il 311%, superando le dApps su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Un post di <a href="https://www.crypto-news-flash.com/solana-sol-surges-past-150-pantera-capital-bid-and-memecoin-activity-drive-rally/" rel="nofollow noopener noreferrer" target="_blank">Utente X, Gumshoe</a>, riassume l’impatto dell’impennata dei prezzi di SOL e di alcune nuove memecoin di Solana sul mercato crittografico.<br><img src="https://gimg2.gateimg.com/image/article/17109027171.jpeg" alt=""><br>Source: <a href="https://www.crypto-news-flash.com/solana-sol-surges-past-150-pantera-capital-bid-and-memecoin-activity-drive-rally/" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Come mostra l’immagine, i valori di SOL e altri contratti intelligenti di Solana sono stati elevati durante i primi due mesi e mezzo di quest’anno. Ad esempio, tra il 5 e il 7 marzo <a href="/price/helium-hnt" target="_blank" class="blog_inner_link">Helium</a> Mobile (MOBILE) ha guadagnato circa il 14,5%, mentre il prezzo di Jito (JTO) è salito del 15,5%. Il diagramma successivo indica alcuni token crittografici basati su Solana.<br><img src="https://gimg2.gateimg.com/image/article/17109027482.jpeg" alt=""><br>Origine: <a href="https://twitter.com/0xGumshoe/status/1736868799846981850" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Non vi è dubbio che l’entusiasmo per i nuovi memecoin di Solana abbia contribuito all’aumento dell’ecosistema di Solana. Ad esempio <a href="https://www.gate.io/post/CQQDFjYMQkpAQgghGxAdA19cWxgEDhkO0O0O/status/5038282" target="_blank">BONK è stato in tendenza</a> nel mercato delle memecoin dal dicembre 2023. È riuscito ad attirare molte persone a <a href="https://www.gate.io/learn/articles/comprehensive-analysis-solana-s-economic-eco/2039" target="_blank">investire nell’ecosistema Solana</a>.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/bonk-bonk" target="_blank">Previsione del prezzo di Bonk &amp; Forecast per il 2024, 2025, 2030</a></p>
<p>Tuttavia, il declino dell’entusiasmo per le memecoin e gli airdrop non ha influenzato le prestazioni delle piattaforme di DeFi di Solana. Ciò indica che ci sono altri fattori che contribuiscono alle eccezionali prestazioni della rete. L’aumento dei volumi di scambio di Solana e la creazione di piattaforme DeFi, progetti di memecoin di Solana e altre dApp hanno aumentato l’attività della rete Solana, che ha un impatto sul prezzo di SOL.</p>
<p>Come esempio, i depositi di contratti intelligenti di Solana, misurati nel valore totale bloccato di Solana, hanno raggiunto un massimo di 16 mesi il 6 marzo. L’aumento dei depositi di dapps di Solana blockchain è il risultato dell’elevata performance di diversi protocolli, tra cui Jito, BlazeStake, Jupiter, Drift MarginFi e Kamino.</p>
<p>Leggi anche: <a href="https://www.gate.io/post/CQQDFjYMQkpAQgghGxAdA19cWxgEDhkO0O0O/status/5032526" target="_blank">Previsione del prezzo di Solana mentre il volume di trading di $12 miliardi spinge SOL sotto i $170 - È il momento di acquistare il calo?</a></p>
<p>Tra il 5 e il 7 marzo diversi scambi decentralizzati basati su Solana hanno registrato volumi di trading elevati. Ad esempio, il 5 marzo gli scambi decentralizzati (DEX) basati su Solana hanno raggiunto un nuovo massimo giornaliero di $2,85 miliardi di volume di trading. In quel giorno, Jupiter, il miglior DEX di Solana, ha avuto un volume di trading di 24 ore di $1.450.102.962 mentre Orca ha avuto un volume di trading di $837.495.350.</p>
<h3 id="h3-Prestazioni20attuali20di20Solana20e20previsioni20di20prezzo20a20breve20termine114248"><a name="Prestazioni attuali di Solana e previsioni di prezzo a breve termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni attuali di Solana e previsioni di prezzo a breve termine</h3><p>Al momento della scrittura <a href="https://www.gate.io/how-to-buy/solana-sol" target="_blank">Gli investitori possono acquistare il token Solana</a> a $183.77 dopo aver perso il 1.4% nelle ultime 24 ore. In generale, però, SOL ha guadagnato il 26.7% nell’ultima settimana come indica il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/17109030073.jpeg" alt=""><br>Grafico dei prezzi di SOL - <a href="https://www.coingecko.com/en/coins/solana" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Il grafico dei prezzi di SOL sopra indica che il prezzo è aumentato costantemente dall’inizio di marzo. Nonostante le sue solide prestazioni, il token è ancora del 28,6% al di sotto del suo massimo storico di $259,96, raggiunto il 6 novembre 2021.</p>
<p>In termini di previsione del prezzo di Solana, <a href="https://changelly.com/blog/solana-price-prediction/" rel="nofollow noopener noreferrer" target="_blank">Changelly</a> prevede che il suo prezzo raggiunga i $621,51 entro aprile di quest’anno. Tuttavia, CoinCodex prevede che il prezzo di SOL oscillerà intorno ai $912,12 entro la fine del 2024.</p>
<p>Leggi anche: <a href="https://www.gate.io/post/CQQDFjYMQkpAQgghGxAdA19cWxgEDhkO0O0O/status/5038595" target="_blank">Previsione del prezzo di Solana mentre SOL raggiunge il livello più alto dal dicembre 2021 - Può SOL superare Ethereum?</a></p>
<h2 id="h2-Conclusione913008"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Un aumento dell’attività di dApp sulla rete Solana ha contribuito al suo solido movimento dei prezzi. L’acquisizione proposta da Pantera Capital di token SOL del valore di $ 250 milioni e l’entusiasmo per i memecoin hanno influenzato anche l’aumento del prezzo della criptovaluta Solana. Nel frattempo, alcuni analisti hanno previsto che il prezzo di SOL potrebbe raggiungere $ 912,12 entro la fine dell’anno.</p>
<h2 id="h2-Domande20frequenti20su20Solana282010"><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-Pantera20Capital2020un20hedge20fund891158"><a name="Pantera Capital è un hedge fund?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pantera Capital è un hedge fund?</h3><p>Pantera Capital è un hedge fund con sede a Menlo Park, California, specializzato in asset digitali che includono criptovalute. Fondato nel 2013, è diventato il primo crypto hedge fund negli Stati Uniti.</p>
<h3 id="h3-Chi20detiene20la20maggior20parte20di20Solana879496"><a name="Chi detiene la maggior parte di Solana?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi detiene la maggior parte di Solana?</h3><p>Il portafoglio 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM detiene il maggior numero di token SOL in quanto ne possiede 11,1 milioni.<br>Gli altri grandi detentori di SOL includono i seguenti portafogli:<br>7mhcgF1DVsj5iv4CxZDgp51H6MBBwqamsH1KnqXhSRc5 con 5,5 milioni di SOL,<br>FWznbcNXWQuHTawe9RxvQ2LdCENssh12dsznf4RiouN5 (5,2 milioni),<br>FbGeZS8LiPCZiFpFwdUUeF2yxXtSsdfJoHTsVMvM8STh (4,5 milioni),<br>52C9T2T7JRojtxumYnYZhyUmrN7kqzvCLc4Ksvjk7TxD (4,3 milioni),<br>8BseXT9EtoEhBTKFFYkwTnjKSUZwhtmdKY2Jrj8j45Rt con 4,001 milioni.</p>
<h3 id="h3-Chi2020dietro20SOL168944"><a name="Chi è dietro SOL?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è dietro SOL?</h3><p>Solana Labs, fondata da Anatoly Yakovenko e Raj Gokal nel 2018, possiede SOL? SOL è una criptovaluta nativa di Solana, una blockchain progettata per ospitare applicazioni decentralizzate.<br>Qual era il nome originale di Solana?<br>Solana, lanciata nel 2018, era inizialmente chiamata Loom. Successivamente il team ha cambiato il nome in Solana per evitare confusione con Loom Network, un fornitore di servizi di interoperabilità <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> multichain che esiste sulla blockchain di Ethereum.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>