UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgbWVyY2F0byBoYSBzdWJpdG8gdW4gY3JvbGxvIHN1IGxhcmdhIHNjYWxh

<p><img src="https://gimg2.gateimg.com/image/article/1740722680weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze991729"><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> è stato colpito dallo shock causato dal furto di una piattaforma di trading di criptovalute. Il mercato ha vissuto un crollo su larga scala. Il calo settimanale delle monete principali ha toccato il livello più alto degli ultimi tempi e la tendenza è stata principalmente al ribasso per la maggior parte della settimana. Gli utenti di mercato mostrano una tendenza a scegliere prima l’avversione al rischio. La tendenza delle monete principali è un chiaro e continuo declino e il sentiment di mercato è sceso anche ai minimi storici. Vicino alla chiusura della settimana, il calo della maggior parte delle monete principali rimane al di sopra del 10%. C’è ancora la possibilità di un ulteriore declino nel breve termine e la probabilità di toccare il fondo e riprendersi questa settimana è bassa.</p>
<p>La maggior parte delle criptovalute principali ha registrato continui cali questa settimana, principalmente caratterizzati da molteplici fasi di declino. Attualmente il trend di mercato nel breve termine è ancora molto incerto, ma il mercato delle criptovalute è entrato in un ciclo di correzione complessivo.</p>
<p>Questa settimana, il prezzo del BTC ha continuato a scendere, ed è ora sceso fino alla fascia di $83.000. C’è ancora il rischio di ulteriori cali. Il punto più basso del BTC era intorno a $82.242, e il punto più alto era intorno a $96.473 durante il periodo di apertura.</p>
<p>Rispetto a BTC, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a> Le fluttuazioni sono maggiori. Il punto più alto della settimana è di circa $ 2.833 e il punto più basso è di circa $ 2.219 nel periodo corrente. Colpito dall’acquisto su larga scala di ETH da parte degli hacker, ETH ha avuto un certo aumento a breve termine, ma anche la valuta è scesa rapidamente a causa delle fluttuazioni del mercato generale. Questa settimana, le tendenze dei prezzi della maggior parte delle principali monete mainstream mostrano ancora una tendenza al calo e al ribasso. L’attuale sentiment del mercato è sceso a circa 20 e l’avversione al rischio è pesante. La crescita complessiva del valore di mercato del mercato delle criptovalute è diminuita in modo significativo, raggiungendo circa $ 2,79 trilioni, con un aumento dello 0,01% in 24 ore.</p>
<p>Rispetto alla settimana scorsa, il complessivo <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> è crollato questa settimana. A causa della notizia, c’è stato un declino e una volatilità su larga scala. Il prezzo attuale del BTC si aggira intorno a $84,000. Il prezzo attuale dell’ETH si mantiene intorno a $2,276.</p>
<p>Attualmente, il mercato cripto nel complesso si trova in un ciclo di aggiustamento, ed è ancora incerto se entrerà in un nuovo range al ribasso. Un nuovo ciclo di cambiamenti complessivi potrebbe verificarsi durante il fine settimana. MKR ha registrato il maggior aumento questa settimana, ma l’effettivo aumento non è elevato, arrivando a circa il 16% in una settimana.</p>
<p>È previsto che il mercato complessivo delle criptovalute subisca piccole fluttuazioni questo fine settimana, e potrebbe avvicinarsi un minimo.</p>
<h2 id="h2-Mercato20cripto989609"><a name="Mercato cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato cripto</h2><p>La giornalista di Fox Business Eleanor Terrett ha scritto sull’X platform che i professionisti legali con cui ha parlato credevano che la Securities and Exchange Commission degli Stati Uniti stesse cercando di raggiungere un accordo con le aziende di criptovalute anziché respingere direttamente le relative cause legali per “provare” che spendere milioni di dollari dei contribuenti fosse ragionevole e salvare un po’ la faccia.</p>
<p>🔥Il produttore e rapper americano Ye (Kanye West) ha twittato: “YEEZY si impegna a creare una vera valuta. Indipendentemente dal settore in cui entro, imparerò dai migliori e tratterò il loro lavoro con il massimo rispetto.”</p>
<p>🔥Secondo Theblock, le collaborazioni tra aziende di criptovalute e organizzazioni sportive stanno aumentando, dai sponsorizzazioni di team di Formula Uno al calcio, arti marziali miste e biliardo.</p>
<p>🔥Secondo le notizie. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a>, citando TASS, la Corte Suprema russa sta spingendo per la classificazione delle criptovalute come proprietà nei casi penali, con l’obiettivo di rafforzare la capacità delle agenzie di applicazione della legge di tracciare, congelare e confiscare attività digitali illegali.</p>
<p>🔥10x Research ha analizzato che sebbene gli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> abbiano attratto $38.6 miliardi di afflussi netti dal loro lancio nel gennaio 2024, la loro analisi mostra che solo $17.5 miliardi (44%) rappresentano acquisti effettivi a lungo termine. La maggior parte (56%) potrebbe essere legata a strategie di arbitrato, in cui posizioni corte nei futures <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> compensano gli afflussi di capitale.</p>
<p>🔥Secondo i dati di CloverPool, la difficoltà del mining di Bitcoin è stata regolata all’altezza del blocco 885.024 (4:29:38 ieri, ora di Pechino), e la difficoltà di mining è stata ridotta del 3,15% a 110,57 T.</p>
<p>🔥Secondo il Procuratorato Daily Justice Network, Zhu Jianhua, professore presso la Southwest University of Political Science and Law, e altri hanno pubblicato un articolo dal titolo “Esplorazione della creazione di una regola graduale per giudicare l’entità del crimine”, che ha evidenziato che secondo la legge non c’è molta controversia sulla classificazione del comportamento degli ufficiali di Stato che utilizzano la propria posizione per accettare illegalmente valuta virtuale da altri e cercare vantaggi per altri come corruzione.</p>
<p>🔥Adam, un ricercatore macro presso Greeks.live, ha pubblicato un briefing della comunità inglese sulla piattaforma X, rivelando che i membri della comunità sono cauti ribassisti nel breve termine, ma ancora rialzisti nel lungo termine, e si aspettano che il mercato fluttui nel prossimo futuro.</p>
<p>🔥Il fondatore di Infini @Christianeth ha pubblicato sulla piattaforma X: “So che gli hacker potrebbero monitorare i miei tweet, quindi dico sinceramente a tutti: ho fatto del mio meglio per dimostrare a tutti che ci sono ancora persone gentili e responsabili in questo settore. Mi rammarico profondamente dei miei errori e lavorerò sodo per rimediare. Spero che ci sia un modo per recuperare le nostre perdite. Sono disposto a fornire il 20% dell’importo rubato e prometto di non intraprendere azioni legali se i fondi verranno restituiti.”</p>
<p>🔥Secondo Business Insider, Nic Puckrin, fondatore di The Coin Bureau, ha affermato che le persone nel mercato crittografico attuale hanno iniziato a stancarsi delle criptovalute meme e il sentiment degli investitori attuale potrebbe essere basso come al momento del crollo di FTX, o addirittura inferiore.</p>
<p>🔥IntoTheBlock ha pubblicato una dichiarazione in cui afferma che domenica scorsa la quota dei minatori di Bitcoin sul totale delle transazioni on-chain è scesa al 2,4%, il livello più basso da maggio 2023.</p>
<p>🔥Secondo il Guangzhou Daily, un tribunale del Guangdong ha recentemente concluso un caso di frode valutaria virtuale. L’imputato Xie Moumou ha fondato l’azienda A per emettere una valuta virtuale chiamata “AA Chain”, promettendo agli investitori che la valuta sarebbe stata quotata in borsa e avrebbe ottenuto alti rendimenti.</p>
<p>L’analista cripto Miles Deutscher ha scritto che il sentimento complessivo del mercato è tornato ai minimi del 2024, anche se il prezzo di negoziazione è molto più alto rispetto al livello precedente. La correlazione tra il sentimento del mercato delle criptovalute e le prestazioni delle altcoin è più alta rispetto a quella del Bitcoin e le altcoin hanno avuto recentemente prestazioni deboli.</p>
<p>🔥Secondo l’analista di criptovalute Miles Deutscher, il tasso premium del valore di mercato di Strategy (ex MicroStrategy) rispetto alle sue detenzioni di Bitcoin è sceso da 3,4 volte lo scorso novembre a 1,6 volte attualmente.</p>
<p>🔥La rete blockchain modulare Hemi Mainnet sarà ufficialmente lanciata il 12 marzo 2025, con l’obiettivo di raggiungere un’integrazione profonda di Bitcoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> attraverso Hemi Virtual Machine (hVM).</p>
<p>🔥Secondo Cointelegraph, il disegno di legge della Riserva Strategica di Bitcoin dell’Ohio ha superato la fase del comitato, un passo più vicino all’approvazione finale.</p>
<p>🔥 Secondo The Block, il fondatore di Time.fun, Kawz, ha dichiarato che considererebbe di emettere i token della piattaforma in futuro. Se su altre piattaforme vengono costruite sul tempo tokenizzato, allora un token basato sulla piattaforma può collegarle tutte insieme.</p>
<p>🔥Secondo i dati di Alternative.me, l’indice di panico e avidità delle criptovalute è sceso a 10 il 27 (ieri era 21), raggiungendo un nuovo minimo da giugno 2024, e il livello era di panico estremo.</p>
<p>Il direttore della ricerca di CryptoQuant, Julio Moreno, ha pubblicato sui social media che non è possibile dire che il prezzo del Bitcoin è ora arrivato al minimo. Tutti gli indicatori di valutazione sono entrati nella gamma di regolazione, e questo processo potrebbe richiedere più tempo. Nota: MVRV è un indicatore relativo, che è il rapporto tra il valore di mercato circolante (Market Cap, MV) e il valore di mercato realizzato (Realized Cap, RV).</p>
<p>🔥Secondo TheCryptobasic, il prezzo del Bitcoin è sceso a circa $86,000 martedì, toccando il suo livello più basso da novembre dell’anno scorso e scendendo di più del 20% rispetto al suo massimo storico di gennaio.</p>
<p>🔥Adam, un ricercatore macro presso Greeks.live, ha rilasciato un briefing alla comunità inglese dicendo che i membri del gruppo erano generalmente pessimisti mentre Bitcoin è crollato da oltre $100.000 a un minimo di $80.000, che i trader hanno descritto come “contagio di crisi”.</p>
<p>🔥Secondo TheCryptobasic, Geoff Kendrick, responsabile della ricerca sugli asset digitali presso la Standard Chartered Bank, ha sottolineato che parte della ragione della svalutazione del Bitcoin è la frenesia nel mercato delle Meme coin. Anche se il Bitcoin non è direttamente correlato a questo mercato, una serie di scandali legati alle Meme coin stanno minando la fiducia degli investitori nell’intero ecosistema delle criptovalute, una tendenza particolarmente sfavorevole per le altcoin.</p>
<p>🔥Secondo Cointelegraph, i costi legali e di consulenza del caso di fallimento di FTX si sono accumulati a $950 milioni, rendendolo uno dei casi di fallimento più costosi nella storia degli Stati Uniti, secondo solo al caso Lehman Brothers.</p>
<p>🔥Secondo CoinDesk, Timothy Massad, ex presidente della Commodity Futures Trading Commission (CFTC) degli Stati Uniti, ha chiesto al Congresso di dare priorità allo sviluppo di un quadro normativo per le stablecoin e di rimandare le discussioni sulla legislazione della struttura del mercato criptato per diversi anni. Egli ritiene che le attuali proposte di struttura di mercato potrebbero aggravare la confusione normativa anziché fornire orientamenti chiari.</p>
<h2 id="h2-Regolamentazione20amp20Politiche20Macro393701"><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 Cointelegraph, la Camera dei Rappresentanti del Montana ha respinto il disegno di legge sul “Riserva Strategica di Bitcoin” con 41 voti contrari e 59 a favore, con molti legislatori preoccupati che il comitato per gli investimenti possa utilizzare denaro dei contribuenti per eccessive speculazioni.</p>
<p>🔥I documenti della SEC mostrano che la Securities and Exchange Commission (SEC) degli Stati Uniti ha concluso la sua indagine sulla Gemini Trust Company, LLC, e ha deciso di non intraprendere azioni di vigilanza.</p>
<p>🔥Secondo Cointelegraph, lo stato americano della Georgia ha proposto un secondo disegno di legge sulla riserva di Bitcoin (SB228), che permetterebbe allo stato di investire in Bitcoin senza alcuna restrizione sugli investimenti.</p>
<p>🔥Secondo Watcher.Guru, la Securities and Exchange Commission (SEC) degli Stati Uniti ha ufficialmente confermato di aver ricevuto una domanda presentata da Grayscale per consentire al suo ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot di fornire servizi di staking.</p>
<p>🔥Secondo l’agenzia di stampa Yonhap, il 25 febbraio la Financial Intelligence Unit (FIU) sudcoreana ha annunciato che avrebbe implementato misure normative su Upbit, il più grande exchange di criptovalute della Corea del Sud. Secondo i regolamenti, nei prossimi tre mesi Upbit sarà limitato dai depositi e dai prelievi di criptovalute per i nuovi utenti registrati.</p>
<p>🔥Secondo Decrypt, il senatore dell’Illinois Dick Durbin ha proposto il Crypto ATM Anti-Fraud Act, che mira a contrastare il crescente problema delle frodi con gli sportelli automatici di criptovalute. Il disegno di legge propone di stabilire un limite di transazione giornaliero di $2.000 e un limite di transazione di 14 giorni di $10.000 per i nuovi utenti, e richiede agli operatori di contattare direttamente gli utenti per la verifica quando la transazione supera i $500 per prevenire le frodi.</p>
<p>I documenti della SEC mostrano che la Securities and Exchange Commission degli Stati Uniti (SEC) ha concluso la sua indagine sulla Gemini Trust Company, LLC, e ha deciso di non intraprendere azioni esecutive.</p>
<p>🔥Secondo CoinDesk, il Comitato Bancario del Senato degli Stati Uniti ha tenuto la sua prima udienza del panello sugli asset digitali, concentrandosi sulla legislazione sulle stablecoin e sul ruolo del Congresso nella futura regolamentazione delle criptovalute.</p>
<p>🔥Secondo CoinDesk, il Comitato per la raccolta fondi della Camera dei Rappresentanti degli Stati Uniti ha approvato una risoluzione con un voto di 26-16 per avviare l’abrogazione delle nuove normative fiscali del Servizio delle Entrate Interne (IRS) sulle piattaforme di finanza decentralizzata (DeFi).</p>
<p>🔥Secondo Solid Intel, l’Atto sulla Riserva Strategica di Bitcoin dell’Oklahoma (HB 1203) è stato approvato dal Comitato di Vigilanza del Governo della Camera di Stato e sarà sottoposto all’intera legislatura per un voto. Il disegno di legge consente di investire fino al 10% dei fondi pubblici in Bitcoin o asset digitali con un valore di mercato superiore a $500 miliardi.</p>
<h2 id="h2-Evidenziazioni20del20mercato20criptato743176"><a name="Evidenziazioni del mercato criptato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evidenziazioni del mercato criptato</h2><p>⭐️La settimana scorsa, la tendenza generale del mercato delle criptovalute è crollata pesantemente. La tendenza delle monete principali si è stabilizzata, ma ulteriori diminuzioni sono ancora possibili. Il valore totale complessivo del mercato è cambiato notevolmente in una settimana, principalmente a causa di continue fasi di declino. Nel breve termine, è improbabile che il mercato generale veda un’impennata su larga scala e c’è ancora una tendenza al ribasso in futuro.</p>
<p>⭐️Questa settimana, l’aumento di MKR nel mercato crittografico si è posizionato al primo posto tra le monete principali, ma l’aumento della valuta è stato anche piuttosto limitato. Nel contesto della volatilità complessiva del mercato di questa settimana, questa valuta è stata una delle prime a riprendersi, con un aumento settimanale di circa il 16%. Il prezzo attuale si attesta intorno a $1,701, e attualmente mostra un trend di fluttuazione continuo relativamente evidente. Si prevede che il rialzo e il ribasso rimarranno in un piccolo intervallo.<br><img src="https://gimg2.gateimg.com/image/article/17407229041.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali163404"><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-Bitcoin20BTC788397"><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/17407229272.jpeg" alt=""><br>(Dati per gentile concessione di TradingView)</p>
<p>Questa settimana, il prezzo del BTC ha mostrato un trend stabile dopo l’apertura. Dopo essere stato influenzato da notizie esterne, ha iniziato a diminuire in diverse fasi durante il periodo di metà settimana. Il trend al ribasso continuo era molto evidente, scendendo al di sotto di $90.000. Attualmente, il prezzo del BTC si trova in un piccolo trend di fluttuazione, mantenendosi intorno a $84.000. Il prezzo del BTC è stato in fase di fondo per la maggior parte di questa settimana. C’è la possibilità e il trend di ulteriori cali, che dipende dall’impatto del trend complessivo di mercato.</p>
<h3 id="h3-Ethereum20ETH993525"><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/17407229493.jpeg" alt=""><br>(Dati forniti da TradingView)</p>
<p>Rispetto al BTC, la variazione di prezzo dell’ETH questa settimana è relativamente intensa, ma il trend complessivo è simile e il calo continuo è evidente. Il prezzo dell’ETH è stabile al di sotto di $2,300, con lievi fluttuazioni, e continua a salire e scendere entro un piccolo intervallo. Il punto più alto del prezzo dell’ETH nella settimana è intorno a $2,850. È prevista una nuova serie di salite e discese durante il fine settimana, con un’elevata probabilità di piccole fluttuazioni di prezzo.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3682573"><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 è diminuito significativamente, e le condizioni di mercato della maggior parte dei settori sono notevolmente calate, con un trend al ribasso come tendenza principale. Il mercato nel complesso è stato principalmente influenzato da fattori di notizie, e c’è ancora la possibilità di ulteriori declini nel breve termine.</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>-13.1%</td>
<td>CAU,MON,SAITO</td>
<td>Il valore di mercato totale della traccia Layer 1 è diminuito significativamente e la crescita delle principali criptovalute è distribuita in modo relativamente uniforme, senza che nessuna valuta mostri un aumento significativo.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>-10.7%</td>
<td>CLV, HACD, CARMIN</td>
<td>Il mercato Layer 2 ha visto un calo significativo, ma le monete più importanti hanno visto un aumento ragionevole e l’aumento complessivo è distribuito in modo non uniforme.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-11.6%</td>
<td>PRIME,DEPAY,PIKA</td>
<td>Il valore di mercato totale del settore DeFi è diminuito significativamente ed è in rapida diminuzione complessiva. Le migliori monete sono aumentate notevolmente.</td>
</tr>
<tr>
<td>NFT</td>
<td>-7.1%</td>
<td>PCNT,TLN,XED</td>
<td>Il valore totale del mercato NFT è diminuito, e le principali monete in aumento sono principalmente monete non di punta, con l’incremento che rimane intorno al 50%.</td>
</tr>
<tr>
<td>MEME</td>
<td>-16.3%</td>
<td>ANTI, PUPS, TARDI</td>
<td>La traccia della moneta MEME ha visto un significativo declino, ma l’incremento delle principali monete è comunque considerevole e l’andamento complessivo mostra chiaramente un trend al ribasso.</td>
</tr>
<tr>
<td>Liquid Staking</td>
<td>-15.9%</td>
<td>HBR,HINJ,ASCAKE</td>
<td>Questo settore ha registrato un significativo calo, con le migliori monete che non hanno avuto crescita e sono rimaste all’interno di un piccolo intervallo, fortemente influenzate dalle tendenze delle monete mainstream.</td>
</tr>
<tr>
<td>AI</td>
<td>1.0%</td>
<td>SUGARB, A1C, MATES</td>
<td>Il tracciato AI si è leggermente ripreso, con le principali criptovalute che vedono guadagni moderati. Nel complesso, il tracciato si è principalmente ripreso di recente. Il recupero è ulteriormente diminuito a causa delle condizioni di mercato complessive.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</strong>, Gate.io Ricercatore<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, verranno intraprese azioni legali a causa dell'infrazione del copyright.<br></div><p></p><br></div></div></div></div>