Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgcXVvdGEgZGkgbWVyY2F0byBkaSBMaWRvJ3MgU3Rha2VkIEVUSCBzY2VuZGUgc290dG8gaWwgMzAlLCBGYW50b20gaGEgbGFuY2lhdG8gbGEgc3RhYmxlY29pbiBVU0RDLmUgYW5jb3JhdGEgYWwgZG9sbGFybyBzdGF0dW5pdGVuc2UsIFJpcHBsZSBwaWFuaWZpY2EgZGkgZW1ldHRlcmUgc3RhYmx

2024-04-05, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/17122891321_6-05.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20Satoshi20Nakamoto20potrebbe20festeggiare20il20suo20492020compleanno20la20quota20di20mercato20Ethereum20staked20di20Lido2020scesa20al20di20sotto20del203020Fantom20ha20annunciato20il20lancio20della20stablecoin20USDCe20supportata20dal20dollaro20USA20oggi20mentre20Ripple20pianifica20di20emettere20stablecoin20ancorate20al20dollaro20USA780076"><a name="Riassunto giornaliero delle criptovalute: Satoshi Nakamoto potrebbe festeggiare il suo 49 ° compleanno, la quota di mercato Ethereum staked di Lido è scesa al di sotto del 30%, Fantom ha annunciato il lancio della stablecoin USDC.e supportata dal dollaro USA oggi, mentre Ripple pianifica di emettere stablecoin ancorate al dollaro USA." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: Satoshi Nakamoto potrebbe festeggiare il suo 49 ° compleanno, la quota di mercato <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> staked di Lido è scesa al di sotto del 30%, <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> ha annunciato il lancio della stablecoin USDC.e supportata dal dollaro USA oggi, mentre Ripple pianifica di emettere stablecoin ancorate al dollaro USA.</h2><p>Secondo la data di nascita che Satoshi Nakamoto ha inserito quando si è registrato su p2pfoundation, è nato il 5 aprile 1975. Oggi, il 5 aprile 2024, compie 49 anni.</p>
<p>Secondo i dati di DeFiLlama, il TVL di Ethena ha superato i 2 miliardi di dollari ed è attualmente a 2,005 miliardi di dollari, raggiungendo un nuovo massimo con un tasso di crescita del 43,33% in 7 giorni.</p>
<p><a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> ha annunciato che la sua stablecoin ufficiale riconosciuta USDC.e sarà lanciata oggi, supportata da Circle e Wormhole. La USDC.e su Wormhole è collegata alla USDC nativa e si trova in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il contratto intelligente di . È possibile passare alla USDC nativa in futuro. Diventerà la stablecoin ufficiale e riconosciuta per l’ecosistema Fantom (e tutti gli aggiornamenti futuri della rete).</p>
<p>SingularityNET ha dichiarato sulla piattaforma X che la proposta di voto sulla fusione di SingularityNET, <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, e i token di Ocean Protocol sono ora aperti ai detentori di token AGIX su <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> e Ethereum. La scadenza è alle 20:00 del 16 aprile (UTC+8).</p>
<p>I dati di Dune mostrano che l’importo totale di ETH depositato sulla catena di beacon Ethereum è di 32.073.148, pari al 26,76% dell’offerta totale di ETH. Tra questi, la quota di deposito del protocollo di staking di liquidità di Lido è scesa al di sotto del 30%, raggiungendo il 29,7%.</p>
<p>Secondo CoinDesk, Ripple emetterà stablecoin garantite dal dollaro statunitense, portando maggiore praticità e liquidità a <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Libro mastro.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20aumenta20leggermente20con20grande20popolarit20delle20nuove20monete346086"><a name="Tendenze di mercato: BTC aumenta leggermente, con grande popolarità delle nuove monete" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC aumenta leggermente, con grande popolarità delle nuove monete</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il (BTC) è salito da circa $65.000 a $69.000 ieri, aumentando il valore di mercato e una crescita collettiva nel settore delle Altcoin. Secondo i dati dal mercato delle opzioni, anche se il mercato ha subito una correzione massima di quasi il 10% questa settimana, le aspettative di volatilità di mercato stanno ancora diminuendo rapidamente. Con la prima settimana di consegna dopo la grande consegna trimestrale di oggi, il Dvol di BTC è sceso al di sotto del 70%, e la pressione verso il basso dell’IV menzionata il mese scorso continua a essere rilasciata. Recentemente, le prestazioni del mercato delle negoziazioni all’ingrosso sono state deboli, e gli investitori scelgono principalmente di acquistare opzioni di chiamata dimezzate come strategia di investimento.</p>
<h3 id="h3-Punti20Caldi20del20Mercato745970"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Settore dei concetti di Hong Kong: il 2024 Hong Kong <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Carnival si terrà dal 6 al 9 aprile presso il 3FG del Centro Convegni ed Esposizioni di Hong Kong. Alcuni progetti del settore dei concetti di Hong Kong, come Alchemy Pay (ACH), Conflux (CFX), Nervos Network (CKB), <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">The Sandbox</a> Le criptovalute come il <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> (SAND) e la rete MASK (MASK) hanno recentemente registrato guadagni significativi.</p>
<p>Settore dei MEME: Le monete MEME sono il settore più popolare recentemente, specialmente <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> a marzo e Base Chain in aprile. Le monete meme sono diventate una fonte calda per questi ecosistemi di catene pubbliche per espandersi. In futuro, il singolo GROK di Elon Musk potrebbe continuare a guidare la follia delle MEME.</p>
<p>ENA: Ethena (ENA) ha recentemente guadagnato popolarità di mercato grazie ai suoi solidi guadagni con stablecoin. Attualmente, il suo TVL ha superato i 2 miliardi di dollari, con un tasso di crescita del 7 giorni del 43,33%, rendendolo uno dei progetti più popolari insieme a PENDLE nella stessa corsa. Ethena ha creato un nuovo tipo di obbligazioni native cripto combinando i rendimenti da Ethereum impiegato con fondi e base dai mercati perpetui e futures. Inoltre, gli utenti possono acquistare o vendere USDe tramite pool AMM esterni utilizzando collaterali stablecoin (come USDT o USDC), un dollaro USA sintetico sotto il protocollo Ethena. Gli utenti possono anche impiegare e disimpegnare USDe per ottenere una quota corrispondente di profitti.</p>
<p>W: Wormhole (W): Wormhole è stato inizialmente incubato e supportato da Jump Crypto, con l’obiettivo di consentire agli sviluppatori di creare applicazioni native cross-chain che coprono più blockchain. Ora si è evoluto da un ponte bidirezionale cross-chain focalizzato su Ethereum e <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> a un protocollo di messaggistica universale che supporta più blockchain, diventando un progetto leader nel settore cross-chain. Di recente, dopo il lancio del token W, è salito a $1.79, con un calo del 17.66% nelle ultime 24 ore.</p>
<p>Nel complesso, gli hotspot di mercato recenti si sono concentrati su token appena lanciati e sul settore MEME con ritorni rapidi. Ciò presenta uno sfondo monotono dell’attuale alta volatilità di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e il consenso speculativo di mercato non si è ancora formato in un consenso altamente unificato. Il ritmo di rotazione dei settori e dei token popolari è veloce.</p>
<h2 id="h2-Macro20Gli20ufficiali20della20Fed20hanno20suggerito20che20non20c20fretta20di20abbassare20i20tassi20di20interesse20nel20prossimo20futuro20e20i20tre20principali20indici20azionari20statunitensi20hanno20chiuso20al20ribasso574871"><a name="Macro: Gli ufficiali della Fed hanno suggerito che non c’è fretta di abbassare i tassi di interesse nel prossimo futuro e i tre principali indici azionari statunitensi hanno chiuso al ribasso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gli ufficiali della Fed hanno suggerito che non c’è fretta di abbassare i tassi di interesse nel prossimo futuro e i tre principali indici azionari statunitensi hanno chiuso al ribasso</h2><p>GUDI, diversi funzionari della Federal Reserve hanno affermato giovedì che l’inflazione rimane alta, non c’è fretta di tagliare i tassi di interesse e si riconosce la resilienza del mercato del lavoro.</p>
<p>Gli intensi discorsi degli ufficiali della Federal Reserve sono seguiti a quello di ieri del presidente della Federal Reserve, Powell. Powell ha sottolineato mercoledì che la Federal Reserve ha tempo per valutare i prossimi dati prima di abbassare i tassi di interesse, indicando che i decisori politici sono disposti ad aspettare segnali più evidenti di declino dell’inflazione prima di agire.</p>
<p>Il presidente della Federal Reserve di Minneapolis, Cashkali, ha dichiarato inaspettatamente che l’inflazione è aumentata quest’anno e potrebbe non esserci un taglio dei tassi, sconvolgendo il mercato. In corrispondenza delle performance del mercato azionario statunitense, l’indice S&amp;P 500 ha aperto in rialzo nella giornata. Ha continuato a oscillare in modo limitato sopra i 5.240 punti prima che iniziasse il discorso di Kashkari, raggiungendo un massimo di 5.256,59 punti. Dopo il discorso falco di Kashkari, il mercato azionario statunitense ha preso una brusca svolta ed è sceso a un minimo giornaliero di circa 5.146,06 punti entro 20 minuti dalla chiusura.</p>
<p>Ma ci sono anche presidenti della Fed di Chicago che sono più accomodanti perché sono preoccupati per possibili problemi nel mercato del lavoro.</p>
<p>Tuttavia, alla fine, tutti e 11 i settori dell’indice S&amp;P 500 hanno subito un crollo completo alla vigilia della pubblicazione della busta paga non agricola, con AMD che ha chiuso in ribasso di oltre l’8,2% e AMD che è scesa di circa il 5,7%, portando al calo del settore tecnologico.</p>
<p>In contrasto con la debolezza del trend del mercato azionario statunitense, le dimensioni dei fondi del mercato monetario stanno aumentando costantemente.</p>
<p>A seguito dell’ultima dichiarazione della Federal Reserve che indica che i funzionari non hanno fretta di avviare un processo di taglio dei tassi, gli investitori si aspettano in generale che i tassi di interesse a breve termine rimangano alti, aumentando così le dimensioni dell’attivo dei fondi del mercato monetario statunitense a massimi storici. Secondo gli ultimi dati pubblicati dall’Investment Company Association, nella settimana fino al 3 aprile, i fondi del mercato monetario statunitense hanno attratto circa $70,5 miliardi di afflussi, il maggior aumento settimanale in quasi tre mesi. Allo stesso tempo, le dimensioni totali dell’attivo del fondo sono passate da $6,04 trilioni nella settimana precedente a $6,11 trilioni. Dal lancio della sua politica di restrizione più aggressiva in decenni nel 2022, la Federal Reserve ha scelto di investire i propri fondi nei fondi del mercato monetario.</p>
<p>Inoltre, stasera gli Stati Uniti pubblicheranno i dati sul tasso di disoccupazione di marzo. I dati economici positivi degli Stati Uniti hanno significativamente ridotto la probabilità che la Federal Reserve tagli i tassi di interesse a maggio. La probabilità di un taglio dei tassi a maggio è scesa dal 90% dello scorso mese al 50% attuale, indicando un cambiamento nelle aspettative di mercato per la futura politica monetaria della Fed.</p>
<p>In generale, il mercato delle criptovalute ha mostrato di recente una tendenza alta e forte. Tuttavia, a causa della diminuzione della volatilità di mercato e dei cambiamenti nelle aspettative di tagli dei tassi di interesse, ci sono ancora alcune incertezze sulle future tendenze del mercato delle criptovalute. Gli investitori non dovrebbero solo prestare attenzione al denaro contante <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> degli ETF spot ma mantengono anche la loro attenzione al cambiamento di politica della Federal Reserve.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</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 il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p></div></div></div></div>