UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIz

2025-04-11, 02:40

<p><img src="https://gimg2.gateimg.com/image/article/1744338191weeklyweb3research.png" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze265533"><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, fattori esterni hanno influenzato notevolmente il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>. La questione dei dazi statunitensi ha causato un forte calo del mercato dei capitali principale, ma le successive comunicazioni aggiuntive hanno spinto il mercato, compreso il mercato azionario statunitense e il mercato crittografico, di nuovo in alto. Anche se le monete principali hanno subito fluttuazioni significative, il mercato nel complesso ha mostrato una notevole resilienza.</p>
<p>La maggior parte delle monete principali sul mercato ha mostrato un trend al ribasso questa settimana. A causa dell’impatto della questione dei dazi, il mercato crittografico ha oscillato e è sceso significativamente. La successiva dichiarazione di aggiustamento ha portato a un rimbalzo a breve termine, ma il trend complessivo del mercato per la settimana è ancora al ribasso. A breve termine, il mercato si troverà di fronte a un punto di svolta chiave dopo che la questione dei dazi sarà definitivamente determinata.</p>
<p>In generale, il mercato ha sperimentato un brusco declino a breve termine dall’apertura di questa settimana. Tutte le principali criptovalute sono scese ai minimi recenti, mostrando un calo generale. Tuttavia, con l’influenza di fattori esterni di natura informativa, il mercato ha registrato un rimbalzo dopo la metà della settimana, ma i relativi fattori esterni sono ancora complessi. Il mercato nel suo complesso è nuovamente entrato in un chiaro canale discendente, con la possibilità di ulteriori cali in futuro.</p>
<p>La fluttuazione del prezzo del BTC è stata molto evidente questa settimana. Dopo il recupero, il prezzo è nuovamente sceso a circa $79,500. Il trend successivo molto probabilmente continuerà ad essere fortemente influenzato da fattori esterni e seguirà principalmente il trend del mercato principale.</p>
<p>Il trend settimanale del prezzo dell’ETH è in linea con il BTC e mostra un trend al ribasso a breve termine. Il prezzo massimo settimanale si attesta intorno a $1,680, mentre il prezzo minimo settimanale è sceso a circa $1,418. Ora è nuovamente entrato in un chiaro canale discendente.</p>
<p>Questa settimana, il trend dei prezzi delle principali criptovalute è stato principalmente in ribasso. La capitalizzazione complessiva del mercato crittografico attuale è diminuita, raggiungendo circa 2,53 trilioni di dollari, una diminuzione di circa il 3,55% in 24 ore. Il prezzo attuale del BTC si attesta intorno a 79.518 dollari. Il prezzo attuale dell’ETH si mantiene intorno a 1.516 dollari.</p>
<p>Questa settimana, il mercato cripto nel complesso è stato in un canale ribassista volatile, con la maggior parte delle monete principali mostrando un trend al ribasso, e pochi prezzi in aumento. La moneta principale con il maggior aumento è stata XCN, che ha raggiunto circa il 90% in una settimana, principalmente perché la moneta ha risposto in modo più attivo alla politica tariffaria di Trump, causando un significativo aumento del prezzo della moneta nel breve termine.</p>
<p>Ci si aspetta che il mercato delle criptovalute nel complesso continui a fluttuare questo fine settimana, ed è probabile che mantenga rapidi aumenti e cali entro un certo intervallo. Le salite e le discese delle principali monete dipenderanno maggiormente dall’impatto dei fattori di notizie esterne.</p>
<h2 id="h2-Mercato20delle20criptovalute655117"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥I dati di Cloverpool mostrano che la difficoltà di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mining è stato regolato all’altezza del blocco 891.072 (21:50:26 ora di Pechino del 5 aprile), con la difficoltà aumentata del 6,81% a 121,51T, un record storico.</p>
<p>🔥Secondo Eleanor Terrett, funzionari della Casa Bianca hanno rivelato che le agenzie federali devono segnalare le loro criptovalute al Segretario del Tesoro Scott Bessent entro il 7 aprile, ora dell’Est. Tuttavia, il decreto esecutivo richiede solo che la relazione venga inviata a Bessent e non obbliga a rendere pubblici i risultati dell’audit. Non è chiaro se e quando queste informazioni saranno rese pubbliche.</p>
<p>🔥L’analista criptico Miles Deutscher ha twittato a sostegno di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>, credendo fermamente che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> raggiungerà un nuovo ATH tra il terzo trimestre di quest’anno e il primo trimestre del 2026.</p>
<p>🔥Secondo CoinDesk, Bitcoin è rimasto stabile di recente nel mezzo del caos indotto dai dazi nel mercato azionario degli Stati Uniti, facendo sì che i partecipanti al mercato fossero entusiasti del potenziale di questa criptovaluta come bene rifugio, ma non si può escludere la possibilità di un brusco declino nel breve termine, specialmente perché il “commercio di base del mercato del Tesoro degli Stati Uniti” è a rischio a causa dell’aumentata volatilità dei prezzi dei bond.</p>
<p>🔥Ki Young Ju, fondatore e CEO di CryptoQuant, ha pubblicato sulla piattaforma X che il ciclo del mercato rialzista del Bitcoin è terminato.</p>
<p>🔥Robert Kiyosaki, autore di “Padre ricco padre povero”, ha recentemente pubblicato sui social media che la crisi economica globale non è più una minaccia futura, ma un problema reale.</p>
<p>🔥Secondo Bitcoin Magazine, il piano di investimento in Bitcoin di GameStop si chiama “Project Rocket”. Notizie precedenti hanno affermato che il 2 aprile GameStop (GME) potrebbe essere in procinto di iniziare o ha già iniziato ad acquistare Bitcoin (BTC) dopo aver completato l’emissione di 1,3 miliardi di dollari in obbligazioni convertibili a cinque anni.</p>
<p>🔥Secondo le leggi sul Bitcoin, una risoluzione proposta dal Partito Democratico alla Camera dei Rappresentanti della Georgia raccomanda che il Dipartimento dell’Istruzione dello Stato introduca contenuti educativi su “blockchain, criptovaluta e <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a>“nel curriculum K-12 (dalla scuola materna alla 12a classe).”</p>
<p>🔥Arthur Hayes ha twittato che i detentori di Bitcoin devono imparare ad abbracciare le politiche tariffarie. Forse Bitcoin ha finalmente spezzato la sua associazione con Nasdaq ed è diventato il più puro “allarme antincendio” per la liquidità della valuta fiat.</p>
<p>🔥 Secondo Decrypt, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Il CEO Paolo Ardoino ha detto che non gli dispiace che USDT sia vietato negli Stati Uniti a causa delle nuove normative. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> sta considerando attivamente la creazione di una nuova stablecoin registrata negli Stati Uniti e si conformerà alla prossima legge sulle stablecoin statunitensi.</p>
<p>🔥Bitcoin è crollato del 10% in 24 ore questa settimana a causa della guerra commerciale del presidente degli Stati Uniti Trump che ha colpito i mercati globali.</p>
<p>Il progetto crypto della famiglia Trump, World Liberty Financial, ha rilasciato una proposta di governance, pianificando di distribuire gratuitamente una piccola quantità di stablecoin USD1 a tutti i detentori di $WLFI tramite il sistema on-chain per testare la sua funzione di airdrop e ringraziare i sostenitori precoci.</p>
<p>🔥Secondo Bitcoin.com, Jack Dorsey, CEO della società tecnologica Bitcoin Block, ha detto nel podcast “21 in 21” di Presidio Bitcoin che Bitcoin potrebbe fallire nonostante il suo sviluppo fino a oggi perché potrebbe perdere la rilevanza nel risolvere i problemi per cui era stato originariamente progettato.</p>
<p>🔥Galaxy Digital ha annunciato di aver ottenuto l’approvazione dalla Securities and Exchange Commission (SEC) degli Stati Uniti per la sua dichiarazione di registrazione S-4, segnando una fase critica nel processo di spostamento della sede registrata dalle Isole Cayman a Delaware, negli Stati Uniti, e pianificando di quotarsi al Nasdaq.</p>
<p>🔥Secondo CoinDesk, mentre il mercato delle criptovalute iniziava a ritirarsi giorni dopo che il mercato finanziario tradizionale ha risposto alla politica tariffaria del presidente Trump, il Bitcoin è crollato a un minimo di cinque mesi di $74.500, una diminuzione cumulativa di un terzo rispetto al suo massimo storico del 20 gennaio.</p>
<p>🔥L’analista di criptovalute Eugene ha detto che ha comprato per la prima volta spot BTC quando il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo BTC</a> era vicino a $75k, che è stata la sua prima operazione dopo aver liquidato le sue principali partecipazioni a gennaio.</p>
<p>🔥Le tariffe ampie imposte dall’amministrazione Trump potrebbero causare il crollo della domanda di macchine per il mining di Bitcoin negli Stati Uniti, il che sarebbe vantaggioso per le operazioni di mining al di fuori degli Stati Uniti in quanto i produttori cercano mercati al di fuori degli Stati Uniti per vendere il loro eccesso di inventario a prezzi più bassi.</p>
<p>🔥Secondo The Block, anche se le recenti tariffe imposte dal Presidente degli Stati Uniti Trump hanno causato gravi turbolenze sia nei mercati delle criptovalute che in quelli tradizionali, gli analisti di Bernstein hanno sottolineato che la resilienza di Bitcoin è incredibile.</p>
<p>Il CEO di Messari Eric Turner e il co-fondatore di Sygnum Bank Thomas Eichenberger hanno dichiarato durante una tavola rotonda alla Paris Blockchain Week che si aspettano un importante cambiamento del coinvolgimento del settore bancario nelle criptovalute nella seconda metà di quest’anno.</p>
<p>🔥Secondo la rivista Fortune, il Dipartimento di Giustizia degli Stati Uniti ha informato i dipendenti lunedì sera che l’agenzia sta sciogliendo un’unità dedicata alle indagini legate alle criptovalute. In un memo di quattro pagine esaminato dalla rivista Fortune, il Vice Procuratore Generale degli Stati Uniti Todd Blanche ha annunciato la decisione, dicendo: “Il Dipartimento di Giustizia non è un regolatore di attività digitali. Tuttavia, l’amministrazione precedente ha utilizzato il Dipartimento di Giustizia per attuare una strategia di regolamentazione imprudente attraverso la persecuzione.”</p>
<p>🔥Gli analisti di Bernstein ritengono che il calo attuale del Bitcoin sia più resistente rispetto ai cali precedenti durante le crisi. Gli analisti hanno citato dati storici per sottolineare che nelle crisi precedenti (come il panico di mercato causato dall’epidemia di COVID-19, gli shock dei tassi di interesse, ecc.), il Bitcoin ha subito un calo del 50% al 70%. “La tendenza attuale dei prezzi (in calo del 26%) mostra che la domanda di Bitcoin proviene da un capitale più resistente.</p>
<p>🔥La strategia divulgata nei “Rischi aziendali” del documento 8-K presentato alla SEC indica che l’azienda è sottoposta a significative pressioni finanziarie. Se la capitalizzazione di mercato del Bitcoin dovesse diminuire in modo significativo, potrebbe essere costretta a vendere Bitcoin a un prezzo inferiore al costo per adempiere ai suoi obblighi, e addirittura correre il rischio di inadempienza, bancarotta o liquidazione.</p>
<p>🔥Secondo CoinDesk, la Standard Chartered Bank ha dichiarato in un rapporto pubblicato martedì che Ripple’s <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Il prezzo del token potrebbe salire a $12.50 prima che il Presidente degli Stati Uniti Trump lasci l’incarico.</p>
<p>🔥Secondo la rivista Fortune, la società di pagamenti crittografici Ripple ha acquisito la società di brokerage primario Hidden Road per $1.25 miliardi nel tentativo di espandere i suoi servizi per gli investitori istituzionali.</p>
<p>🔥Secondo Cryptoslate, il noto avvocato criptato James Murphy (@MetaLawMan) ha intentato una causa contro il Dipartimento della Sicurezza Interna degli Stati Uniti (DHS) in base al Freedom of Information Act (FOIA). È stata intentata una causa contro il Dipartimento della Sicurezza Interna degli Stati Uniti (DHS) in base al Freedom of Information Act (FOIA).</p>
<p>🔥Secondo ilStraits Times, il tasso di possesso di criptovalute a Singapore raggiungerà il 26% nel 2024, in aumento dal 24,4% dell’anno precedente. La Generazione Z e i millenni (di età compresa tra 16 e 44 anni) sono gli utenti principali, di cui circa il 40% detiene asset criptati e più della metà li utilizza per lo shopping online e il pagamento delle bollette.</p>
<p>Gli analisti hanno osservato che Bitcoin ha significativamente ridotto il suo rischio mentre entra nel periodo di chiusura, e quasi l’80% degli aggiustamenti ciclici dei prezzi è stato completato. Man mano che il mercato si stabilizza gradualmente, Bitcoin potrebbe essere in procinto di terminare il suo attuale ciclo al ribasso, portando a una prospettiva più stabile per gli investitori.</p>
<p>🔥Gli investitori di Farside pubblicano l’aggiornamento sulla produzione mineraria di Bitcoin di marzo 2025: Tutte le principali società minerarie quotate hanno rilasciato i dati. Questo è un mese record dal momento che il <a href="/explore/bitcoin-halving-countdown" rel="nofollow noopener noreferrer" target="_blank">Bitcoin halving</a>, con un totale di 3.648 Bitcoins minati.</p>
<p>🔥Bitcoin e altre importanti criptovalute sono scese mercoledì dopo che Trump ha preso ulteriori misure tariffarie, ha riferito The Block.</p>
<p>Il co-fondatore di Ledn ha rivelato che il costo dei prestiti ipotecari in Bitcoin verrà significativamente ridotto a livello mondiale, con l’obiettivo di migliorare la competitività del mercato dei prestiti crittografici. Questa tendenza potrebbe spingere più istituzioni e individui ad adottare il finanziamento ipotecario BTC, promuovendo al contempo ulteriormente l’integrazione tra DeFi e finanza tradizionale. Il piano specifico di regolazione dei tassi di interesse e il tempo di attuazione non sono ancora stati annunciati.</p>
<p>🔥Secondo CoinDesk, l’agenzia di rating Moody’s ha sottolineato in un rapporto mercoledì che, anche se la tokenizzazione dei fondi è in pieno sviluppo, gli investitori non possono ignorare i gravi rischi ad essa associati.</p>
<p>🔥 Secondo Decrypt, la società di sicurezza informatica Kaspersky ha scoperto un nuovo tipo di malware per frodi crittografiche che ha manomesso l’indirizzo del portafoglio negli appunti.</p>
<h2 id="h2-Regulatory20amp20Macro20Policies618248"><a name="Regulatory &amp; Macro Policies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regulatory &amp; Macro Policies</h2><p>🔥Secondo TheBlock, Mark T. Uyeda, Presidente ad interim della Securities and Exchange Commission degli Stati Uniti (SEC), ha istruito il personale dell’agenzia sabato scorso di riesaminare diverse dichiarazioni del personale precedentemente emesse sugli investimenti in criptovalute e sulle leggi applicabili per i titoli di attività digitali. Questa istruzione è stata emessa in conformità con il Decreto Esecutivo 14192 (intitolato “Promozione della prosperità attraverso la deregolamentazione”) e ha risposto alle raccomandazioni del Dipartimento dell’Efficienza Governativa (DOGE).</p>
<p>🔥La Divisione Finanza Societaria della Securities and Exchange Commission degli Stati Uniti ha rilasciato una dichiarazione sui stablecoin, affermando che secondo la normativa attuale, determinati tipi di criptoasset (cioè, “Covered Stablecoin”) non sono titoli, e le persone coinvolte nel processo di “coniazione” e scambio di stablecoin non devono registrare tali transazioni presso la Commissione ai sensi del Securities Act, né devono conformarsi a una delle esenzioni dalla registrazione previste dal Securities Act.</p>
<p>🔥Il gruppo di lavoro criptato della Securities and Exchange Commission degli Stati Uniti (SEC) ha pubblicato l’ordine del giorno e l’elenco dei relatori per il suo tavolo rotondo dell’11 aprile, “Tra un blocco e un posto difficile: adattare la regolamentazione per il trading di criptovalute.”</p>
<p>🔥La Securities and Futures Commission di Hong Kong ha ufficialmente rilasciato linee guida relative alle garanzie per le piattaforme di trading di attività virtuali autorizzate e ai fondi di attività virtuali approvati, che stabiliscono che le piattaforme di trading di attività virtuali autorizzate possono fornire servizi di garanzia, inclusa la fornitura di garanzie per gli ETF spot di attività virtuali.</p>
<p>🔥Secondo Fortune, nuovi documenti che gli consulenti di investimento devono presentare ai sensi dei regolamenti della Securities and Exchange Commission (SEC) degli Stati Uniti mostrano la dimensione degli asset in gestione (AUM) di ciascuna società.</p>
<p>🔥Il Dipartimento di Giustizia degli Stati Uniti ha rilasciato una dichiarazione ufficiale sulle leggi cripto, affermando che gli sviluppatori non saranno ritenuti responsabili e i criminali che utilizzano il codice saranno considerati responsabili. Cioè, è chiaro che gli sviluppatori non sono responsabili dell’uso del codice da parte dei criminali, e l’attenzione delle forze dell’ordine si è spostata verso crimini reali come frodi e finanziamenti terroristici. Il memorandum sottolinea la protezione dei diritti e degli interessi degli utenti e delle imprese legittimi della blockchain, il sostegno a un accesso equo ai servizi bancari e la riduzione delle azioni delle forze dell’ordine contro piattaforme di trading cripto e servizi di mixing. Questa mossa potrebbe segnare un ulteriore allentamento delle restrizioni sull’industria cripto da parte dell’amministrazione Trump, iniettando nuova vitalità nello sviluppo dell’industria.</p>
<p>🔥Il memorandum del Dipartimento di Giustizia degli Stati Uniti ha dichiarato che smetterà di regolare gli scambi di valute virtuali e i portafogli offline. Il memorandum istruisce i pubblici ministeri a concentrarsi sui casi di criptovaluta legati alle monete dei Cartelli e al terrorismo.</p>
<p>🔥Secondo Cryptoslate, la Commissione per i titoli e gli investimenti australiana (ASIC) ha annunciato il 7 aprile che la Corte federale ha approvato la sua richiesta di chiudere 95 società legate a truffe criptate e schemi di uccisione di maiali. Queste entità sono state sciolte a causa di comportamenti impropri e registrazioni false.</p>
<p>🔥La Camera dei rappresentanti degli Stati Uniti ha tenuto un’audizione per discutere la legislazione sulla struttura del mercato crittografico, segnando un passo importante avanti per il disegno di legge. I legislatori hanno dibattuto un quadro normativo per gli asset digitali volto a stabilire regole chiare per gli scambi crittografici e l’emissione di token. L’audizione apre la strada a una legislazione finale che potrebbe cambiare il panorama normativo dell’industria crittografica statunitense. I sostenitori del disegno di legge credono che porterà maggiore certezza e protezione degli investitori al mercato.</p>
<p>🔥Secondo Bitcoinist, il deputato svedese Rickard Nordin ha chiesto al Ministro delle Finanze di diversificare le riserve di cambio estero per includere Bitcoin.</p>
<p>🔥Caroline D. Pham, presidente ad interim della Commodity Futures Trading Commission (CFTC) degli Stati Uniti, ha espresso il suo sostegno all’annuncio del Dipartimento di Giustizia di porre fine alla sua politica di regolamentazione dell’industria degli asset crittografici attraverso procedimenti penali e ha istruito la CFTC a non intentare cause nei casi relativi agli asset digitali per violazione delle disposizioni di registrazione del Commodity Exchange Act quando il convenuto manca di intento soggettivo.</p>
<p>🔥Caroline Pham, Presidente ad interim della Commodity Futures Trading Commission (CFTC) degli Stati Uniti, ha elogiato l’annuncio recente del Dipartimento di Giustizia di porre fine alla sua politica di regolamentazione dell’industria degli asset digitali attraverso il perseguimento penale, e ha istruito il personale della CFTC a seguire l’ordine esecutivo del Presidente e la nuova guida del Dipartimento di Giustizia sull’applicazione degli asset digitali.</p>
<p>🔥Natasha Cazenave, direttore esecutivo dell’Autorità europea degli strumenti finanziari e dei mercati (ESMA), il regolatore del mercato dei titoli dell’UE, ha dichiarato in un’audizione al Parlamento europeo che sebbene gli asset crittografici rappresentino attualmente meno dell’1% del sistema finanziario globale e abbiano limitati ‘effetti a catena’ sulla finanza tradizionale, le dimensioni del mercato crittografico raddoppieranno fino a 3,3 trilioni di euro nel 2024 e il collegamento tra istituzioni e finanza tradizionale si sta approfondendo rapidamente.</p>
<h2 id="h2-Evidenziazioni20del20mercato20delle20criptovalute424307"><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 scorsa settimana, il mercato crittografico nel suo complesso è stato fortemente influenzato da fattori esterni, e il mercato globale dei capitali è stato gravemente colpito dalle questioni tariffarie, ma il mercato crittografico è rimasto relativamente resiliente e il trend generale di ripresa è riapparso in breve tempo. Nella scorsa settimana, le principali criptovalute hanno principalmente continuato a salire e scendere nel breve termine, e solo un piccolo numero di monete è aumentato. Il mercato è ancora in un canale discendente, e ci si aspetta che continui fino a quando non saranno determinate informazioni esterne chiave.</p>
<p>⭐️Questa settimana, XCN ha raggiunto il primo posto tra le monete principali del mercato crittografico, arrivando a circa il 90%, principalmente perché la moneta ha recentemente adottato misure positive per affrontare la politica tariffaria di Trump, e la comunità ha risposto con entusiasmo, e il sentiment rialzista esterno è dominante. Il prezzo di XCN rimane intorno a $0.01688, e il massimo settimanale si attesta intorno a $0.017. Attualmente è in una tendenza di fluttuazione a breve termine, e il prezzo è leggermente diminuito.<br><img src="https://gimg2.gateimg.com/image/article/17443387511.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali528720"><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-Bitcoin20BTC536839"><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/17443388512.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Questa settimana, la tendenza del prezzo del BTC ha mostrato un rapido declino dopo l’apertura, e il prezzo ha raggiunto il recente minimo di $74,400, per poi mostrare brevi periodi di alti e bassi. Dopo il punto di svolta chiave della questione dei dazi, il prezzo del BTC è salito rapidamente in un breve periodo di tempo ed è salito di nuovo sopra gli $80,000, ma ora è entrato in un nuovo intervallo di prezzo, mantenendo rapide fluttuazioni intorno a $79,500. La tendenza dei prezzi del BTC ha mostrato una forte resistenza agli shock. Il successivo prezzo del BTC continuerà a seguire la tendenza complessiva del mercato e sarà fortemente influenzato dai principali fattori delle notizie esterne.</p>
<h3 id="h3-Ethereum20ETH173293"><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/17443388733.jpeg" alt=""><br>(Dati Cortesia Di TradingView)</p>
<p>Il trend del prezzo dell’ETH di questa settimana è approssimativamente in linea con quello del BTC, ma la frequenza delle variazioni a breve termine è relativamente bassa. Il prezzo dell’ETH era intorno a $1.790 all’apertura. Dopo essere stato colpito dalla questione dei dazi, il prezzo dell’ETH è sceso a circa $1.400, e persino è sceso sotto i $1.400 in un breve periodo di tempo. Attualmente, il prezzo dell’ETH ha nuovamente superato i $1.500 e continua a fluttuare. Si prevede che rimarrà nell’attuale intervallo durante il fine settimana.</p>
<h2 id="h2-Tendenza20del20progetto20Web3839157"><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 limite di mercato totale dei sette tipi di progetti ha continuato a diminuire in generale, ma il calo è stato più lieve rispetto alla settimana scorsa. La questione dei dazi ha ancora fortemente influenzato il mercato e il trend al ribasso complessivo è stato più evidente. Recentemente, il mercato nel complesso è stato principalmente influenzato da fattori esterni, ed è previsto che il trend attuale dei prezzi sarà mantenuto in modo appropriato durante il periodo di chiusura del fine settimana.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione a 7 giorni</th>
<th>Top 3 Guadagnatori</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Livello 1</td>
<td>-4.7%</td>
<td>XCN,MET,WEMIX</td>
<td>Il market cap totale del Layer 1 track è diminuito. Tra le prime monete, XCN è il principale esecutore. Nel complesso, la maggior parte dei progetti ha subito un significativo calo.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>-7.6%</td>
<td>MANA3,ZRC,KONET</td>
<td>Il settore Layer 2 è sceso in modo significativo. L’ascesa di alcuni coin è stata principalmente dovuta a poche monete leader, mentre la maggior parte delle monete è scesa.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-6.5%</td>
<td>BABY, VERSE, VSP</td>
<td>Il market cap totale della traccia DeFi è diminuito. La distribuzione dei guadagni delle principali monete è estremamente sbilanciata, principalmente dominata da singole monete, e la maggior parte delle monete nella traccia sta principalmente diminuendo.</td>
</tr>
<tr>
<td>NFT</td>
<td>-5.5%</td>
<td>MTRM,GUM,DG</td>
<td>Il valore totale del mercato NFT è diminuito. I guadagni delle migliori monete sono distribuiti in modo relativamente uniforme e la maggior parte delle monete nella traccia sta principalmente diminuendo.</td>
</tr>
<tr>
<td>MEME</td>
<td>-6.1%</td>
<td>MINDS,GME,BRITTO</td>
<td>Il settore delle monete MEME ha mostrato un certo calo, con le prime monete in ascesa che continuano ad essere le monete migliori della scorsa settimana, principalmente guidate dai ritiri dei prezzi.</td>
</tr>
<tr>
<td>Staking Liquido</td>
<td>-13.0%</td>
<td>SDL,URO,SARA</td>
<td>Questo tracciato ha registrato un netto calo, mostrando un trend complessivamente al ribasso. I guadagni delle principali criptovalute in ascesa sono rimasti all’interno di un piccolo intervallo, con una distribuzione relativamente uniforme.</td>
</tr>
<tr>
<td>AI</td>
<td>-6.5%</td>
<td>MINDS,VDA,$HWTR</td>
<td>Il settore dell’IA è diminuito significativamente. I guadagni delle migliori criptovalute erano concentrati in singole criptovalute e i prezzi sono principalmente diminuiti. Nel complesso, la tendenza è stata fortemente influenzata dalle fluttuazioni di mercato.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</strong>, Ricercatore di Gate.io<br><div>Translator: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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 repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>