UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgaGEgc3BlcmltZW50YXRvIGZsdXR0dWF6aW9uaSBlIG1vdmltZW50aSBhbCByaWFsem87IGwnRVRGIFNwb3QgQlRDIGludGVycm9tcGUgaWwgdHJlbmQgZGkgZGVmbHVzc28gbmV0dG8gcGVyIDUgZ2lvcm5pIGNvbnNlY3V0aXZpOyB

2024-03-29, 01:56

<p><img src="https://gimg2.gateimg.com/image/article/1711677358zb.jpeg" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze839729"><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 si è ripreso questa settimana, ma il processo è ancora accompagnato da certe fluttuazioni. Tuttavia, l’ampiezza complessiva non è significativa ed è risalita nuovamente nel periodo di chiusura vicino al weekend. Tuttavia, la crescita complessiva del valore di mercato non è particolarmente grande rispetto allo stesso periodo della settimana scorsa, mantenendosi intorno a 2,65 trilioni di dollari, un aumento del 1,66% in 24 ore. Il sentiment del mercato continua a rimanere sopra gli 80 punti e rimane ottimista. La maggior parte delle principali criptovalute ha mostrato un trend positivo questa settimana, ma ad eccezione di alcune criptovalute di settore, la maggior parte delle criptovalute ha mantenuto il suo trend positivo all’interno di aree relativamente piccole, generalmente al di sotto del 10%. Nel complesso, a causa del calo di mercato della settimana scorsa, il mercato delle criptovalute è ancora in un periodo di adeguamento questa settimana e ci si aspetta di vedere un significativo rimbalzo complessivo nel corso del fine settimana.</p>
<p>Rispetto alla settimana scorsa, il mercato delle criptovalute ha mostrato questa settimana un trend di ripresa, ma è stato accompagnato da un pullback volatile. Tuttavia, l’aumento delle valute principali specifiche è più pronunciato, come il chiaro aumento del 44% nella settimana per DOGE. Al momento, mentre si avvicina la fase di chiusura del fine settimana e l’avvicinarsi dell’halving di BTC, il sentimento rialzista generale nel mercato rimane predominante. Si prevede che ci sarà un trend al rialzo nel fine settimana, e ci sarà un leggero pullback dopo aver continuato ad aumentare fino alla prossima settimana.</p>
<p>I primi 100 progetti crittografici hanno un rapporto di salita e discesa di circa 80:20 entro una settimana, e la maggior parte delle valute principali hanno mostrato un trend al rialzo nel mercato di questa settimana, che è strettamente legato al rimbalzo complessivo del mercato. Il prezzo del BTC è risalito sopra i $70.000 entro una settimana, con una variazione settimanale di circa il 7,75%. Attualmente, rimane in fluttuazione a $70.797. Il mercato dell’ETH è simile questa settimana, ma con una maggiore volatilità. Il punto più basso settimanale del prezzo è sceso sotto i $3.300, con un aumento complessivo di circa il 2,27%. Attualmente si attesta intorno ai $3.553 e continua a fluttuare.</p>
<p>La performance di mercato questa settimana è stata ancora relativamente alta nel segmento MEME, con un aumento del 46,01% in 7 giorni in WIF. Il prezzo della moneta è attualmente mantenuto intorno a $3,36, posizionandosi al primo posto in una settimana di guadagni.</p>
<p>Anche se il mercato cripto nel complesso è in qualche misura rimbalzato questa settimana, la distribuzione del trend al rialzo è disomogenea e non complessiva. Alcune valute sono ancora chiaramente in un trend al ribasso, ed è molto probabile che il mercato avrà bisogno di un trend al rialzo supplementare durante il fine settimana per guidare il trend complessivo.</p>
<h2 id="h2-Mercato20delle20criptovalute747983"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥 Questa settimana, il mercato delle criptovalute ha subito fluttuazioni di prezzo, con un leggero ritracciamento a metà settimana dopo un rimbalzo.</p>
<p>🔥 Diversi settori hanno registrato un trend positivo lunedì, con BTC +4,0% e ETH +3,6% nelle ultime 24 ore; prezzo di PENDLE, prezzo di ONDO, prezzo di AERO, prezzo di DEGEN e nuovi massimi storici settimanali degli utenti di Base; MEME dell’ecosistema di Base e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Gli ecosistemi MEME sono generalmente in crescita.</p>
<p>🔥 Questa settimana, saranno sbloccati token come $84.32 milioni di OP, $37.53 milioni di PRIME, $16.89 milioni di YGG, $9.26 milioni di AGIX, $6.68 milioni di SUI e $900000 di ACA.</p>
<p>🔥 Negentropy promette di donare $1 milione a Slerf per supportare i suoi NFT.</p>
<p>🔥 PUMP è aperto per il trading stasera, con un valore di mercato di $12,9 milioni basato sulla liquidità iniziale.</p>
<p>🔥 MEME ha spinto il TVL di Base a superare i 2 miliardi di dollari, con un volume di trading giornaliero del DEX sulla catena Base che supera i 200 milioni di dollari per diversi giorni consecutivi in una settimana.</p>
<p>Il responsabile del protocollo Base ha dichiarato che sarà rilasciato lo strumento di migrazione ERC20 BaseMigrate.</p>
<p>🔥 Scroll Co Creation ha annunciato che lancerà 4844, DA Compression, Proof Aggregation e altro entro pochi mesi.</p>
<p>🔥 Il valore totale bloccato in PENDLE ha superato 1 miliardo di dollari questa settimana.</p>
<p>🔥 Gli esecutivi di Circle interpretano le normative europee antiriciclaggio: l’impatto sui portafogli autogestiti e su CASP è molto limitato.</p>
<p>🔥 UniCross ha annunciato la sospensione di RUFI Mint a causa della congestione della rete Merlin.</p>
<p>🔥 Un certo indirizzo ha donato 1558,8 SOL a SLERF come compensazione per il trasferimento del portafoglio.</p>
<p>🔥 La Borsa di Londra accetterà le domande di BTC e ETH ETN a partire dall’8 aprile e prevede di iniziare il trading degli ETN il 28 maggio.</p>
<p>🔥 <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> intende parallelizzare FVM e ampliare il finanziamento per Sonic Labs e l’investimento sarà reso noto nelle prossime settimane.</p>
<p>🔥 L’ecosistema di Curio è stato attaccato, con una perdita di 16 milioni di dollari.</p>
<p>🔥 Vitalik ha menzionato ENS nel suo post.</p>
<p>🔥 Musk ha chiesto a Vitalik perché ha lasciato la piattaforma X.</p>
<p>FTX venderà due terzi delle sue azioni in Aerospace per 884 milioni di dollari.</p>
<p>🔥 BRC20 supporterà presto 5 caratteri e implementerà MINT.</p>
<p>🔥 Gli Munchables dell’Ecosistema Blast sono stati attaccati, causando una perdita di $62.3 milioni, ma sono stati completamente recuperati.</p>
<p>🔥 Durante la settimana, c’è stata una leggera correzione del mercato, con BTC -1,6% ed ETH -2,9%; il prezzo di SUI, il prezzo di ALT, il prezzo di ETHFI, il prezzo di NAVX, il prezzo di WEN, il TVL di base, il prezzo delle azioni di MicroStrategy e il valore di mercato del portafoglio BTC di BlackRock IBIT hanno raggiunto livelli storici; il settore RWA è generalmente aumentato.</p>
<p>🔥 Questa settimana, circa 20 progetti hanno annunciato il completamento di oltre $230 milioni di finanziamenti.</p>
<p>🔥 Nel giro di una settimana, l’ETF BTC spot ha interrotto la tendenza di deflusso netto per cinque giorni consecutivi.</p>
<p>🔥 Casey ha affermato che se il valore di mercato dell’ecosistema Runes non raggiunge 1 miliardo di dollari nel primo mese del suo lancio, è pronta a commettere seppuku.</p>
<p>🔥 Vitalik Buterin esprime il suo sostegno per il pegno decentralizzato attraverso incentivi anti-correlati; L’astrazione dell’account fornisce sicurezza e convenienza per sviluppatori e utenti; Le informazioni di Farcaster non vengono memorizzate nella blockchain e possono migliorare la sicurezza e la scalabilità; La definizione del metaverso è ancora vaga e richiede una combinazione di criptovalute, realtà virtuale e intelligenza artificiale.</p>
<p>🔥 L’organizzazione non-profit FLI ha reso noto di aver ricevuto una donazione di 665 milioni di SHIB da Vitalik Buterin.</p>
<p>🔥 Direttore legale capo di Grayscale: la SEC non ha condotto discussioni approfondite sugli ETF spot ETH a causa del consenso raggiunto sulle questioni correlate agli ETF BTC.</p>
<p>🔥 GameFi Illuvium rilascia una nuova roadmap e dettagli per il Private Beta 4.</p>
<p>🔥 Avvicinandosi alla fase di chiusura del weekend, BTC+1,4% nelle ultime 24 ore, ETH+0,8%; prezzo ETHFI, TVL di rinnovo della liquidità ETH re pledge, TVL di base, TVL di esplosione, TVL di Sui, contratti di interesse aperti per opzioni BTC di Deribit in scadenza a marzo, flusso netto giornaliero di ARKB che raggiunge un massimo storico; flusso netto giornaliero di Fuda FBTC che raggiunge un nuovo minimo.</p>
<p>🔥 Questa settimana, un totale di 9 progetti hanno annunciato finanziamenti superiori a $100 milioni.</p>
<p>🔥 Il fondo ETF BTC spot degli Stati Uniti ha registrato un afflusso netto di 254 milioni di dollari ieri.</p>
<p>🔥 Il fondatore Casey di Ordinals ha annunciato il documento Runes, introducendo un meccanismo di aggiornamento del monumento.</p>
<p>🔥 MerlinSwap ha iniziato a distribuire i token esMP; L’IDO del token MP è terminato, con un importo di sottoscrizione superiore a $480 milioni.</p>
<p>🔥 Il mainnet di BEVM è stato lanciato questa settimana.</p>
<p>🔥 <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> La fuoriuscita di capitale della catena EVM di ’s è aumentata a 1,78 miliardi di dollari.</p>
<p>🔥 Arbitrum e Azuki si sono uniti per lanciare la rete di anime AnimeChain.</p>
<p>🔥 Ethena effettuerà un airdrop di 750 milioni di ENA e lancerà CEX il 2 aprile.</p>
<p>🔥 Ondo Finance ha introdotto servizi di investimento e riscatto in tempo reale, con 95 milioni di dollari investiti da OUSG Fund in BUIDL di BlackRock.</p>
<p>🔥 Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il blob viene utilizzato per creare iscrizioni e ieri sono state create 2.437 iscrizioni di blob; L’iscrizione guida il blob a raggiungere il limite di capacità di utilizzo impostato.</p>
<p>Il progetto Meme di Huang Licheng, Bobaopa, ha raccolto 38 milioni di dollari in SOL attraverso la promozione.</p>
<p>🔥 LADYS lancia Meme Phone.</p>
<p>🔥 <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, SingularityNET e Ocean Protocol uniscono i token per formare un’alleanza decentralizzata di intelligenza artificiale.</p>
<h2 id="h2-Politiche20normative911279"><a name="Politiche normative" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche normative</h2><p>🔥 La dichiarazione di Bostic della Federal Reserve suggerisce che i tagli prematuri dei tassi potrebbero essere più distruttivi, con un solo taglio dei tassi previsto quest’anno.</p>
<p>🔥 La SEC degli Stati Uniti sta cercando di ottenere 2 miliardi di dollari in multe e sanzioni nel <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> caso.</p>
<h2 id="h2-Evidenze20del20mercato20delle20criptovalute814288"><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 settimana scorsa, il trend complessivo del mercato delle criptovalute è stato principalmente guidato dalla popolarità dei settori individuali e il trend complessivo delle valute correlate è ancora in un ciclo di correzione. La maggior parte delle criptovalute è entrata in un intervallo al ribasso mentre si avvicinava alla chiusura del fine settimana, ma attualmente l’entità non è significativa e la maggior parte delle valute non ne è stata influenzata. La ripresa dei prezzi di BTC questa settimana indica anche che il mercato ha iniziato a mostrare segnali chiari di rialzo nella settimana scorsa e possiamo aspettarci una performance di mercato durante il periodo del fine settimana.</p>
<p>⭐️Diversi settori del mercato hanno avuto una buona performance questa settimana, ed è previsto che il settore MEME si riprenderà. Tra questi, WIF si è distinto maggiormente, con un aumento settimanale simile a DOGE. Attualmente, l’aumento settimanale della criptovaluta è di circa il 46%, e il suo prezzo rimane entro il range di $3.3. Il settore MEME ha vissuto un forte rimbalzo questa settimana dopo essere stato influenzato dal surriscaldamento del mercato la settimana scorsa, ed è prevedibile che continuerà a mantenere un certo periodo di trend positivo in futuro.<br><img src="https://gimg2.gateimg.com/image/article/17116774701.jpeg" alt=""><br>(Dati Cortesia Di Coinmarketcap)</p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali669463"><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-Bitcoin20BTC95813"><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/17116774932.jpeg" alt=""><br>(Dati forniti da TradingView)</p>
<p>Il trend dei prezzi di BTC questa settimana è caratterizzato da continua volatilità dopo l’apertura, tranne per un breve ritracciamento sperimentato a metà settimana. Per la maggior parte del tempo, è rimasto nell’intervallo di 70.000-710.000 dollari ed è stato in continua oscillazione. L’aumento settimanale del prezzo della moneta è il più grande tra diverse valute mainstream leader e attualmente c’è un ulteriore trend al rialzo. Si prevede che supererà nuovamente il livello di prezzo di 71.000 dollari nel prossimo futuro.</p>
<p>L’analisi mostra che le prestazioni dei prezzi di BTC di questa settimana rappresentano sostanzialmente la tendenza generale del mercato, che è il ciclo di ripresa e aggiustamento. Anche se i principali aumenti di prezzo sono concentrati in altri settori popolari, l’atterraggio dell’applicazione L2 legata all’ecosistema di BTC di questa settimana, unita all’avvicinarsi del tempo di dimezzamento, ha intensificato il sentiment di mercato. Pertanto, le sue prestazioni di prezzo hanno iniziato a mostrare un significativo rimbalzo e hanno iniziato a mostrare una certa tendenza all’accelerazione. La fase di chiusura del fine settimana potrebbe portare ulteriori ricariche di mercato.</p>
<h3 id="h3-Ether20ETH929196"><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/17116775603.jpeg" alt=""><br>(Dati forniti da TradingView)</p>
<p>Il trend dei prezzi dell’ETH di questa settimana continua ad avere una forte correlazione con il BTC, sperimentando un trend al rialzo sostenuto dopo l’apertura, raggiungendo circa $3.680. Tuttavia, la crescita complessiva è ancora debole, con un significativo declino seguito da un lieve rimbalzo verso la fine del periodo di chiusura del fine settimana. Al momento, la moneta rimane all’interno dell’intervallo di $3.500- $3.600 con lievi fluttuazioni e nessun significativo trend al rialzo o al ribasso osservato.</p>
<p>L’analisi suggerisce che le prestazioni dei prezzi delle monete ETH questa settimana siano fondamentalmente coerenti con le fluttuazioni cicliche del mercato. Sebbene il trend generale sia ancora in aumento, è stato oggetto di controversie normative da parte del mercato, in particolare dalla SEC, il che ha portato alla mancanza di segnali chiari di ripresa per la moneta. Ma è molto probabile che ci sia un certo aumento nel periodo di chiusura del weekend mentre il mercato generale si riprende, ma potrebbe essere difficile superare il prezzo chiave di $3800 nel breve termine.</p>
<h3 id="h3-Tendenza20del20progetto20Web3590863"><a name="Tendenza del progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza del progetto Web3</h3><p>Questa settimana, il valore di mercato totale della maggior parte delle nove categorie di progetti ha mostrato una tendenza di ripresa. A causa della fluttuazione e dell’adattamento del ciclo di mercato, le varie tracce sono principalmente in una tendenza al rialzo. Ad eccezione della scarsa performance di BRC-20, gli altri tipi di progetti sono nuovamente aumentati, soprattutto l’impressionante performance delle tracce legate a MEME. Sembra che ci sarà un altro ciclo al rialzo fino alla fase di chiusura del weekend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1711706418img_v3_029e_1e189bae-cc09-4ea7-bc18-1d634f717bix.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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato 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>