UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgc3ViaXNjZSB1biBjYWxvIGZsdXR0dWFudGUgcXVlc3RhIHNldHRpbWFuYTsgZ2xpIEVURiBzcG90IGRpIEJUQyBjb250aW51YW5vIGEgc3ViaXJlIGRlZmx1c3NpIG5ldHRp

2024-03-22, 03:01

<p><img src="https://gimg2.gateimg.com/image/article/1711095466zb.jpeg" alt=""></p>
<h2 id="h2-Panoramica20delle20tendenze20settimanali163726"><a name="Panoramica delle tendenze settimanali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica delle tendenze settimanali</h2><p>Questa settimana ha visto una diminuzione del mercato delle criptovalute, con un significativo calo giornaliero tra le principali criptovalute. Nonostante un lieve recupero verso la fine di questa settimana, il mercato non è tornato alle condizioni più favorevoli riscontrate nelle due settimane precedenti. Il sentiment di mercato è ancora alto a 80 punti, riflettendo un umore complessivamente ottimista. La capitalizzazione di mercato totale si attesta a 2,46 trilioni di dollari, segnando un aumento del 1,28% nelle ultime 24 ore. Le criptovalute mainstream sono state soggette a oscillazioni erratiche, con prezzi attuali inferiori rispetto all’apertura settimanale. Nel complesso, il mercato ha sperimentato forti fluttuazioni, guidate dalla chiusura di posizioni lunghe consistenti, notizie sfavorevoli e ritiro di fondi over-the-counter (OTC), con conseguente prestazione generalmente negativa per la maggior parte delle valute.</p>
<p>Questa settimana, il mercato delle criptovalute ha visto un continuo declino nel volume complessivo delle transazioni rispetto alla settimana scorsa. Le valute mainstream, dopo aver raggiunto un picco iniziale, hanno subito una considerevole caduta, riflettendo la tendenza nel volume complessivo del mercato. Nonostante ciò, alcuni settori del mercato hanno raggiunto nuovi massimi sia in volume di trading che in prezzi, anche se la maggior parte dei settori ha subito notevoli declini. Mentre il weekend volge al termine, c’è un aumento generale della tendenza del mercato. Guardando avanti, è previsto che il mercato incontri cambiamenti significativi durante il fine settimana, con una forte probabilità di assistere ad un modesto aumento.</p>
<p>Le prime 100 criptovalute di questa settimana mostrano un rapporto tra vincitori e perdenti di circa 20:80. In linea con il sentiment complessivamente ribassista del mercato, la maggior parte delle valute principali ha registrato un trend al ribasso. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) ha infranto diversi livelli di supporto critici, scendendo al di sotto del livello di $61,000 per un certo periodo e registrando una variazione settimanale del -7,39%; attualmente è scambiato intorno a $64,848. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH) ha rispecchiato questa volatilità, scendendo brevemente al di sotto dei $3.100, e ha registrato un calo settimanale del -10,09%, con il suo prezzo attualmente intorno a $3.432</p>
<p>In una settimana contrassegnata da diffusi ribassi di mercato, ONDO si è distinto con un impressionante crescita di 7 giorni del 35,2%, ora valutato intorno a $0,7353 e guadagnando il titolo di miglior performante della settimana.</p>
<p>Il mercato delle criptovalute di questa settimana ha registrato notevoli fluttuazioni e tendenze generali al ribasso. Verso la fine della settimana si è verificato un leggero aumento, tuttavia è un modesto miglioramento. Attualmente il mercato si sta adeguando attraverso una fase di correzione. Nelle prossime settimane non è previsto che la capitalizzazione complessiva di mercato e i prezzi delle principali criptovalute tornino ai massimi recenti. È necessaria un’osservazione continua per valutare come si svilupperà il mercato.</p>
<h2 id="h2-mercato20delle20criptovalute709300"><a name="mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>mercato delle criptovalute</h2><p>🔥A causa della liquidazione di posizioni lunghe massive e notizie sfavorevoli, il mercato è crollato significativamente questa settimana.<br>🔥All’inizio della settimana, abbiamo assistito a performance senza precedenti su diversi progetti, con picchi nei prezzi di NDR e PRIME, un’impennata della capitalizzazione di mercato di SOL, volumi di transazioni record di sempre per <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Il BonkBot di Gate.io, l’interesse di ricerca in aumento per <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> su Google Trends e le transazioni giornaliere senza precedenti su Base. I BTC e gli ETF spot degli Stati Uniti hanno registrato i loro flussi netti settimanali più alti e i volumi di trading nella scorsa settimana, e i prodotti di investimento in asset digitali hanno anche registrato i flussi netti settimanali più alti. La mania dei MEME su Solana è continuata e il settore dell’IA ha registrato un trend generale al rialzo.<br>🔥Secondo i dati di lunedì, i guadagni cumulativi pre-vendita di tutti i progetti di Meme coin delle ultime 72 ore hanno raggiunto la cifra di 100 milioni di dollari.<br>🔥Questa settimana SOL ha temporaneamente sorpassato <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, rivendicando la posizione di quarta criptovaluta per valore di mercato, prima che <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> riguadagnasse la sua posizione.<br>🔥A causa di un errore del team di Slerf, il token LP per la raccolta fondi e i token airdrop sono stati distrutti e non sono recuperabili, portando a gravi fluttuazioni nella performance di mercato di Slerf. Il fondatore di Slerf ha assicurato che il team sta cercando attivamente soluzioni a questo problema e si impegna a sistemare le cose con i collaboratori della prevendita. Tuttavia, il problema più urgente è la mancanza di fondi adeguati per fornire rimborsi ai partecipanti alla prevendita.<br>🔥Diversi progetti hanno annunciato l’intenzione di distribuire token airdrop a coloro che hanno partecipato alla vendita SLERF.<br>🔥Il wallet di El Salvador ha ricevuto quasi 200 donazioni in BTC.<br>🔥NodeMonkes ha superato Boring Ape NFT in termini di valore di mercato, rivendicando il posto come il secondo NFT più grande per capitalizzazione di mercato.<br>🔥ether.fi airdrop è ora aperto per la rivendicazione.<br>🔥Nel corso della settimana, gli ETF spot su BTC hanno raggiunto un nuovo massimo di deflussi netti in un solo giorno, mentre GBTC ha assistito al suo più grande prelievo in un solo giorno di sempre; ciò ha coinciso con una flessione generale del mercato e un calo dei prezzi delle criptovalute statunitensi.<br>🔥Il volume degli scambi nelle 24 ore di SLERF sulla chain Solana ha superato i 2,2 miliardi di dollari, secondo solo a SOL e USDC.<br>🔥Secondo le statistiche del 19, i primi tre DEX per volume di scambi nelle 24 ore sono tutti sulla catena Solana, vale a dire Raydium, Jupiter e Orca.<br>🔥Il New York Times ha riferito che circa il 30% dei minatori d’oro del gioco blockchain del mondo ha sede nelle Filippine.<br>🔥L’ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ha registrato ampi deflussi netti per giorni consecutivi, con i titoli legati alla blockchain in generale in calo. Il 19 marzo, gli ETF spot su Bitcoin hanno registrato un deflusso netto di 326 milioni di dollari, seguito da un deflusso di 500 milioni di dollari il 20, e un ulteriore deflusso di 261,5 milioni di dollari è stato registrato nuovamente il 20.<br>🔥 <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> L’aiuto di $4 milioni di Starbucks per l’ingresso nella criptovaluta è stato insufficiente, terminando in un fallimento.<br>🔥Entro 24 ore il 20 marzo, la rete ha visto una liquidazione diffusa delle posizioni per un importo di $666 milioni.<br>🔥Un analista ETF di Bloomberg prevede che le probabilità di ottenere il via libera a un ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot a maggio siano scarse.<br>🔥Grayscale GBTC ha registrato un deflusso di US$444 milioni il 19 marzo.<br>🔥 <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha emesso un ulteriore 1 miliardo di USDT sul <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> rete (autorizzata ma non ancora rilasciata).<br>🔥NFTfi lancia la NFTfi Foundation e lancerà la DAO attraverso l’NFTfi Council.<br>🔥Il 19 marzo, Bitcoin ha registrato il suo più grande calo in un solo giorno dal crollo di FTX, con il prezzo che è sceso di oltre l’8% in un solo giorno.<br>🔥Il volume cumulativo degli scambi dell’ETF spot statunitense su Bitcoin ha superato i 150 miliardi di dollari.<br>🔥Lo sconto di Grayscale Ethereum Trust raggiunge il livello più basso da novembre 2023.<br>🔥Robinhood lancia il suo portafoglio di criptovalute per gli utenti Android di tutto il mondo.<br>🔥C’erano voci di mercato che suggerivano che la Ethereum Foundation fosse sotto indagine da parte del governo di un paese, ma i partner di CEHV hanno successivamente chiarito che la notizia era falsa.<br>🔥Nell’ultima settimana, la catena Base ha registrato un afflusso di oltre 840.000 nuovi utenti, segnando un sostanziale aumento del 510% rispetto alla settimana precedente.<br>🔥Mystiko Network, il livello base del Web3, ha completato un finanziamento di seed round da 18 milioni di dollari.<br>🔥CryptoPunk #7804 è stato venduto per oltre 16 milioni di dollari in ETH.<br>🔥Il 20 marzo Grayscale GBTC aveva registrato un deflusso netto di 386 milioni di dollari.<br>🔥L’halving di BTC dovrebbe essere completato il 20 aprile, con un conto alla rovescia inferiore ai 30 giorni.<br>🔥Global X lancerà presto l’ETF sulla strategia sui futures su BTC con il codice BTRN.<br>🔥Il valore di mercato totale delle stablecoin nel mercato delle criptovalute ha superato i 150 miliardi di dollari.<br>🔥Si prevede che le richieste totali del governo degli Stati Uniti nei confronti di FTX oscilleranno tra i 3 e i 5 miliardi di dollari.</p>
<h2 id="h2-Politica20regolamentare873908"><a name="Politica regolamentare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politica regolamentare</h2><p>🔥Dopo 17 anni, la Banca del Giappone ha aumentato i tassi di interesse, spostando il tasso di riferimento da -0,1% a un intervallo tra 0 e -0,1%, ponendo così fine all’era dei tassi di interesse negativi. Ci si aspetta che un ambiente monetario relativamente accomodante venga mantenuto per il futuro prevedibile.</p>
<p>Le autorità olandesi accusano Alexey Pertsev di aver aiutato a riciclare 1,2 miliardi di dollari attraverso Tornado Cash.</p>
<p>SBF ha sostenuto che la proposta dei pubblici ministeri statunitensi di poterlo sottoporre a un massimo di 50 sentenze è una distorsione della realtà.</p>
<p>🔥La SEC degli Stati Uniti ha avviato una campagna legale mirata a classificare Ethereum come una security.</p>
<p>🔥La Federal Reserve ha mantenuto invariati i tassi di interesse, con il presidente che ha affermato che sebbene vi sia stato un notevole calo dell’inflazione, questa rimane al di sopra dei livelli obiettivo, aprendo la possibilità di un taglio dei tassi più avanti nell’anno. Ha inoltre affermato che la Fed non sta segretamente favorire la creazione di CBDC.</p>
<h2 id="h2-Destaques20del20mercato20cripto607443"><a name="Destaques del mercato cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Destaques del mercato cripto</h2><p>⭐️Nella scorsa settimana, il mercato delle criptovalute ha registrato un trend prente al ribasso, con la maggior parte della settimana caratterizzata da candele rosse. Tuttavia, si è verificato un leggero recupero mentre la settimana volge al termine, offrendo un barlume di speranza per l’attività di trading del fine settimana. Dopo un periodo di rapida crescita nelle ultime settimane, c’è un sentimento crescente che il mercato potrebbe essere stato surriscaldato. La diminuzione dei prezzi delle principali valute ha scatenato significative liquidazioni delle posizioni long. Ciò, insieme a liquidazioni diffuse e consistenti deflussi dai BTC spot ETF, ha contribuito alla letargia di mercato di questa settimana. Attualmente, il mercato delle criptovalute sta attraversando un periodo di consolidamento e adeguamento, con la possibilità di notevoli cambiamenti di tendenza nella settimana a venire.</p>
<p>⭐️ Il mercato ha proseguito il suo percorso discendente questa settimana, con numerose valute che riflettono questo calo. Nonostante una scarsità di notizie rialziste all’interno della sfera delle criptovalute, il mercato dei fondi statunitensi ha registrato diversi cambiamenti positivi a causa delle recenti politiche della Federal Reserve. Questi cambiamenti hanno beneficiato in modo significativo Ondo, specializzata nella tokenizzazione di asset reali (RWA). L’aumento del 35,2% di Ondo potrebbe non eguagliare le recenti impennate delle valute del settore MEME, tuttavia rimane un’eccezione degna di nota nel trend ribassista, con un prezzo che si aggira intorno a $0.7353. Oltre ai fattori di mercato esterni, il movimento al rialzo di Ondo può anche essere attribuito al suo breve ciclo di emissione e al sentiment di mercato ottimista verso il suo potenziale come criptovaluta nascente.<br><img src="https://gimg2.gateimg.com/image/article/17110955971.jpeg" alt=""><br>(Fonti dati: <a href="https://coinmarketcap.com/" rel="nofollow noopener noreferrer" target="_blank">Coinmarketcap</a>)</p>
<h2 id="h2-Prestazioni20settimanali20di20Bitcoin20amp20Ethereum501273"><a name="Prestazioni settimanali di Bitcoin &amp; Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni settimanali di Bitcoin &amp; Ethereum</h2><h3 id="h3-Bitcoin20BTC732109"><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/17110956192.jpeg" alt=""><br>(Fonti dei dati: <a href="https://www.tradingview.com/" rel="nofollow noopener noreferrer" target="_blank">TradingView</a>)<br>Dall’inizio della settimana, BTC è stato in una traiettoria al ribasso, entrando successivamente in una fase di adeguamenti significativi e bruschi. Il prezzo ha subito una caduta drammatica da $69.000 a $61.000 in un breve lasso di tempo, con il più grande calo giornaliero che supera l’8%. Attualmente, BTC si trova in una fase di consolidamento, mantenendo fluttuazioni giornaliere attive. Si prevede un potenziale cambiamento di tendenza all’avvicinarsi della fine della settimana.<br>Gli analisti ritengono che il BTC abbia infranto diversi livelli di supporto chiave questa settimana, innescando liquidazioni massive, che hanno un maggiore impatto sul mercato. Unitamente all’enorme deflusso di fondi ETF OTC, il BTC è entrato in una tendenza relativamente lenta. Unitamente all’imminente evento di halving, potrebbe essere necessario del tempo affinché la valuta torni a superare i $70.000, realizzabile solo con un cambiamento sostanziale nella dinamica di mercato interna ed esterna.</p>
<h3 id="h3-Ethereum20ETH377462"><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/17110956793.jpeg" alt=""><br>(Fonti dati: <a href="https://www.tradingview.com/" rel="nofollow noopener noreferrer" target="_blank">TradingView</a>)</p>
<p>Il movimento del prezzo dell’ETH questa settimana ha riflettuto quello del BTC. Similmente al BTC, l’ETH ha visto un rapido declino all’apertura del mercato. Dopo essere sceso sotto la soglia dei 3.100 dollari, ha poi visto un certo recupero. Per gran parte della settimana, le fluttuazioni del prezzo dell’ETH sono state in qualche modo più miti rispetto a quelle del BTC, riuscendo a rimanere al di sopra del livello di supporto cruciale di 3.000 dollari. Attualmente sospeso intorno ai 3.500 dollari, ci si aspetta che l’ETH subisca un rimbalzo mentre il fine settimana volge al termine.</p>
<p>Gli analisti sostengono che le recenti performance di ETH non solo siano in sintonia con il calo generale del mercato delle criptovalute, ma siano anche in parte dovute alla posizione regolamentare della SEC nei confronti di ETH. Il rigetto delle richieste di ETP legate a Ethereum, insieme alle azioni di contrasto della SEC nei confronti della moneta, hanno gettato un’ombra sul mercato di ETH. Date queste circostanze, gli analisti prevedono che sarà difficile per ETH tornare al punto di prezzo di $4.000 nel breve termine.</p>
<h2 id="h2-Tendenze20dei20progetti20Web3278001"><a name="Tendenze dei progetti Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze dei progetti Web3</h2><p>Questa settimana, i principali nove settori nello spazio Web 3 hanno visto un forte calo del valore di mercato. Con il mercato che abbraccia una tendenza generale al ribasso, Solana MEME spicca come eccezione, mantenendo una traiettoria di crescita complessiva. Tuttavia, la maggior parte degli altri progetti ha affrontato forti ribassi, con tutti che mostrano rapidi declini e le prospettive per un recupero rapido e sostanziale sembrano scarse.<br><img src="https://gimg2.gateimg.com/image/article/17110957611.png" alt=""><img src="https://gimg2.gateimg.com/image/article/17110957832.png" alt=""><img src="https://gimg2.gateimg.com/image/article/17110958023.png" alt=""></p>
<div class="blog-details-info"><br><div>Autore: Charles T., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<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, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>