UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIz

<p><img src="https://gimg2.gateimg.com/image/article/1743752349weeklyweb3research.png" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze866938"><a name="Panoramica settimanale delle tendenze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica settimanale delle tendenze</h2><p>Il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato cripto</a> è stato fortemente influenzato da fattori esterni questa settimana. La politica tariffaria di Trump è entrata in vigore, l’avversione al rischio del capitale si è intensificata, e il mercato azionario statunitense ha esercitato una forte pressione sul mercato delle criptovalute, causando un continuo trend al ribasso dell’intero mercato da lo scorso fine settimana. Non vi sono stati segni di ripresa dopo l’apertura, e il trend al ribasso complessivo è stato molto evidente.</p>
<p>Questa settimana, le principali criptovalute sul mercato hanno mostrato un generale calo. A causa del declino delle azioni statunitensi, le società quotate nel settore delle criptovalute sono state seriamente colpite, e le due tendenze erano piuttosto simili. Inoltre, l’impatto dell’aggiustamento dei dazi da parte del governo statunitense e delle politiche relative alle criptovalute ha causato un certo colpo al mercato. Il mercato delle criptovalute continua ad avere un forte trend al ribasso nel breve termine.</p>
<p>Il mercato ha sperimentato un trend al ribasso continuo dall’apertura di questa settimana, e alcune criptovalute principali sono scese del 30% in una settimana. Tuttavia, dopo essere entrati nel periodo a metà settimana, alcune criptovalute principali hanno avuto un leggero trend di ripresa, principalmente a causa dell’impatto delle notizie, ma questo trend non è continuato. Poiché il mercato si avvicina al periodo di chiusura della settimana, il mercato nel complesso mostra ancora un trend al ribasso a breve termine, e c’è la possibilità di ulteriori declini in futuro.</p>
<p>Il prezzo del BTC è sceso questa settimana ed ha ora raggiunto il livello chiave di supporto di circa $81,500. Se scende al di sotto dell’attuale range di prezzo, c’è un’alta probabilità di un calo compensativo. C’è una certa probabilità che scenda al di sotto di $80,000.</p>
<p>Il trend settimanale del prezzo di ETH è simile a quello di BTC e attualmente mostra un trend al ribasso a breve termine. Il prezzo massimo settimanale si aggira intorno a $1.941. È ora entrato nel range dei prezzi minimi settimanali, raggiungendo circa $1.760. La diminuzione complessiva del prezzo è maggiore rispetto a quella di BTC.</p>
<p>Il trend dei prezzi delle principali criptovalute chiave di questa settimana è principalmente al ribasso. La capitalizzazione di mercato complessiva del mercato cripto attuale è diminuita significativamente, raggiungendo circa $2.6 trilioni, con una diminuzione di circa il 5.3% in 24 ore. Il prezzo attuale del BTC si aggira intorno a $81,700. Il prezzo attuale dell’ETH si mantiene intorno a $1,760.</p>
<p>Questa settimana, il mercato cripto nel complesso è stato in un canale ribassista volatile, con la maggior parte delle principali monete che mostravano un trend al ribasso. Alcuni prezzi sono aumentati ma l’incremento è stato relativamente piccolo. <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a> è stata la criptovaluta con il maggior aumento, raggiungendo circa il 43% in una settimana. Questo è stato principalmente dovuto al fatto che, essendo una criptovaluta utility basata su blockchain, ha recentemente promosso il rinnovamento del marchio e incentivi allo staking, causando l’impennata del prezzo della criptovaluta nel breve termine.</p>
<p>Il mercato delle criptovalute continuerà a fluttuare questo fine settimana, e le fluttuazioni a breve termine saranno il mercato dominante. L’ascesa e la caduta delle principali monete dipenderanno dal fatto che le monete leader mostrino un calo compensativo.</p>
<h2 id="h2-Mercato20delle20criptovalute971397"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Secondo Samaa, l’esperto di mercato finanziario di Exness Inky Cho ha dichiarato che il recente calo del mercato delle criptovalute potrebbe essere correlato alla vendita di panico causata dal rimborso del debito di Mt.Gox e dal trasferimento di BTC. Allo stesso tempo, le osservazioni di Trump sull’imminente recessione economica hanno scosso i mercati azionari e delle criptovalute.</p>
<p>🔥Secondo le notizie. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a>, nei 89 giorni trascorsi dall’ingresso del 2025, il valore totale del settore delle criptovalute è diminuito di oltre 600 miliardi di dollari, passando da circa 32.700 a circa 2,6 trilioni di dollari.</p>
<p>Secondo Cointelegraph, il volume di scambio delle prime dieci stablecoin è sceso a un quarto del livello del ciclo del mercato toro di dicembre dello scorso anno. Gli analisti ritengono che l’affaticamento dei trader, l’incertezza regolamentare e il calo dell’offerta di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> a un minimo di sette anni siano fattori chiave.</p>
<p>🔥Peter Schiff, un economista ostile alle criptovalute, ha pubblicato sulla piattaforma X che il prezzo dell’oro ha nuovamente raggiunto un nuovo record di oltre $3.080 all’oz., mentre milioni di giovani americani hanno lasciato passare questo “treno ad alta velocità” e hanno rivolto la loro attenzione al Bitcoin.</p>
<p>🔥L’analista di Greeks.live Adam ha dichiarato che i membri del gruppo sono generalmente cauti verso gli orsi. I trader si concentrano sulla vendita di opzioni put a $81.000 come potenziale minimo. Attualmente, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha un tasso di finanziamento negativo e l’indicatore di volatilità DVOL è aumentato, riflettendo un’incerta del mercato.</p>
<p>🔥Secondo Cryptoslate, secondo un recente rapporto della società di ricerca Decentralised, in mezzo a un aumento del numero di token, i nuovi flussi di capitale si sono bloccati, lasciando molti progetti crittografici senza fondi.</p>
<p>L’analista cripto Ali Martinez ha pubblicato un’analisi grafica sulla piattaforma X, affermando che il rapporto venditore di BTC è sceso al 0,086%. Negli ultimi due anni, un rapporto venditore inferiore allo 0,1% di solito ha annunciato un forte rimbalzo nei prezzi.</p>
<p>🔥Secondo i media sudcoreani SBS, alla fine di febbraio di quest’anno, il numero totale di utenti delle borse di asset virtuali della Corea del Sud ha superato i 16 milioni, raggiungendo 16,29 milioni, pari a circa il 32% della popolazione totale del paese (circa 51,68 milioni).</p>
<p>🔥Secondo TheBlock, dopo le elezioni negli Stati Uniti il 5 novembre, il volume di scambi giornaliero delle criptovalute è schizzato a 126 miliardi di dollari in mezzo a un’elevata entusiasmo di mercato e speculazione attiva. Ora è sceso a 35 miliardi di dollari, circa il 70% in meno rispetto al picco, tornando ai livelli pre-elettorali. Le recenti annunciazioni di tariffe contro i principali partner commerciali degli Stati Uniti hanno portato incertezza, indebolendo l’entusiasmo degli scambi sia nei mercati tradizionali che in quelli crittografici.</p>
<p>🔥Secondo Cointelegraph, David Pakman, socio gestore di CoinFund, ha affermato che l’offerta globale di stablecoin potrebbe aumentare dalle attuali dimensioni di circa $225 miliardi a $1 trilione, il che potrebbe diventare un fattore chiave per la crescita del mercato crittografico.</p>
<p>🔥Secondo Benzinga, Matt Mena, uno stratega di ricerca cripto presso 21Shares, ha dichiarato che mentre le azioni statunitensi hanno oscillato in mezzo all’incertezza macroeconomica, il BTC ha mostrato resilienza e difende l’area di supporto $84.000-85.000. Nic Puckrin, fondatore di The Coin Bureau, ha sottolineato che i dati del PCE rilasciati venerdì potrebbero indurre la Federal Reserve a posticipare i suoi recenti piani di taglio dei tassi. Non ci si aspetta che Bitcoin torni ai suoi massimi storici fino a quando la Fed non taglierà nuovamente i tassi.</p>
<p>🔥Secondo CoinDesk, il partner di Architect Partners Elliot Chun ha scritto in un rapporto di osservazione di mercato: “Combinando varie disposizioni strategiche, si prevede che entro il 2030, il 25% delle aziende dell’indice S&amp;P 500 includerà Bitcoin come attivo a lungo termine nei loro bilanci.”</p>
<p>🔥Secondo Decrypt, il 30 marzo, durante un incontro pubblico tenutosi presso il Musk’s America PAC a Green Bay, Wisconsin, Musk ha preso le distanze dal Dipartimento dell’Efficienza Federale (D.O.G.E.) <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> criptovaluta.</p>
<p>🔥Secondo Beincrypto, il CEO di BlackRock Larry Fink ha affermato in una recente lettera che Bitcoin e le criptovalute potrebbero minare lo status internazionale del dollaro statunitense. Se gli investitori considerano Bitcoin come un’alternativa all’inflazione del dollaro statunitense, ciò potrebbe causare seri problemi.</p>
<p>🔥Secondo 10x Research, il rally del Bitcoin delle ultime tre settimane è stato ostacolato dai dati del core PCE superiori alle attese, che hanno mostrato un’inarrestabile inflazione, in parte dovuta alla politica tariffaria di Trump, che ha indebolito la fiducia dei consumatori.</p>
<p>🔥 Secondo The Block, Miller Whitehouse-Levine, un sostenitore da tempo del settore crittografico, sta lanciando la sua prossima impresa a Washington, D.C. - il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’Istituto di Politica per educare legislatori e regolatori a pensare “oltre Bitcoin”. L’organizzazione non partigiana senza scopo di lucro è ufficialmente debuttata lunedì, mentre gli asset digitali stanno attirando l’attenzione dei legislatori e la legislazione correlata sta avanzando rapidamente (coprendo tutto, dai stablecoin alla struttura di mercato).</p>
<p>🔥Quando World Liberty Financial ha raccolto più di $500 milioni, esperti del settore hanno sottolineato che la famiglia dell’ex presidente degli Stati Uniti, Donald Trump, ha preso il controllo del business criptato e ha preso la maggior parte dei soldi, grazie ai termini di governance che favorivano gli insider, secondo Reuters.</p>
<p>🔥Forbes ha rilasciato la 39a lista dei miliardari globali. Il numero di miliardari nel mondo ha superato per la prima volta i 3.000, raggiungendo quota 3.028, con una ricchezza totale di $16,1 trilioni, un aumento di $2 trilioni rispetto all’anno scorso. La lista mostra che 15 miliardari hanno un patrimonio netto superiore a $100 miliardi, tra cui Elon Musk ha riconquistato il titolo di uomo più ricco del mondo con $342 miliardi, seguito da Mark Zuckerberg ($216 miliardi) e Jeff Bezos ($215 miliardi). Inoltre, un totale di 16 miliardari nel campo delle criptovalute hanno fatto parte della lista, con una ricchezza totale di più di $164 miliardi e un patrimonio netto medio di $6,8 miliardi.</p>
<p>🔥Secondo le informazioni di monitoraggio di ElonsX, Musk ha appena aggiunto l’account del co-fondatore di F2Pool, Wang Chun, sulla piattaforma X. Notizie precedenti, il co-fondatore di F2Pool, Wang Chun, guiderà un volo orbitale di SpaceX di quattro giorni.</p>
<p>🔥Secondo l’annuncio della Borsa di Hong Kong, Zhongzefeng, una società quotata a Hong Kong, ha pubblicato il suo annuncio sul rendimento annuale 2024, che ha rivelato che la sua controllata Atlantic Asset Management Co., Ltd. è stata approvata dalla Commissione per i Valori Mobiliari e i Futures di Hong Kong per consentire ai fondi gestiti da Zhongzefeng di investire non più del 10% dei loro asset gestiti (AUM) in asset virtuali. Inoltre, l’annuncio ha anche rivelato che nell’anno a venire, i fondi di Zhongzefeng si concentreranno su azioni globali, futures e opzioni, coprendo aree tra cui indici, criptovalute, ecc.</p>
<p>La società giapponese quotata in borsa Metaplanet ha annunciato che spenderà 1,998 miliardi di yen (circa 13,34 milioni di dollari) per aumentare la propria partecipazione di 160 bitcoins, portando il totale dei suoi Bitcoin detenuti a 4.206 BTC.</p>
<p>La piattaforma X di Elon Musk esorta la Corte Suprema degli Stati Uniti a proteggere le aziende dalle citazioni in giudizio emesse dalle agenzie federali di applicazione della legge ‘senza ragionevole sospetto’ per evitare di essere costrette a divulgare dati finanziari sensibili degli utenti, ha riferito Bloomberg.</p>
<p>🔥Secondo DL News, il gigante globale della gestione patrimoniale BlackRock ha ottenuto l’approvazione dall’Autorità di Condotta Finanziaria del Regno Unito (FCA) ed è ufficialmente diventata un’azienda di asset crittografici registrata.</p>
<p>🔥VANECK ha registrato il VANECK <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> ETF in Delaware, che indica che la società potrebbe lanciare un prodotto di investimento basato su <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> negli Stati Uniti.</p>
<p>🔥Secondo Decrypt, JPMorgan ha dichiarato in un rapporto martedì che i minatori di Bitcoin continuano ad affrontare sfide e le 14 società minerarie elencate nel settore hanno vissuto collettivamente il mese peggiore di sempre a marzo.</p>
<p>🔥Secondo CoinDesk, il direttore delle ricerche di Grayscale Zach Pandl ha dichiarato che l’impatto dei dazi sulle criptovalute potrebbe essere stato “prezzato” e il peggio potrebbe essere passato.</p>
<p>🔥Layer1 blockchain Shardeum ha ufficialmente annunciato che il suo mainnet blockchain di espansione automatica basato su EVM sarà ufficialmente lanciato il 15 aprile 2025. In precedenza, Shardeum ha lanciato un evento di airdrop prima del lancio del mainnet, e la registrazione all’airdrop è ora online.</p>
<p>🔥Secondo Cointelegraph, la principale fonte di reddito per il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> rete dalla catena di espansione Layer 2 - “Blob fees” - è scesa al suo livello settimanale più basso di quest’anno.</p>
<p>I dati di RootData mostrano che l’importo totale di finanziamento del mercato crittografico nel marzo 2025 è stato di $2.883 miliardi, un aumento del 153% rispetto a $1.139 miliardi di marzo 2024 e del 198% rispetto a $967 milioni di febbraio 2025. Inoltre, il numero di finanziamenti nel marzo 2025 è stato di 74, in calo del 28,8% rispetto ai 104 di febbraio. Per quanto riguarda l’importo totale di finanziamento della traccia, le prime tre tracce sono altre categorie, Cefi e Defi.</p>
<p>🔥Secondo The Block, il rivenditore di videogiochi GameStop ha annunciato martedì che avrebbe raccolto $1,5 miliardi attraverso un collocamento privato di obbligazioni convertibili e aveva intenzione di utilizzare il ricavato per acquistare Bitcoin.</p>
<p>🔥Il protocollo dell’infrastruttura AI Cambrian Network ha annunciato di aver completato un round di finanziamento di $5,9 milioni guidato da a16z Crypto Startup Accelerator (CSX) e partecipato da BB Fund.</p>
<p>🔥Secondo Bloomberg, i prezzi di Bitcoin e altre principali criptovalute sono caduti dopo che il presidente degli Stati Uniti Trump ha imposto tariffe ai partner commerciali statunitensi in tutto il mondo, scatenando un crollo degli asset rischiosi.</p>
<p>🔥Secondo CoinDesk, il volume medio giornaliero di scambi di derivati crittografici del Chicago Mercantile Exchange Group (CME) nel primo trimestre del 2025 ha raggiunto 198.000 contratti, con un valore nominale di $11,3 miliardi, un record storico.</p>
<p>🔥Il fondatore di <a href="/price/mask-network-mask" target="_blank" class="blog_inner_link">Mask Network</a>, Suji Yan, ha dichiarato sulla piattaforma X: “Il team ha notato il repentino calo del prezzo recente di MASK e sta lavorando duramente per ottenere maggiori informazioni/dettagli. La soluzione sarà annunciata entro 1-2 giorni.”</p>
<p>🔥Secondo The Block, la Standard Chartered Bank ha iniziato la ricerca di copertura sul blockchain Layer1 <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> e ha detto di aspettarsi che il token nativo della rete AVAX salga più di 10 volte rispetto al prezzo attuale di circa $20 a $250 entro la fine del 2029.</p>
<p>🔥Secondo The Block, la piattaforma di emissione di token CoinList ha annunciato che tornerà sul mercato statunitense per la prima volta dal 2019 e terrà una vendita di token per la DoubleZero Foundation, il team dietro il protocollo DoubleZero. Il token, chiamato 2Z, sarà aperto agli investitori qualificati degli Stati Uniti. Questo segna la prima volta in cinque anni che CoinList ha permesso agli investitori statunitensi di partecipare alle vendite di token.</p>
<p>🔥Secondo CoinDesk, la controllata britannica della società di servizi finanziari per asset digitali Galaxy Digital ha annunciato che la sua domanda di licenza per il trading di derivati presso l’Autorità di condotta finanziaria del Regno Unito (FCA) è stata ufficialmente approvata.</p>
<p>Lo sviluppatore di Bitcoin Ruben Somsen ha pubblicato sulla piattaforma X che Google ha “rimosso permanentemente” la mailing list del gruppo di sviluppo di Bitcoin BitcoinDev. Ruben ha precedentemente affermato: “Per quanto ne so, non è stato pubblicato alcun contenuto inappropriato”.</p>
<p>🔥Secondo CoinDesk, Fidelity ha ufficialmente lanciato un conto pensione criptato IRA senza commissioni. Attraverso questo piano, gli utenti oltre i 18 anni negli Stati Uniti possono investire in Bitcoin, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> Fidelity gestisce gli asset e li conserva in portafogli freddi. Il prodotto supporta Roth, tradizionali e IRAs rotativi, soddisfacendo la forte domanda dei clienti per canali di investimento crittografico con vantaggi fiscali.</p>
<h2 id="h2-Normative20e20politiche20macroeconomiche541216"><a name="Normative e politiche macroeconomiche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Normative e politiche macroeconomiche</h2><p>🔥 Secondo Cryptoslate, Panama ha pubblicato un progetto di legge completo per regolare le criptovalute e promuovere lo sviluppo dei servizi blockchain.</p>
<p>🔥Secondo Decrypt, la Federal Deposit Insurance Corporation (FDIC) degli Stati Uniti ha annunciato che le banche possono impegnarsi nelle criptovalute e in altre attività legalmente consentite senza dover richiedere preventivamente l’approvazione dei regolatori, purché riescano a gestire correttamente i rischi. Questo cambiamento di politica revoca un requisito del 2022 che imponeva ai regolatori della FDIC di notificare all’agenzia prima di impegnarsi in attività legate alle criptovalute. Secondo le nuove linee guida, le banche possono fornire servizi che coinvolgono asset digitali senza il permesso preventivo dell’agenzia.</p>
<p>🔥Secondo il Wen Wei Po di Hong Kong, Chen Weimin, vice direttore esecutivo dell’Autorità Monetaria di Hong Kong, ha dichiarato che è in corso la creazione di un quadro regolatorio per l’emissione di stablecoin al fine di gettare le basi per lo sviluppo dell’ecosistema crittografico. Hong Kong ha compiuto progressi significativi nello sviluppo delle stablecoin, e il relativo disegno di legge è in fase di revisione da parte del Consiglio Legislativo e si prevede che venga approvato nei prossimi mesi.</p>
<p>🔥Secondo Eleanor Terrett, il prossimo presidente della U.S. Commodity Futures Trading Commission (CFTC), Brian Quintenz, ha iniziato a parlare con i senatori al Campidoglio per prepararsi all’audizione di nomina. Oggi si è incontrato con Chuck Grassley, senatore repubblicano dell’Iowa e membro del Comitato per l’Agricoltura del Senato, per discutere delle questioni della CFTC, compresa la regolamentazione del mercato spot delle criptovalute.</p>
<p>🔥Secondo Bitcoin.com, Hester Peirce, membro della Securities and Exchange Commission degli Stati Uniti (SEC), ha chiesto al Congresso di semplificare la regolamentazione delle criptovalute e ridurre la confusione normativa all’8° Summit Blockchain della Camera di Commercio Digitale a Washington, DC, il 26 marzo.</p>
<p>🔥Secondo la giornalista di criptovalute Eleanor Terrett, Bryan Steil, presidente della sottocommissione per gli asset digitali della Camera dei rappresentanti degli Stati Uniti, ha rivelato che dopo le deliberazioni di mercoledì, il STABLE Act (Stablecoin Transparency and Accountability for a Better Ledger Economy Act) della Camera dei rappresentanti degli Stati Uniti sarà “ben allineato con il GENIUS Act (Guidance and Establishment of the United States Stablecoin National Innovation Act) del Senato”, che è stato ottenuto dopo diverse fasi di “revisioni del progetto” nella Camera e nel Senato e assistenza tecnica dalla SEC e dalla CFTC.</p>
<p>🔥Secondo CoinDesk, il Consiglio Monetario Nazionale Brasiliano (CMN) ha emesso la Risoluzione 5.202⁄2025, vietando ai fondi pensione chiusi come le Entidades Fechadas de Previdência Complementar (EFPC) di investire le loro riserve garantite in Bitcoin (BTC) o in altri asset crittografici perché le criptovalute sono considerate troppo rischiose.</p>
<p>🔥Secondo Bitcoin.com, la Nigerian Investment and Securities Act (ISA) 2025, recentemente firmata dal presidente nigeriano Bola Ahmed Tinubu, ha effettivamente posto fine all’incertezza sullo status delle criptovalute, e il nuovo disegno di legge ha effettivamente abrogato l’Investment and Securities Act n. 29 del 2007. Questa legge sui titoli riveduta riconosce ufficialmente le criptovalute come una classe di attività.</p>
<p>🔥Secondo People’s Finance, il 2 aprile, Li Chunlin, vicedirettore della Commissione nazionale per lo sviluppo e le riforme, ha dichiarato in una conferenza stampa dell’Ufficio informazioni del Consiglio di Stato che, in termini di rafforzamento del supporto tecnico e della garanzia, la Commissione nazionale per lo sviluppo e la riforma ha applicato nuove tecnologie come il privacy computing alla condivisione e all’applicazione delle informazioni creditizie per ridurre il rischio di fuga di informazioni. Allo stesso tempo, esplorerà l’uso della tecnologia blockchain per promuovere il “concatenamento” dei dati chiave, realizzare l’elaborazione della crittografia dei dati e la plasticità dei processi.</p>
<p>🔥Secondo Bitcoin Magazine, il Texas House Bill 4258 (H.B. 4258) è stato presentato oggi al Government Efficiency utive Committee per la revisione. Il disegno di legge autorizza il revisore dello stato a investire fino a $250 milioni in Bitcoin, e autorizza anche i comuni o le contee a investire fino a $10 milioni dei loro fondi o fondi sotto il loro controllo in Bitcoin e/o altre criptovalute.</p>
<p>🔥Secondo il “Rapporto sui detentori di criptovalute negli Stati Uniti nel 2025” commissionato dalla National Cryptocurrency Association (NCA) e pubblicato da The Harris Poll, circa il 21% degli adulti negli Stati Uniti (circa 55 milioni di persone) possiede criptovalute, e il 76% di loro ha dichiarato che gli asset criptati hanno un impatto positivo sulle loro vite.</p>
<h2 id="h2-Evidenziazioni20del20mercato20delle20criptovalute870625"><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 complesso è diminuito e ha continuato a seguire il trend al ribasso delle azioni statunitensi, con un calo complessivo significativo. Nella settimana scorsa, le monete principali sono state in generale in calo e solo un piccolo numero di monete ha mostrato una performance in rialzo. Il mercato è ancora in uno stato di fluttuazione e declino, è previsto che ci sarà una fase di maggiori fluttuazioni di mercato in futuro.</p>
<p>⭐️Questa settimana, <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> si è classificato al primo posto tra le principali monete in termini di crescita, raggiungendo circa il 43%. Questo è principalmente perché la moneta ha recentemente promosso varie forme di dinamiche della piattaforma, come il rinnovamento del marchio e incentivi allo staking. Di recente la comunità ha risposto con entusiasmo, il che ha promosso congiuntamente la moneta ad avere un trend al rialzo relativamente evidente. È una delle poche monete principali che ha ottenuto una grande tendenza al rialzo entro una settimana. Attualmente <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">Prezzo EOS</a> rimane intorno a $0.82, con un massimo settimanale di $0.85. Attualmente si trova in una tendenza di fluttuazione a breve termine e il prezzo ha una leggera correzione.<br><img src="https://gimg2.gateimg.com/image/article/17437525981.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali141539"><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-Bitcoin20BTC597376"><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/17437527782.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 ha mostrato un’oscillazione a breve termine dopo l’apertura e ha mantenuto una piccola gamma di fluttuazioni intraday. Il prezzo complessivo ha registrato un round di piccoli aumenti, ma poi c’è stata una caduta e il prezzo è rapidamente sceso da un massimo di $88,000 a una gamma di $82,000. Il mercato crittografico complessivo ha continuato a seguire mentre il mercato azionario statunitense ha registrato un rapido calo. Il prezzo del BTC ha mostrato principalmente un livello di supporto dei prezzi stabile. In futuro, il prezzo del BTC continuerà a seguire il trend complessivo del mercato e non si può escludere la comparsa di un calo compensativo.</p>
<h3 id="h3-Ethereum20ETH121118"><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/17437528043.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Il trend del prezzo dell’ETH di questa settimana è in linea con il BTC, ma il calo è maggiore rispetto al BTC ed è previsto un ulteriore ribasso. Il prezzo dell’ETH ha raggiunto il picco di $1,950 in una settimana, ma poi è rapidamente diminuito entro la giornata. Attualmente, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a> rimane intorno a $1.750-$1.800 e continua a oscillare. Il prezzo ha raggiunto circa $1.780. Ci si aspetta un nuovo round di fluttuazioni di prezzo durante il fine settimana, e c’è la possibilità di un leggero calo ancora una volta.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3427606"><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, la capitalizzazione di mercato totale dei sette tipi di progetti è diminuita in modo trasversale e la maggior parte dei mercati è crollata bruscamente. Il mercato è stato influenzato dal calo delle azioni statunitensi e il trend generale al ribasso è stato molto evidente. Di recente, il mercato nel complesso è stato principalmente influenzato da fattori esterni, e ci si aspetta un nuovo round di fluttuazioni di mercato alla chiusura del fine settimana.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione a 7 giorni</th>
<th>Top 3 Vincitori</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>-6.8%</td>
<td>SPR,ACG,CUDOS</td>
<td>Il market cap totale della traccia di Livello 1 è sceso significativamente, mentre la crescita delle migliori criptovalute è rimasta al di sopra del 20%. Nel complesso, la maggior parte dei progetti ha avuto una scarsa performance.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>-20.0%</td>
<td>RITARDO, EPII, MINT</td>
<td>Il settore Layer 2 ha registrato un grande calo, con un calo generale su tutta la linea, e i guadagni delle principali monete erano molto limitati.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-11.9%</td>
<td>AX,DEPAY,SQT</td>
<td>Il market cap totale della traccia DeFi è diminuito e i guadagni delle prime monete sono distribuiti in modo uniforme. In generale, le prestazioni di mercato sono scarse.</td>
</tr>
<tr>
<td>NFT</td>
<td>-19.5%</td>
<td>MSTR,METADOGE,PONCH</td>
<td>Il valore totale del mercato degli NFT è diminuito bruscamente. La crescita delle principali criptovalute è stata distribuita in modo molto disuguale, concentrata su poche criptovalute individuali, mentre la maggior parte delle altre criptovalute è principalmente diminuita.</td>
</tr>
<tr>
<td>MEME</td>
<td>-19.7%</td>
<td>MINDS,METADOGE,GME</td>
<td>La traccia della moneta MEME è crollata bruscamente, ma la crescita delle migliori monete in aumento è ancora accettabile. Tuttavia, la crescita è concentrata in singole monete, e la maggior parte delle monete è principalmente in un trend al ribasso.</td>
</tr>
<tr>
<td>Liquid Staking</td>
<td>-12.1%</td>
<td>MSTR,LAY3R,LBR</td>
<td>Questo settore ha registrato un certo calo. Ad eccezione di MSTR, le altre criptovalute tendono generalmente a scendere in generale.</td>
</tr>
<tr>
<td>AI</td>
<td>-19.9%</td>
<td>MINDS, ARCX, SENT</td>
<td>La traccia dell’IA è diminuita bruscamente, con i guadagni delle principali monete concentrati nelle singole monete. La traccia complessiva è stata fortemente influenzata dal calo del mercato complessivo influenzando notevolmente l’andamento complessivo.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</strong>, Ricercatore Gate.io<br><div>Translator: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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato 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>