UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgc3RhIHZpdmVuZG8gdW4gc2lnbmlmaWNhdGl2byBjYWxvOyBJbCB2b2x1bWUgZGkgdHJhZGluZyBzcG90IGRpIENFWCBhIG1hcnpvIMOoIGRpICQyLjQ4VDsgVyBoYSBhdHR1YWxtZW50ZSB1bmEgY2FwaXRhbGl6emF6aW9uZSBkaSB

2024-04-04, 22:29

<p><img src="https://gimg2.gateimg.com/image/article/1692587604touyanzhoubao.jpeg" alt=""></p>
<h2 id="h2-Panoramica20delle20tendenze20settimanali113401"><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, il mercato delle criptovalute ha mostrato una leggera fluttuazione seguita da un rapido declino, con un’ampiezza complessiva relativamente elevata. Attualmente, si è ripreso verso la chiusura del fine settimana. La crescita complessiva del valore di mercato è diminuita rispetto al periodo della settimana scorsa, mantenendosi intorno a 2,59 trilioni di dollari e aumentando del 4,65% nelle ultime 24 ore. Il sentiment di mercato è diminuito e si è mantenuto intorno al 72. La maggior parte delle principali criptovalute ha mostrato un trend al ribasso questa settimana, mentre alcune valute hanno mantenuto un trend al rialzo, ma di entità relativamente ridotta. Nel complesso, il mercato delle criptovalute ha mostrato una certa debolezza nella sua crescita questa settimana e il mercato si trova in un periodo di rapido aggiustamento. Ci si aspetta un round di ripresa complessiva nel fine settimana.</p>
<p>Rispetto alla settimana scorsa, il mercato totale delle criptovalute ha mostrato una tendenza al ribasso, con fluttuazioni relativamente piccole mantenute fino a martedì, seguite da una rapida e volatile tendenza al ribasso. I primi 100 progetti criptovalutari hanno registrato un aumento e una diminuzione di circa il 50% in una settimana, con un lato che mostra un significativo calo delle valute mainstream e l’altro che mostra un significativo aumento di alcune nuove valute all’inizio del loro lancio. Il prezzo del BTC è sceso nuovamente sotto i $70.000 in una settimana ed è attualmente intorno ai $68.845, con una variazione settimanale di circa -2,72%. Anche l’ETH ha subito un significativo calo questa settimana, con un aumento complessivo di circa -5,38%. Attualmente si mantiene intorno ai $3.380 e continua a fluttuare.</p>
<p>La moneta con le migliori performance sul mercato questa settimana è CORE, che è aumentata del 107,89% in 7 giorni. Il prezzo della moneta è attualmente di circa $2,47, posizionandosi al primo posto in una settimana di guadagni.</p>
<p>Il trend generale del mercato delle criptovalute di questa settimana è principalmente al ribasso, ma il declino avviene principalmente dopo la metà della settimana. Tuttavia, alcune valute hanno ancora mostrato un trend contrario al rialzo, e è probabile che il mercato nel complesso subirà un rimbalzo durante il fine settimana.</p>
<h2 id="h2-Mercato20delle20criptovalute20336"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥 Il mercato delle criptovalute ha subito un significativo rapido declino nella scorsa settimana e da allora si è ripreso.</p>
<p>🔥 4.1 BTC giornaliero di 4 ore -1,6%, ETH -2,4%; Le prime 500 aziende con un aumento o diminuzione del valore di mercato ≥ 30%: CORE+56%, TRUMP+41%, GFI+34%, MEW -37%; I prezzi di WIF, i prezzi di PENDLE, il TVL di Base, il TVL di Pendle, gli indirizzi di possesso di ETH e i prezzi dell’oro fisico hanno raggiunto livelli storici; <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema e le monete Meme sulla Base chain sono generalmente aumentate.</p>
<p>🔥 Sblocco dei token ad alto valore di questa settimana: SUI $65,08 milioni, GAL $14,51 milioni, HFT $6 milioni, ACA $5 milioni, LQTY $1,03 milioni, ecc.</p>
<p>🔥 SLERF significa che gli utenti che inviano oltre 5 SOL in pre-vendita possono scegliere di ricevere NFT.</p>
<p>🔥 <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha nuovamente aumentato il proprio portafoglio di 8.888 BTC, con una posizione totale che supera i 75.000.</p>
<p>🔥 UniSat: Aggiornato alla v1.2.10, supporta BRC20 a 5 byte.</p>
<p>🔥 I minatori del blocco 837090 della rete BTC hanno ricevuto un totale di 8,595 BTC di ricompense.</p>
<p>🔥 Il fondatore di Ordinals ha rilasciato la runa genesi, che è stata dimezzata e ha continuato a essere lanciata per circa quattro anni.</p>
<p>🔥 Il CEO di <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> ha dichiarato che L3 si spoglierà <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> del suo valore e non svilupperà L3.</p>
<p>🔥 I proprietari di canali con oltre 1000 iscritti su Telegram possono ricevere il 50% dei ricavi pubblicitari del loro canale e i prelievi saranno lanciati su Fragment entro poche settimane.</p>
<p>🔥 Il fondatore di <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> ha annunciato che la prossima versione di <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> sarà costruita su L4.</p>
<p>🔥 La Fondazione gm.ai ha proposto l’economia dei token e si prevede che il sito web principale verrà lanciato nella terza settimana di aprile.</p>
<p>🔥 Al giorno 4.2, BTC -4.5% nelle ultime 24 ore, ETH -5.2%; Le prime 500 aziende con un aumento o una diminuzione del valore di mercato ≥ 30%: GHST+52%, XVG+39%; Il prezzo di GHST, il prezzo di PUFF, il prezzo di JTO, il prezzo di Fren Pet e il volume delle transazioni di DEX a marzo hanno raggiunto massimi storici; Le monete meme sulla catena Zora sono generalmente aumentate.</p>
<p>🔥 Il 1° aprile, l’ETF spot BTC ha avuto un deflusso netto di 88 milioni di dollari, un afflusso netto di circa 40 milioni di dollari e un afflusso netto di 114 milioni di dollari.</p>
<p>🔥 Zeus Network condurrà TGE e distribuirà token il 4 aprile.</p>
<p>🔥 Vitalik Buterin ha rilasciato una spiegazione per semplificare il protocollo <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e ridurre il carico delle risorse dei nodi, affermando che L3 non può magicamente migliorare ulteriormente la capacità di trasmissione.</p>
<p>🔥 Blast ha lanciato un’attività di bonus punti, che consente l’uso di specifiche DApp per aumentare i punti.</p>
<p>🔥 Ethena ha aperto l’applicazione per i token di airdrop e ha incluso i titolari di Milady Maker nel campo di airdrop. La seconda stagione di Sats inizierà il 2 aprile.</p>
<p>Il volume di trading spot di CEX a marzo è stato di $2,48 trilioni, avvicinandosi al livello di novembre 2021.</p>
<p>🔥 Memeland: lancerà la blockchain Memenet, utilizzando MEME come gas.</p>
<p>🔥 Robinhood lancerà OP.</p>
<p>🔥 Il 3 aprile, BTC+0.3% nelle ultime 24 ore, ETH -0.2%; ENA+45% per le prime 500 aziende con un aumento o diminuzione del valore di mercato di ≥ 30%; il prezzo di BGB, l’emissione di TRC20-USDT, il ricavo dei minatori di BTC di marzo e il conteggio degli utenti di Ethereum L2 hanno raggiunto un massimo storico.</p>
<p>🔥 Questa settimana, oltre 20 progetti o istituzioni hanno annunciato (pianificato) il completamento di oltre $3,1 miliardi di finanziamenti.</p>
<p>🔥 Il valore di mercato circolante di ENA è di 1,25 miliardi di dollari, con un valore di mercato totale di 12,18 miliardi di dollari.</p>
<p>🔥 Ethena ha suscitato ampio dibattito e controversie nell’industria.</p>
<p>🔥 Il progetto TON Meme Notcoin rilascerà un token NOT il 20 aprile.</p>
<p>🔥 La proposta di ridurre la circolazione di Ethereum ha suscitato aspre critiche dalla comunità crittografica.</p>
<p>🔥 <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> ha annunciato l’integrazione della rete Blast e v2 LP può ricevere vantaggi nativi.</p>
<p>🔥 OpenSea supporta la configurazione e l’esecuzione del reddito del creatore utilizzando ERC721-C.</p>
<p>🔥 BCH ha completato l’halving della ricompensa per blocco questa volta.</p>
<p>🔥 BTC +1,0% in 24 ore, ETH +1,0%; Le prime 500 aziende con una variazione di valore di mercato ≥ 30%: PANDORA +36%, TRIBE +60%, XVG -31%; I prezzi di ENA, JTO e PUFF hanno raggiunto livelli storici.</p>
<p>🔥 Degen: L’estensione del browser IDriss supporta DEGEN per la mance agli utenti X.</p>
<p>🔥 Slerf ha completato il secondo round di rimborso per 2200 SOL.</p>
<p>🔥 Rarible già supporta l’uso di MFER per pagare per Base Chain NFT.</p>
<p>🔥 Bobaopa ha subito una distruzione di token.</p>
<p>🔥 L’artista Crypto XCOPY condivide le mosche raccomandate.</p>
<p>🔥 La prevendita dei preservativi ha raccolto quasi 5000 SOL dopo il Rug.</p>
<h2 id="h2-Politiche20regolamentari419068"><a name="Politiche regolamentari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche regolamentari</h2><p>🔥 Lugano, in Svizzera, permette ai residenti e ai turisti di effettuare transazioni quotidiane utilizzando le criptovalute.</p>
<p>🔥 Si prevede che Daley e Mester della Federal Reserve taglieranno i tassi di interesse tre volte quest’anno.</p>
<p>🔥 Il rendimento dei titoli di Stato a 5, 10 e 30 anni degli Stati Uniti ha raggiunto il punto più alto dell’anno.</p>
<p>🔥 <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Diversi stati degli Stati Uniti sono interessati a sviluppare un sistema di conteggio dei voti basato su Cardano.</p>
<p>🔥 La Banca per i Regolamenti Internazionali e sette banche centrali testeranno la tokenizzazione per migliorare i pagamenti transfrontalieri.</p>
<h2 id="h2-Crypto20Market20Highlights473527"><a name="Crypto Market Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Market Highlights</h2><p>⭐ La scorsa settimana, il mercato cripto nel complesso ha vissuto un chiaro trend al ribasso, e attualmente sta subendo un’oscillazione e un aggiustamento rapidi. La maggior parte delle criptovalute è entrata in un range al ribasso verso la fine del fine settimana, ma c’è un trend di ripresa. Man mano che l’halving del BTC si avvicina, unito a giorni consecutivi di grandi afflussi netti di ETF, è probabile che si verifichi nuovamente un recupero complessivo nel periodo successivo.</p>
<p>⭐ Nonostante la situazione di mercato sia peggiorata questa settimana, alcune valute principali hanno registrato buone performance. Tra queste, CORE ha mostrato una buona tendenza al rialzo grazie alla dinamica del progetto stesso e all’attenzione dedicata al settore Layer2 nel mercato. Il prezzo ha superato i $4 in breve tempo, registrando un aumento settimanale del 107,89%. Attualmente, il prezzo si mantiene intorno a $2,45. Il prezzo settimanale si attesta intorno a $4,1 e la posizione si aggira intorno a $1,18 durante il periodo di apertura.<br><img src="https://gimg2.gateimg.com/image/article/17122695501.jpg" alt=""><br>(Dati Cortesia di Coinmarketcap)</p>
<h2 id="h2-BTC20amp20ETH20Performance20Settimanale537757"><a name="BTC &amp; ETH Performance Settimanale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Performance Settimanale</h2><h3 id="h3-Bitcoin20BTC201069"><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/17122695742.jpg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>La tendenza dei prezzi di BTC questa settimana è stata principalmente caratterizzata da lievi fluttuazioni sostenute dopo l’apertura, seguite da una rapida tendenza al ribasso, con evidenti fluttuazioni dei prezzi. Entrando nel periodo di chiusura vicino al fine settimana, c’è una tendenza di rimbalzo relativamente evidente, mantenendo una continua fluttuazione di circa $69.000. Il prezzo settimanale ha un punto basso di circa $64.500 e un punto alto di circa $71.400.</p>
<p>L’analisi suggerisce che le prestazioni del prezzo di BTC di questa settimana sono state fortemente influenzate dalle fluttuazioni complessive del trading nel mercato. Sebbene i fondi ETF abbiano mostrato un ritorno rapido e grande, il mercato ha subito significative fluttuazioni intraday. Tuttavia, questa serie di cambiamenti di prezzo sembra essere più influenzata dal comportamento di vendita del mercato. Sebbene il trend complessivo della moneta continuerà generalmente a essere dominato dal comportamento sopra menzionato in futuro, potrebbero ancora verificarsi trend al ribasso simili prima della riduzione a metà di BTC, ma dovrebbero comunque mostrare fluttuazioni a breve termine. Attualmente, il trend della moneta è rimbalzato leggermente e si prevede che tornerà sopra i $70.000 durante la fase di chiusura del weekend.</p>
<h3 id="h3-Ether20ETH748337"><a name="Ether (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ether (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17122696043.jpg" alt=""><br>(Dati cortesia di TradingView)</p>
<p>Il trend dei prezzi dell’ETH questa settimana ha mantenuto una forte correlazione con il BTC, anche se le recenti prestazioni dei prezzi dell’ETH sono state relativamente deboli e questo trend al ribasso della moneta è apparso prima. Nel breve termine, il punto basso settimanale del prezzo si avvicina a $3.200, con un significativo calo. Il punto alto del prezzo entro una settimana è di circa $3.640, mentre il punto basso è di circa $3.209.</p>
<p>L’analisi suggerisce che le performance dei prezzi delle monete ETH questa settimana continuano a seguire la tendenza complessiva del mercato, con un calo complessivo maggiore rispetto a BTC. Ciò è correlato all’opinione pubblica scatenata dalle informazioni dinamiche su Ethereum questa settimana, ma, cosa più importante, ETH stesso manca di un supporto significativo nel ciclo di mercato attuale. Mentre si avvicina la fase di chiusura del fine settimana, la tendenza al recupero della moneta non è particolarmente evidente e si teme che il punto più alto della settimana rimarrà ancora sopra i $3.600, con una probabilità inferiore di ulteriore aumento.</p>
<h2 id="h2-Tendenza20del20progetto20Web3392844"><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 della maggior parte delle nove categorie di progetti ha mostrato un trend al ribasso. A causa dell’effetto delle fluttuazioni cicliche di mercato, il trend principale è stato al ribasso in diverse categorie. Le altre categorie hanno avuto una performance scadente, ad eccezione di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> MEME, che ha continuato a salire. Sembra che ci vorrà ancora del tempo prima del recupero del mercato nel complesso.<br><img src="https://gimg2.gateimg.com/image/article/1712292336img_v3_029l_bf9389fa-1660-4579-bbda-8519a4e005ix.jpg" alt=""></p>
<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.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>