Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGVkIEVUSCBjb250aW51YW5vIGEgZGltaW51aXJlOyBsJ2FnZ2lvcm5hbWVudG8gZGkgRGVuY3VuIHBvdHJlYmJlIGNhdXNhcmUgdW4ndWx0ZXJpb3JlIGluZmxhemlvbmUgZGkgRXRoZXJldW07IFNvcGhvbiBoYSByYWNjb2x0byA2MCBtaWxpb25pIGRpIGRvbGxhcmkgYXR0cmF2ZXJzbyBsZSA

2024-05-09, 03:56

<p><img src="https://gimg2.gateimg.com/image/article/17152269481_5.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Laggiornamento20di20Dencun20potrebbe20portare20di20nuovo20allinflazione20di20Ethereum20Sophon20ha20raccolto206020milioni20tramite20vendite20di20nodi20Lyra20Finance20ha20lanciato20il20nuovo20token20LDX20airdrop195384"><a name="Riepilogo giornaliero delle criptovalute: L’aggiornamento di Dencun potrebbe portare di nuovo all’inflazione di Ethereum; Sophon ha raccolto $60 milioni tramite “vendite di nodi”; Lyra Finance ha lanciato il nuovo token LDX airdrop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: L’aggiornamento di Dencun potrebbe portare di nuovo all’inflazione di Ethereum; Sophon ha raccolto $60 milioni tramite “vendite di nodi”; Lyra Finance ha lanciato il nuovo token LDX airdrop</h2><p>Un rapporto della società di dati CryptoQuant suggerisce che l’aggiornamento a Dencun potrebbe portare a un’altra inflazione in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, poiché i costi delle transazioni di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sono diminuiti e la sua combustione è scesa ad uno dei livelli più bassi da quando è avvenuta la fusione. Questa riduzione della combustione ha portato ad una crescita senza precedenti nell’offerta di Ethereum, che è la prima volta dalla fusione della rete Ethereum.</p>
<p>Gli analisti sottolineano che prima dell’aggiornamento di Dencun, livelli di attività più elevati sulla rete Ethereum significavano costi di transazione più alti, con conseguente minor offerta di Ethereum. Tuttavia, con l’implementazione dell’aggiornamento di Dencun, il rapporto tra i costi di combustione e le attività di rete è stato scollegato.</p>
<p>In generale, la conclusione tratta dal rapporto è che Ethereum è “improbabile che subisca nuovamente deflazione” perché al livello attuale di attività online, l’inflazione di Ethereum potrebbe continuare e la svalutazione di ETH è inevitabile. Ciò significa che ETH potrebbe non possedere più le caratteristiche di una “valuta supersonica”, o che ripristinare questa caratteristica potrebbe richiedere un livello più elevato di attività online.</p>
<p>Secondo il rapporto del blocco, il “hyperchain” Sophon di zkSync ha raccolto con successo circa 60 milioni di dollari attraverso la vendita dei nodi.</p>
<p>“Hyperchain” Sophon, è una rete di livello 2 costruita sul framework open source modulare ZK Stack di Matter Labs. Le vendite hanno fornito opportunità di acquisto per 200.000 nodi e hanno adottato un modello di prezzo a livelli; Mercoledì, l’azienda ha dichiarato che gli investitori hanno acquistato 121.000 nodi, portando a Sophon circa $ 60 milioni di wETH.</p>
<p>Sebastien, co-fondatore di Sophon e ex responsabile DeFi presso zkSync, ha dichiarato che Sophon ha raccolto 20800 wETH. Sebstien ha affermato che le vendite dei nodi danno potere alle comunità poiché possono essenzialmente acquisire token di progetto a prezzi scontati nelle prime fasi e ricevere distribuzioni di token.</p>
<p>Sophon pianifica di lanciare la sua rete nei prossimi mesi. In quel momento, si dice anche che ci sarà un ordinatore centralizzato in cui i detentori dei nodi possono delegare le loro licenze a Sophon e ricevere la loro quota delle commissioni di rete. Il progetto afferma: “Questi detentori potranno anche partecipare alle operazioni di Sophon, come ad esempio l’esecuzione di nodi leggeri attraverso le catene di indice o l’utilizzo di livelli di disponibilità dei dati selezionati da Sophon.”</p>
<p>Sophon ha deciso che il 20% del suo totale di token (SOPH) sarà distribuito ai detentori di licenze di nodo nei primi 36 mesi dopo il lancio della mainnet di Sophon.</p>
<p>Lo strumento DeFi Lyra Finance ha annunciato un piano di trasformazione dei token, lanciando il token LDX come valuta nativa della rete di derivati di Lyra, con l’intenzione di lanciarlo nel terzo trimestre di quest’anno. I token Lyra esistenti saranno migrati ai nuovi token. E pianificano di condurre airdrop di LDX per premiare i trader e i profit farmers, incoraggiandoli ad aumentare la liquidità e il tasso di adozione dei prodotti Lyra. L’airdrop adotterà un sistema integrale, con LDX allocati proporzionalmente ogni quattro settimane.</p>
<p>Lyra ha anche lanciato un prodotto che tokenizza derivati redditizi, concentrandosi inizialmente sul trading di base e successivamente ha lanciato una strategia di opzioni di chiamata coperte per i token di reinvestimento della liquidità su EigenLayer. Ciò consentirà agli utenti di depositare LRT emessi da protocolli come EtherFi (eETH) e Swell (rswETH) per guadagnare profitti. Questo protocollo tokenizzerà le politiche su LRT e le confezionerà sotto forma di token ERC-20.</p>
<p>Lyra Finance è stato inizialmente presentato come un protocollo di trading di opzioni on-chain, utilizzando vault di market maker e un pool di asset specifico finanziato dai fornitori di liquidità utilizzando stablecoin in cambio di una parte delle commissioni di trading.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20continua20a20diminuire20IO20sta20per20effettuare20distribuzioni20gratuite20di20token205178"><a name="Tendenze di mercato: BTC continua a diminuire, IO sta per effettuare distribuzioni gratuite di token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC continua a diminuire, IO sta per effettuare distribuzioni gratuite di token</h2><p>Nelle ultime 24 ore, il prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) ha subito significative fluttuazioni, scendendo al di sotto dei 61.000 dollari in un momento e ora si è ripreso leggermente intorno ai 61.500 dollari. Anche l’Ethereum (ETH) è sceso al di sotto dei 3.000 dollari, e l’intero mercato delle Altcoin ha subito un colpo. Inoltre, il mercato ha osservato un continuo deflusso di ETF spot, a indicare l’atteggiamento cauto degli investitori. Dal punto di vista macroeconomico, le performance delle azioni statunitensi sono state volatili, e il mercato è in attesa dei dati sull’indice dei prezzi al consumo (CPI) della prossima settimana come importante indicatore per valutare le future direzioni economiche e di politica.</p>
<h3 id="h3-Punti20Caldi20del20Mercato403006"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>Il protocollo Oracle: Teller (TRB) ha registrato un aumento del prezzo triplicato in pochi giorni e poi ha subito una diminuzione. Questa volatilità dei prezzi dimostra tipicamente il comportamento delle valute forti in mercati volatili, dove salgono rapidamente e poi cadono con la stessa intensità. Inoltre, la fluttuazione di TRB ha anche spinto la crescita di altri token di protocollo Oracle come UMA e API3. API3 ha recentemente annunciato una partnership con Xlayer’s Layer2, che potrebbe essere un fattore che spinge l’aumento del prezzo.</p>
<p>Lo sviluppo del concetto di DePIN: Io.net, il progetto principale del concetto DePin, ha annunciato il lancio di IO tokens, con un prezzo futuro di $3.66 su DEX, corrispondente a un valore di mercato di quasi $2 miliardi. Si prevede che i token IO saranno distribuiti a metà maggio, il che potrebbe stimolare l’interesse di mercato per IO. Tuttavia, nonostante l’enorme hype che circonda i concetti correlati a DePIN, i token concettuali in questo settore non sono ancora esplosi collettivamente. Altri token sulla stessa traccia, come RNDR e AKT, hanno valori di mercato rispettivamente di $5 miliardi e $1 miliardo, dimostrando il profondo potenziale di questo settore.</p>
<p>Il trend principale del mercato in questa fase ruota ancora attorno ai token AI e Meme. Con il prossimo rilascio dei dati importanti dell’IPC la prossima settimana, il mercato potrebbe affrontare una maggiore volatilità. Gli investitori dovrebbero rimanere vigili e prestare attenzione allo sviluppo degli indicatori macroeconomici e dei progetti cripto correlati al fine di regolare tempestivamente le proprie strategie in risposta a possibili cambiamenti di mercato.</p>
<h2 id="h2-Macro20Il20mercato20statunitense2020in20fluttuazione20quello20asiatico2020stabile20e20i20prezzi20delloro20e20del20petrolio20greggio20stanno20aumentando537020"><a name="Macro: Il mercato statunitense è in fluttuazione, quello asiatico è stabile e i prezzi dell’oro e del petrolio greggio stanno aumentando" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato statunitense è in fluttuazione, quello asiatico è stabile e i prezzi dell’oro e del petrolio greggio stanno aumentando</h2><p>Giovedì, mentre gli investitori continuavano a scommettere sul supporto della politica monetaria statunitense, il Dow Jones Industrial Average ha chiuso in rialzo mercoledì, salendo per sei giorni consecutivi e chiudendo sopra i 39000 punti per la prima volta in cinque settimane. Tuttavia, a causa della stagnazione del momentum nel giorno dell’asta dei titoli di stato decennali e dell’aumento del rendimento dei titoli di stato statunitensi, gli altri indici di riferimento di Wall Street si sono leggermente raffreddati. L’indice S&amp;P 500 ha chiuso invariato dopo quattro giorni consecutivi di rialzo, mentre l’indice Nasdaq Composite è sceso per il secondo giorno consecutivo.</p>
<p>Per quanto riguarda la salita e la caduta dei tre principali indici, l’indice S&amp;P 500 è rimasto invariato, il Nasdaq è sceso dello 0,18% e l’indice Dow Jones è salito dello 0,44%.</p>
<p>I responsabili delle politiche della Federal Reserve che hanno parlato mercoledì sono coerenti con le informazioni recenti, compresa l’ultima riunione della Federal Reserve della scorsa settimana. La rappresentante di Boston, Susan Collins, ha affermato che l’attuale impostazione della politica monetaria rallenterà l’economia, cosa che ritiene necessaria per il obiettivo della Federal Reserve di “riportare l’inflazione al 2%”.</p>
<p>Secondo lo strumento Fedwatch di CMEGroup, i trader prevedono una probabilità del 67% che la Federal Reserve riduca i tassi di interesse di almeno 25 punti base a settembre, in aumento dal 54% della scorsa settimana.</p>
<p>Le politiche e le performance di mercato in Asia ed Europa sono piuttosto diverse. Giovedì 9 maggio, i mercati azionari asiatici sono attualmente in fase di stabilizzazione e gli investitori sono in attesa dei dati commerciali della Cina per valutare lo stato di salute dell’economia cinese; il Giappone ha indicato possibili interventi valutari, con lo yen che si sta stabilizzando dopo tre giorni consecutivi di declino.</p>
<p>Dopo il taglio dei tassi overnight da parte della banca centrale svedese, anche la Bank of England (BoE) deciderà la sua politica dei tassi di interesse e sta considerando quanto tempo ci vorrà per abbassare i tassi di interesse dall’attuale massimo di 16 anni. Tutti sono preoccupati per la prospettiva di un taglio dei tassi a giugno, che mette anche in evidenza la divergenza tra l’Europa e la Federal Reserve.</p>
<p>Nel frattempo, il mercato del lavoro nel Regno Unito è diventato un punto di attenzione. I dati ufficiali più recenti mostrano che nei tre mesi fino a febbraio, il tasso di crescita annuale del salario era di circa il 6%, mentre il tasso di disoccupazione è salito al 4,2%, raggiungendo un massimo di sei mesi. Il compito dell’occupazione è diventato più complesso.</p>
<p>REC ha dichiarato che sempre più persone stanno entrando nel mercato del lavoro e i candidati stanno crescendo al ritmo più veloce degli ultimi cinque mesi, in parte a causa di un aumento dei licenziamenti e di un aumento generale dei cercatori di lavoro. L’aumento dell’offerta di lavoro è accolto favorevolmente dal governo, poiché il governo e la banca centrale sono preoccupati dell’inflazione e dell’impatto fiscale causato dal continuo declino del tasso di partecipazione alla forza lavoro negli ultimi due anni.</p>
<p>Nel mercato asiatico, l’indice azionario MSCI Asia Pacifico è aumentato dello 0,1% dopo che il presidente della Federal Reserve Jerome Powell ha ribadito la sua ‘posizione di politica monetaria accomodante’ per la fine dell’anno, non lontano dal precedente massimo di 15 mesi. L’indice Nikkei in Giappone è aumentato dello 0,3%.</p>
<p>A causa di un rimbalzo del 2% nelle azioni tecnologiche e del recupero degli sviluppatori immobiliari cinesi, le azioni blue chip cinesi sono aumentate dello 0,6%, mentre il mercato azionario di Hong Kong Hang Seng è salito dello 0,7%. L’indice immobiliare CSI è salito dello 0,9%, riprendendosi dal calo della giornata precedente.</p>
<p>Gli investitori presteranno attenzione ai dati sull’inflazione dei consumatori statunitensi di aprile rilasciati mercoledì prossimo per comprendere meglio la direzione della politica della Federal Reserve; I dati sono aumentati inaspettatamente per tre round consecutivi.</p>
<p>In termini di materie prime, la diminuzione delle scorte di greggio negli Stati Uniti indica un restringimento dell’offerta, e la crescente speranza di un taglio dei tassi d’interesse della Federal Reserve prima della fine dell’anno ha portato a un lieve aumento dei prezzi del petrolio giovedì, riprendendo dai minimi di due mesi della precedente giornata di negoziazione. I futures del greggio Brent sono saliti dello 0,2% a $83,76 al barile, mentre i futures del greggio statunitense sono saliti dello 0,3% a $79,24 al barile.</p>
<p>Il prezzo dell’oro è salito dello 0,1% a $2.311,23 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</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 repostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>