Tm90aXppYSBxdW90aWRpYW5hIHwgSWwgRGVGaVRWTCBoYSByYWdnaXVudG8gdW4gbnVvdm8gbWFzc2ltbyBpbiAyIGFubmksIFVuaXN3YXAgVjQgw6ggaW4gcHJvY2ludG8gZGkgZXNzZXJlIGxhbmNpYXRvLCBKdXBpdGVyIGFubnVuY2lhIGkgcHJpbWkgZHVlIHByb2dldHRpIGNoZSBzYXJhbm5vIGxhbmNpYXRp

2024-03-11, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/17101295371_6-06.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20il20TVL20DeFi20onchain20raggiunge20un20nuovo20massimo20in20due20anni20Uniswap20v42020pronto20per20essere20lanciato20termina20il20lancio20del20Jupiter20LFG20Launchpad20BVM20ha20integrato20Filecoin20come20strato20di20archiviazione738266"><a name="Riepilogo giornaliero delle criptovalute: il TVL DeFi on-chain raggiunge un nuovo massimo in due anni; Uniswap v4 è pronto per essere lanciato; termina il lancio del Jupiter LFG Launchpad; BVM ha integrato Filecoin come strato di archiviazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: il TVL DeFi on-chain raggiunge un nuovo massimo in due anni; <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> v4 è pronto per essere lanciato; termina il lancio del Jupiter LFG Launchpad; BVM ha integrato <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> come strato di archiviazione</h2><p>In termini di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Attività di trading ETF, secondo i dati di Farside Investor, l’8 marzo (venerdì scorso), l’uscita di Grayscale GBTC è stata di circa 302,9 milioni di dollari, l’ETF BlackRock <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot (IBIT) ha avuto un afflusso netto di 336 milioni di dollari al giorno, l’ETF Bitwise Bitcoin Spot (BITB) ha avuto un afflusso di 8 milioni di dollari, l’ETF ARK 21Shares Bitcoin Spot (ARKB) ha avuto un afflusso di 1,7 milioni di dollari ieri e l’ETF Fidelity Bitcoin Spot (FBTC) ieri c’è stato un afflusso di 130,3 milioni di dollari.</p>
<p>Secondo i dati raccolti da BitMEX Research, al 8 marzo, IBIT di BlackRock detiene 197.943 Bitcoin del valore di oltre 13,5 miliardi di dollari, superando le criptovalute di MicroStrategy.</p>
<p>Dopo che Bitcoin ha raggiunto un massimo di $70.000, molti Altcoin hanno ottenuto buoni risultati; E l’aumento generale del mercato ha migliorato il sentiment dell’intera industria crittografica. I dati di DefiLlama mostrano che il valore totale bloccato (TVL) dei protocolli di finanza decentralizzata (DeFi) a livello globale è salito per la prima volta a oltre $100 miliardi in circa due anni. Tuttavia, anche dopo un aumento significativo, il TVL è ancora ben al di sotto del record di $189 miliardi stabilito nel novembre 2021.</p>
<p><a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> ha notizie ufficiali; Uniswap v4 sta per essere rilasciato. La prima fase precedentemente condotta è stata il blocco del codice, compresa la completamento del codice principale, i test, ecc. La seconda fase riguarda l’audit e il rilascio della testnet, dove verranno effettuati audit completi e competizioni di audit comunitario da parte di diverse società di audit, oltre a v4, verrà rilasciato sulla testnet. La terza fase è l’inizio della spinta e v4 sarà spinto verso <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet nel terzo trimestre.</p>
<p>DEX Giove su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha pubblicato che il primo voto di LFG Launchpad è terminato. In questo voto hanno partecipato 175.000 votanti, e i primi due progetti selezionati da Jupiter DAO sono Zeus Network e SharkyFi. Inoltre, viene ribadito che “indipendentemente da chi voti, tutti riceveranno la stessa ricompensa in base ai propri diritti di voto.” In precedenza, Jupiter aveva suscitato grande attenzione per il suo airdrop previsto di 4 miliardi di token in quattro fasi.</p>
<p><a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> ha annunciato ufficialmente che BVM (Bitcoin Virtual Machine) ha integrato Filecoin come suo livello di archiviazione. Questa integrazione rappresenta un miglioramento significativo nella soluzione Bitcoin Layer2 supportata da BVM e Filecoin, fornendo una maggiore sicurezza e scalabilità.</p>
<p>BVM ora può utilizzare lo storage decentralizzato di Filecoin per archiviare i record di transazione, semplificando il lavoro di indicizzazione degli sviluppatori di Bitcoin tramite l’aggregatore di nodi Lighthouse.</p>
<h2 id="h2-Tendenze20di20mercato20Adattamento20vicino20al20precedente20massimo20di20BTC638563"><a name="Tendenze di mercato: Adattamento vicino al precedente massimo di BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Adattamento vicino al precedente massimo di BTC</h2><p>La scorsa settimana, i prezzi del BTC hanno brevemente superato il massimo precedente, ma poi hanno subito aggiustamenti a breve termine, con i prezzi attualmente in fluttuazione intorno al massimo precedente. Tuttavia, la tanto attesa stagione degli Altcoin non è ancora arrivata, e la maggior parte degli Altcoin ha già sperimentato una crescita eccessiva nelle fasi iniziali ed è attualmente nella fase di aggiustamento. Inoltre, il mercato azionario statunitense ha subito un calo, il prezzo delle azioni di Nvidia è crollato e il mercato dei token del concetto di intelligenza artificiale è ancora in fase di aggiustamento.</p>
<h3 id="h3-Punti20caldi20di20mercato681889"><a name="Punti caldi di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi di mercato</h3><p>Le monete del concetto di Gamefi hanno registrato un aumento significativo: token come <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a>, YGG e PIXELS sono aumentati significativamente la scorsa settimana. <a href="/price/gala-gala" target="_blank" class="blog_inner_link">GALA</a> e YGG sono guidati dal mercato da DWF Labs, utilizzando tecniche di pull up aggressive. Gli utenti attivi giornalieri di PIXELS hanno raggiunto quota 500000, e il prezzo del token ha superato oggi $1, raggiungendo un nuovo massimo storico.</p>
<p>Il settore dei token di utilità ha registrato una significativa crescita: <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, <a href="/price/okb-okb" rel="nofollow noopener noreferrer" target="_blank">OKB</a>, e altri token utility sono significativamente aumentati, portando ID, EDU, BNX e altri a fare altrettanto. I fondi stanno iniziando a ruotare verso le valute con valori di mercato più elevati ma tassi di crescita più lenti sopra menzionati. È importante notare che l’ID subirà un grande sblocco il 27 marzo. Attualmente, il mercato specula che ci sia stata una fenomeno di vendita prima dello sblocco, ma ci si aspetta che la tendenza al rialzo non continuerà.</p>
<p>I settori dell’IA e dei Meme hanno guidato il declino: le monete dell’IA e dei Meme stanno attualmente guidando il mercato in calo. La scorsa settimana, diverse monete Meme hanno raggiunto nuovi massimi, con un valore di mercato totale di oltre 63 miliardi di dollari. DOGE si posiziona ancora al primo posto con un valore di mercato di oltre 25 miliardi di dollari, seguito da PEPE, FLOKI, WIF e altri. Come una nuova moneta Meme emessa nel 2023, WIF ha raggiunto nuovi massimi diverse volte la scorsa settimana, classificandosi al quinto posto per valore di mercato delle monete Meme con un valore di mercato di 21 miliardi di dollari.</p>
<p>Attività di airdrop aumentata: Saga ha annunciato che 60 milioni di SAGA saranno distribuiti agli indirizzi idonei. Allo stesso tempo, Wormhole ha aperto le query di airdrop e annunciato i dettagli dell’airdrop, di cui il 6,17% dei token verrà utilizzato per gli airdrop della comunità.</p>
<p>Nel complesso, c’è stato un fenomeno di rotazione tra settori diversi nel mercato crittografico. Il concetto di moneta Gamefi e i settori dei token di utilità hanno avuto prestazioni eccezionali, mentre i settori dell’IA e dei Meme hanno mostrato aggiustamenti significativi. Gli investitori devono monitorare da vicino le tendenze di mercato, cogliere con cautela le opportunità di investimento e prestare attenzione al controllo dei rischi. Allo stesso tempo, gli investitori dovrebbero rimanere vigili e evitare di seguire ciecamente la tendenza nei prossimi eventi di sblocco su larga scala.</p>
<h2 id="h2-Macro20Rapporto20sulloccupazione20negli20Stati20Uniti20emesso20calo20dei20mercati20globali20I20prezzi20delloro20raggiungono20un20nuovo20massimo20mentre20i20prezzi20del20petrolio20diminuiscono20leggermente451922"><a name="Macro: Rapporto sull’occupazione negli Stati Uniti emesso, calo dei mercati globali; I prezzi dell’oro raggiungono un nuovo massimo, mentre i prezzi del petrolio diminuiscono leggermente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Rapporto sull’occupazione negli Stati Uniti emesso, calo dei mercati globali; I prezzi dell’oro raggiungono un nuovo massimo, mentre i prezzi del petrolio diminuiscono leggermente</h2><p>Secondo Reuters, nel mercato internazionale, gli indici S&amp;P 500 e NASDAQ hanno raggiunto nuovi massimi storici durante le negoziazioni. Hanno chiuso in ribasso venerdì, mentre le azioni chip in crescita si sono invertite anche dopo che il gigante dell’intelligenza artificiale NVDA ha visto delle prese di profitto venerdì, con un calo del 5,6%.</p>
<p>Per quanto riguarda i report sul mercato del lavoro, i risultati sono contrastanti, indicando che ci sono più nuove opportunità di lavoro rispetto alle aspettative, ma il tasso di disoccupazione è aumentato. Il rapporto sull’indice dei prezzi al consumo (CPI) di febbraio, pubblicato martedì, dovrebbe aumentare dello 0,4% e stabilizzarsi a un tasso annuale del 3,1%. Si prevede che l’inflazione di base aumenti dello 0,3%, portando il tasso di crescita annuale al livello più basso dal primo trimestre del 2021, pari al 3,7%. Integreremo la situazione debole nel rapporto sulle retribuzioni non agricole di febbraio, con il tasso di disoccupazione che raggiunge il massimo in due anni, pari al 3,9%, e manterremo la Federal Reserve su una traiettoria di taglio dei tassi nei prossimi mesi.</p>
<p>I mercati azionari asiatici sono crollati pesantemente lunedì, mentre il dollaro statunitense è sceso prima che i dati sull’inflazione degli Stati Uniti possano accelerare o ritardare i tagli ai tassi di interesse globali. Lo yen giapponese è leggermente salito, e sempre più membri della Banca del Giappone sono inclini a porre fine ai tassi di interesse negativi questo mese a causa delle aspettative di un significativo aumento salariale nelle trattative annuali di quest’anno. L’indice Nikkei del Giappone (.N225) è sceso del 2,3% dopo aver raggiunto la settimana scorsa livelli storici; le azioni blue chip cinesi (.CSI300) sono salite dello 0,2%.</p>
<p>Secondo i dati pubblicati lunedì, il Giappone non è entrato in recessione dopo che il tasso di crescita economica su base annua nel quarto trimestre è stato aumentato al 0,4%.</p>
<p>Per quanto riguarda i prezzi dell’oro, il calo del dollaro statunitense e dei rendimenti obbligazionari ha sostenuto il prezzo dell’oro senza interessi, con un aumento dell’oro fino a $2180 all’oncia, che è salito del 4,5% la settimana scorsa raggiungendo un nuovo massimo storico.</p>
<p>Per quanto riguarda le materie prime, le preoccupazioni sulla domanda cinese hanno compensato la riduzione della produzione da parte dell’OPEC+, un’organizzazione produttrice di petrolio, e i prezzi del petrolio ne sono stati influenzati. Il greggio Brent è sceso di 54 centesimi a $81,54 al barile, mentre il greggio statunitense è sceso di 57 centesimi a $77,44 al barile.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</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.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>