UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgdm9sdW1lIHRvdGFsZSBkZWwgbWVyY2F0byBjcml0dG9ncmFmaWNvIMOoIGNhbWJpYXRvIHJlbGF0aXZhbWVudGUgcG9jbyBpbiB1bmEgc2V0dGltYW5hOyBWaXRhbGlrIMOoIGFwcGFyc28gYSBISyBwZXIgdGVuZXJlIHVuIGRpc2NvcnNvOyBJbCBwcm9ibGVtYSBkZWxsYSBjb25

2024-04-12, 02:52

<p><img src="https://gimg2.gateimg.com/image/article/1712889994zb.jpeg" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze472472"><a name="Panoramica settimanale delle tendenze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica settimanale delle tendenze</h2><p>Il mercato complessivo delle criptovalute ha mantenuto una fluttuazione relativamente contenuta questa settimana, con una fluttuazione generale relativamente bassa. Nel corso della settimana, è salito prima e poi è sceso. C’è stata una certa ripresa verso la fine settimana, sebbene il cambiamento complessivo non sia stato significativo. La crescita complessiva del valore di mercato non è cambiata molto rispetto alla stessa settimana dell’anno scorso, mantenendosi intorno ai 2,6 trilioni di dollari, e è aumentata dello 0,10% nelle ultime 24 ore. Il sentiment di mercato ha raggiunto il 76. Questa settimana, le principali valute mainstream hanno mostrato un trend misto di rialzo e calo, ma la maggior parte di esse ha mantenuto un’oscillazione relativamente contenuta, con una tendenza generale di fluttuazioni principalmente oscillanti. Nel complesso, il mercato delle criptovalute non ha raggiunto un rimbalzo questa settimana, e il mercato complessivo è ancora in fase di aggiustamento delle fluttuazioni. Si prevede di sperimentare un leggero rimbalzo nel corso del fine settimana, e c’è una forte probabilità che si mantenga una tendenza fluttuante in futuro.</p>
<p>Rispetto alla settimana scorsa, il mercato criptato totale di questa settimana ha mostrato un leggero calo, con un lento trend al rialzo globale sin dall’apertura. C’è stata una rapida crescita durante il giorno, seguita da un’altra diminuzione fino alla fine del weekend, quando c’è stata qualche ripresa. Il rapporto di fluttuazione dei primi 100 progetti criptati in una settimana è di 3:7, con la principale crescita concentrata principalmente sulle valute popolari recenti, e le variazioni di prezzo delle principali valute mainstream sono relativamente ridotte. Il prezzo del BTC è tornato sopra i $70.000 in una settimana ed attualmente si aggira intorno ai $70.060, con una variazione settimanale di circa il 2,44%. Anche l’ETH ha registrato un certo aumento questa settimana, con un aumento complessivo di circa il 5,04%, mantenendo attualmente una fluttuazione sostenuta intorno ai $3.501.</p>
<p>La moneta che ha ottenuto le migliori prestazioni sul mercato questa settimana è <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, con un aumento del 47,8% in 7 giorni. Il prezzo della moneta è attualmente mantenuto intorno a $21,94, classificandosi al primo posto nella settimana di guadagni.</p>
<p>Il trend generale del mercato delle criptovalute di questa settimana è caratterizzato principalmente da lievi fluttuazioni e le salite e le discese non sono significative. Ci sono comunque alcune valute principali con guadagni significativi e è probabile che il mercato nel complesso subisca un altro lieve rimbalzo durante il fine settimana. Nonostante il trend sia al rialzo, il tasso di crescita è limitato.</p>
<h2 id="h2-Mercato20cripto673552"><a name="Mercato cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato cripto</h2><p>🔥 La tendenza settimanale del mercato delle criptovalute è principalmente caratterizzata da fluttuazioni volatili, con variazioni relativamente piccole nel volume totale.</p>
<p>🔥 Lunedì, BTC+4,2% in 24 ore, ETH+6,7%; Top 500 aumento o diminuzione del valore di mercato ≥ 30%: Nessuno; Il prezzo di TON, il prezzo di base di Runestone, il TVL di base, il TVL di Pendle e il volume di transazioni giornaliere di base hanno raggiunto livelli storici.</p>
<p>🔥 Martedì BTC -1,7%, ETH+1,1% delle ultime 24 ore; Le prime 500 aziende con un aumento o diminuzione del valore di mercato di ≥ 30%: VELO+53%, NEO+32%; Prezzo TON, prezzo ENA, prezzo token ARC-20 AVM, prezzo floor di Runestone e Base TVL raggiungono nuovi massimi storici.</p>
<p>🔥 Mercoledì BTC -1,9%, ETH -2,9% per 24 ore; Top 500 aumento o diminuzione del valore di mercato ≥ 30%: Nessuno; I prezzi di BORED e il TVL di Mantle raggiungono massimi storici; Le altcoin hanno seguito il declino generale del mercato, mentre il settore Meme è generalmente diminuito.</p>
<p>🔥 Giovedì BTC+2,5% in 24 ore, ETH+2,1%; Top 500 aumento o diminuzione del valore di mercato ≥ 30%: Nessuno; Prezzo TON, prezzo ENA, prezzo PENDLE, prezzo RIVUS, prezzo del pavimento Runestone, difficoltà di mining di BTC, Base TVL raggiungendo massimi storici; L’uscita netta giornaliera di GBTC ha raggiunto un nuovo minimo; BRC20 e BTC NFT sono generalmente aumentati.</p>
<p>🔥 Il numero di nuovi indirizzi aggiunti a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> A marzo ha raggiunto un nuovo massimo da novembre 2021 e l’attività dei detentori a lungo termine è diminuita.</p>
<p>🔥 <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>: UniswapX è stato lanciato sull’interfaccia.</p>
<p>🔥 Color Protocol lancia il protocollo di conversione ERC-404 per Meme.</p>
<p>🔥 Il protocollo Atomico sta testando la soluzione di divisione dei token ARC20.</p>
<p>La roadmap 2024 di TON sarà lanciata, incluso il lancio del trading senza gas, Wallet v5, la nuova tecnologia cross chain Teleport e altro ancora.</p>
<p>🔥 TON lancia un milione <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> programma di sponsorizzazione per la comunità cinese.</p>
<p>🔥 Saga annuncia il lancio della prima fase del mainnet; La capitalizzazione di mercato circolante attuale di SAGA è di circa $500 milioni, con un valore di mercato totale di circa $5.7 miliardi.</p>
<p>🔥 L’ETF spot BTC statunitense ha avuto un deflusso netto di circa 223 milioni di dollari ieri.</p>
<p>🔥 Il valore totale degli asset di garanzia BTC di USDe ha superato i 550 milioni di dollari.</p>
<p>🔥 Vitalik Buterin è apparso a Hong Kong per tenere un discorso sui Limiti del Design del Protocollo, Costruire su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> negli anni 2020.</p>
<p>🔥 Il problema del congestionamento che peggiora in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha causato ritardi nell’avvio di diversi progetti sulla rete.</p>
<p>Il valore di mercato di TON ha superato ADA ed è diventata la decima criptovaluta più grande per capitalizzazione di mercato.</p>
<p>🔥 Degen avvia il “Deploy on Degen Week”, offrendo oltre 10 milioni di premi in token DEGEN.</p>
<p>Il ricavo del protocollo Farcaster ha superato 1 milione di dollari.</p>
<p>🔥 Friend.tech ha avviato un nuovo processo di registrazione.</p>
<p>🔥 La proporzione dell’offerta di circolazione di BTC che non è stata trasferita per almeno un anno ha raggiunto il 65,84%, un nuovo minimo dal mese di ottobre 2022.</p>
<p>🔥 L’ETF BTC spot degli Stati Uniti ha registrato un deflusso netto di circa 18,6 milioni di dollari martedì.</p>
<p>🔥 <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> CEO: Il piano di mining di BTC da 500 milioni di dollari sta per essere completato e messo in funzione.</p>
<p>🔥Worldcoin: Le persone che si sono registrate con un World ID possono richiedere la rimozione delle scansioni dell’iride.</p>
<p>🔥Il fondatore di Jupiter parlerà alla conferenza Token 2049 e presenterà un “nuovo animale”.</p>
<p>🔥Pandora ha lanciato il protocollo di scambio ERC-404 Box.</p>
<p>🔥L’indicatore di finanziamento di friend.tech è aumentato prima che potenziali airdrop e versioni V2 fossero rilasciate.</p>
<p>🔥Sui ha annunciato la console portatile da gioco SuiPlay0x1, prevista per il lancio l’anno prossimo.</p>
<p>🔥 UNI 24-ore -16%, il fondatore Adams ha pubblicato che combatterà fino alla fine.</p>
<p>🔥L’ETF spot BTC degli Stati Uniti ha registrato un afflusso netto di 124 milioni di dollari mercoledì.</p>
<p>Questa settimana, il numero di miner che detengono BTC ha raggiunto il suo livello più basso dall’inizio del 2021.🔥</p>
<p>🔥Il lancio della moneta MSTAR IDO della piattaforma MerlinStarter avverrà venerdì.</p>
<p>🔥Il fondatore di Marginfi ha annunciato la sua partenza dal team.</p>
<p>🔥Il fondatore di SLERF ha annunciato il lancio del dominio .slerf Solana.</p>
<p>🔥L’artista Crypto XCOPY condivide le mosche consigliate.</p>
<p>🔥La pre-vendita di CONDOM ha raccolto quasi 5.000 SOL Rug.</p>
<h2 id="h2-Regolamentazione20e20politiche20macroeconomiche186114"><a name="Regolamentazione e politiche macroeconomiche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione e politiche macroeconomiche</h2><p>Il rilascio dei dati sull’IPC degli Stati Uniti più alto del previsto ha causato volatilità di mercato.</p>
<p>🔥Il mercato prevede che la Federal Reserve possa abbassare i tassi di interesse più avanti quest’anno e li abbasserà solo 1-2 volte.</p>
<p>🔥Uniswap ha ricevuto una notifica da parte dei Wells della SEC degli Stati Uniti.</p>
<p>🔥Il Paraguay sta rivalutando i divieti di mining e sta considerando la vendita di energia in eccesso ai minatori.</p>
<h2 id="h2-Evidenze20del20Mercato20delle20Criptovalute149796"><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 mercato complessivo delle criptovalute non ha iniziato a riprendersi ed è ancora in un ciclo di adeguamento leggermente volatile. Anche se la maggior parte delle criptovalute ha mostrato un trend al rialzo verso la fine del fine settimana, i cambiamenti non sono significativi. Attualmente, sembra che i prossimi eventi chiave nel calendario possano avere un impatto limitato sul mercato delle criptovalute, con un maggiore impatto sulle performance delle singole valute. Con l’avvicinarsi dell’halving di BTC, i flussi di ingresso e uscita degli ETF in tempi recenti hanno oscillato, ed è molto probabile che il mercato delle criptovalute reagirà in futuro. Tuttavia, nella fase iniziale, è ancora principalmente caratterizzato dalla volatilità.</p>
<p>⭐️Anche se la situazione complessiva del mercato non è stata buona questa settimana, alcune valute di punta hanno comunque registrato guadagni significativi. Le principali 100 valute, NEO, CKB, ENA e TON, hanno tutte registrato guadagni superiori al 40%. Questo è strettamente legato alle azioni ufficiali che ci sono dietro. L’effetto trainante complessivo del settore MEME surriscaldato è gradualmente diminuito. Tra queste, l’aumento settimanale di <a href="/price/neo-neo" target="_blank" class="blog_inner_link">NEO</a> è stato del 47,8%, e il prezzo attuale si mantiene intorno ai $21,94. Il punto più alto del prezzo settimanale si attesta intorno ai $23,5, mentre il punto più basso appare intorno ai $14,8 durante il periodo di apertura.<br><img src="https://gimg2.gateimg.com/image/article/17128901511.jpeg" alt=""><br>(Dati Cortesia di Coinmarketcap)</p>
<h2 id="h2-Performance20settimanale20di20BTC20e20ETH788400"><a name="Performance settimanale di BTC e ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Performance settimanale di BTC e ETH</h2><h3 id="h3-Bitcoin20BTC743111"><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/17128901882.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>La tendenza dei prezzi del BTC questa settimana è stata principalmente influenzata dall’ampio afflusso netto degli ETF spot e dalle aspettative di mercato dopo l’apertura, e c’è stata una fase di tendenza al rialzo, ma è rimasta sostanzialmente compresa tra $69.000 e $72.500. Dopo aver raggiunto un massimo settimanale, ha iniziato a oscillare al ribasso. Con la chiusura del weekend, è salito di nuovo e ha continuato a oscillare intorno ai $70.000. Il punto più alto del prezzo settimanale è $72.769, mentre il punto più basso è intorno ai $67.470.</p>
<p>L’analisi suggerisce che le prestazioni dei prezzi di BTC questa settimana sono in linea con il trend convenzionale, con poco impatto dal lato del trading e più probabilmente dovuto alla fluttuazione del trend convenzionale sotto l’influenza dei fattori di notizie. I flussi di ingresso e uscita dei fondi ETF hanno mostrato un trend fluttuante di grandi flussi netti in uscita e grandi flussi netti in entrata negli ultimi giorni e l’halving di BTC è imminente. Inoltre, a causa delle recenti prestazioni di mercato della traccia BTC L2, i prezzi di BTC avranno ancora una chiara forza di supporto nel breve termine, ma potrebbe essere difficile vedere un significativo trend al rialzo. Attualmente, il trend di fluttuazione della moneta è dettagliato e si prevede che raggiungerà nuovamente oltre i $71.000 durante la fase di chiusura del weekend, seguito da una leggera diminuzione. C’è una alta probabilità di significative fluttuazioni dei prezzi nella prossima settimana.</p>
<p><a href="/price/audius-audio" rel="nofollow noopener noreferrer" target="_blank">Audius</a><img src="https://gimg2.gateimg.com/image/article/17128902273.jpeg" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Il trend dei prezzi dell’ETH di questa settimana è simile a quello del BTC. Di recente, le prestazioni dei prezzi dell’ETH hanno oscillato ripetutamente nell’intervallo di $3.300-$3.600. Il trend di questa settimana è ancora più influenzato dal mercato e mostra un trend di fluttuazione regolare. Il punto più alto del prezzo entro una settimana è di circa $3.730, mentre il punto più basso è di circa $3.347 nella fase di apertura.</p>
<p>L’analisi suggerisce che il prezzo della moneta ETH manca di significativi momenti salienti questa settimana, e l’ecosistema Ethereum è stato anche in un punto relativamente caldo di recente. Ciò ha portato alla fluttuazione complessiva della moneta in un mercato più convenzionale, e le sue prestazioni di prezzo sono più influenzate dai cambiamenti di mercato portati da altre valute. Man mano che si avvicina la fase di chiusura del fine settimana, non c’è molta evidenza di un recupero per la moneta, e la probabilità di ulteriore apprezzamento nella prossima settimana è bassa, con una forte probabilità di rimbalzo sopra i $3,600 durante il periodo weekend.</p>
<h2 id="h2-Tendenza20del20progetto20Web3624493"><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 del mercato, il trend principale è stato in varie direzioni. Ad eccezione di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> MEME, che ha continuato a salire, le altre direzioni hanno avuto una performance negativa. Al momento, sembra che ci vorrà ancora del tempo prima della ripresa del mercato complessivo.<br><img src="https://gimg2.gateimg.com/image/article/1712912544img_v3_029s_19c215c1-ecb1-40a5-9458-c30531711aix.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. Il ripostaggio dell'articolo sarà consentito a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>