UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIz

<p><img src="https://gimg2.gateimg.com/image/article/1744960807weeklyweb3research.png" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze781610"><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 criptovalutario</a> ho visto una leggera ripresa a causa della politica di esenzione dai dazi di Trump, ma l’effettivo aumento è limitato e concentrato nelle principali criptovalute. Nel complesso, il mercato è ancora in uno stato di aggiustamento strutturale, e il trend successivo del mercato è ancora fortemente influenzato da fattori esterni. Anche se le principali criptovalute hanno sperimentato fluttuazioni evidenti nei giorni recenti, la capacità complessiva di far fronte agli shock esterni è ancora forte.</p>
<p>La maggior parte delle principali criptovalute presenti sul mercato ha mostrato un lieve recupero questa settimana. A causa dell’aggiustamento tempestivo della politica tariffaria di Trump, il mercato azionario statunitense e il mercato delle criptovalute sono stati influenzati in modo positivo, ma le dimensioni complessive del mercato per la settimana non hanno ancora mostrato segni di un rimbalzo sostanziale.</p>
<p>In generale, il mercato ha visto un lieve recupero dall’apertura di questa settimana, e la maggior parte delle principali monete è generalmente aumentata. Tuttavia, poiché non vi sono stati cambiamenti significativi nell’ambiente esterno complessivo, la tendenza è stata relativamente piatta e mantenuta all’interno di un piccolo intervallo. Attualmente, mentre il mercato si avvicina alla fine della settimana, il mercato principale sta vivendo un lieve aumento e diminuzione.</p>
<p>Il prezzo del BTC è rimbalzato significativamente questa settimana. Dopo essere risalito sopra gli $86,000, è leggermente sceso e si mantiene intorno agli $85,000. È probabile che il trend successivo continui a essere significativamente influenzato da fattori esterni.</p>
<p>Il trend settimanale del prezzo dell’ETH è simile a quello del BTC. È sceso significativamente dopo aver raggiunto un massimo settimanale. Il massimo settimanale era di circa $1,682 e attualmente è mantenuto intorno a $1,600.</p>
<p>Questa settimana, la tendenza dei prezzi delle principali criptovalute è stata principalmente un lieve recupero. Il valore di mercato complessivo del mercato delle criptovalute è aumentato, raggiungendo circa $2.68 trilioni, un aumento di circa 1.54% in 24 ore. Il prezzo attuale del BTC si attesta intorno a $85,052. Il prezzo attuale dell’ETH si mantiene intorno a $1,600.</p>
<p>Il mercato crittografico complessivo è ancora in un ciclo di adeguamento strutturale questa settimana. La maggior parte delle valute principali ha registrato aumenti di prezzo dovuti a fattori esterni, anche se l’incremento complessivo è stato relativamente modesto. La valuta principale con il maggiore aumento è RAY, che ha raggiunto circa il 38% in una settimana. Questo è principalmente dovuto al lancio di LaunchLab dopo l’incidente di Pump.fun, che ha ottenuto una creazione di token senza soluzione di continuità. Questo ha aumentato la liquidità per la piattaforma AMM Raydium, guidando l’ultimo aumento del prezzo del token RAY.</p>
<p>Questo fine settimana, nel complesso <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> si prevede che mantenga un trend di lievi fluttuazioni. È probabile che mantenga un rapido aumento e calo all’interno di un certo intervallo. È improbabile che l’intero mercato cada nuovamente bruscamente. La salita e la caduta delle principali criptovalute dipenderanno ancora dall’impatto dei fattori esterni delle notizie.</p>
<h2 id="h2-Mercato20delle20criptovalute872322"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Secondo Bloomberg, il Presidente Trump e la sua famiglia sono coinvolti in quasi ogni settore dell’industria criptovalutaria. Secondo i dati pubblici, anche tenendo conto della volatilità di mercato causata dall’ultima tornata di guerra commerciale, il reddito totale di bilancio di questi progetti si avvicina ancora a $1 miliardo.</p>
<p>🔥Secondo CoinDesk, il CEO di JPMorgan Chase Jamie Dimon si sta preparando al caos nel mercato dei titoli del Tesoro statunitense, che ammonta a quasi 30 trilioni di dollari, e la Federal Reserve agirà solo se inizieranno a entrare in panico. Il mercato dei titoli del Tesoro statunitense svolge un ruolo centrale nella finanza globale, stabilendo il tono per tutti i fattori di mercato, dai tassi ipotecari ai rendimenti dei bond aziendali.</p>
<p>L’analista di CryptoQuant mignolet ha detto che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> le balene non hanno ancora lasciato il mercato, e la tendenza attuale è simile all’accumulo visto durante la consolidazione laterale da agosto a settembre dell’anno scorso. Quello che stiamo vedendo ora è probabilmente solo un ritracciamento all’interno del ciclo di mercato rialzista in corso (sebbene grande), piuttosto che una crisi strutturale che scatena un’uscita a livello di “balene”. Una volta risolta questa falsa crisi, verrà ripresa l’agevolazione quantitativa. Dopo l’oro, il prossimo grande beneficiario di questa ondata di liquidità sarà <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>.</p>
<p>🔥Secondo Cointelegraph, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha invertito la maggior parte delle perdite della settimana precedente dopo che Trump ha annunciato una sospensione dei dazi doganali.</p>
<p>🔥Secondo CNBC, Larry Fink, CEO del gigante della gestione patrimoniale BlackRock, spera che tutti gli asset (dalle azioni alle obbligazioni, all’immobiliare, ecc.) possano essere scambiati online sulla blockchain. Ha affermato che il concetto di “tokenizzazione” rivoluzionerà la proprietà finanziaria e gli investimenti, e ogni asset potrà essere tokenizzato.</p>
<p>🔥Jim Iuorio, un trader senior di futures e opzioni, ha scritto un articolo sul sito ufficiale di CME analizzando le ragioni delle recenti prestazioni deboli di Bitcoin. Ha sottolineato che ci sono due motivi principali: Primo, dopo che Bitcoin ha raggiunto un picco di $109,000 a metà gennaio, le notizie positive sono state digerite dal mercato, ed è previsto che dopo la conferma delle notizie, sceglierà di vendere, aumentando nel frattempo la liquidazione delle posizioni lunghe; secondo, molti trader istituzionali hanno incluso Bitcoin e l’indice Nasdaq nello stesso portafoglio di investimenti. Quando il Nasdaq cala bruscamente, scatenerà una vendita di Bitcoin per soddisfare i requisiti di margine.</p>
<p>🔥 L’analista senior James Van Straten ha scritto che l’Indice di Volatilità S&amp;P è salito ai suoi livelli più alti da agosto dello scorso anno, indicando un aumento dell’incertezza di mercato. Il rapporto tra il Bitcoin e il VIX ha raggiunto la linea di tendenza a lungo termine a 1903. L’ultima volta che ha toccato la linea di tendenza è stata durante la volatilità di mercato prima e dopo lo sgretolamento degli scambi di carry yen.</p>
<p>🔥Secondo Cointelegraph, Michael Saylor, fondatore di Strategy (precedentemente MicroStrategy), ha dichiarato durante un evento che Bitcoin non ha bisogno degli Stati Uniti, ma gli Stati Uniti hanno bisogno di Bitcoin.</p>
<p>🔥Secondo Cryptoslate, un sondaggio condotto da Harris Poll ha scoperto che circa 55 milioni di adulti americani (21% della popolazione totale) possiedono attualmente criptovalute e il 76% dei detentori ritiene che la loro esperienza con gli asset digitali abbia avuto un impatto positivo su di loro personalmente.</p>
<p>🔥Secondo Cryptodnes, il CEO di BlackRock Larry Fink ha avvertito di una possibile recessione negli Stati Uniti in un’intervista con CNBC, avvertendo che la recessione potrebbe essere già iniziata. Larry Fink ha sottolineato che le crescenti pressioni economiche e le politiche commerciali protezionistiche sono i principali fattori trainanti di ciò che lui ritiene essere una lenta contrazione economica.</p>
<p>🔥Santiment ha pubblicato che la politica di esenzione dai dazi di Trump durante il fine settimana ha scatenato un’immediata crescita del mercato crittografico.</p>
<p>🔥Secondo Crypto.news, i dati di CryptoSlam hanno mostrato che il volume delle transazioni NFT è diminuito del 4,7% a $94,7 milioni lunedì.</p>
<p>🔥McKenna, socio fondatore di Arete Capital, ha affermato che il mercato spesso tocca il fondo nelle peggiori notizie. Ha menzionato che Bitcoin è una volta sceso a $74,000 a causa di tariffe reciproche e di mercati azionari in calo, che è stato uno dei peggiori panici che abbia mai visto sul mercato. Crede che a meno che le relazioni con la Cina non peggiorino seriamente, le future notizie causeranno solo fluttuazioni di mercato.</p>
<p>Il responsabile della sostenibilità del Gruppo HKEX, Chow Kwun Ying, ha affermato che l’uso di nuove tecnologie come la blockchain potrebbe rendere il monitoraggio dei crediti di carbonio più trasparente ed efficiente, e facilitare le transazioni transfrontaliere. Pertanto, HKEX è aperto all’uso di tecnologie come la blockchain per risolvere i problemi esistenti del mercato del carbonio.</p>
<p>🔥Alex Thorn, capo della ricerca presso Galaxy Digital, ha dichiarato in un post su X che, basandosi su una revisione di documenti pubblici, documenti di fallimento e divulgazioni volontarie da parte dei creditori attivi, la dimensione totale dei prestiti di finanza centralizzata (CeFi) sarà di 11,2 miliardi di dollari alla fine del 2024, in calo del 68% rispetto al picco storico (ATH) di 34,8 miliardi di dollari nel 2022.</p>
<p>🔥Arthur, fondatore e direttore degli investimenti di DeFiance Capital, ha scritto sulla piattaforma X che il più grande problema che affligge l’attuale mercato crittografico liquido è come i progetti e i market maker lavorano insieme per creare prezzi artificiali che possono essere sostenuti per lungo tempo, e questo processo è completamente in uno stato di scatola nera.</p>
<p>🔥Secondo Cointelegraph, secondo il rapporto “Enterprise Bitcoin Adoption nel primo trimestre del 2025” pubblicato da Bitwise, nel primo trimestre del 2025 le società quotate hanno acquistato un totale di 95.431 bitcoin, un aumento del 16,11% rispetto al trimestre precedente, portando il totale dei bitcoin detenuti dalle società quotate a 688.000, corrispondente al 3,28% dell’offerta totale di 21 milioni di bitcoin. Il numero di società quotate che detengono Bitcoin è salito a 79, con un aumento del 17,91% rispetto al trimestre precedente, e 12 nuove società hanno acquistato Bitcoin nel trimestre.</p>
<p>🔥 Secondo Cointelegraph, il CEO di Mantra, John Mullin, ha risposto alle preoccupazioni della comunità dopo il crollo del token OM. Ha assicurato che Mantra e i suoi partner stanno promuovendo il recupero dei token OM, ma i dettagli del riacquisto e della distruzione sono ancora in fase di definizione.</p>
<p>🔥Secondo CoinDesk, Visa si unirà alla Global Dollar Network (USDG) stablecoin alliance avviata da Paxos, diventando la prima istituzione finanziaria tradizionale a farlo. Tra i membri dell’alleanza ci sono anche Robinhood, Kraken, Galaxy Digital, Anchorage Digital, Bullish e Nuvei. USDG mira a condividere i ricavi della stablecoin con i membri per incentivare la costruzione di liquidità e interconnessione, che è diversa dal modello di trattenere i ricavi, come <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>.</p>
<p>Laser Digital ha rilasciato una dichiarazione sulla piattaforma X dicendo che non aveva nulla a che fare con il recente crollo dei prezzi di $OM (Mantra). In risposta ai rumors sui social media secondo cui Laser era coinvolta nella vendita degli investitori, l’azienda ha dichiarato che le dichiarazioni rilevanti erano “fattualmente false e fuorvianti”.</p>
<p>🔥Secondo The Defiant, Bitcoin ha ottenuto risultati positivi in tutti i periodi temporali, superando l’S&amp;P 500 ogni anno degli ultimi 14 anni. Durante questo periodo, Bitcoin ha ottenuto un rendimento di circa il 7,2 milioni%, superando di gran lunga il rendimento del 116% dell’oro e il rendimento del 306% dell’S&amp;P 500. In un periodo temporale più breve, il rendimento di Bitcoin negli ultimi due anni è stato del 173%, consolidando ulteriormente il suo predominio sugli asset di investimento tradizionali come l’oro e l’S&amp;P 500.</p>
<p>🔥Secondo Ledger Insights, un recente sondaggio sulle riserve delle banche centrali effettuato dalla Banca per i Regolamenti Internazionali ha mostrato che nel 2024, il 15,9% dei partecipanti delle banche centrali ha dichiarato di considerare gli investimenti in asset digitali o monete entro cinque o dieci anni. Ma in un sondaggio del 2025, solo il 2,1% delle banche centrali ha preso in considerazione gli investimenti in criptovalute nello stesso arco di tempo.</p>
<p>🔥Secondo Phoenix.com, State Street Global Advisors Hong Kong Limited ha annunciato che lancerà l’applicazione di investimento criptovalutario e tradizionale “State Street Galaxy” con Galaxy Asset Management, una controllata di Galaxy Digital Holdings.</p>
<p>🔥Secondo Cryptoslate, Matthew Sigel, responsabile della ricerca sugli asset digitali presso VanEck, ha proposto un nuovo strumento di debito chiamato “BitBonds”, che combina i titoli del Tesoro degli Stati Uniti con l’esposizione al Bitcoin come nuova strategia per gestire le imminenti esigenze di rifinanziamento del governo pari a $14 trilioni.</p>
<p>🔥Tether ha annunciato un investimento strategico in Fizen, una società fintech focalizzata su portafogli auto-ospitati e pagamenti digitali, per potenziare l’applicazione pratica e l’infrastruttura di pagamento delle stablecoin in tutto il mondo. Fizen supporta gli utenti a pagare con stablecoin e saldare in valuta fiat attraverso codici QR e altri metodi senza la necessità di hardware aggiuntivo, il che aiuta a abbattere le barriere ai servizi finanziari e migliorare l’efficienza dell’accesso dei commercianti.</p>
<p>🔥Secondo l’annuncio ufficiale di ZKsync, il team di sicurezza ha scoperto che un account amministrativo del contratto di airdrop è stato compromesso, e l’attaccante ha controllato e venduto circa $5 milioni di token di airdrop ZK non richiesti. L’incidente è stato causato da una singola fuga di chiave, che non ha influenzato il protocollo stesso o il contratto del token ZK, e i fondi degli utenti sono sempre al sicuro.</p>
<p>🔥Secondo The Block, la banca d’investimento TD Cowe ha avvertito che i rischi politici nell’industria delle criptovalute stanno aumentando poiché le azioni del Presidente degli Stati Uniti Trump e della sua amministrazione potrebbero ostacolare i progressi nella regolamentazione delle criptovalute.</p>
<p>🔥 Secondo CryptoSlate, il CEO di Gate Mantra, John Patrick Mullin, ha proposto di distruggere i suoi token OM per ripristinare la fiducia degli investitori dopo il crollo del prezzo del token nativo del protocollo.</p>
<p>La società tecnologica medica quotata al Nasdaq Semler Scientific ha presentato domanda alla Securities and Exchange Commission (SEC) degli Stati Uniti per una offerta di titoli da $500 milioni presentando un documento di registrazione S-3. L’offerta sarà utilizzata principalmente per scopi aziendali generici, inclusi ma non limitati all’acquisto di Bitcoin.</p>
<p>🔥Secondo Fortune, Trump sta preparando il lancio di un gioco immobiliare crypto incentrato sul suo marchio. Due persone informate sulla questione hanno detto che il gioco è simile a Monopoly GO! ed è guidato dal suo partner commerciale di lunga data, Bill Zanker. Il progetto fa parte del piano criptato della famiglia Trump ed è stato coinvolto in NFT, stablecoin, DeFi e mining di Bitcoin. Anche se Zanker nega qualsiasi collegamento con Monopoly, ci si aspetta che il progetto vada online alla fine di aprile, e non è ancora stato rivelato come verrà utilizzata la tecnologia blockchain.</p>
<p>🔥Secondo The Block, il presidente della Federal Reserve, Jerome Powell, ha dichiarato che le regole bancarie relative alle criptovalute potrebbero essere ‘rilassate’ in futuro.</p>
<p>🔥Secondo Protos, gli utenti DeFi hanno recentemente riscontrato un nuovo tipo di frode: i truffatori si impossessano del sito ufficiale dei progetti abbandonati e inducono i vecchi utenti a firmare transazioni dannose di “fuga di fondi”. Questa frode passiva è diversa dalle tradizionali truffe attive. Si rivolge in modo specifico ai vecchi utenti che potrebbero avere ancora segnalibri di vecchi progetti.</p>
<p>🔥Il presidente e CEO di Bitdeer (BTDR) Jihan Wu ha rilasciato una dichiarazione su X in risposta alla relazione di vendita allo scoperto di BTDR. Ha dichiarato che il rapporto era basato su una posizione preimpostata, mettendo insieme fatti complessi ma non rilevanti e utilizzando una logica assurda e fuorviante per costruire una narrazione, con lo scopo di manipolare il sentimento di mercato per i venditori allo scoperto in cerca di guadagno personale. Ha sottolineato che l’azienda continuerà a concentrarsi sui fondamentali effettivi del business e sulla creazione di valore a lungo termine, riservandosi il diritto di intraprendere azioni legali per proteggere la reputazione dell’azienda e gli interessi degli azionisti.</p>
<p>🔥Secondo Cointelegraph, alcuni market maker stanno trasformando i prestiti token in una macchina del profitto e mettendo in una spirale discendente piccoli progetti di criptovaluta. Si riferisce che un modello di market maker chiamato il “modello di opzione di prestito” permetterà ai progetti di prestare token ai market maker, che utilizzeranno poi questi token per fornire liquidità, stabilizzare i prezzi e assistere i progetti nell’elenco sulle piattaforme di trading di criptovalute. Tuttavia, dietro le quinte, alcuni market maker stanno utilizzando questa controversa struttura di prestito di token per trarre profitto per se stessi. Questi protocolli sono spesso confezionati come “basso rischio, alto rendimento,” ma in realtà colpiranno pesantemente i prezzi dei token, causando alle nascenti squadre di criptovaluta di cadere nel caos e lottare.</p>
<p>🔥Secondo Bitcoin.com, il principale sviluppatore di ENS Nick Johnson ha rivelato un sofisticato attacco di phishing che ha sfruttato le vulnerabilità nei sistemi di Google, in particolare la vulnerabilità OAuth recentemente risolta.</p>
<p>🔥Secondo The Block, VanEck ha intenzione di lanciare un <a href="/price/view/new-cryptocurrencies" rel="nofollow noopener noreferrer" target="_blank">nuova criptovaluta</a> ETF correlato il prossimo mese, con il codice di negoziazione NODE. L’obiettivo dell’ETF è quello di fornire agli investitori l’esposizione all’ampia economia crittografica investendo in strumenti finanziari e azioni legate agli scambi crittografici, ai minatori di Bitcoin e ai data center.</p>
<h2 id="h2-Normative20e20politiche20macroeconomiche168909"><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 Cointelegraph, Tim Scott, presidente del Comitato bancario, degli alloggi e degli affari urbani del Senato degli Stati Uniti, ha recentemente dichiarato che il disegno di legge sulla struttura del mercato crittografico dovrebbe diventare legge entro agosto 2025. Tim Scott ha anche sottolineato che il Comitato bancario del Senato ha fatto avanzare un disegno di legge regolamentare completo sulle stablecoin, il GENIUS Act, nel marzo 2025, indicando che il comitato ha reso la politica crittografica una priorità.</p>
<p>🔥La Commissione per i Titoli e gli Scambi degli Stati Uniti (SEC) ha deciso di estendere il periodo di revisione per una proposta di modifica delle regole presentata da NYSE Arca per consentire a Grayscale <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Trust ETF e Mini Trust ETF per impegnare le detenzioni di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>.</p>
<p>🔥Secondo The Defiant, la Securities and Exchange Commission (SEC) degli Stati Uniti ha rinviato la decisione sulle sottoscrizioni fisiche e i rimborsi per gli ETF spot su Bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> di WisdomTree e VanEck al 3 giugno 2025. Le transazioni fisiche coinvolgono lo scambio diretto di attività sottostanti, come Bitcoin ed Ethereum, anziché denaro contante.</p>
<p>🔥Secondo Barron, il team Anti-Riciclaggio di Denaro e Criminalità Finanziaria del Dipartimento della Sicurezza Interna degli Stati Uniti ha avviato un’indagine sulla banca di custodia crittografica Anchorage Digital Bank. La società è sostenuta dal capitale di Wall Street e ha pubblicamente sostenuto le politiche di Trump nel campo degli asset digitali. L’indagine si concentra sulla conformità e sul comportamento delle transazioni finanziarie e i dettagli non sono ancora stati resi pubblici.</p>
<p>🔥Secondo Bitcoin Magazine, Bo Hines, direttore esecutivo del Comitato consultivo sugli asset digitali del Presidente Trump, ha dichiarato che gli Stati Uniti potrebbero utilizzare i ricavi tariffari per acquistare Bitcoin.</p>
<p>🔥Secondo The Block, l’ultima relazione della Standard Chartered Bank prevede che il prossimo Stablecoin Regulation Act degli Stati Uniti (GENIUS Act) porterà la scala globale degli stablecoin dagli attuali $230 miliardi a $2 trilioni entro la fine del 2028.</p>
<p>🔥L’Autorità di regolamentazione dei servizi finanziari (FSRA) del Mercato Globale di Abu Dhabi ha multato l’azienda cripto Hayvn e il suo ex CEO, Christopher Flinos, per un totale di $12,45 milioni per l’elaborazione delle transazioni dei clienti attraverso l’entità SPV non autorizzata AC Holding dal 2018 e per non aver mantenuto controlli efficaci contro il riciclaggio di denaro per un lungo periodo.</p>
<p>🔥Secondo la giornalista di criptovalute Eleanor Terrett, la Securities and Exchange Commission (SEC) degli Stati Uniti ha annunciato i dettagli del suo terzo tavolo rotondo sulla politica delle criptovalute. L’incontro del 25 aprile si concentrerà sulle questioni della custodia, con due discussioni a pannello - una sui broker-dealer e la custodia del portafoglio, e l’altra sugli investment advisors e la custodia delle società di investimento.</p>
<p>🔥Secondo l’avvocato James K. Filan, la richiesta di “sospensione dell’appello” presentata congiuntamente dalla SEC degli Stati Uniti e da Ripple è stata approvata dal tribunale. Alla SEC è richiesto di presentare una relazione sullo stato del caso entro 60 giorni dall’ordine.</p>
<p>🔥La Russia dovrebbe sviluppare la propria stablecoin ancorata ad altre monete dopo che lo stablecoin USDT detenuto dai portafogli digitali associati alla Russia è stato congelato il mese scorso, ha dichiarato mercoledì un alto funzionario del Ministero delle Finanze russo, secondo quanto riportato da Reuters.</p>
<p>🔥 Secondo The Block, il sindaco di Panama City, Mayer Mizrachi Matalon, ha pubblicato mercoledì sulla piattaforma X che il governo di Panama City ha approvato l’uso delle criptovalute per pagare tasse, spese, multe e licenze.</p>
<p>🔥 Secondo Cointelegraph, la HB 92 della Carolina del Nord è stata approvata dalla commissione per la pensione e il ritiro della Camera. Il disegno di legge consente al tesoriere dello Stato di investire in attività digitali idonee come Bitcoin.</p>
<h2 id="h2-Evidenzi20del20mercato20cripto194561"><a name="Evidenzi del mercato cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evidenzi del mercato cripto</h2><p>⭐️La scorsa settimana, il mercato crittografico nel complesso è continuato ad essere influenzato da fattori esterni. Con l’introduzione della politica di esenzione dai dazi di Trump, la maggior parte dei mercati finanziari principali ha ripreso, mentre il mercato crittografico ha principalmente visto un lieve aumento. Si trova ancora nella fase di aggiustamento strutturale. Nella scorsa settimana, le monete principali hanno principalmente sperimentato alti e bassi a breve termine, e il trend generale della settimana è stato principalmente un lieve aumento. Il mercato attuale si trova in un canale di rialzo a breve termine, e si prevede che il mercato attuale continuerà.</p>
<p>⭐️Questa settimana, l’aumento del prezzo di RAY nel mercato crittografico si è classificato al primo posto tra le valute principali, raggiungendo circa il 38%. Questo è principalmente dovuto al recente lancio di LaunchLab dopo l’incidente di Pump.fun. La liquidità è aumentata nel breve termine, il che ha guidato l’incremento del prezzo di RAY. Il prezzo attuale di RAY si attesta intorno a $2.2, e il massimo settimanale si aggira intorno a $2.4. Attualmente è in un trend di fluttuazione a breve termine e il prezzo è leggermente diminuito.<br><img src="https://gimg2.gateimg.com/image/article/17449610061.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali229298"><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-Bitcoin20BTC732624"><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/17449610282.jpeg" alt=""><br>(Dati Cortesia Di TradingView)</p>
<p>Questa settimana, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo BTC</a> Il trend ha continuato il trend della settimana scorsa dopo l’apertura, mostrando un trend di continuo aumento e calo durante il giorno. Il prezzo è sceso a un minimo settimanale di $83.000 e successivamente ha mostrato molteplici serie consecutive di trend di breve termine al rialzo e al ribasso. Influenzato da fattori esterni di notizie, il prezzo del BTC ha raggiunto anche un massimo di una settimana di $86.400. Anche se è sceso nuovamente in seguito, è rimasto all’interno dell’intervallo di $83.000 a $85.000. Il trend del prezzo del BTC si è comportato bene. Con $83.000 come livello chiave di supporto del prezzo, il trend del prezzo del BTC è stato relativamente forte. In futuro, è probabile che la moneta continui a seguire il trend del mercato generale. Mantenere continui alti e bassi in un piccolo range sarà lo stato di mercato predominante nel breve termine.</p>
<h3 id="h3-Ethereum20ETH394647"><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/17449610523.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Il trend dei prezzi dell’ETH di questa settimana è approssimativamente coerente con quello del BTC, ma la fluttuazione è relativamente più moderata. Il punto più alto di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a> nella settimana è vicino a $1,700, ed è sceso nel breve termine a metà settimana per poi raggiungere il punto più basso della settimana intorno a $1,540. Il prezzo di ETH è sceso sotto il livello chiave di $1,600 di nuovo, e il trend successivo continuerà a salire e scendere in un piccolo range. Il prezzo di ETH rimane intorno a $1,580 e continua a fluttuare. Ci si aspetta che arrivi un nuovo round di aggiustamenti dei prezzi durante il fine settimana.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3170904"><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 è fluttuato, ma l’ampiezza è rimasta entro un piccolo intervallo. Il mercato è continuato ad essere fortemente influenzato da fattori esterni, e il lieve trend di ripresa è stato più evidente. Ci si aspetta che il trend attuale del mercato continuerà 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>Layer 1</td>
<td>1.7%</td>
<td>NETZ,BLD,DEC</td>
<td>Il market cap totale del Layer 1 ha registrato un lieve rimbalzo, ma l’aumento delle principali criptovalute non è significativo e rimane all’interno di un range moderato. Nel complesso, la maggior parte dei progetti ha mantenuto un’ampia oscillazione limitata.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>-4.3%</td>
<td>COMBO,FHE,PEPU</td>
<td>Il settore Layer 2 ha continuato il suo trend al ribasso, con solo poche monete che mostrano un trend al rialzo, mentre la maggior parte delle monete ha continuato il suo trend al ribasso.</td>
</tr>
<tr>
<td>DeFi</td>
<td>0.5%</td>
<td>BOR,COMBO,SYNO</td>
<td>Il market cap totale del DeFi ha registrato un lieve rimbalzo, ma i guadagni delle migliori criptovalute sono concentrati in singole monete e la maggior parte delle monete nel mercato non ha tendenze particolarmente evidenti in crescita.</td>
</tr>
<tr>
<td>NFT</td>
<td>3.4%</td>
<td>COMBO,BFOX,REALM</td>
<td>Il valore totale del mercato NFT ha mostrato un certo recupero. Le principali monete in rialzo erano principalmente progetti completi, e la maggior parte delle monete nel settore ha visto un lieve recupero.</td>
</tr>
<tr>
<td>MEME</td>
<td>0.3%</td>
<td>DWOG, MUNCAT, CATEX</td>
<td>Il percorso della moneta MEME ha registrato un leggero aumento, ma è lo stesso del periodo della settimana scorsa. I guadagni delle migliori monete in crescita sono ancora accettabili.</td>
</tr>
<tr>
<td>Liquid Staking</td>
<td>-2.1%</td>
<td>LBR, AGI, LAY3R</td>
<td>Questo settore ha mostrato un lieve calo, con i guadagni delle principali monete che sono rimasti all’interno di un piccolo intervallo e la distribuzione che continua a rimanere relativamente equa.</td>
</tr>
<tr>
<td>AI</td>
<td>2.9%</td>
<td>TSAI,FLARE,39A</td>
<td>La traccia AI ha visto una certa ripresa, ma i guadagni delle principali monete sono concentrati nelle singole monete, mentre i guadagni delle 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 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. 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>