UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgbWVyY2F0byBoYSBjb250aW51YXRvIGlsIGNpY2xvIGRpIG9zY2lsbGF6aW9uZSBhdHR1YWxl

<p><img src="https://gimg2.gateimg.com/image/article/1740119412weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze395084"><a name="Panoramica settimanale delle tendenze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica settimanale delle tendenze</h2><p>Questa settimana, nel complesso <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha continuato il suo recente ciclo di oscillazione. Simile alle variazioni di mercato della scorsa settimana, non c’è ancora un segnale chiaro al rialzo nel mercato, e la maggior parte della settimana è dominata da piccole salite e discese. Questa settimana, il mercato è principalmente dominato da piccole salite e discese all’interno della giornata, e la tendenza delle monete principali manca sostanzialmente di grandi fluttuazioni. Con l’avvicinarsi della chiusura della settimana, i prezzi della maggior parte delle monete principali sono sostanzialmente nella stessa fascia del prezzo di apertura, e non c’è possibilità di cambiamenti su larga scala nella tendenza nel breve termine.</p>
<p>La maggior parte delle criptovalute principali ha mancato di evidenti salite e discese questa settimana, e c’è stata una leggera diminuzione dopo l’apertura di questa settimana. Tuttavia, il trend di mercato nel breve termine è ancora molto incerto, e ci si aspetta di mantenere salite e discese nel breve termine entro la giornata.</p>
<p>Questa settimana, il prezzo di BTC è rimasto nell’intervallo tra $ 94.000 e $ 99.000 per la maggior parte del tempo, ma c’è stato un calo significativo nel periodo di metà settimana e il prezzo è sceso sotto i $ 94.000 in un breve periodo di tempo. Il punto più basso di BTC è stato di circa 93.487$, ma è rimasto sopra i 95.000$ per la maggior parte della settimana e ha continuato a fluttuare, con il punto più alto che ha sfondato i 98.000$.</p>
<p>Rispetto a BTC, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a> Le oscillazioni sono maggiori, con un massimo settimanale di circa 2.819$ e un minimo di circa 2.617$. Questa settimana, l’andamento dei prezzi della maggior parte delle principali monete mainstream ha continuato a salire e scendere all’interno di un piccolo intervallo. Il sentiment del mercato non è cambiato in modo significativo, mantenendosi intorno a 40. Il valore di mercato complessivo del mercato delle criptovalute è leggermente aumentato, raggiungendo circa $ 3,21 trilioni, in aumento dell’1,11% in 24 ore.</p>
<p>Il mercato crittografico complessivo ha mantenuto il suo recente trend ciclico questa settimana, con un aumento e una diminuzione relativamente evidenti. Il prezzo attuale di BTC si aggira intorno a $98,300. Il prezzo attuale di ETH si aggira intorno a $2,740.</p>
<p>Il mercato generale delle criptovalute non ha evidenti alti e bassi questa settimana e non c’è alcuna tendenza a ulteriori cambiamenti su larga scala. I prezzi attuali di un numero considerevole di monete tradizionali si collocano nello stesso intervallo dei prezzi di apertura. La moneta con il maggiore aumento di questa settimana è IP, che è aumentata di circa il 110% in una settimana.</p>
<p>Si prevede che il mercato delle criptovalute rimarrà nell’intervallo attuale questo fine settimana, con le fluttuazioni a breve termine che rimarranno la tendenza principale.</p>
<h2 id="h2-Mercato20delle20criptovalute369718"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Secondo Cointelegraph, i dati di CoinGlass hanno mostrato che alle 10:35 UTC del 16 febbraio, più del 70% dei contratti aperti delle opzioni ETH erano contratti di acquisto. Nicolai Sondergaard, analista di ricerca di Nansen, ha affermato che le posizioni rialziste indicano che gli investitori sono cautiamente ottimisti sull’apprezzamento a medio termine dell’ETH.</p>
<p>L’analista crittografico Immortal ha twittato: “Il volume delle transazioni on-chain di BTC è lontano dai livelli del 2021… ma ci aspettiamo un grande rialzo? Anche le commissioni di transazione non indicano necessariamente un rialzo - basta guardare ai cicli passati.”</p>
<p>🔥Secondo Cointelegraph, secondo uno studio condotto dal Perryman Group e pubblicato dalle organizzazioni di sostegno alla blockchain Texas Blockchain Council e Digital Chamber of Commerce, nonostante sia un settore emergente, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’industria mineraria ha creato più di 31.000 posti di lavoro negli Stati Uniti direttamente attraverso le operazioni minerarie e indirettamente attraverso le industrie di supporto.</p>
<p>🔥Secondo Crypto.news, il co-fondatore di Coingecko, Bobby Ong, ha dichiarato che il mercato cripto ha registrato un’impennata nella creazione di nuovi token a gennaio, con 600.000 nuovi token coniati, un aumento di 12 volte rispetto ai 50.000 token coniati al mese dal 2022 al 2023.</p>
<p>🔥Adam, un ricercatore macro presso Greeks.live, ha rilasciato un briefing alla comunità inglese dicendo che i trader di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> stanno osservando da vicino l’intervallo di $94.000-98.000, con il livello di resistenza principale a $98.000. Allo stesso tempo, molte persone hanno notato che la volatilità è stata insolitamente bassa di recente e c’è una mancanza di certezza nei trend dei prezzi.</p>
<p>🔥Ray Dalio, fondatore dei Fondi Bridgewater, ha parlato nuovamente di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> nell’ultima intervista podcast “All-In” e ha menzionato la follia di DeepSeek. Ha detto di aver visto deprezzamento della valuta attraverso le tendenze di mercato, specialmente rispetto all’oro, Bitcoin, o altri asset fisici.</p>
<p>🔥Adam, un ricercatore macro presso Greeks.live, ha scritto sulla piattaforma X che le notizie macro più significative di questa settimana provengono dagli Stati Uniti e dall’Europa riguardo alla guerra tra Russia e Ucraina. La guerra tra Russia e Ucraina è sempre stata una ragione importante per l’aumento dei prezzi delle materie prime. Se la situazione rilevante cambia, potrebbe causare una modifica nella logica attuale dell’inflazione complessiva.</p>
<p>🔥Secondo il monitoraggio dell’analista di criptovalute Ali, gli afflussi di capitale in Bitcoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sono diminuiti significativamente nel mese scorso, da $45 miliardi a $30 miliardi, una diminuzione di oltre il 30%.</p>
<p>🔥Secondo Cryptoslate, al 31 dicembre 2024, gli investitori istituzionali detenevano il 25,4% degli asset in gestione (AUM) degli ETF Bitcoin spot, per un totale di 26,8 miliardi di dollari.</p>
<p>🔥Secondo Cryptoslate, la versione 1.15.2 di Geth, un cliente chiave del protocollo <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>, è stata rilasciata per correggere un bug nella versione precedente che ha influenzato la creazione dei blocchi della mainnet. Secondo Go Ethereum, questo aggiornamento di emergenza risolve un problema di regressione nel motore di consenso beacon che ha causato ai validatori di perdere opportunità di blocco e potenzialmente causare perdite economiche.</p>
<p>🔥Secondo Cointelegraph, con la salita del Presidente degli Stati Uniti Donald Trump, sempre più criminali colletti bianchi, tra cui l’ex CEO di FTX SBF, stanno esplorando modi per ottenere il perdono.</p>
<p>🔥Michael Saylor, fondatore di Strategy (ex MicroStrategy), ha twittato un riassunto delle “21 regole di Bitcoin”.</p>
<p>🔥Secondo Cryptoslate, l’Autorità europea degli strumenti finanziari e dei mercati (ESMA) ha avviato una consultazione pubblica sulle linee guida per valutare la conoscenza e la competenza dei professionisti che forniscono servizi di cripto-attività ai sensi del Regolamento sul mercato delle cripto-attività (MiCA).</p>
<p>🔥Secondo Cointelegraph, l’istituto di investimento del miliardario Paul Tudor Jones ha rivelato di detenere un IBIT di BlackRock per un valore di 426,9 milioni di dollari, il doppio dell’ultima volta che ha riportato le sue partecipazioni nei documenti della SEC.</p>
<p>🔥Secondo Crypto Briefing, Kyle Song, <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> L’esperto di Google Cloud Asia Pacifico, ha rivelato nel suo discorso al Carne della Tecnologia Bitcoin di Hong Kong che Google si impegna a rendere i portafogli Bitcoin così user-friendly come le applicazioni Web2. La visione di Google è quella di consentire agli utenti di accedere ai portafogli Bitcoin utilizzando i loro account Google esistenti. Lo scopo di questo obiettivo è quello di avvicinare Bitcoin agli utenti mainstream.</p>
<p>Secondo CoinDesk, un rapporto pubblicato da JPMorgan Chase ha mostrato che i minatori di Bitcoin quotati negli Stati Uniti hanno rappresentato il 29% della potenza di calcolo della rete Bitcoin globale nel febbraio 2025, quasi il doppio dello stesso periodo dell’anno scorso.</p>
<p>🔥Secondo l’analista on-chain Ember, anche se il tasso di cambio ETH/BTC è sceso a 0,028, ci sono ancora balene che guardano con disprezzo il tasso di cambio ETH/BTC: una balena ha prelevato un totale di 1.444 cbBTC (circa $138 milioni) da Coinbase nelle ultime due settimane e poi l’ha depositato in <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> come garanzia per prendere in prestito 29.025 ETH (circa 77,6 milioni di dollari) e poi lo ha trasferito a Coinbase.</p>
<p>🔥Secondo The Daily Hodl, citando Barron’s, mentre il gigante dei servizi finanziari Charles Schwab espande i suoi tentacoli commerciali negli investimenti in criptovalute, l’azienda sta istituendo una nuova posizione dirigenziale. Questa nuova posizione è il capo degli asset digitali, che sarà responsabile della strategia complessiva di Schwab sugli asset criptati.</p>
<p>🔥Secondo TheBlock, Vetle Lunde, responsabile della ricerca presso K33 Research, ha analizzato in un rapporto che Bitcoin si trova ancora in un intervallo di bassa volatilità. Questa settimana, Bitcoin è sceso leggermente del 2% poiché i trader avversi al rischio hanno spinto al ribasso i rendimenti, la volatilità e i volumi di scambio ai minimi plurimestrali.</p>
<p>🔥Secondo Bloomberg, Reeve Collins, uno dei fondatori originali di <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>, sta lanciando la sua propria stablecoin.</p>
<p>🔥 Secondo The Block, Strategy (ex MicroStrategy) ha dichiarato martedì che prevede di emettere 2 miliardi di dollari in obbligazioni senior convertibili a tasso zero poche ore dopo aver emesso un profit warning.</p>
<p>🔥Secondo Bloomberg, la piattaforma di sicurezza crittografica Blockaid ha recentemente completato un round di finanziamento Serie B da 50 milioni di dollari guidato da Ribbit Capital, con la partecipazione di GV (ex Google Ventures) e degli investitori esistenti Variant e Cyberstarts.</p>
<p>🔥Trump ha detto alla conferenza dell’Istituto per l’Investimento Futuro a Miami mercoledì: “Il Bitcoin ha raggiunto molti massimi storici perché tutti sanno che sono impegnato a fare degli Stati Uniti la capitale delle criptovalute.”</p>
<p>🔥Ki Young Ju, CEO di CryptoQuant, ha detto di credere che Bitcoin non entrerà in un mercato orso quest’anno ed è ancora in un ciclo di mercato toro.</p>
<h2 id="h2-Politiche20Regolatorie20e20Macro300059"><a name="Politiche Regolatorie e Macro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche Regolatorie e Macro</h2><p>Secondo The Block, avvocati argentini hanno intentato una causa contro il presidente del paese Javier Milei, accusandolo di frode per il suo coinvolgimento nel progetto di token LIBRA, uno scandalo che è esploso nel fine settimana quando il valore del token è crollato del 95% dopo la promozione iniziale di Milei.</p>
<p>Nel frattempo, Javier Milei potrebbe affrontare un procedimento di impeachment al Congresso per le accuse secondo cui avrebbe agevolato un crypto rug pull che ha causato il crollo del valore di mercato del token da 4 miliardi a 418 milioni di dollari in poche ore.</p>
<p>🔥Secondo il Wen Wei Po di Hong Kong, un emittente di fondi prevedeva in precedenza di lanciare il primo fondo di mercato monetario tokenizzato nella regione Asia-Pacifico ad Hong Kong entro la fine di questo mese. Il CEO della Commissione per i titoli e i futures di Hong Kong, Leung Fung-yee, ha dichiarato di aver discusso del progetto Ensemble con l’HKMA e di ritenere che i fondi di mercato monetario abbiano il maggior potenziale di tokenizzazione tra gli asset del mondo reale poiché possono rendere efficienti sottoscrizione e rimborso. Attualmente, molte altre applicazioni di tokenizzazione sono in fase di revisione, tra cui prodotti al dettaglio e fondi di mercato monetario.</p>
<p>Secondo Cointelegraph, il sito web del governo del Texas ha annunciato che la prima udienza pubblica sull’istituzione di una potenziale riserva strategica di Bitcoin in Texas è prevista per il 18 febbraio, meno di una settimana dopo che il Segretario del Senato ha ricevuto la proposta di legge.</p>
<p>🔥Secondo il sito web della Radio di Hong Kong, Ye Zhiheng, direttore esecutivo del Dipartimento degli Intermediari della Commissione per i Titoli e i Futures di Hong Kong, dovrebbe annunciare una tabella di marcia per lo sviluppo degli asset virtuali questo mese. Oltre a spiegare i principi di sviluppo, la tabella di marcia menzionerà anche le aspettative della SFC e l’ambito della ricerca di mercato nel breve termine, nonché le aree in cui i partecipanti della piattaforma sperano di ottimizzare.</p>
<p>🔥Secondo Cointelegraph, la borsa valori statunitense MEMX ha presentato domanda alla Securities and Exchange Commission (SEC) per l’approvazione della quotazione delle 21Shares <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF come “fondo di materie prime,” e i documenti pertinenti sono stati presentati all’autorità di regolamentazione. Questa mossa segna un altro sforzo da parte delle borse statunitensi di elencare ETF che includono spot <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a>. Questa domanda mette anche in evidenza il cambiamento di posizione della SEC nei confronti delle criptovalute.</p>
<p>🔥Secondo The Block, la Securities and Exchange Commission degli Stati Uniti (SEC) sta cercando commenti pubblici per decidere se il trading di opzioni dovrebbe essere approvato su tre ETF spot Ethereum. Secondo un documento regolamentare pubblicato martedì, la SEC ha cercato pareri su se permettere al Chicago Board Options Exchange (Cboe Exchange, Inc.) di elencare e scambiare opzioni sul Grayscale <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Trust ETF, Grayscale Ethereum Mini Trust ETF e Bitwise Ethereum ETF.</p>
<p>🔥Secondo il sito ufficiale del Dipartimento di Giustizia degli Stati Uniti, i pubblici ministeri statunitensi hanno intentato una causa civile per confisca in un caso di frode negli investimenti in criptovalute e hanno recuperato 7,24 BTC, 14.120 USDT, 105,75 ETH e altri asset crittografici.</p>
<p>🔥È stato annunciato l’elenco degli emittenti di stablecoin conformi al “Markets in Crypto-Assets Act” (MiCA) dell’UE. Dieci istituzioni, tra cui Circle, Crypto.com e Société Générale, sono state autorizzate a emettere stablecoin in euro e dollari USA, per un totale di 10 stablecoin di tipo euro e 5 stablecoin di tipo dollaro USA.</p>
<p>🔥Secondo Decrypt, la Securities and Exchange Commission degli Stati Uniti (SEC) ha ritirato volontariamente il suo appello contro una sentenza che ha impedito all’agenzia di ampliare le leggi sui titoli esistenti per coprire gli utenti e i progetti DeFi.</p>
<p>🔥Secondo il Satoshi Action Fund, il disegno di legge “Strategic Bitcoin Reserve” del Montana è stato approvato in commissione ed è entrato nella fase di votazione della Camera dei Rappresentanti.</p>
<p>🔥La Securities and Exchange Commission degli Stati Uniti (SEC) ha ufficialmente confermato di aver accettato il <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> Domanda ETF (LITE) presentata da CoinShares.</p>
<p>🔥Secondo CoinDesk, Ales Michl, governatore della Banca centrale ceca, ha affermato che Bitcoin differisce in modo significativo dagli altri asset crittografici e non deve essere confuso con le criptovalute.</p>
<p>🔥Secondo Edaily, il Financial Supervisory Service (FSS) della Corea del Sud ha annunciato il suo piano di ispezione per quest’anno, che include il rafforzamento della supervisione dei fornitori di servizi di asset virtuali (VASP). FSS intende verificare rigorosamente se queste piattaforme sono conformi alle leggi e ai regolamenti, nonché alle regole di conformità volontaria.</p>
<p>🔥Secondo CoinDesk, Franklin Templeton ha annunciato il lancio del primo fondo obbligazionario del Tesoro degli Stati Uniti completamente tokenizzato in Lussemburgo, offrendo agli investitori istituzionali europei l’opportunità di partecipare.</p>
<p>🔥Secondo l’ultima tabella di marcia regolatoria ‘A-S-P-I-Re’ pubblicata dalla Commissione per i valori mobiliari e i futures di Hong Kong (SFC), Hong Kong migliorerà ulteriormente la supervisione del mercato degli asset virtuali per bilanciare l’innovazione e la gestione del rischio.</p>
<h2 id="h2-Punti20salienti20del20mercato20delle20criptovalute118396"><a name="Punti salienti del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti salienti del mercato delle criptovalute</h2><p>La settimana scorsa, il trend generale del mercato crittografico ha continuato il recente trend di mercato, e le piccole fluttuazioni a breve termine sono ancora i cambiamenti predominanti. Il valore complessivo del mercato è cambiato poco ed è vicino all’orario di chiusura del weekend. È improbabile che il mercato nel suo complesso subisca fluttuazioni su larga scala nel breve termine, e la probabilità di mantenere piccole fluttuazioni nel futuro è alta.</p>
<p>Questa settimana, l’aumento del valore della proprietà intellettuale nel mercato delle criptovalute si è classificato al primo posto tra le monete tradizionali. Essendo una moneta lanciata di recente, questa moneta ha inaugurato un’ascesa continua su larga scala. La moneta è aumentata di circa il 110% in una settimana e il prezzo attuale rimane intorno ai 3,7$, mostrando una tendenza al rialzo continua relativamente evidente.<br><img src="https://gimg2.gateimg.com/image/article/17401195761.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali54973"><a name="BTC &amp; ETH Prestazioni Settimanali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Prestazioni Settimanali</h2><h3 id="h3-Bitcoin20BTC705898"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/17401195972.jpeg" alt=""><br>(Dati forniti da TradingView)</p>
<p>Questa settimana, il prezzo di BTC ha mostrato un calo continuo a breve termine dopo l’apertura, scendendo rapidamente a un minimo settimanale nel periodo di metà settimana, per poi rimbalzare rapidamente sopra i 95.000$. Attualmente, il prezzo di BTC è in uno stato di rapida ascesa, avvicinandosi al prezzo di $ 98.500. Il prezzo di BTC è stato mantenuto nell’intervallo tra $ 95.000 e 98.000$ per la maggior parte di questa settimana, che è simile al trend del prezzo della scorsa settimana, ma ora ha superato i $ 98.000. Nel complesso, la probabilità che BTC superi la soglia dei 100.000$ nel breve termine è molto bassa e la probabilità di mantenere l’attuale fascia di prezzo è relativamente alta.</p>
<h3 id="h3-Ethereum20ETH651017"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17401196203.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Rispetto al BTC, il cambiamento di prezzo dell’ETH questa settimana è relativamente intenso, con un’ampia gamma di fluttuazioni. Dopo l’apertura, il prezzo dell’ETH ha registrato un’onda di mercato in crescita, ma è stata di breve durata, seguita da un declino continuo. C’è stata un’onda di rapida crescita a metà settimana, seguita da un tuffo a breve termine. Il prezzo attuale è sostanzialmente stabile, mantenendo una piccola gamma di fluttuazioni continue. Il punto più alto del prezzo dell’ETH nella settimana si avvicina a $2,820. Ci si aspetta che ci sarà un’onda di rapida salita e discesa durante il fine settimana, ma il prezzo si alzerà e scenderà principalmente leggermente.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3771017"><a name="Tendenza del Progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza del Progetto Web3</h2><p>Il valore di mercato totale dei sette tipi di progetti ha oscillato questa settimana, ma la maggior parte di essi sono ancora negli stessi alti e bassi. Il mercato nel suo complesso è stato principalmente influenzato dalle recenti condizioni di mercato e piccoli alti e bassi a breve termine sono ancora la tendenza principale.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>7d Cambia</th>
<th>I primi 3 guadagni</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>0.3%</td>
<td>EQPAY,MON,IP</td>
<td>Il valore di mercato totale della traccia Layer 1 è rimasto piccolo, con la crescita delle principali criptovalute distribuita in modo uniforme e nessuna criptovaluta ha registrato un aumento significativo.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>4.9%</td>
<td>RITARDO, KONET, WCO</td>
<td>L’andamento del mercato Layer 2 ha visto un certo aumento, ma l’aumento delle monete più importanti è rimasto all’interno di un piccolo intervallo e la distribuzione complessiva è stata relativamente uniforme.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-0.9%</td>
<td>SHAO,MNT,RAMEN</td>
<td>Il valore di mercato totale della traccia DeFi è cambiato poco, ma nel complesso è stato in un trend discendente continuo e le migliori monete sono aumentate significativamente.</td>
</tr>
<tr>
<td>NFT</td>
<td>0.8%</td>
<td>PAPER,DYP,WOMBAT</td>
<td>Il valore totale del mercato degli NFT è aumentato leggermente, ma le monete più in aumento sono concentrate in singole monete e nel complesso il trend manca di un chiaro supporto al rialzo.</td>
</tr>
<tr>
<td>MEME</td>
<td>-5.4%</td>
<td>PRINTR,CATEX,BEPE</td>
<td>Il tracciamento della moneta MEME è sceso in misura limitata e l’incremento delle principali monete è rimasto al di sopra del 500%, ma il trend generale è al ribasso.</td>
</tr>
<tr>
<td>Liquid Staking</td>
<td>-1.0%</td>
<td>ANKRMATIC, ANKRFTM, STS</td>
<td>Questo settore ha visto una leggera tendenza al ribasso e i tassi di crescita delle prime monete sono distribuiti in modo relativamente uniforme. Il lieve calo è principalmente dovuto alla tendenza delle monete principali.</td>
</tr>
<tr>
<td>AI</td>
<td>1.5%</td>
<td>WAIFU, CBM, YOKO</td>
<td>Il percorso dell’IA ha continuato a salire, con le principali monete che registrano guadagni più consistenti, ma il percorso complessivo è ancora in fase di ripresa e la probabilità di un rapido aumento nel breve termine è relativamente bassa.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il re-post dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>