RGFpbHkgTmV3cyB8IEhLIEV0aGVyZXVtIEVURiBpbiB2ZW5kaXRhOyBpbCBmb25kYXRvcmUgZGkgV0xEIHNpIMOoIGluY29udHJhdG8gY29uIGkgbGVhZGVyIG1hbGVzaSBwZXIgcmFmZm9yemFyZSBsZSByZWxhemlvbmkgZ292ZXJuYXRpdmUgZSBhdW1lbnRhcmUgbCdvZmZlcnRhIGRpIFdMRCBkZWwgMTkl

2024-04-24, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/171393015624.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20LETF20Ethereum20di20HK20verr20aperto20per20la20negoziazione20il203020aprile20Il20fondatore20di20Worldcoin20ha20incontrato20i20leader20malesi20per20rafforzare20le20relazioni20governative20e20aumentare20lofferta20di20WLD20del201920nei20prossimi20sei20mesi546666"><a name="Crypto Daily Digest: L’ETF Ethereum di HK verrà aperto per la negoziazione il 30 aprile; Il fondatore di Worldcoin ha incontrato i leader malesi per rafforzare le relazioni governative e aumentare l’offerta di WLD del 19% nei prossimi sei mesi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: L’ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> di HK verrà aperto per la negoziazione il 30 aprile; Il fondatore di Worldcoin ha incontrato i leader malesi per rafforzare le relazioni governative e aumentare l’offerta di WLD del 19% nei prossimi sei mesi</h2><p>Innanzitutto, diamo un’occhiata alle attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 23 aprile, gli ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) hanno continuato a registrare deflussi di fondi pari a 66,9 milioni di dollari. Nel frattempo, l’afflusso dell’ETF Fidelity Bitcoin spot (FBTC) è stato di 4,4 milioni di dollari, l’afflusso dell’ETF Bitwise Bitcoin spot (BITB) di 23,2 milioni di dollari, l’afflusso dell’ARK 21Shares Bitcoin spot ETF (ARKB) di 33,3 milioni di dollari e l’afflusso netto dell’ETF WisdomTree Bitcoin spot (BTCW) di 6,6 milioni di dollari.</p>
<p>Il Bitcoin spot e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF emessi congiuntamente da HashKey Capital e Bosch International saranno aperti per la negoziazione alla Borsa di Hong Kong il 30 aprile. Si prevede che questi due ETF seguano i prezzi di Bitcoin ed Ethereum e adottino un meccanismo di sottoscrizione fisica, consentendo agli investitori di sottoscrivere le quote degli ETF utilizzando direttamente Bitcoin ed Ethereum.</p>
<p>In precedenza, Bosch International aveva ottenuto l’approvazione dalla Commissione per i Titoli e i Futures di Hong Kong per ampliare il proprio ambito di attività e fornire servizi di gestione patrimoniale relativi ad asset virtuali. Allo stesso tempo, HashKey Capital, una istituzione di gestione patrimoniale di asset virtuali a livello istituzionale, ha ottenuto l’approvazione dalla Commissione per i Titoli e i Futures di Hong Kong per fornire servizi di prodotto di fondi di asset virtuali a investitori al dettaglio.</p>
<p>Sul fronte della SEC, dopo la precedente decisione di posticipare l’ETF spot di Ethereum, stiamo ora cercando pareri sulla proposta rivista di BlackRock. Famose aziende, tra cui Fidelity e BlackRock, hanno presentato domanda per ETF spot di Ethereum nei mesi scorsi. Tuttavia, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> la domanda di approvazione di tali prodotti da parte della Securities and Exchange Commission degli Stati Uniti sta diminuendo costantemente.</p>
<p>Martedì, in un rapporto di ricerca, Standard Chartered Bank ha sottolineato che gli asset digitali hanno recentemente subito una dannosa tempesta di vento contrario. Il periodo peggiore è passato e il mercato si trova in una posizione favorevole per la ripresa. L’analista Jeff Kendrick ritiene che l’afflusso di fondi negli ETF spot su Bitcoin si sia fermato, mentre sembra improbabile che gli ETF su Ethereum ricevano l’approvazione nell’atteso mese di maggio.</p>
<p>Worldcoin ha recentemente subito due divieti temporanei da parte di Spagna e Portogallo, che chiedono di interrompere la raccolta di dati personali degli utenti. Questi divieti temporanei sono dovuti al fatto che World Coin scandisce gli occhi degli utenti per creare identità personali mondiali e fornisce token WLD, suscitando preoccupazioni sulla privacy personale e sulla gestione dei dati.</p>
<p>I fondatori Sam Altman e Alex Blania hanno recentemente incontrato i leader malesi per migliorare le relazioni con il governo e dimostrare il loro impegno nella protezione dei dati degli utenti e della privacy. Secondo un post rilasciato dai leader del governo, venerdì scorso, Blania e Altman, co-fondatori di Tools for Humanity, hanno partecipato a una videochiamata con il primo ministro malese Anwar Ibrahim.</p>
<p>Prima di incontrare i funzionari malesi, Worldcoin ha adottato misure per dimostrare che il progetto prende sul serio la raccolta dei dati e le questioni legate alla privacy ed è disposta a lavorare più strettamente con le agenzie regolatorie e i funzionari governativi. Ciò indica che i funzionari governativi di alto livello sono ancora interessati a intraprendere un dialogo con Worldcoin.</p>
<p>È stato dimostrato che a causa della crescente curiosità e preoccupazione delle persone riguardo all’intelligenza artificiale (inclusa la minaccia di frodi profonde), alti funzionari governativi di vari paesi continuano a mostrare interesse nel dialogo con Worldcoin.</p>
<p>Nelle ultime notizie, Worldcoin ha annunciato che World Assets (una controllata della Worldcoin Foundation responsabile dell’emissione dei token) venderà fino a 1,5 milioni di WLD del valore approssimativo di $8,2 milioni a settimana attraverso collocamenti privati con istituzioni selezionate. Attualmente, l’offerta circolante dei token WLD è di 193 milioni, e le vendite tramite collocamento privato comportano un aumento del 18,6% dell’offerta totale disponibile nello stesso periodo.</p>
<h2 id="h2-Tendenze20di20mercato20Il20mercato2020volatile20le20monete20Meme20continuano20a20performare20bene883409"><a name="Tendenze di mercato: Il mercato è volatile, le monete Meme continuano a performare bene" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Il mercato è volatile, le monete Meme continuano a performare bene</h2><p>Il mercato cripto nel complesso sta mostrando una tendenza volatile, con il settore dei meme in testa. Per quanto riguarda la macroeconomia, il mercato azionario statunitense si è ripreso, con dati di produzione inferiori alle aspettative di mercato, il che ha alzato, in qualche misura, le aspettative di mercato per possibili futuri tagli dei tassi di interesse.</p>
<h3 id="h3-Hotspot20di20mercato196994"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Il settore Meme continua a essere molto performante: diversi token importanti nel settore Meme, come BONK, PEPE e FLOKI, hanno registrato un aumento giornaliero di oltre il 20%. Grazie alla mancanza di pressione derivante dallo sblocco di molti token, questo tipo di token ha una struttura di chip relativamente semplice e meno resistenza alla manipolazione del mercato, il che lo rende eccezionale.</p>
<p>Il token concettuale di AI AKT è aumentato: Akash, un progetto di potenza di calcolo AI nell’ecosistema Cosmos, è stato lanciato ieri su un exchange sudcoreano e la notizia ha stimolato un significativo aumento del prezzo. Questo progetto ha ricevuto grande attenzione dal mercato fornendo risorse di calcolo cloud decentralizzate per supportare vari bisogni di calcolo AI.</p>
<p>Il concetto di Gamefi ha visto un aumento delle valute BIGTIME e BNX. Ieri i token BIGTIME sono stati lanciati su una piattaforma di trading coreana, suscitando l’attenzione del mercato e l’entusiasmo degli investitori per il progetto di gioco. Allo stesso tempo, il token BNX ha registrato un significativo aumento di prezzo a seguito di voci su un nuovo gioco in uscita, indicando che gli investitori rimangono ottimisti sull’innovazione dei giochi e sui potenziali modelli di business nel settore Gamefi.</p>
<p>Sebbene il mercato delle criptovalute sia generalmente volatile, le forti performance del settore dei Meme e i guadagni significativi nei concetti di AI e Gamefi dimostrano l’attività di investimento e l’attenzione del mercato in settori specifici. Gli investitori dovrebbero continuare a prestare attenzione agli indicatori macroeconomici e agli sviluppi interni del settore per fare scelte di investimento più sagge. Allo stesso tempo, si dovrebbe prestare attenzione ai rischi delle fluttuazioni di mercato.</p>
<h2 id="h2-Macro20Le20azioni20tecnologiche20supportano20un20sentimento20positivo20nel20mercato20con20gli20investitori20che20prestano20attenzione20ai20dati20economici20chiave20negli20Stati20Uniti729831"><a name="Macro: Le azioni tecnologiche supportano un sentimento positivo nel mercato, con gli investitori che prestano attenzione ai dati economici chiave negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le azioni tecnologiche supportano un sentimento positivo nel mercato, con gli investitori che prestano attenzione ai dati economici chiave negli Stati Uniti</h2><p>Il mercato azionario statunitense ha chiuso in rialzo martedì, sostenuto principalmente dalla buona performance delle principali aziende, con gli investitori che prestano attenzione alle performance trimestrali dei Magnifici Sette e altre grandi azioni di crescita. Tesla ha annunciato il lancio di un nuovo modello di veicolo elettrico dopo la chiusura delle contrattazioni martedì, e nonostante il fatturato trimestrale sia inferiore alle aspettative degli analisti, il prezzo delle sue azioni è salito del 6% durante le ore di negoziazione prolungate.</p>
<p>Dei 11 settori dell’indice S&amp;P 500, dieci sono saliti, trainati dalla crescita delle azioni dei servizi di comunicazione. Tuttavia, il settore dei materiali S&amp;P è stato trascinato verso il basso dal produttore di acciaio NUE. N, il cui prezzo delle azioni è sceso dell’8,9% dopo che il profitto del primo trimestre è risultato al di sotto delle aspettative.</p>
<p>I dati di martedì hanno mostrato che a causa della debole domanda, l’attività commerciale negli Stati Uniti è scesa al minimo di quattro mesi in aprile. Nonostante un significativo aumento dei prezzi di input, i tassi di inflazione sono comunque leggermente rallentati, indicando che gli aumenti dei prezzi al consumo potrebbero essersi attenuati.</p>
<p>Oltre ai profitti aziendali, gli investitori monitoreranno attentamente l’indice delle spese di consumo personali (PCE) di marzo, che sarà pubblicato venerdì come indicatore di inflazione preferito dalla Federal Reserve. Secondo i dati della Borsa di Londra, il mercato del denaro si aspetta solo un taglio dei tassi di circa 43 punti base, che è circa 150 punti base più basso rispetto all’inizio dell’anno.</p>
<p>Lerner ha aggiunto: “Il rapporto PMI e l’occupazione sono relativamente deboli e attualmente il mercato vede questa situazione come una brutta notizia, ma ci sono anche buone notizie, il che significa che le aspettative delle persone nei confronti della Federal Reserve sono diventate troppo aggressive.”</p>
<p>Anche il mercato azionario asiatico ha mostrato un trend ottimista a seguito dell’ascesa di Wall Street, sostenuto dai profitti ottimisti di alcune aziende americane, portando ad un aumento del sentimento di rischio di mercato.</p>
<p>L’MSCI, l’indice azionario dell’Asia Pacifica più ampiamente utilizzato al di fuori del Giappone, è salito dell’1% e dell’1,55% martedì dopo essersi ripreso dalla forte vendita della scorsa settimana. L’indice Nikkei in Giappone è aumentato del 2%. Il mercato azionario cinese mostra una tendenza mista di salite e discese, con l’indice blue-chip che rimane invariato, mentre l’indice Hang Seng di Hong Kong è aumentato dell’1,6%.</p>
<p>Per quanto riguarda le materie prime, il petrolio greggio statunitense è sceso dello 0,1% a $83,28 al barile, mentre il petrolio Brent è sceso dello 0,12% a $88,31 al barile. Martedì, mentre gli investitori spostavano la loro attenzione dalla situazione tesa in Medio Oriente, i prezzi del petrolio sono saliti.</p>
<p>L’oro spot è sceso dello 0,2% a $2.317,39 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 re-post dell'articolo 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>