UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIz

<p><img src="https://gimg2.gateimg.com/image/article/1743138298weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze190688"><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 delle criptovalute</a> ha seguito il trend di ripresa del mercato azionario statunitense e ha mostrato un trend di riscaldamento relativamente evidente dopo l’apertura. A causa dei segnali positivi portati dalle notizie esterne e dai fattori politici, il mercato nel complesso ha una lieve tendenza al rialzo. Tuttavia, nella complessità, la maggior parte delle principali criptovalute è ancora in uno stato di consolidamento, ma un numero considerevole di criptovalute è principalmente aumentato nella settimana. Inoltre, l’aggiustamento della politica statunitense sulle criptovalute è ancora in un rapido ciclo di cambiamento. A breve termine, c’è ancora una certa possibilità di volatilità nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato criptovalute</a>, ma molti analisti sono ancora ottimisti riguardo alla tendenza a lungo termine.</p>
<p>Il mercato ha sperimentato una rapida crescita a breve termine dall’apertura di questa settimana, ma l’ampiezza rimane all’interno di un piccolo intervallo. Dopo essere entrato nel periodo di metà settimana, il mercato complessivo ha iniziato a oscillare all’interno di un nuovo intervallo di prezzo. Anche se c’è stata una fase di ripresa dovuta a fattori esterni, il segnale complessivo del mercato è ancora poco chiaro e ci vorrà del tempo affinché l’intero mercato si riprenda. Attualmente, mentre il mercato si avvicina alla chiusura della settimana, i prezzi delle principali criptovalute sono principalmente in aumento e in lieve calo. Nel breve termine, ci si aspetta che il mercato continui a seguire le dinamiche del mercato azionario statunitense.</p>
<p>I prezzi del BTC sono stati relativamente forti questa settimana, riprendendo a circa $88,000. Ci si aspetta che siano ulteriormente influenzati da fattori di notizie esterne in futuro e il rialzo a lungo termine rimane il consenso dominante.</p>
<p>Il prezzo attuale dell’ETH è tornato indietro dopo essere salito. Il punto più alto della settimana è intorno a $2,100, e il punto più basso è intorno a $1,980. La fluttuazione complessiva del prezzo è piccola. Il trend dei prezzi delle principali criptovalute questa settimana segue il trend generale del mercato, mostrando un certo trend di ripresa. Il valore complessivo di mercato del mercato delle criptovalute è aumentato, raggiungendo circa $2.85 trilioni, in calo dello 0.54% in 24 ore.</p>
<p>Il mercato complessivo delle criptovalute si è ulteriormente ripreso questa settimana rispetto alla settimana scorsa, ma l’entità è ancora inferiore rispetto alla settimana scorsa ed è nello stesso ciclo di aggiustamento. Il prezzo attuale del BTC si attesta intorno a $87,365, e il prezzo attuale dell’ETH rimane intorno a $2,012.</p>
<p>Il mercato delle criptovalute è in un ciclo di aggiustamento questa settimana e le monete principali hanno registrato alcuni guadagni, ma rimangono all’interno di un range appropriato. SPX ha registrato il maggiore aumento, raggiungendo circa il 45% in una settimana, principalmente perché è stato trainato dalla community tra diverse memecoin per lungo tempo e il recente sentiment degli utenti ha spinto il prezzo al rialzo.</p>
<p>Ci si aspetta che il mercato cripto nel complesso continui a oscillare leggermente questo fine settimana, e i fattori di notizie esterne non saranno in grado di guidare cambiamenti di mercato su larga scala nel breve termine.</p>
<h2 id="h2-Mercato20delle20criptovalute230528"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Bo Hines, direttore esecutivo del Digital Asset Advisory Council del presidente Trump, ha dichiarato in un’intervista che gli Stati Uniti potrebbero utilizzare i proventi delle loro riserve auree per acquistarne altri <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Secondo Hines, questa mossa potrebbe essere un modo neutro dal punto di vista del bilancio per aumentare il paese <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> riserve.</p>
<p>🔥I dati di Cloverpool mostrano che la difficoltà del mining di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è stata regolata all’altezza del blocco 889.056 (ora di Pechino 03-23 19:15:42), con la difficoltà aumentata del 1,43% a 113,76 T, vicino al massimo storico (114,17).</p>
<p>🔥Secondo Aggr News, Fidelity lancerà un fondo tokenizzato che investe in bond del Tesoro degli Stati Uniti per competere con il BUIDL di BlackRock.</p>
<p>🔥Secondo la giornalista Eleanor Terrett, uno dei fattori chiave che ha portato al “debanking” in passato è stato che i regolatori richiedevano alle banche di considerare il cosiddetto “rischio reputazionale” nell’valutare se i clienti potessero ottenere servizi finanziari. La Federal Reserve una volta ha istruito i dipendenti in un manuale interno a prestare attenzione a se gli esecutivi bancari hanno fatto “dichiarazioni controverse”, ma il presidente della Federal Reserve Powell ha promesso di eliminare la clausola il mese scorso.</p>
<p>🔥Secondo l’annuncio ufficiale, Strategy ha aumentato la dimensione dell’emissione delle azioni privilegiate perpetue della Serie A di STRF da $500 milioni a $722.5 milioni, con un prezzo di emissione di $85 per azione e un tasso di interesse annuo del 10%. Ci si aspetta che sia regolato il 25 marzo, con una raccolta netta di circa $711 milioni, che verrà utilizzata per l’acquisto di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e per le operazioni generali.</p>
<p>🔥Secondo uno studio di Atmos, gli Emirati Arabi Uniti sono il paese più crypto-friendly al mondo con un punteggio di 98,4, leggermente davanti a Singapore, che si classifica al secondo posto con 97,5. Gli Stati Uniti si sono piazzati al terzo posto con un punteggio di 85,4.</p>
<p>🔥Secondo l’analista on-chain Yu Jin, in sole 10 ore, sono affluiti 1,859 milioni di AUCTION ($70,36 milioni) in CEX, il 24,3% del totale delle AUCTION. Il prezzo delle AUCTION è sceso anche da $57 a $23 in breve tempo, con una diminuzione del 60%.</p>
<p>🔥Matthew Sigel, direttore della ricerca sugli asset digitali presso VanEck, ha twittato che gli analisti legali di Bloomberg ritengono che ci sia una probabilità del 30% che il governo federale lo farà <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquistare Bitcoin</a> quest’anno. Egli crede che Trump non investirà capitale politico nella legislazione perché può raggiungere questo obiettivo unilateralmente attraverso il Fondo di Stabilità degli Scambi (ESF) se lo desidera.</p>
<p>🔥Tom Wan, direttore dei dati presso Entropy Advisors, ha scritto sulla piattaforma X che BUSD era una volta il terzo stablecoin più grande per valore di mercato, raggiungendo i $23 miliardi, e il suo attuale valore di mercato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> la catena è solo di circa $50 milioni.</p>
<p>🔥Trader Eugene ha detto nel suo canale personale che il mercato attuale è entrato nella quinta fase (perdite rialziste, consolidamento del prezzo delle monete, riduzione del volume degli scambi e volatilità). In questa fase, alcune altcoin più forti hanno raggiunto il fondo, ma è ancora incerto se la maggior parte degli asset ha toccato il fondo.</p>
<p>🔥Secondo Crypto.news, i dati di CryptoSlam hanno mostrato che il volume delle transazioni NFT è sceso a $102 milioni questa settimana, una diminuzione del 3.19% rispetto alla settimana precedente.</p>
<p>🔥Bitcoin Magazine ha divulgato dati sulla piattaforma X. Al martedì, gli ETF statunitensi su Bitcoin avevano acquistato un totale di 8.775 BTC, mentre i minatori di Bitcoin avevano prodotto solo 3.150 BTC.</p>
<p>🔥Secondo News.bitcoin, nonostante il recente rimbalzo dei prezzi del BTC, gli indicatori a lungo termine continuano a essere ribassisti.</p>
<p>🔥Il ricercatore macro di Greeks.live, Adam, ha rilasciato un briefing alla comunità cinese, che ha sottolineato che la comunità è cauta circa la volatilità del Bitcoin e ha discusso se colpirà un nuovo minimo. I membri sono principalmente preoccupati nel costruire razionalmente strutture di copertura e scegliere strategie di opzioni convenienti, piuttosto che semplicemente prevedere la direzione degli alti e bassi del mercato.</p>
<p>🔥Secondo The Block, il <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> La Fondazione ha stabilito un “ufficiale” <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> riserva” attraverso la sua nuova organizzazione aziendale House of Doge, e ha acquistato 10 milioni di DOGE, che corrispondono approssimativamente a $1.8 milioni al prezzo di mercato.</p>
<p>🔥Secondo The Block, Trump Media &amp; Technology Group (TMTG) ha annunciato di aver firmato un accordo preliminare con Crypto.com per lanciare una serie di asset digitali e ETF e ETP azionari a tema “Made in America” attraverso il suo marchio fintech Truth.Fi.</p>
<p>🔥Secondo Business Insider, diverse istituzioni si aspettano ancora che BTC raggiunga i $200,000.</p>
<p>🔥Secondo Decrypt, l’analista della Standard Chartered Bank Geoff Kendrick ha affermato che data l’alta correlazione tra i prezzi del Bitcoin e l’indice Nasdaq, gli investitori sono meglio vedere il Bitcoin come un’azione tecnologica piuttosto che come uno strumento per coprirsi dalle fluttuazioni nei mercati tradizionali.</p>
<p>🔥Circle Japan KK, la filiale giapponese del fornitore di stablecoin USDC Circle, collaborerà con il gruppo SBI Holdings per lanciare completamente lo stablecoin USDC in Giappone tramite SBI VC Trade il 26 marzo.</p>
<p>🔥Secondo Coindesk, l’ultimo rapporto della società svizzera di analisi blockchain Global Ledger mostra che la borsa di criptovalute russa sanzionata Garantex è stata ribattezzata Grinex. Una grande quantità di dati on-chain e off-chain mostra che Grinex è il diretto successore di Garantex. Parte della liquidità di Garantex, compreso tutto il stablecoin A7A5 garantito dal rublo di Garantex, è stata trasferita a un portafoglio controllato da Grinex.</p>
<p>🔥Secondo i dati di Santiment, l’attività di rete di DOGE è scesa al suo livello più basso da ottobre 2024 questa settimana, con una media di sole 66 transazioni “whale” al giorno e meno di 60.000 indirizzi attivi.</p>
<p>QCP Capital, una società di investimento cripto con sede a Singapore, ha dichiarato che il mercato cripto ha registrato un modesto rimbalzo durante il fine settimana, con BTC ed ETH che hanno superato rispettivamente i $85.000 e i $2.000. La ripresa sembra essere guidata dal mercato azionario, con i futures azionari che registrano un forte rimbalzo. Mentre le preoccupazioni per la recessione continuano, il discorso di Powell alla riunione della scorsa settimana del FOMC, sebbene misurato, ha contribuito a ridurre la nervosità degli investitori.</p>
<p>🔥Lisa Gordon, presidente della banca d’investimento britannica Cavendish, ha proposto di imporre una tassa sugli acquisti di criptovalute per incoraggiare più investitori a investire nel mercato azionario del Regno Unito.</p>
<p>🔥Secondo MarketWatcher, il mercato ritiene che la Federal Reserve preveda di passare da un restringimento quantitativo (QT) a un allentamento quantitativo (QE), che inietterà liquidità nel mercato finanziario. Attualmente, le aspettative dell’industria crittografica per il QE rimangono alte. Il precedente ciclo QE ha spinto il Bitcoin a crescere del 1.000% tra marzo 2020 e novembre 2021.</p>
<p>🔥Secondo Cointelegraph, la borsa statunitense ha aperto leggermente al rialzo, portando la lungamente attesa <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> ai trader. Un fattore chiave che impedisce agli asset a rischio di cadere è che il governo degli Stati Uniti e Trump potrebbero aggiustare un nuovo piano di tariffe commerciali. Analizzando il breve termine <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo BTC</a> trend, i trader si concentrano sul livello di resistenza chiave di $90,000. Data la forte tendenza storica dei prezzi del Bitcoin, anche i partecipanti al mercato del Bitcoin hanno alte aspettative per aprile.</p>
<p>🔥Secondo Eleanor Terrett, giornalista di Crypto in America, in seguito all’Ufficio del Controllore della Valuta degli Stati Uniti, la Federal Deposit Insurance Corporation (FDIC) degli Stati Uniti ha intenzione di rimuovere il “rischio reputazionale” dai suoi standard regolamentari, il che potrebbe essere positivo per l’industria delle criptovalute perché questo standard regolamentare è stato utilizzato per giustificare la chiusura di attività legittime, comprese le aziende criptovalutari.</p>
<p>🔥Secondo il monitoraggio di Whale , i dati on-chain mostrano che l’emittente USDC Treasury ha emesso 100.000.000 nuovi USDC su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, con un totale di circa $300 milioni di USDC coniati in tre transazioni.</p>
<p>🔥Secondo CoinDesk, citando i dati da rwa.xyz, il valore di mercato dei titoli del Tesoro statunitense tokenizzati ha superato i $5 miliardi per la prima volta, con un aumento di $1 miliardo in soli due settimane, principalmente dai prodotti BUIDL emessi da BlackRock e Securitize.</p>
<p>🔥Secondo le notizie di mercato, il Chicago Board Options Exchange (CBOE) ha presentato una <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Domanda ETF per Fidelity. Cboe BZX, una controllata del Chicago Board Options Exchange Group, ha inoltre presentato una proposta di modifica normativa (documento di domanda 19b-4) alla Securities and Exchange Commission degli Stati Uniti.</p>
<p>🔥Secondo l’annuncio ufficiale di GameStop, il consiglio di amministrazione della società ha approvato all’unanimità un aggiornamento della propria politica di investimento il 25 marzo, ora dell’Est, per includere Bitcoin tra gli asset di riserva della società.</p>
<p>🔥Secondo CoinDesk, Ripple ha raggiunto un accordo di transazione preliminare con la SEC, in cui la SEC ha accettato di rimborsare $75 milioni dei $125 milioni di multa inflitta dal tribunale l’anno scorso, trattenendo solo $50 milioni per chiudere il caso. In cambio, Ripple ritirerà il suo appello incrociato. La transazione proposta deve ancora essere approvata dal tribunale e dalla commissione, e potrebbe segnare la fine della lunga controversia legale tra le due parti.</p>
<p>🔥David Sacks, il direttore della Casa Bianca per la criptovaluta e l’IA, ha pubblicato sulla piattaforma X che la Federal Deposit Insurance Corporation (FDIC) sta seguendo le orme dell’Ufficio del Controllore della Valuta per eliminare il “rischio reputazionale” come fattore nella supervisione bancaria, il che è una grande vittoria per l’industria delle criptovalute.</p>
<p>🔥Secondo Bloomberg, GameStop ha annunciato mercoledì di avere intenzione di collocare privatamente 1,3 miliardi di dollari in obbligazioni convertibili senior con scadenza nel 2030. La società ha dichiarato che consentirà agli acquirenti iniziali di acquistare obbligazioni per un importo principale totale non superiore a 200 milioni di dollari.</p>
<p>🔥Secondo quanto riportato dal quotidiano “Culture Daily” della Corea del Sud, la Commissione per l’Etica dei Funzionari Pubblici del governo sudcoreano ha reso noti i cambiamenti patrimoniali nel 2025. Il consigliere comunale di Seoul Kim Hye-young ha primeggiato nella lista degli alti funzionari che possiedono criptoattivi con 1,7 miliardi di won (circa 1,27 milioni di dollari).</p>
<p>🔥Secondo The Block, gli analisti di K33 hanno affermato che sebbene il mercato crittografico sia stato in un tranquillo trend rialzista nelle ultime settimane poiché le dichiarazioni del governo USA mostravano un’atteggiamento moderato verso i dazi e la posizione leggermente accomodante della Federal Reserve, mancano ancora otto giorni al “Giorno della Liberazione” del Presidente Trump, e la volatilità di mercato causata dai dazi potrebbe ulteriormente intensificarsi.</p>
<p>🔥Secondo The Block, l’analista Bloomberg James Seyffart ha detto che il <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF potrebbe essere lanciato nei prossimi mesi, ed è probabile che il <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF futures saranno visti per primi. Dato che la SEC degli Stati Uniti ha ritirato la causa contro Ripple, la probabilità che l’ETF <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> venga approvato nel 2025 è aumentata.</p>
<p>🔥Canaan Inc. ha annunciato i suoi risultati finanziari non auditati per il quarto trimestre e l’intero anno conclusosi il 31 dicembre 2024. Il rapporto finanziario ha mostrato che il ricavo totale per l’intero anno 2024 ha raggiunto i $269.3 milioni, con un aumento del 27.4% anno su anno.</p>
<p>🔥Secondo Business Insider, GameStop ha precedentemente dichiarato in una breve dichiarazione che il consiglio di amministrazione ha approvato all’unanimità l’aggiornata politica di investimento per utilizzare Bitcoin come riserva finanziaria dell’azienda.</p>
<p>🔥Cathie Wood ha detto in un discorso al Digital Asset Summit a New York: “Pensiamo che la tokenizzazione sarà enorme e speriamo di poter tokenizzare il fondo di investimento (ARKVX) o il fondo della Rivoluzione degli Asset Digitali.” Ma gli analisti ritengono che, anche se Cathie Wood sta preparando la tokenizzazione del fondo di investimento Ark Invest, si trova di fronte a ostacoli da parte della supervisione e delle normative degli Stati Uniti, il che potrebbe causare il blocco di questo processo.</p>
<p>🔥Il fondatore di Synthetix Kain Warwick ha condiviso le sue opinioni sui market maker. Ha sottolineato che alcuni market maker manipolavano i prezzi attraverso mercati a bassa liquidità, utilizzavano prestiti e arbitraggio di opzioni e vendevano persino token scontati prima degli eventi di generazione di token (TGE) e li vendevano rapidamente dopo averne aumentato i prezzi.</p>
<p>Augustine Fan, capo della ricerca presso SignalPlus, ha dichiarato che nonostante le persistenti preoccupazioni per un rallentamento dell’economia statunitense, il mercato potrebbe gradualmente riprendersi dal calo della scorsa settimana ed è previsto che mantenga un moderato recupero prima della fine del mese.</p>
<h2 id="h2-Regolamentazione20amp20Politiche20Macro352417"><a name="Regolamentazione &amp; Politiche Macro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione &amp; Politiche Macro</h2><p>🔥Secondo Bloomberg, è previsto che la Commissione per i servizi finanziari della Camera dei rappresentanti degli Stati Uniti esaminerà il progetto di legge sulla stablecoin il 2 aprile.</p>
<p>🔥Secondo Crypto in America, la Casa Bianca sta spingendo attivamente per far approvare il GENIUS Act al Senato per la deliberazione il prima possibile, e si sforza di essere firmato in legge dal Presidente Trump entro due mesi. Il disegno di legge è stato approvato dal Comitato bancario del Senato con 18 voti a favore e 6 contrari il 13 marzo, e intende stabilire un quadro normativo per i pagamenti stabili collegati al dollaro statunitense. La versione della Camera dello STABLE Act inizierà la deliberazione il 2 aprile, e la Casa Bianca spera che la versione del Senato ottenga abbastanza sostegno per spingere la Camera dei Rappresentanti a passarlo direttamente e evitare il processo di negoziazione legislativa.</p>
<p>🔥La Camera dei Rappresentanti dell’Oklahoma ha approvato la HB1203, la Legge sulla Riserva Strategica di Bitcoin, con una schiacciante maggioranza di 77 voti a 15. Il disegno di legge mira a sostenere i governi statali nel detenere Bitcoin come asset di riserva, consentendo di investire fino al 10% dei fondi pubblici in Bitcoin o asset digitali con un valore di mercato superiore a $500 miliardi.</p>
<p>🔥Il Governatore del Kentucky, USA, ha ufficialmente firmato l’HB701 in legge il 24 marzo, ora locale, per proteggere i diritti dei residenti di utilizzare asset digitali, portafogli auto-ospitati e eseguire nodi blockchain. Il disegno di legge esclude esplicitamente tali comportamenti dalle licenze di trasmissione di denaro e dalla supervisione dei titoli, e limita i governi locali dalla gestione discriminatoria delle attività tecniche correlate.</p>
<p>🔥Secondo il sito ufficiale della SEC, il Gruppo di lavoro sulla criptovaluta della Securities and Exchange Commission (SEC) degli Stati Uniti ha annunciato che terrà quattro nuovi round di incontri tavola rotonda da aprile a giugno 2025, che copriranno argomenti come il trading di criptovalute, la custodia, la tokenizzazione degli asset e DeFi.</p>
<p>🔥Secondo The Block, il Senato degli Stati Uniti ha approvato una risoluzione con 70 voti a favore e 28 contrari per abrogare le normative fiscali sulle criptovalute introdotte alla fine dell’amministrazione Biden. Il disegno di legge sarà sottoposto al Presidente Trump per la firma. La regola del broker DeFi dell’IRS richiede a alcune piattaforme DeFi di segnalare le informazioni sulle transazioni degli utenti e rilasciare moduli 1099 come broker di titoli, suscitando controversie sulla privacy e la conformità.</p>
<p>🔥I congressisti statunitensi Tom Emmer e Darren Soto hanno riproposto il Securities Clarity Act, che mira a chiarire la distinzione legale tra cripto-attività e contratti di titoli e a fornire un percorso di conformità per progetti innovativi. Il disegno di legge ha ricevuto il sostegno di Coin Center, della Blockchain Association e di altri, ed è considerato un importante preludio alla legislazione sulla struttura del mercato cripto statunitense.</p>
<p>🔥Secondo un annuncio rilasciato dal Governatore del Wyoming, il Comitato per la Stablecoin del Wyoming ha annunciato che la sua stablecoin WYST garantita dal fiat e completamente riservata è entrata nella fase di test multi-chain ed è stata implementata su reti di test come <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, e <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>.</p>
<p>I legislatori della Carolina del Nord hanno presentato due disegni di legge alla Camera dei Rappresentanti e al Senato, proponendo di consentire che una parte dei fondi pensione sia investita in criptoattività, fino al 5%. Il rappresentante Brenden Jones ha proposto il “State Investment Modernization Act” (HB506), e il Senato ha presentato un disegno di legge simile, il SB709.</p>
<h2 id="h2-Evidenze20del20mercato20delle20criptovalute352680"><a name="Evidenze del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evidenze del mercato delle criptovalute</h2><p>⭐️La scorsa settimana, il mercato delle criptovalute si è ulteriormente ripreso e ha seguito principalmente il trend del mercato azionario statunitense, ma l’ampiezza complessiva è rimasta entro un intervallo ristretto. Anche se la salita e la discesa delle monete principali sono state diverse nella settimana scorsa, il mercato nel complesso si trova in una fase di ripresa al rialzo e si prevede che ci sarà una fase di mercato al rialzo volatile in futuro.</p>
<p>⭐️Questa settimana, la criptovaluta SPX ha registrato il maggior aumento tra le principali criptovalute. Essendo un progetto guidato dalla comunità tra le memecoin, il recente sentimento della comunità ha spinto la criptovaluta a salire notevolmente. Il prezzo attuale si attesta intorno a $0.62. Rispetto al massimo settimanale di $0.66, il prezzo è tornato indietro ed è attualmente in uno stato di fluttuazione a breve termine.<br><img src="https://gimg2.gateimg.com/image/article/17431384991.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali700349"><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-Bitcoin20BTC173285"><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/17431385232.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Questa settimana, il prezzo del BTC ha mostrato un breve trend al rialzo dopo l’apertura, e la rapida salita e discesa durante la giornata è stata la tendenza principale. Con il recente recupero del mercato azionario statunitense, il mercato crittografico nel complesso ha continuato a seguire. Il prezzo del BTC è stato relativamente ottimistico di recente, e il suo prezzo si è avvicinato al prezzo di $89.000 in una settimana. Il prezzo del BTC rimane nell’intervallo di $87.000-$88.000. In futuro, il prezzo del BTC probabilmente continuerà a seguire il trend generale del mercato.</p>
<h3 id="h3-Ethereum20ETH365244"><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/17431385473.jpeg" alt=""><br>(Dati per gentile concessione di TradingView)</p>
<p>Le fluttuazioni di prezzo di ETH questa settimana sono più drammatiche di quelle di BTC. Dopo una rapida crescita a breve termine, il prezzo è sceso più bruscamente. Il punto più alto di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a> in una settimana era di $2,100, ma in seguito ha mostrato un evidente trend al ribasso continuo. Attualmente, il prezzo dell’ETH si mantiene intorno ai $2,000 e continua a fluttuare. Il prezzo ha raggiunto i $2,012. Ci si aspetta una nuova fase di fluttuazioni di prezzo durante il fine settimana, e la probabilità di mantenere l’attuale fascia di prezzo è relativamente alta.</p>
<h2 id="h2-Andamento20del20progetto20Web3673185"><a name="Andamento del progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andamento del progetto Web3</h2><p>Questa settimana, il valore di mercato totale dei sette tipi di progetti ha continuato la recente tendenza al rialzo, principalmente seguendo il trend del mercato complessivo. L’ampiezza complessiva è ancora mantenuta entro un piccolo intervallo e il mercato complessivo è ancora in un ciclo di correzione. Di recente, il mercato complessivo è stato principalmente influenzato da fattori di notizie e dall’economia macro. La probabilità di mantenere l’attuale intervallo di fluttuazioni continue durante il periodo di chiusura del fine settimana è relativamente alta.</p>
<table>
<thead>
<tr>
<th>Categoria del Progetto</th>
<th>Variazione 7 giorni</th>
<th>Top 3 Gainers</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>0.5%</td>
<td>EIOB,CUDOS,MIRAI</td>
<td>Il market cap totale del settore Layer 1 ha registrato un lieve rimbalzo e la crescita delle principali criptovalute è stata distribuita in modo disomogeneo. Nel complesso, la maggior parte dei progetti è ancora nel ciclo di aggiustamento.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>3.5%</td>
<td>DLC,SFI,KONET</td>
<td>Le condizioni di mercato della traccia Layer 2 sono simili a quelle della traccia L1, ma i guadagni sono distribuiti in modo più uniforme. In generale, i guadagni effettivi delle migliori criptovalute sono relativamente limitati.</td>
</tr>
<tr>
<td>DeFi</td>
<td>1.6%</td>
<td>DEPAY,SPEX,SB</td>
<td>Il market cap totale del settore DeFi è aumentato leggermente e i guadagni delle principali criptovalute sono stati distribuiti in modo uniforme, con una bassa volatilità complessiva.</td>
</tr>
<tr>
<td>NFT</td>
<td>3.6%</td>
<td>$RAINI,MST,TUNE</td>
<td>Il valore totale del mercato NFT è aumentato leggermente. La crescita delle migliori monete è distribuita in modo molto disomogeneo, con $RAINI che guida la strada, mentre altre monete hanno una crescita più debole.</td>
</tr>
<tr>
<td>MEME</td>
<td>8.1%</td>
<td>GME, BABY, CATEX</td>
<td>Il settore delle monete MEME ha mostrato un forte momento di ripresa e le principali monete in aumento hanno registrato guadagni molto impressionanti, il che costituisce un segnale di calore relativamente positivo per il mercato.</td>
</tr>
<tr>
<td>Liquid Staking</td>
<td>-0.3%</td>
<td>EGP,STZETA,RAFT</td>
<td>Questo percorso ha registrato un leggero calo, ma il valore totale effettivo è cambiato molto poco e il tasso di crescita delle principali monete è stato anch’esso relativamente piccolo, ed è stato fortemente influenzato dal mercato complessivo delle monete principali.</td>
</tr>
<tr>
<td>AI</td>
<td>5.3%</td>
<td>CUDOS,VAIX,39A</td>
<td>Il settore dell’IA ha mantenuto il suo recupero, con le principali criptovalute che hanno registrato guadagni relativamente significativi. Nel complesso, la tendenza è stata influenzata dal recente recupero del mercato ed è stata in linea con il trend.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripost di questo articolo sarà consentito 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>