UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgbWVyY2F0byBoYSBvc2NpbGxhdG8gbGVnZ2VybWVudGU=

<p><img src="https://gimg2.gateimg.com/image/article/1739503365weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze567807"><a name="Panoramica settimanale delle tendenze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica settimanale delle tendenze</h2><p>Complessivamente <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> Questa settimana il mercato è stato relativamente volatile. Influenzato dal continuo declino delle azioni statunitensi della settimana scorsa, non vi è alcun segnale chiaro di rialzo per il mercato, ma nel complesso è riuscito a sfuggire al declino generale ed è entrato in un nuovo ciclo volatile. Rapide salite e discese intraday hanno dominato il mercato, e la tendenza delle criptovalute principali ha mantenuto fluttuazioni continue all’interno di un piccolo intervallo. Il mercato tende a concentrarsi nello stesso intervallo di prezzo, e la tendenza attuale del mercato principale è probabile che continui nel breve termine.</p>
<p>I prezzi della maggior parte delle criptovalute principali hanno ripreso il rialzo lo scorso fine settimana e sono significativamente scesi dopo l’apertura di questa settimana. Il trend di mercato è ancora incerto nel breve termine e ci si aspetta che rimanga principalmente fluttuazioni intraday a breve termine.</p>
<p>Questa settimana, il prezzo del BTC ha oscillato tra $95,000 e $99,000 per la maggior parte del tempo, con un significativo calo durante il periodo di apertura. Il punto più basso di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo BTC</a> è sceso al di sotto del prezzo chiave di $95,000, e successivamente è rimasto al di sopra di $95,000 e ha continuato a oscillare. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a> Le variazioni sono simili. La maggior parte delle tendenze dei prezzi delle principali criptovalute è continuata a salire e scendere entro un piccolo range. Il sentimento di mercato attuale si è riscaldato fino a circa 40. Il valore complessivo del mercato delle criptovalute non è cambiato significativamente, raggiungendo circa $3.16 trilioni, in calo dello 0.75% nelle ultime 24 ore.</p>
<p>Il mercato delle criptovalute è entrato in un nuovo ciclo di oscillazione questa settimana, con molteplici fasi di piccoli rialzi e ribassi in una settimana, e c’è una tendenza al ulteriore declino. Il prezzo attuale del BTC si aggira intorno ai $95,618. Anche il trend dei prezzi dell’ETH è simile, e il prezzo attuale si mantiene intorno ai $2,624.</p>
<p>Il mercato complessivo delle criptovalute è stato principalmente in crescita e in calo questa settimana, e non c’è alcuna ulteriore tendenza al rialzo e al ribasso su larga scala. I prezzi attuali di molte monete principali si trovano nella stessa fascia del prezzo di apertura. La moneta principale con il maggior aumento questa settimana è CAKE, che è aumentata di circa il 90% in una settimana.</p>
<p>Il mercato complessivo delle criptovalute è rimasto volatile questo fine settimana, con fluttuazioni a breve termine che sono la tendenza principale. Nel breve termine, il ciclo di mercato attuale continuerà per un po’ di tempo.</p>
<h2 id="h2-Mercato20delle20criptovalute969171"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Secondo la giornalista di Fox Business Eleanor Terrett, i membri repubblicani del consiglio della Federal Reserve Michelle Bowman e Christopher Waller hanno mostrato una posizione più aperta nei confronti dell’industria delle criptovalute nei loro discorsi del 7 febbraio, segnando un cambiamento nell’atteggiamento della Fed verso la regolamentazione degli asset digitali.</p>
<p>Secondo Bloomberg, giganti di Wall Street come Morgan Stanley, Bank of America e Royal Bank of Canada (RBC) stanno attivamente investendo nell’industria della criptovaluta, e ci si aspetta che la politica pro-cripto dell’amministrazione Trump guidi un’impennata nelle IPO, nelle emissioni di azioni e nelle transazioni di obbligazioni convertibili.</p>
<p>Il Presidente delle Maldive Mohamed Muizzu ha pubblicato sulla piattaforma X che il token $MLDVS sarà lanciato sul <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> rete, con l’obiettivo di utilizzare la cultura digitale per unire le persone e portare le Maldive sul mercato crittografico globale.</p>
<p>I dati di Mempool.space mostrano che la tariffa di transazione attuale (tariffa gas) del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la rete è scesa a 1 satoshi/byte, circa $0.14. I dati di Etherscan mostrano che il prezzo mediano di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La tassa sul gas è attualmente di circa 0,9 gwei, pari a circa 0,05 dollari.</p>
<p>Il gigante giapponese dei titoli SBI Group ha annunciato che la sua attività crittografica ha registrato un utile trimestrale record. SBI ha inoltre collaborato con l’operatore USDC Circle per promuovere il lancio delle coppie di trading USDC in Giappone.</p>
<p>🔥Secondo PR Newswire, la società quotata in borsa Nasdaq e fornitore di servizi di tecnologia olografica MicroCloud Hologram Inc. (NASDAQ: <a href="/price/holo-hot" rel="nofollow noopener noreferrer" target="_blank">HOLO</a>) ha annunciato di avere intenzione di raccogliere fino a $200 milioni per acquistare <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> o altre criptovalute e i relativi derivati di titoli, e incorporare questi asset nella sua strategia di riserva di capitale.</p>
<p>🔥Secondo Blockworks, PitchBook ha rivelato in un nuovo rapporto che la spesa per il venture capital cripto continuerà ad essere lenta prima della fine del 2024. I dati specifici hanno mostrato che il valore delle transazioni è aumentato a $2.4 miliardi nel quarto trimestre del 2024, un aumento del 13.6% rispetto al terzo trimestre, ma il numero di transazioni è diminuito da 411 a 351.</p>
<p>🔥Secondo il monitoraggio di Lookonchain, il progetto criptato della famiglia Trump, World Liberty Financial (WLFI per abbreviare), ha speso 156.667 USDC per acquistare altri 273.937 MOVEs.</p>
<p>🔥Secondo Cryptoslate, il developer di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Core Luke Dashjr ha sollevato preoccupazioni sulla definitività delle transazioni di Bitcoin, affermando che la regola delle sei conferme ormai ampiamente accettata non è più applicabile.</p>
<p>🔥Secondo le notizie ufficiali, la Fondazione <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha annunciato di concedere una sovvenzione di $200,000 per sostenere l’aggiornamento dell’ecosistema di Pectra, e la data di presentazione delle domande terminerà il 23 febbraio.</p>
<p>🔥Secondo CoinDesk, un portavoce di Invest Hong Kong ha confermato che le criptovalute, tra cui Bitcoin ed Ethereum, possono essere utilizzate come prova di attività al momento di richiedere un visto nel quadro del Capital Investment Entrant Scheme.</p>
<p>🔥Secondo Cointelegraph, i dati mostrano che il Bitcoin sta mostrando segni di un classico minimo locale mentre i minatori affrontano una nuova fase di “capitulazione”.</p>
<p>🔥Secondo TheBlock, basandosi sui dati dell’indice GMCI, i settori dei token Meme e AI hanno subito le maggiori diminuzioni nel recente aggiustamento di mercato, con gli indici GMMEME e GMAI che sono diminuiti rispettivamente del 60% e del 56% rispetto ai loro massimi di dicembre 2024.</p>
<p>🔥Secondo CoinDesk, la banca di Wall Street JPMorgan Chase (JPM) ha citato dati da TradingView in un rapporto di ricerca pubblicato martedì, sottolineando che la crescita dell’ecosistema cripto si è rallentata a gennaio, con un calo del volume di trading totale del 24%.</p>
<p>🔥Secondo le notizie ufficiali, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha annunciato di aver completato un investimento strategico nel portafoglio crittografico auto-custodito ZengoWallet. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> ha dichiarato che questo investimento dimostra l’impegno di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> nello sviluppare soluzioni di auto-custodia sicure e nel promuovere la popolarità globale delle stablecoin.</p>
<p>🔥Secondo le notizie ufficiali, il progetto criptato della famiglia Trump World Liberty Financial (WLFI per abbreviare) e Ondo Finance hanno annunciato una partnership strategica per promuovere l’adozione di beni reali tokenizzati (RWA) e portare la finanza tradizionale sulla catena.</p>
<p>🔥Michael Saylor, fondatore di Strategy (ex MicroStrategy), ha pubblicato sulla piattaforma X: “Finora quest’anno, le operazioni finanziarie di Strategy hanno portato a casa 18.527 bitcoin, equivalenti a circa $1,8 miliardi di valore in bitcoin per gli azionisti di $MSTR.”</p>
<p>🔥Secondo CoinDesk, KULR Technology quotata al New York Stock Exchange ha aumentato il suo portafoglio di Bitcoin a 610.3.</p>
<p>🔥Secondo Beincrypto, Bitwise Asset Management ha riportato che la maggior parte dell’offerta totale di Bitcoin è controllata da singoli detentori. Dei 21 milioni di Bitcoin in circolazione, il 69,4% appartiene a investitori privati. Data questa concentrazione di proprietà di Bitcoin tra singoli individui, grandi istituzioni e governi potrebbero incontrare sfide nell’acquisire Bitcoin.</p>
<p>🔥Secondo Sunil, rappresentante dei creditori di FTX, se SBF non avesse presentato istanza di fallimento, la valutazione dei suoi asset avrebbe potuto superare i $65 miliardi.</p>
<p>La reporter di Fox Business Eleanor Terrett ha twittato che, poiché gli asset digitali diventano un focus regolatorio, la Securities and Exchange Commission (SEC) degli Stati Uniti e la Commodity Futures Trading Commission (CFTC) stanno esplorando modi per rafforzare la cooperazione nella regolamentazione delle criptovalute.</p>
<p>🔥Secondo The Block, Robinhood ha rilasciato il suo rapporto finanziario del quarto trimestre, mostrando che il volume di trading di criptovalute è aumentato del 400% anno su anno a $70 miliardi. In precedenza, il volume di trading era diminuito nel 2024, con i primi tre trimestri che erano rispettivamente di $36 miliardi, $21,5 miliardi e $14,4 miliardi.</p>
<p>🔥Franklin Templeton ha annunciato sulla piattaforma X che il suo fondo monetario dei titoli del Tesoro degli Stati Uniti “BENJI” basato su blockchain è ora attivo su <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a>. Franklin Templeton ha affermato che <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> è una blockchain di Livello 1 veloce, sicura e resistente alla censura che incoraggia l’adozione globale attraverso la sua infrastruttura aperta.</p>
<p>🔥Secondo i dati di Cointelegraph, il tempo di conferma di Bitcoin ha raggiunto un livello record nel 2025, con una media di 19 minuti per transazione. La congestione di rete, i limiti di dimensione dei blocchi e la dinamica delle commissioni di transazione sono i principali fattori che causano ritardi.</p>
<p>La giornalista di Fox Business News Eleanor Terrett ha scritto sull’X platform che secondo questa tabella molto utile fornita dagli analisti ETF di Bloomberg James Seyffart ed Eric Balchunas, possiamo vedere che se la Securities and Exchange Commission (SEC) degli Stati Uniti sceglie di riconoscere, potrebbe riconoscere il <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> domanda spot ETF già giovedì (13 febbraio).</p>
<p>🔥Secondo Cointelegraph, Bitcoin ha continuato a scambiare al di sotto del livello chiave di $100.000 dal 4 febbraio mentre le preoccupazioni per la guerra commerciale globale hanno inciso sul sentiment degli investitori dopo che gli Stati Uniti e la Cina hanno annunciato nuove tariffe d’importazione.</p>
<p>Secondo Cointelegraph, la piattaforma blockchain del presidente degli Stati Uniti Donald Trump ha lanciato un fondo di riserva strategico per sostenere la crescita di alcune delle più grandi criptovalute.</p>
<h2 id="h2-Normative20e20politiche20macroeconomiche573786"><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 CNBC, i pubblici ministeri federali degli Stati Uniti hanno accusato il noto avvocato della Corte Suprema Tom Goldstein di aver nascosto due portafogli crittografici che hanno ricevuto più di $8 milioni di fondi e trasferito $6 milioni nella scorsa settimana in violazione di ordinanze giudiziarie, ed è stato nuovamente arrestato.</p>
<p>🔥Secondo CoinDesk, il Sottocomitato degli attivi digitali della Camera dei rappresentanti degli Stati Uniti ha tenuto un’audizione l’11 febbraio per esplorare lo sviluppo futuro dell’industria crittografica negli Stati Uniti e promuovere una legislazione per fornire chiarezza regolamentare.</p>
<p>Secondo The Block, il presidente della Federal Reserve Jerome Powell ha dichiarato che, data la critica secondo cui l’industria delle criptovalute è stata esclusa dai servizi bancari, è ora di ‘riesaminare’ la questione del de-banking. Durante un’audizione del Comitato bancario del Senato martedì, il presidente del comitato, il senatore repubblicano Tim Scott della Carolina del Sud, ha chiesto a Powell se lavorerebbe con lui per garantire che le regole finanziarie ‘non impongano più oneri del necessario’.</p>
<p>🔥Secondo Cointelegraph, Hester Peirce, membro della Securities and Exchange Commission (SEC) degli Stati Uniti, ha dichiarato che l’agenzia potrebbe attendere che il Senato confermi il nuovo presidente prima di decidere l’agenda regolamentare per le criptovalute.</p>
<p>🔥Secondo Cointelegraph, il presidente degli Stati Uniti Trump ha nominato l’ex Chief Legal Officer di Bitfury Jonathan Gould come Direttore dell’Ufficio del Controllore della Valuta (OCC) degli Stati Uniti, responsabile della supervisione del sistema bancario nazionale. La nomina è stata presentata al Senato l’11 febbraio per un mandato quinquennale.</p>
<p>🔥Secondo Coinpost, oggi Yukiyuki Aruba, direttore dell’Ufficio pianificazione e mercato dell’Agenzia dei servizi finanziari del Giappone, ha proposto un piano di riforma istituzionale completo per gli asset crittografici e gli stablecoin basato sulla discussione del gruppo di lavoro del Consiglio di revisione finanziaria dello scorso mese.</p>
<h2 id="h2-Evidenze20del20mercato20delle20criptovalute366165"><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 trend generale del mercato delle criptovalute era ancora in uno stato di fame dopo i fattori di notizie esterne della scorsa settimana, e le fluttuazioni a breve termine sono il trend di mercato predominante. Anche se il valore complessivo del mercato è cambiato poco, il mercato nel suo complesso non è ancora emerso dal recente stato di mercato lento mentre si avvicina all’orario di chiusura del fine settimana, e la probabilità di mantenere un piccolo range di fluttuazioni in futuro è alta.</p>
<p>⭐️ Questa settimana, CAKE si è classificato al primo posto nell’aumento del mercato crittografico tra le principali monete, principalmente a causa dell’influenza delle azioni dell’AMM platform, che ha attirato una grande quantità di fondi dalla traccia DeFi, facendo aumentare significativamente il prezzo di CAKE entro una settimana. La moneta è aumentata di circa il 90% in una settimana e il prezzo attuale è rimasto intorno a $2,66, con un certo trend al ribasso del prezzo.<br><img src="https://gimg2.gateimg.com/image/article/17395035701.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali781229"><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-Bitcoin20BTC335280"><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/17395035922.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Questa settimana, il prezzo del BTC è stato principalmente in fluttuazioni a breve termine dall’apertura, ma ha anche registrato un calo relativamente evidente. Ha registrato un rimbalzo nel periodo successivo, ma c’è stato un calo continuo nel periodo di metà settimana. Il prezzo del BTC è sceso al di sotto di $95,000 in un breve periodo, e poi c’è stata un’altra serie di alti e bassi. Il prezzo attuale del BTC si mantiene nell’intervallo di $95,000-$96,000. Nel complesso, il prezzo non presenta segnali di importanti alti e bassi entro una settimana ed è nella stessa fascia del prezzo di apertura.</p>
<h3 id="h3-Ethereum20ETH430001"><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/17395036163.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Le variazioni di prezzo di ETH durante questa settimana hanno mantenuto un trend simile a BTC, ma le fluttuazioni di prezzo sono state minori durante il periodo di metà settimana. Dopo l’apertura, il prezzo di ETH ha subito una serie di picchi, e il prezzo a breve termine è sceso una volta a circa $2,520. Il prezzo successivamente è rimbalzato, e ETH ha raggiunto il livello di $2,800. Attualmente si trova in un intervallo di declino continuo, con i prezzi che si mantengono nell’intervallo $2,600-$2,700. Il massimo settimanale di ETH si avvicina a $2,800, ed è previsto che il fine settimana mantenga il trend principale della settimana, con piccole fluttuazioni di prezzo come trend principale.</p>
<h2 id="h2-Tendenza20del20progetto20Web3459603"><a name="Tendenza del progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza del progetto Web3</h2><p>Il valore di mercato totale dei sette tipi di progetti è aumentato questa settimana, ma la maggior parte del valore di mercato totale è rimasto vicino allo stesso livello della settimana scorsa. Il mercato complessivo è stato principalmente influenzato dalle condizioni di mercato recenti, e piccole fluttuazioni a breve termine erano il trend dominante. Anche se l’aumento delle singole monete era più evidente, il trend complessivo era ancora principalmente di piccole variazioni.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione 7 giorni</th>
<th>Top 3 Guadagnatori</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>0.0%</td>
<td>LLD, TARA, HMND</td>
<td>Il valore di mercato totale della traccia Layer 1 è rimasto invariato, con le principali monete che aumentano a un tasso relativamente uniforme, principalmente le monete mainstream, e rimanendo all’interno di un range moderato.</td>
</tr>
<tr>
<td>Strato 2</td>
<td>-1.0%</td>
<td>DG,ZKF,BVM</td>
<td>Il trend di mercato del settore Layer 2 è simile a quello della traccia L1. L’ampiezza crescente delle principali criptovalute rimane moderata e c’è una mancanza complessiva di alti e bassi su larga scala.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-0.5%</td>
<td>BOR,TIME,TUNE</td>
<td>Il valore di mercato totale della traccia DeFi è cambiato poco, e la distribuzione complessiva delle salite e delle discese è stata disomogenea, concentrata sulla moneta BOR.</td>
</tr>
<tr>
<td>NFT</td>
<td>2.1%</td>
<td>XED,STARS,MOON</td>
<td>Il valore totale del mercato NFT è aumentato leggermente, con le principali monete in ascesa concentrate su singole monete e la distribuzione complessiva varia notevolmente.</td>
</tr>
<tr>
<td>MEME</td>
<td>-0.1%</td>
<td>RUNES•X•BITCOIN,ZYGO,CATME</td>
<td>La scala di capitale complessiva della traccia della moneta MEME è cambiata poco, ma la maggior parte delle monete è caduta e i guadagni si sono concentrati nelle prime monete.</td>
</tr>
<tr>
<td>Staking Liquido</td>
<td>-4.5%</td>
<td>BRG,AFSUI,URO</td>
<td>Questo settore ha una tendenza al ribasso più evidente. I tassi di crescita delle principali criptovalute sono distribuiti in modo relativamente uniforme, e il piccolo calo è principalmente dovuto alla tendenza delle criptovalute mainstream.</td>
</tr>
<tr>
<td>IA</td>
<td>3.4%</td>
<td>KAAI, NFTXBT, BAD</td>
<td>Il settore dell’AI ha registrato una certa ripresa. Dopo che l’impatto complessivo di DeepSeek sull’industria dell’AI è stato ridotto, il settore ha mostrato un trend di ripresa lento.</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; Un processo decisionale prudente è essenziale.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>