UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIz772cSWwgbWVyY2F0byDDqCBzYWxpdG8gc3UgdHV0dGEgbGEgbGluZWE=

<p><img src="https://gimg2.gateimg.com/image/article/1745564796weeklyweb3research.png" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze5771"><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, il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> ha sperimentato un forte rimbalzo ed è entrato in una crescita generale su tutti i fronti. Influenzato dal cambio nella politica tariffaria di Trump e dalla questione dell’indipendenza della Federal Reserve, il mercato crittografico ha inaugurato un nuovo round di liquidità e afflusso di capitali, e ha visto una crescita su larga scala insieme al mercato azionario statunitense. In generale, il mercato è attualmente in uno stato di rapida crescita, e il trend a breve termine del mercato è principalmente un continuo recupero.</p>
<p>La maggior parte delle monete principali presenti sul mercato ha mostrato un trend al rialzo piuttosto evidente questa settimana. A causa delle preoccupazioni sul sentiment di mercato causate dalla politica tariffaria di Trump e del indebolimento del dollaro a causa della questione dell’indipendenza della Federal Reserve, il mercato delle criptovalute ha registrato un aumento significativo.</p>
<p>In generale, il mercato è stato ancora fortemente influenzato da fattori esterni questa settimana, ma la liquidità complessiva è stata significativamente migliorata, il che rende possibile per il mercato liberarsi dello stato di consolidamento continuo precedente. La tendenza complessiva del mercato per la settimana ha mostrato una rapida crescita nel breve termine, e ha superato una volta il valore di $3 trilioni in breve tempo. C’è stato un lieve calo, ed è molto probabile che il mercato aprirà un nuovo round di fluttuazioni vicino alla chiusura della settimana.</p>
<p>Il prezzo del BTC è aumentato significativamente questa settimana. Dopo aver superato i $93.000, il prezzo attualmente oscilla all’interno di un piccolo intervallo e si mantiene intorno ai $93.500. È molto probabile che stabilisca nuovamente un nuovo record massimo nel breve termine.</p>
<p>L’aumento settimanale del prezzo dell’ETH è maggiore di quello del BTC. Il prezzo della criptovaluta è leggermente diminuito dopo aver superato 1.800$. Il massimo settimanale era di circa 1.811$ e attualmente si attesta intorno a 1.766$.</p>
<p>Questa settimana, il trend dei prezzi delle principali criptovalute è principalmente in rialzo. Il valore di mercato complessivo del mercato delle criptovalute è aumentato, raggiungendo circa $2.93 trilioni, in calo di circa lo 0.3% nelle ultime 24 ore. Il prezzo attuale del BTC si attesta intorno a $93,500. Il prezzo attuale dell’ETH si attesta intorno a $1,760.</p>
<p>Il mercato crittografico complessivo è salito significativamente questa settimana. La maggior parte delle principali valute è aumentata a causa di fattori esterni, e l’incremento medio complessivo è stato il più grande degli ultimi tempi. La valuta principale con il maggior aumento è stato TRUMP, che è aumentato di circa il 58% in una settimana ed è stato quotato intorno ai $12. Il recente rapido aumento di questa valuta riflette anche l’ulteriore impatto di una serie di politiche dopo l’insediamento di Trump sul mercato crittografico.</p>
<p>Questo fine settimana, in generale <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> si prevede che subisca lievi fluttuazioni, con un trend al rialzo che rimane il trend principale nel breve termine. Tuttavia, l’ascesa e la caduta delle principali criptovalute sono ancora fortemente influenzate da fattori esterni, in particolare dai problemi complessivi affrontati dalla successiva maturità dei titoli del Tesoro statunitense.</p>
<h2 id="h2-Mercato20delle20criptovalute758925"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Secondo Cointelegraph lunedì, il senior commodity strategist di Bloomberg Mike McGlone ha dichiarato che con l’attuazione delle recenti politiche di Trump, gli investitori si sono rivolti a asset più sicuri come l’oro.</p>
<p>🔥Come ha riportato Cointelegraph lunedì, la piattaforma di analisi on-chain CryptoQuant ha avvertito nel suo post Quicktake che il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mercato sta per subire uno shock.</p>
<p>🔥Secondo Riabiz, il nuovo CEO di Charles Schwab, Rick Wurster, prevede di lanciare il trading diretto di criptovalute entro i prossimi 12 mesi, e il trading di criptovalute diventerà una “scommessa” per ogni grande società di intermediazione.</p>
<p>🔥Secondo CoinDesk, 21Shares ha rilasciato un report affermando che, basandosi su un’analisi delle tendenze storiche e sui segnali di mercato attuali, ci si aspetta che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> possa raggiungere $138,555 entro la fine del 2025.</p>
<p>🔥Secondo Cointelegraph, i dati di Glassnode mostrano che le balene del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> si trovano ancora in una forte zona di accumulo. Attualmente, i grandi detentori (balene e squali) con più di 100-1.000 Bitcoin stanno assorbendo Bitcoin alla velocità più rapida della storia. L’assorbimento attuale di questo gruppo ha superato del 300% l’emissione annuale di Bitcoin.</p>
<p>🔥Secondo LedgerInsights, la Banca per i Regolamenti Internazionali (BRI) ha pubblicato questa settimana un documento che esplora i rischi di stabilità finanziaria legati alle criptovalute e alla finanza decentralizzata (DeFi). La maggior parte dei funzionari delle banche centrali ritiene che le criptovalute siano troppo piccole e autonome, quindi non rappresentano ancora un rischio per la stabilità finanziaria.</p>
<p>🔥Il CEO di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> Paolo Ardoino ha dichiarato che gli utenti globali di <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> La capitalizzazione di mercato della stablecoin (USDT) ha superato i 450 milioni e attualmente vengono aggiunti più di 30 milioni di nuovi utenti ogni trimestre. La crescita principale proviene dai mercati emergenti. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> sta continuando a promuovere la diffusione del “dollaro digitale” in tutto il mondo.</p>
<p>🔥Adam, un ricercatore macro presso Greeks.live, ha pubblicato un briefing alla comunità cinese, affermando che il sentiment di mercato era diviso. Alcuni trader erano ottimisti sulle performance delle altcoin durante il fine settimana e credevano che SOL fosse salito più di 10 volte dal minimo, ma c’erano anche opinioni che avvertivano che questa potrebbe essere l’ultima follia.</p>
<p>🔥Secondo Bitcoinist, dopo diversi giorni di consolidamento, sia i tori che gli orsi non sono riusciti a controllare completamente la situazione. Questa indecisione riflette l’incertezza generale nei mercati finanziari globali.</p>
<p>🔥Michael Saylor, fondatore di Strategy (ex MicroStrategy), ha nuovamente rilasciato informazioni relative al Bitcoin Tracker sulla piattaforma X: “Il numero di punti arancioni non è sufficiente.”</p>
<p>🔥L’analista di CryptoQuant Carmelo Alemán ha scritto che il 14 aprile 2025, la capitalizzazione realizzata di Bitcoin (o il valore di mercato realizzato di Bitcoin) ha raggiunto un record.</p>
<p>🔥Secondo The Block, BTC ha raggiunto un nuovo record oggi, per la prima volta dall’inizio di aprile, trainato dal recupero della liquidità globale e dal possesso istituzionale. Strategy ha aumentato le sue partecipazioni di 3.459 BTC all’inizio di questo mese, e la crescita dell’offerta di denaro totale M2 ha anche trainato il mercato al rialzo. Tuttavia, gli analisti hanno avvertito che è ancora troppo presto per parlare di un mercato rialzista perché la politica tariffaria degli Stati Uniti è ancora poco chiara.</p>
<p>🔥Secondo il Wall Street Journal, citando fonti, un consorzio bancario che include la Deutsche Bank della Germania e la Standard Chartered Bank della Gran Bretagna sta considerando di espandere la propria attività criptata negli Stati Uniti.</p>
<p>🔥Pavel Durov, fondatore di Telegram, ha pubblicato sul canale ufficiale di TG che la Francia ha quasi vietato le criptovalute il mese scorso. Il Senato ha approvato una legge che richiede alle applicazioni di comunicazione di creare un backdoor per consentire alla polizia di accedere alle informazioni private. Fortunatamente, la legge è stata respinta dall’Assemblea Nazionale. Tuttavia, tre giorni fa, il capo della polizia di Parigi si è nuovamente espresso a favore della legge.</p>
<p>🔥L’analista di criptovalute PlanB ha pubblicato sulla piattaforma X che crede che <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, come progetto “centralizzato, pre-minato, basato su PoS e con un meccanismo di fornitura arbitrariamente modificabile”, è dannoso per l’ecosistema cripto, affermando candidamente che “merita tutte le prese in giro.”</p>
<p>🔥Secondo un grafico condiviso dall’analista ETF di Bloomberg Eric Balchunas, attualmente ci sono 72 ETF di criptovalute che coprono vari temi come <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a>, <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> e persino “2x Melania” registrata presso la SEC degli Stati Uniti, in attesa di approvazione o opzioni di quotazione.</p>
<p>🔥Julio Moreno, direttore della ricerca presso CryptoQuant, ha detto sulla piattaforma X che il livello di resistenza di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> potrebbe essere intorno a $91,000 a $92,000, che coincide con il prezzo realizzato sulla piattaforma dai trader.</p>
<p>🔥Jeff Kendrick, un analista presso Standard Chartered Bank, ha detto che Bitcoin potrebbe salire ai massimi storici se persistono preoccupazioni sull’indipendenza della Federal Reserve. Ha detto che grazie al suo registro decentralizzato, la criptovaluta è un’alternativa contro i rischi nel sistema finanziario esistente. Questo si riflette nel rischio dei titoli del Tesoro degli Stati Uniti dopo che Trump ha accennato che potrebbe rimuovere il presidente della Federal Reserve Powell a causa della sua speranza di abbassare i tassi di interesse.</p>
<p>🔥Bernstein ritiene che, anche se la volatilità a breve termine persiste, le prospettive per gli asset digitali rimangono ottimistiche e evidenzia cinque importanti catalizzatori strutturali che supportano la resilienza di Bitcoin e il suo potenziale al rialzo futuro.</p>
<p>🔥Secondo CoinDesk, il rapporto attuale BTC/Nasdaq è di 4,96, vicino al suo massimo storico. In precedenza, il rapporto ha raggiunto un record di 5,08 nel gennaio 2025, quando Bitcoin ha toccato un massimo storico.</p>
<p>🔥Secondo gli ultimi dati di 8marketcap, Bitcoin ha superato l’argento e il gigante tecnologico Amazon, salendo al sesto posto per valore di mercato degli asset globali.</p>
<p>🔥Secondo Bloomberg, il figlio di Trump ha co-fondato una nuova società, American Bitcoin, con altri investitori e l’ha fusa con l’azienda mineraria quotata in borsa Hut 8 Corp., guidata dal CEO Asher Genoot e dal Chief Strategy Officer Michael Ho.</p>
<p>🔥Secondo Globenewswire, Trump Media Technology Group (DJT.O) ha firmato un accordo vincolante con la piattaforma di trading di criptovalute Crypto.com e la società di gestione patrimoniale Yorkville America Digital per lanciare una serie di ETF attraverso il marchio Truth.Fi.</p>
<p>🔥Secondo il FT, tre persone a conoscenza della questione hanno rivelato che Cantor Fitzgerald, guidata da Brandon Lutnick, figlio del segretario al commercio degli Stati Uniti Howard Lutnick, sta lavorando con SoftBank, Tether e Bitfinex per costruire una piattaforma di acquisizione di Bitcoin del valore di miliardi di dollari.</p>
<p>🔥 Secondo Cointelegraph, <a href="/price/chiliz-chz" rel="nofollow noopener noreferrer" target="_blank">Chiliz</a>, una sussidiaria di SportsFi, si è incontrata con la SEC degli Stati Uniti per discutere gli investimenti e il rientro nel mercato crittografico degli Stati Uniti sotto la guida della Casa Bianca amica delle criptovalute, nonché per aumentare la promozione della trasparenza regolamentare per gli asset digitali.</p>
<p>🔥Secondo CoinDesk, persone a conoscenza della questione hanno rivelato che la banca olandese ING sta sviluppando una stablecoin, sperando di approfittare delle nuove normative europee sulle criptovalute entrate in vigore l’anno scorso.</p>
<p>🔥Il sito web ufficiale della coin meme del presidente degli Stati Uniti Trump, “TRUMP”, ha annunciato mercoledì ora locale che inviterà i primi 220 detentori della coin a cena in un club di golf vicino a Washington il 22 maggio, affermando che ci sarà l’opportunità di ascoltare informazioni “di prima mano” da Trump sul futuro delle criptovalute.</p>
<p>CoinGecko ha riportato giovedì che il valore di mercato totale delle criptovalute ha superato i $3 trilioni per la prima volta dal 7 marzo 2025.</p>
<p>🔥Secondo Cointelegraph, Bitcoin è salito bruscamente questa settimana e i fondi negoziati in borsa (ETF) correlati hanno registrato forti afflussi. Gli analisti ritengono che Bitcoin possa presto raggiungere i 100.000 dollari, ma Markus Thielen, responsabile della ricerca presso 10xResearch, ha dichiarato in un rapporto di mercato: “Dato che gli indicatori di creazione di stablecoin non sono ancora tornati ai livelli attivi, rimaniamo cauti sulla sostenibilità dell’attuale rally di Bitcoin.”</p>
<p>🔥Secondo SolanaFloor, SOL Strategies, una società quotata alla Borsa di Toronto, ha ottenuto un finanziamento obbligazionario convertibile fino a $500 milioni da ATW Partners, il più grande finanziamento del genere nell’ecosistema <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a>.</p>
<p>🔥Secondo Cointelegraph, l’Ufficio del Controllore della Valuta degli Stati Uniti (OCC) ha espresso la propria posizione sulle criptovalute e sulle banche, affermando: “L’OCC ha chiarito che certe attività legate alle criptovalute sono legalmente consentite.”</p>
<p>🔥Secondo CoinDesk, l’ultimo “Rapporto di conformità alla Travel Rule 2025” di Notabene mostra che il 90% dei 91 fornitori di servizi di asset virtuali esaminati prevede di conformarsi pienamente alle regole di viaggio contro il riciclaggio di denaro entro metà del 2025, e tutte le istituzioni esaminate si sono impegnate a rispettare gli standard entro la fine dell’anno.</p>
<p>🔥Secondo Crypto America, circa 15 aziende criptovalutarie e fintech stanno richiedendo licenze bancarie presso l’Ufficio del Controllore della Valuta degli Stati Uniti (OCC), e alcune di esse stanno cercando un modo più conveniente per ottenere account master federali.</p>
<p>L’azienda di analisi on-chain Glassnode ha pubblicato un’analisi sulla piattaforma X, affermando che la mappa di fornitura di Bitcoin mostra che i venditori che hanno acquistato Bitcoin per la prima volta ad aprile hanno avuto un’attività intensa. Anche se i prezzi sono saliti, il sentimento di “paura di perdere” (FOMO) nel mercato era ancora in aumento e nuovi fondi stavano affluendo.</p>
<p>Il direttore della ricerca di CoinShares, James Butterfill, ha scritto sulla piattaforma X che dal giorno dell’annuncio dei dazi per il ‘Giorno della Liberazione’ degli Stati Uniti il 2 febbraio, il Bitcoin ha sovraperformato l’Indice Nasdaq 100 del 15,9%, evidenziando i suoi vantaggi come asset di investimento decentralizzato.</p>
<h2 id="h2-Regolamentazione20e20Politiche20Macroeconomiche568447"><a name="Regolamentazione e Politiche Macroeconomiche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione e Politiche Macroeconomiche</h2><p>🔥Secondo Cointelegraph, una proposta di legge sulle riserve di criptovalute in Arizona è stata approvata dalla Camera dei Rappresentanti ed è ora a soli un voto di successo dall’essere presentata alla scrivania del governatore per l’approvazione formale. Il 17 aprile, la Strategic Digital Asset Reserve Act (SB 1373) dell’Arizona è stata approvata dal Comitato della Camera. Prima che la proposta di legge venga letta per la terza e ultima volta e sottoposta a un voto completo, deve essere esaminata da 60 membri della Camera dei Rappresentanti. La SB 1373 mira a istituire un fondo di riserva strategico per gli asset digitali, composto da asset digitali confiscati attraverso procedimenti penali e gestito dal tesoriere dello stato.</p>
<p>🔥Il sito web ufficiale della Procura Suprema del Popolo ha recentemente pubblicato un articolo di ricerca teorica dal titolo “Migliorare il meccanismo di identificazione e prova della valuta virtuale coinvolta nei casi criminali”. L’articolo ha affermato che a causa dell’anonimato e della complessità tecnica della valuta virtuale, è difficile identificarla nei casi criminali, difficile tracciarla <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> dei fondi e difficile determinarne il valore.</p>
<p>🔥La Banca Popolare Cinese, l’Amministrazione Statale alla Supervisione Finanziaria, l’Amministrazione Statale per gli Scambi Esterni e il Governo Popolare Municipale di Shanghai hanno emesso congiuntamente il ‘Piano d’azione per il Centro Finanziario Internazionale di Shanghai per migliorare ulteriormente la comodità dei servizi finanziari transfrontalieri’.</p>
<p>🔥La rappresentante americana Nydia Velazquez di New York ha presentato il Puerto Rico Digital Asset Fair Taxation Act, che mira a impedire agli investitori di utilizzare il territorio americano di Puerto Rico come paradiso fiscale per le criptovalute.</p>
<p>🔥Secondo Cointelegraph, la Banca Centrale Europea (BCE) ha avvertito delle possibili conseguenze del sostegno radicale degli Stati Uniti all’industria delle criptovalute, affermando che l’aumento degli stablecoin denominati in dollari statunitensi potrebbe minare la stabilità del sistema finanziario europeo. Secondo un documento politico ottenuto da POLITICO, la BCE ha chiesto una revisione del quadro normativo del mercato degli asset crittografici (MiCA) solo mesi dopo la sua entrata in vigore. Al centro della disputa c’è il fatto che le riforme statunitensi sostenute dal Presidente Trump potrebbero inondare i mercati europei di stablecoin denominati in dollari. La BCE è preoccupata che ciò possa innescare un flusso di capitale europeo verso attività statunitensi, indebolire la sovranità finanziaria dell’UE e esporre le banche a rischi di liquidità.</p>
<p>🔥Secondo Watcher.Guru, Michael Saylor ha detto: “Paul Atkins, Presidente della Securities and Exchange Commission degli Stati Uniti, avrà un atteggiamento positivo nei confronti di Bitcoin.” Notizie precedenti hanno rivelato che Paul Atkins è stato giurato per sostituire Gary Gensler come Presidente della SEC degli Stati Uniti.</p>
<p>🔥Secondo Bloomberg, Trump ha firmato un ordine esecutivo all’inizio di marzo che prevede la creazione di una riserva strategica separata di Bitcoin e altri token, e richiede al Segretario del Tesoro di valutare le considerazioni legali e di investimento del piano entro 60 giorni.</p>
<p>🔥Secondo CNBC, il commissario della Securities and Exchange Commission (SEC) degli Stati Uniti Mark Uyeda ha partecipato al programma “Money Movers” per discutere di come l’attuale SEC sia diversa da quella di Gary Gensler e quando ci si può aspettare il quadro normativo criptato. Uyeda ha affermato che il gruppo di lavoro criptato sta lavorando duramente per sviluppare un quadro normativo.</p>
<p>🔥Secondo le notizie ufficiali della Securities and Exchange Commission (SEC) degli Stati Uniti, il presidente della SEC, Paul Atkins, terrà un discorso al prossimo tavolo rotondo crittografico il 25 aprile. Notizie precedenti hanno affermato che la SEC degli Stati Uniti terrà il terzo tavolo rotondo sulla politica crittografica il 25 aprile, concentrandosi sulle questioni di custodia.</p>
<p>🔥Secondo Interfax, il Ministero delle Finanze russo e la Banca Centrale istituiranno uno scambio di criptovalute per investitori ad alto reddito come uno dei meccanismi di conformità nell’ambito della ‘legge sperimentale’. I partecipanti devono avere un patrimonio di oltre 120 milioni di rubli o un reddito annuo di oltre 50 milioni di rubli. Il piano mira a legalizzare le transazioni criptate e ad aumentare la trasparenza del mercato, ma è limitato agli insediamenti commerciali esteri e non si applica ai pagamenti interni. Le transazioni pertinenti saranno avviate su base sperimentale entro 6 mesi.</p>
<h2 id="h2-Evidenziazioni20del20mercato20delle20criptovalute245332"><a name="Evidenziazioni del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evidenziazioni del mercato delle criptovalute</h2><p>⭐️La settimana scorsa, il mercato criptato nel suo complesso ha registrato un’ampia crescita. Influenzati dalla riduzione delle preoccupazioni sulla politica dei dazi di Trump e dalla questione dell’indipendenza della Federal Reserve, il mercato azionario statunitense e il mercato criptato hanno registrato un significativo rimbalzo, e il mercato criptato ha registrato una crescita generale su tutta la linea. Nella scorsa settimana, le criptovalute principali hanno principalmente registrato aumenti giornalieri rapidi a breve termine. Attualmente, il mercato è in un trend di piccole salite e discese, e ci si aspetta che il mercato attuale mantenga una crescita compensativa.</p>
<p>⭐️Questa settimana, l’aumento del prezzo di TRUMP nel mercato delle criptovalute si è classificato al primo posto tra le monete principali, raggiungendo circa il 60%. Questo è principalmente perché la moneta è il token ufficiale certificato da Trump. Recentemente, influenzato dalle dinamiche correlate a Trump, il prezzo ha mostrato un rapido aumento a breve termine. Il prezzo di TRUMP è tornato indietro e si attesta intorno ai $12. Il massimo settimanale è di circa $14,6. Attualmente si trova in una tendenza di fluttuazione a breve termine e il prezzo è relativamente stabile.<br><img src="https://gimg2.gateimg.com/image/article/17455650021.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali953298"><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-Bitcoin20BTC963253"><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/17455650262.jpeg" alt=""><br>(Dati forniti da TradingView)</p>
<p>Questa settimana, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo BTC</a> Il trend è aumentato continuamente dall’apertura e il prezzo ha superato una volta i $94,000. È sceso leggermente, ma rimane comunque nel recente intervallo di prezzi elevati. Influenzato da fattori di notizie esterne, il prezzo del BTC ha raggiunto un record storico e la scala di capitale complessiva ha raggiunto il sesto asset più grande al mondo. Il prezzo del BTC è probabile che continui ad aumentare nel breve termine, e la continua salita e discesa in un piccolo intervallo sarà il mercato principale.</p>
<h3 id="h3-Ethereum20ETH957253"><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/17455650523.jpeg" alt=""><br>(Dati Cortesia Di TradingView)</p>
<p>Il trend del prezzo dell’ETH questa settimana è superiore a quello del BTC, ma anche le fluttuazioni a breve termine sono più volatili. Il prezzo dell’ETH ha toccato il picco sopra gli $1.800 in una settimana. Attualmente, il prezzo dell’ETH si attesta intorno a $1.760. Il trend successivo è probabile che continui a salire e scendere in un piccolo range, ma c’è un ampio spazio verso l’alto. Ci si aspetta che ci siano certe variazioni di prezzo durante il fine settimana.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3683517"><a name="Tendenza del Progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza del Progetto Web3</h2><p>Questa settimana, il valore di mercato totale dei sette tipi di progetti è aumentato su tutta la linea, e l’incremento ha raggiunto un massimo recente. Il mercato ha vissuto una ripresa in rialzo a causa di fattori esterni. Di conseguenza, la maggior parte delle tracce è stata dominata dal rimbalzo. Ci si aspetta che il principale trend attuale continuerà durante il periodo di chiusura del fine settimana, e un leggero trend al rialzo sarà il trend più probabile.</p>
<table>
<thead>
<tr>
<th>Categoria del Progetto</th>
<th>Variazione a 7 giorni</th>
<th>Top 3 Gainers</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>11.5%</td>
<td>PAC, MIRAI, KRU</td>
<td>Il market cap totale della traccia Layer 1 è aumentato notevolmente e l’aumento delle prime monete è rimasto all’interno di un range moderato, con una distribuzione complessivamente abbastanza uniforme.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>24.2%</td>
<td>BB,RENTA,MERL</td>
<td>Il settore Layer 2 è notevolmente ripartito, ma l’incremento medio complessivo è stato distribuito in modo uniforme e l’incremento delle migliori monete è stato moderato e non elevato.</td>
</tr>
<tr>
<td>DeFi</td>
<td>15.1%</td>
<td>PBTC,COMBO,FLURRY</td>
<td>Il tetto del mercato totale della traccia DeFi è notevolmente rimbalzato, ma i guadagni delle migliori monete sono concentrati in monete individuali, il che è un trend che è continuato rispetto alla settimana scorsa.</td>
</tr>
<tr>
<td>NFT</td>
<td>24.6%</td>
<td>DREAMS,CHMPZ,YAKA</td>
<td>Il limite totale del mercato NFT è aumentato rapidamente, ma le principali monete in aumento sono ancora principalmente progetti completi e la distribuzione complessiva della crescita è relativamente uniforme.</td>
</tr>
<tr>
<td>MEME</td>
<td>21.3%</td>
<td>CATX,CATME,UNI</td>
<td>Il tracciamento della moneta MEME ha registrato un significativo aumento, ma questa crescita è concentrata nelle singole principali monete, con ampie differenze all’interno del tracciamento.</td>
</tr>
<tr>
<td>Liquid Staking</td>
<td>12.6%</td>
<td>QCKUJI,BRG,RAPR</td>
<td>Questo settore ha mostrato un certo grado di aumento, ma i guadagni delle principali criptovalute sono relativamente concentrati, e i guadagni sono effettivamente piuttosto limitati rispetto ad altre tracce.</td>
</tr>
<tr>
<td>AI</td>
<td>21.8%</td>
<td>MINDS,SUIDEPIN,SENT</td>
<td>La traccia AI ha registrato un significativo recupero, ma i guadagni nelle principali criptovalute sono concentrati nelle singole monete, mentre i guadagni nelle altre monete nell’insieme della traccia sono relativamente piccoli.</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 suggerimenti 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 riposting dell'articolo a condizione che venga referenziato 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>