Qk9NRSBoYSBjcmVhdG8gdW4gcmVjb3JkIGRpIHJhcGlkYSBjcmVzY2l0YSwgdW4gcmllcGlsb2dvIGRlaSBwcm9nZXR0aSBwb3BvbGFyaSBkaSBTT0wgY2hlIGRldm9ubyBlc3NlcmUgc2VndWl0aQ==

2024-03-16, 06:16

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR20Dopo20laggiornamento20di20Ethereum20Cancun20sorprendentemente20SOL20si2020distinto20di20pi20Solana2020Una20serie20di20progetti20popolari20come20MemeCoin20AI20DePIN20e20altri20sono20emersi20sulla20blockchain20occupando20i20punti20caldi20del20mercato128055"><a name="TL; DR] Dopo l’aggiornamento di Ethereum Cancun, sorprendentemente SOL si è distinto di più [Solana  Una serie di progetti popolari come MemeCoin, AI, DePIN e altri sono emersi sulla blockchain, occupando i punti caldi del mercato." class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">TL; DR] Dopo l’aggiornamento di Ethereum Cancun, sorprendentemente SOL si è distinto di più [Solana</a> Una serie di progetti popolari come MemeCoin, AI, DePIN e altri sono emersi sulla blockchain, occupando i punti caldi del mercato.</h2><p>Grazie alla sua profondità estrema e alla capacità di accogliere una grande quantità di denaro, BOME ha attirato un gran numero di ordini di acquisto di grandi dimensioni di oltre centinaia di SOL, che hanno rapidamente contagiato l’intero settore crittografico e spinto il prezzo a salire costantemente.</p>
<p>Solana ha completamente superato l’ombra di FTX e attualmente sta attirando gli investitori desiderosi di alti rendimenti grazie al suo enorme potenziale di investimento.</p>
<h2 id="h2-Introduzione46351"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dopo l’aggiornamento di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> a Cancun, è sorprendente vedere che SOL ha ottenuto ancora più attenzione. Sulla rete Solana, continuano a nascere numerosi progetti popolari come MemeCoin, AI e DePIN. In particolare, i MemeCoin sulla rete <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> continuano a salire in modo impressionante, permettendo a molti investitori di ottenere profitti considerevoli.</p>
<p>Alla data di scrittura, secondo i dati di CoinMarketCap, il volume delle transazioni di Memes24 nelle ultime 24 ore è di $14 miliardi, con una capitalizzazione di mercato di $57,6 miliardi, pari all’8,5%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105694491.png" alt=""><br>Figura 1 da: CoinMarketCap</p>
<p>Pertanto, qui condivideremo inizialmente le famiglie di meme più popolari su Sol.</p>
<h2 id="h2-BOOK20OF20MEMEBOME253478"><a name="BOOK OF MEME（BOME）" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BOOK OF MEME（BOME）</h2><p>Il nuovo meme coin BOOK OF MEME（BOME）è stato lanciato dal famoso artista di Pepe Meme, Darkfarm. Originariamente previsto di raccogliere 500 SOL, i dati rivelati da Darkfarms mostrano che alla fine ha raccolto un’incredibile quantità di 10131 SOL.</p>
<p>Successivamente, Darkfarms ha messo decisamente tutti i SOL raccolti nel pool di LP, con un prezzo di partenza di 0,0{3}496 USDT°.</p>
<p>Grazie alla sua profonda liquidità, è in grado di accogliere un’enorme quantità di fondi, attirando così una grande quantità di ordini di acquisto di grandi dimensioni, superiori a centinaia di SOL, che entrano costantemente, infettando rapidamente l’intero settore crittografico e spingendo continuamente al rialzo il prezzo, mentre la serie NFT SMOWL precedentemente lanciata da Darkfarms è stata anche apprezzata, registrando un aumento consecutivo.</p>
<p>Secondo i dati di Gate.io, attualmente il prezzo è raggiunto $0.0137, realizzando un aumento del 28000%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105694902.png" alt=""><br>Figura 2 Fonte: Gate.io</p>
<h2 id="h2-COCO376085"><a name="COCO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>COCO</h2><p>L’esplosione di BOME ha portato a una serie di imitazioni, con il progetto MEME COCO (coccodrillo) avviato da KOL Kero (@KeroNFTs) su X platform. I dati on-chain mostrano che l’indirizzo ha ricevuto un totale di circa 54696 SOL, del valore di oltre 10 milioni di dollari.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695143.png" alt=""><br>Figura 3 Fonte: @KeroNFT</p>
<p>Gate.io continuerà a monitorare se questo progetto può influenzare le tendenze della comunità.</p>
<p>Bonk (BONK) è una criptovaluta memetica a tema cane che è stata lanciata sul mercato il 25 dicembre 2022 e funziona sulla blockchain di Solana.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695324.png" alt=""><br>Figura 4 Fonte: Gate.io</p>
<p>Il token è stato creato per promuovere la liquidità degli scambi decentralizzati (DEX) basati su Solana. Il team di sviluppo lo ha posizionato come un token comunitario multifunzionale che può essere ampiamente utilizzato in tutte le applicazioni decentralizzate (dApp) costruite su Solana.</p>
<p>L’offerta totale di BONK ha raggiunto circa 100 trilioni di monete. Per attirare l’attenzione dei membri della comunità di Solana, il 50% dell’offerta totale viene distribuito agli utenti di Solana tramite airdrop, che include artisti, creatori e membri attivi della comunità. Questa strategia mira a creare una comunità dinamica e partecipativa intorno al token.</p>
<p>Durante il periodo natalizio del 2022, il lancio di BONK è stato considerato un regalo speciale alla comunità di Solana. La successiva rapida crescita ha dimostrato il notevole successo di BONK nella comunità web3. Inizialmente, attraverso una distribuzione aerea gratuita, BONK ha attirato l’ampia attenzione della comunità di Solana, offrendo agli utenti un’opportunità di partecipazione a bassa soglia e promuovendo così la sua rapida diffusione.</p>
<p>Naturalmente, al momento BONK non è più solo un meme puro, ma è stato integrato con successo in alcuni progetti basati su Solana per aumentarne l’adozione, con alcune piattaforme che offrono anche l’opportunità di stakeare gli NFT per guadagnare token BONK.</p>
<h2 id="h2-dogwifhatWIF500746"><a name="dogwifhat（WIF）" class="reference-link"></a><span class="header-link octicon octicon-link"></span>dogwifhat（WIF）</h2><p>dogwifhat criptovaluta nata dalla diffusione su vasta scala del meme “dogwifhat”, il cui fondatore Issa ha rapidamente reso virale questo meme online dopo aver cambiato la propria immagine del profilo su Twitter con un cane Shibu Inu con un cappello.</p>
<p>Questo meme è diventato rapidamente un simbolo di unità nella comunità, particolarmente popolare tra i giocatori e le persone famose su Internet, quindi viene ampiamente utilizzato come avatar sui social media.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695575.png" alt=""><br>Fonte Figura 5: Gate.io</p>
<p>Il team di dogwifhat ha colto questa tendenza popolare, lanciando la criptovaluta $dogwifhat, con l’obiettivo di celebrare l’impatto culturale dei meme e allo stesso tempo infondere nuova vitalità nel settore della raccolta e degli investimenti digitali.</p>
<p>La criptovaluta utilizza una struttura economica unica, concentrata sulla beneficenza, sul supporto del team e sulla <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Liquidità, per garantire il suo sviluppo a lungo termine e la partecipazione della comunità.</p>
<p>Naturalmente, l’ecosistema su Sol non si limita a MemeCoin, una serie di progetti come AI, DePIN, RWA, Gamefi continuano ad attirare l’attenzione del mercato, creando le caratteristiche del mercato rialzista di un ‘protocollo snello, applicazioni robuste’.</p>
<p>Jupiter (JUP)<br>Jupiter è un aggregatore DEX basato su Solana, progettato per fornire liquidità ai trader con il miglior prezzo e lo slippage minimo.</p>
<p>Non solo come motore di trading, ma anche come prodotto che si espande in una varietà di prodotti come costo medio in dollari, ordine a prezzo limite, trading perpetuo e Launchpad per soddisfare le diverse esigenze degli utenti.</p>
<p>Dopo che il progetto ha annunciato il token JUP a novembre dello scorso anno durante Breakpoint, il volume delle transazioni mensili ha raggiunto un nuovo record storico di oltre 16 miliardi di dollari, avvicinandosi alla quota di mercato delle transazioni di Uniswap, un leader consolidato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695946.png" alt=""><br>Figura 6 Fonte: Gate.io</p>
<p>Al momento, Jupiter ha superato Uniswap, con un volume di trading di oltre $2.5 miliardi nelle ultime 24 ore, rappresentando oltre il 16% del volume organico DEX, il che è significativo per i rivenditori di Solana.</p>
<p>Jito (JTO)<br>Jito è il primo protocollo di staking della liquidità su Solana che combina i profitti MEV con i profitti di staking.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105696167.png" alt=""><br>Figura 7 Fonte: Gate.io</p>
<p>Nonostante ci siano ancora differenze tra Jito e Marinade in termini di composizione ecologica, decentralizzazione e modello di staking, queste differenze si ridurranno gradualmente con lo sviluppo di Jito. Nel frattempo, il vantaggio principale di Jito nella cattura e distribuzione del valore MEV si rafforzerà ulteriormente con la crescita della rete Solana.</p>
<p>È prevedibile che con l’aumento dei nuovi asset di Solana, dei nuovi utenti e del volume degli scambi, insieme alla bassa percentuale di liquid staking di Solana, si prevede che il protocollo LSD rappresentato da Jito attirerà più TVL di staking e diventerà il principale protocollo LSD nell’ecosistema Solana.</p>
<h2 id="h2-IONETIO875118"><a name="IO.NET（IO）" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IO.NET（IO）</h2><p>Da all’inizio del primo trimestre, sono emersi molti progetti AI e DePIN basati su Sol, con IO.NET attualmente il più popolare.</p>
<p>IO.NET è una rete GPU basata su Sol che aggrega risorse da fonti sottoutilizzate come data center, minatori di criptovalute e <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> E <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> GPU（scheda grafica di elaborazione）dei progetti in attesa），costituendo la rete infrastrutturale fisica decentralizzata (DePIN)</p>
<p>Rispetto ad altri progetti di calcolo DePIN sul mercato, IO.NET si concentra esplicitamente sulla potenza di calcolo delle GPU ed è riuscito a creare una rete di GPU con una scala 100 volte superiore rispetto ai progetti simili.<br>Da notare è che IO.NET è anche il primo progetto nel campo della blockchain a integrare tecnologie all’avanguardia come i cluster Ray, i cluster Kubernetes e i cluster di grandi dimensioni nel progetto GPU DePIN e a metterli in pratica su larga scala. Ciò consente a IO.Net di non solo avere un vantaggio in termini di quantità di GPU, ma anche di dimostrare un’eccellente posizione di leadership nell’applicazione tecnologica e nella capacità di addestramento dei modelli.<br>Attualmente, il progetto non ha ancora lanciato la sua criptovaluta e Gate.io continuerà a seguire gli sviluppi di questo settore.</p>
<h2 id="h2-Riepilogo359149"><a name="Riepilogo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo</h2><p>Nel complesso, Solana è completamente uscita dall’ombra di FTX e attualmente sta attirando investitori desiderosi di alti rendimenti con il suo enorme potenziale di investimento. Siamo lieti di vedere che questo ecosistema sta gradualmente costruendo solide relazioni di collaborazione e sta attirando finanziamenti continui e costruttori e utenti creativi della comunità.</p>
<p>Naturalmente, dobbiamo anche renderci conto con chiarezza del fatto che l’attuale atmosfera di mercato può facilmente far cadere gli investitori nella frenesia cieca del FOMO.</p>
<p>Con il boom dell’ecosistema SOL, sono sorti una varietà di progetti, molti dei quali sono misti. Sebbene l’ecosistema SOL sia destinato a brillare nel lungo periodo, nel breve termine gli investitori devono comunque rimanere razionali e cauti e valutare attentamente il potenziale di sviluppo di ciascun progetto.</p>
<div class="blog-details-info"><br>  <div>Autore: <em><em>Carl Y.</em><br>  </em><div class="info-tips"><em></em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading.<br><div>*Il contenuto di questo articolo è originale, il copyright appartiene a Gate.io, se si desidera riprodurlo, si prega di indicare l'autore e la fonte, altrimenti si perseguiranno le responsabilità legali.<br></div><p></p><br></div></div></div>