Tm90aXppZSBxdW90aWRpYW5lIHwgRWlnZW5sYXllciByaWxhc2NpYSBpbCB0b2tlbiBFSUdFTjsgSG9uZyBLb25nIGxhbmNpYSB1ZmZpY2lhbG1lbnRlIGlsIHByaW1vIEVURiBiaXRjb2luIGUgZXRoZXJldW0gc3BvdCBkZWxsJ0FzaWE7IHBpw7kgZGVsIDUwJSBkaSBSdW5lcyDDqCBpbiByb3NzbywgaW4gcXVlc3Rpb25l

2024-04-30, 05:24

<p><img src="https://gimg2.gateimg.com/image/article/171445847230.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Eigenlayer20rilascia20EIGEN20Whitepaper20ma20nessun20airdrop20per20gli20utenti20statunitensi20Hong20Kong20lancia20ufficialmente20il20primo20ETF20Bitcoin20e20Ethereum20spot20dellAsia20oltre20il205020percento20delle20Rune20nel20rosso20il20protocollo20Rune20in20discussione499798"><a name="Crypto Daily Digest: Eigenlayer rilascia EIGEN Whitepaper, ma nessun airdrop per gli utenti statunitensi; Hong Kong lancia ufficialmente il primo ETF Bitcoin e Ethereum spot dell’Asia; oltre il 50 percento delle Rune nel rosso, il protocollo Rune in discussione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Eigenlayer rilascia EIGEN Whitepaper, ma nessun airdrop per gli utenti statunitensi; Hong Kong lancia ufficialmente il primo ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot dell’Asia; oltre il 50 percento delle Rune nel rosso, il protocollo Rune in discussione</h2><p>Diamo un’occhiata all’attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF prima. Secondo i dati di Farside Investor, il 29 aprile, l’ETF Grayscale Bitcoin Spot (GBTC) ha registrato continui deflussi per 24,7 milioni di dollari; nel frattempo, l’ETF Fidelity Bitcoin Spot (FBTC) ha registrato deflussi per 6,9 milioni di dollari, l’ETF Bitwise Bitcoin Spot (BITB) ha registrato afflussi per 29 milioni di dollari e l’ETF ARK 21Shares Bitcoin Spot (ARKB) ha registrato deflussi per 31,3 milioni di dollari.</p>
<p>Aprile si è rivelato un mese difficile per gli ETF di bitcoin fisico. In precedenza, il trust Grayscale era il motore della fuga di capitali dagli ETF, ma stiamo iniziando anche a vedere denaro uscire dagli ETF di recente lancio. In generale, però, i nuovi ETF sono rimasti di successo.</p>
<p>Eigenlayer, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La piattaforma di restaking, ha pubblicato un whitepaper per il suo nuovo token proposto, EIGEN, il 29 aprile. Secondo il whitepaper, il token EIGEN verrà utilizzato per applicazioni che si basano su accordi intersoggettivi, come i mercati di previsione, i servizi di archiviazione e le macchine virtuali da gioco. Tuttavia, l’airdrop presto da annunciare escluderà diverse giurisdizioni come gli Stati Uniti e il Canada.</p>
<p>ETH con interessi su Ethereum può essere reinvestito in Eigenlayer e guadagnare ricompense aggiuntive verificando transazioni su entrambe le reti. La soluzione è considerata dai programmatori più sicura rispetto all’utilizzo di token separati, poiché consente a Eigenlayer di ereditare la sicurezza di Ethereum senza la necessità di costruire una rete di fiducia da zero.</p>
<p>Il principale utilizzo dei token EIGEN è quello di formare un consenso intorno ai dati off-chain ma facilmente verificabili, come ad esempio determinare se qualcuno ha archiviato adeguatamente i dati. Secondo il nuovo whitepaper, l’ETH depositato continuerà a essere utilizzato per formare un consenso intorno ai dati che possono essere verificati on-chain, come ad esempio la validità di una transazione. Il cinque per cento dell’offerta totale di EIGEN è stato allocato agli utenti attuali che hanno rinnovato l’ETH attraverso la rete, secondo il whitepaper di Eigenlayer, che è stato acquisito il 15 marzo. Il team non ha ancora annunciato quando finirà la seconda stagione.</p>
<p>Nonostante le segnalazioni secondo cui il team di Eigenlayer si sta preparando a distribuire nuovi token agli utenti, è stato osservato che la pagina web non può essere accessa dagli indirizzi IP degli Stati Uniti o da alcuni indirizzi di server VPN situati in Europa, suggerendo che gli Stati Uniti, il Canada e diversi paesi africani e asiatici non parteciperanno all’airdrop.</p>
<p>Sei fondi negoziati in borsa per bitcoin ed ethereum sono stati ufficialmente quotati oggi alla Borsa di Hong Kong, rendendoli i primi ETF di criptovalute quotati in Asia.</p>
<p>Questi includono Bosera HashKey Bitcoin ETF (3008.HK), Bosera HashKey Ethereum ETF (3009.HK), Huaxia Bitcoin ETF (3042.HK), Huaxia Ethereum ETF (3046.HK), Harvest Bitcoin Spot ETF (3439.HK) e Harvest Ethereum Spot ETF (3179.HK).</p>
<p>Precedentemente, Hong Kong ha approvato diversi ETF Bitcoin spot e ETF Ethereum spot gestiti da Huaxia Funds, Harvest Global, Bosera e HashKey. La quotazione dei primi ETF criptovalutari spot dell’Asia migliorerà ulteriormente la diversità e la liquidità dei prodotti dell’HKEx, ha dichiarato Brian Roberts, responsabile dello sviluppo dei prodotti azionari della borsa.</p>
<p>Questi ETF su criptovalute spot non sono solo aperti agli investitori di Hong Kong, ma anche agli investitori qualificati al di fuori di Hong Kong, anche se gli investitori cinesi del continente sono ancora limitati.</p>
<p>Il lancio di Runes ha suscitato un’enorme attenzione sul potenziale di memecoin, oltre a fornire una nuova funzionalità per la rete Bitcoin. Le Runes possono estendere la funzionalità della blockchain Bitcoin, consentendo agli utenti di tokenizzare una vasta gamma di asset del mondo reale. Ciò apre nuove possibilità per le app DeFi e altri casi d’uso nell’ecosistema Bitcoin.</p>
<p>Nonostante il suo entusiasmo iniziale, Runes ha ricevuto notevoli critiche per aver causato un aumento delle commissioni di transazione di bitcoin e per non essere redditizio per la maggior parte degli investitori. Al 29 aprile, il numero dei primi 50 detentori di Runes era diminuito in media del 30 percento, con due terzi di loro che hanno perso denaro.</p>
<p>I sostenitori dicono che è troppo presto per essere pessimisti riguardo a Runes. Credono che man mano che gli sviluppatori continuano a migliorare il protocollo e fornire un’utilità più sostanziale, Runes sarà in grado di migliorare l’esperienza di trading e diventare più ampiamente utilizzato nell’ecosistema Bitcoin. Come tale, guardano avanti al potenziale di Runes in futuro.</p>
<h2 id="h2-Tendenze20di20mercato20mercati20cripto20si20restringono20Eigenlayer20pronto20a20emettere20token300575"><a name="Tendenze di mercato: mercati cripto si restringono; Eigenlayer pronto a emettere token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: mercati cripto si restringono; Eigenlayer pronto a emettere token</h2><h3 id="h3-Tendenza20Ampia20del20Mercato487822"><a name="Tendenza Ampia del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza Ampia del Mercato:</h3><p>Bitcoin (BTC), che è sceso al di sotto dei $62.000 in un certo momento della scorsa notte, è tornato sopra i $64.000 in un trend oscillante ristretto. Nel mercato delle criptovalute, sta mostrando in generale un calo. A livello macroeconomico, le azioni statunitensi hanno registrato un rally, con le azioni di Tesla in particolare in aumento del 15%, aggiungendo alcuni segnali positivi al mercato.</p>
<h3 id="h3-Punti20caldi20del20mercato430802"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><ol>
<li><p>ENA (Token di stabilità dell’algoritmo) è salito di oltre il 20%. Questo comportamento del prezzo potrebbe essere correlato allo sblocco imminente del token. Secondo i dati on-chain, ENA è destinato a uno sblocco di token del valore di circa 50 milioni di dollari la prossima settimana. Il rally attuale potrebbe essere guidato dallo sblocco in attesa del mercato.</p>
</li><li><p>Eigenlayer, il progetto leader nel restaking, ha annunciato che effettuerà un token airdrop il 10 maggio con un rapporto di airdrop del 15%, di cui il 5% sarà assegnato alla prima tranche dei partecipanti e il restante 10% sarà assegnato alla tranche di partecipanti di un anno.</p>
</li></ol>
<p>Il prezzo futuro attuale di Eigenlayer corrisponde a una capitalizzazione di mercato di 17 miliardi di dollari, un valore molto più alto rispetto a quello di Lido (LDO), che ha una capitalizzazione di mercato di soli 2 miliardi di dollari, anche se il valore totale bloccato di Lido (TVL) è doppio rispetto a quello di Eigenlayer.</p>
<p>Particolarmente degno di nota, il numero di airdrop EIGEN non è proporzionale agli asset depositati, una strategia che potrebbe essere più favorevole agli investitori al dettaglio. Il token di resa Pendle YT sulla stessa traccia è stato contrattaccato, causando la caduta di Pendle. Gli utenti che hanno scommesso su Pendle non riceveranno il primo round di token airdrop EIGEN.</p>
<p>3.MSN, il token del progetto di banda larga decentralizzato di Meson Network, è stato lanciato su Gate.io ieri. Valutata $250 milioni in un round di finanziamento 2 anni fa, Meson Network ha attualmente una capitalizzazione di mercato di $300 milioni. Il prezzo di MSN ha toccato un massimo di $13 dopo il lancio, ma è poi sceso bruscamente a $2,80, con una performance dei prezzi ben al di sotto delle aspettative di mercato, riflettendo l’atteggiamento cauto degli investitori nei confronti del progetto.</p>
<p>Il mercato è attualmente in uno stato volatile, con fluttuazioni dei prezzi di Bitcoin e delle principali altcoin che ricordano agli investitori che devono rimanere vigili sul mercato. Vari eventi imminenti sui token, come lo sblocco di ENA e l’airdrop di Eigenlayer, potrebbero influenzare ulteriormente il sentiment di mercato e le variazioni dei prezzi. Gli investitori dovrebbero tenere d’occhio da vicino il mercato e gestire adeguatamente il proprio rischio, nonché prestare attenzione a varie informazioni fondamentali e tecniche al fine di prendere decisioni di investimento più informate.</p>
<h2 id="h2-Macro20La20performance20del20mercato20azionario20statunitense2020stata20inferiore20alle20aspettative20mentre20il20mercato20asiatico20ha20aperto20bene20luned20Il20tasso20di20cambio20dello20yen20giapponese2020sceso20al20di20sotto20di20un20livello20critico220144"><a name="Macro: La performance del mercato azionario statunitense è stata inferiore alle aspettative, mentre il mercato asiatico ha aperto bene lunedì. Il tasso di cambio dello yen giapponese è sceso al di sotto di un livello critico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La performance del mercato azionario statunitense è stata inferiore alle aspettative, mentre il mercato asiatico ha aperto bene lunedì. Il tasso di cambio dello yen giapponese è sceso al di sotto di un livello critico</h2><p>I titoli americani hanno chiuso in rialzo lunedì 29 aprile, trainati dalle azioni di Tesla e Apple, mentre gli investitori si concentravano sulle prospettive della Federal Reserve sui tassi di interesse a seguito della riunione di politica di questa settimana.</p>
<p>Le azioni di Tesla sono salite del 15,3%, facendo progressi dopo aver ottenuto l’approvazione normativa per lanciare il suo programma di assistenza avanzata alla guida in Cina. Le azioni di Apple sono salite del 2,5%, con guadagni legati alle rinnovate discussioni di OpenAI sull’utilizzo della tecnologia generatrice di IA della startup. Le azioni di altre importanti aziende tecnologiche, tra cui Alphabet, Meta Platforms e Microsoft, hanno chiuso in rialzo dopo aver recuperato le perdite iniziali.</p>
<p>Per quanto riguarda i tre principali indici, il Dow Jones è salito dello 0,38 per cento, l’S&amp;P ha guadagnato lo 0,32 per cento e il Nasdaq è salito dello 0,35 per cento.</p>
<p>Gli investitori hanno ridotto le loro aspettative per il tempismo e l’entità di un taglio dei tassi quest’anno, in mezzo all’incertezza sull’outlook dei tassi d’interesse negli Stati Uniti, con il mercato che prevede una probabilità del 57 per cento di un taglio dei tassi a settembre, secondo lo strumento CME FedWatch.</p>
<p>I trader si aspettano ora un taglio dei tassi di interesse di 35 punti base nel 2024, ben al di sotto dei 150 punti base previsti all’inizio dell’anno. Questo cambiamento nelle aspettative dei tassi di interesse statunitensi ha spinto al rialzo i rendimenti dei titoli del Tesoro statunitense e il dollaro, dominando i mercati valutari. Il dollaro è rimasto praticamente invariato rispetto a un paniere di valute a 105,73. L’indice è salito di oltre l’1 per cento ad aprile e di oltre il 4 per cento per l’anno.</p>
<p>I dati in uscita questa settimana includono l’inflazione europea e un rapporto sul mercato del lavoro negli Stati Uniti, mentre la Federal Reserve ha programmato una riunione di due giorni martedì e si prevede che rimanga invariata sui tassi di interesse.</p>
<p>Le azioni asiatiche hanno registrato un lieve aumento martedì 30 aprile, mentre gli investitori attendevano una serie di dati economici, utili aziendali e una riunione della Fed. Lo yen si è leggermente indebolito un giorno dopo che presunte manovre di intervento lo hanno salvato da un crollo di 34 anni.</p>
<p>L’indice azionario MSCI Asia-Pacific è salito dello 0,36 per cento ed è in procinto di guadagnare quasi l’1 per cento questo mese, il suo terzo guadagno mensile consecutivo. Il Giappone Nikkei ha riaperto dopo la festività di lunedì con le azioni in rialzo dell’1 per cento.</p>
<p>Tra le migliori aziende dell’Asia, le azioni di Samsung Electronics sono aumentate dell’1,8% martedì dopo che l’azienda ha riportato un aumento di oltre dieci volte del profitto operativo del primo trimestre. La domanda di intelligenza artificiale di Samsung rimarrà forte e stringerà l’offerta di alcuni chip di alta gamma; i produttori di chip potrebbero beneficiare di un forte rimbalzo nel colpito mercato globale dei chip di memoria.</p>
<p>I prezzi del petrolio sono leggermente diminuiti nelle prime contrattazioni di martedì, con i colloqui di cessate il fuoco tra Israele e Hamas al Cairo che hanno contribuito a calmare le preoccupazioni di mercato riguardo al conflitto in Medio Oriente in espansione, ma le preoccupazioni per le prospettive dei tassi d’interesse degli Stati Uniti hanno messo sotto pressione il mercato. Il greggio americano è sceso dello 0,18% a $82,48 al barile, mentre il greggio Brent è sceso dello 0,1% a $88,31 al barile.</p>
<p>L’oro spot è rimasto stabile a $2,334.79 l’oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Sherry S. &amp; Icing. </strong>, Ricercatore di Gate.io<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 re-post dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>