Tm90aXppZSBxdW90aWRpYW5lIHwgRmluYWxtZW50ZSBhcHByb3ZhdG8gbCdFVEYgRXRoZXJldW0gU3BvdDsgVVNEWSBkaSBPbmRvIHNhcsOgIGxhbmNpYXRvIG5lbGwnZWNvc2lzdGVtYSBDb3Ntb3M7IEhLIGxhbmNlcsOgIGkgcHJpbWkgRVRGIEJpdGNvaW4gaW52ZXJzaSBkZWxsJ0FzaWE=

2024-07-23, 03:25

<p><img src="https://gimg2.gateimg.com/image/article/17217050141_18.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20LETF20Ethereum20spot20ha20ricevuto20lapprovazione20finale20ed2020pronto20per20iniziare20le20negoziazioni20USDY20di20Ondo2020stato20lanciato20nellecosistema20Cosmos20Hong20Kong20lancer20il20primo20ETF20Bitcoin20inverso20dellAsia639977"><a name="Crypto Daily Digest: L’ETF Ethereum spot ha ricevuto l’approvazione finale ed è pronto per iniziare le negoziazioni; USDY di Ondo è stato lanciato nell’ecosistema Cosmos; Hong Kong lancerà il primo ETF Bitcoin inverso dell’Asia" 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> spot ha ricevuto l’approvazione finale ed è pronto per iniziare le negoziazioni; USDY di Ondo è stato lanciato nell’ecosistema Cosmos; Hong Kong lancerà il primo ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> inverso dell’Asia</h2><p>Prima, esaminiamo l’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 22 luglio, l’ETF Fidelity Bitcoin Spot (FBTC) ha ricevuto un’afflusso di 23,7 milioni di dollari, l’ETF BlackRock Bitcoin Spot (IBIT) ha ricevuto un’afflusso di 523,3 milioni di dollari e l’ETF VanEck Bitcoin Spot (HODL) ha registrato un deflusso di 38,4 milioni di dollari.</p>
<p><strong>Il posto <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF ha ricevuto l’approvazione finale ed è pronto per iniziare le negoziazioni</strong></p>
<p>Dopo settimane di modifica delle dichiarazioni di registrazione, gli ETF Ethereum spot di diversi fondi negoziati in borsa sono stati approvati e inizieranno a essere negoziati martedì.</p>
<p>Lunedì pomeriggio, la Securities and Exchange Commission (SEC) degli Stati Uniti ha approvato le domande di registrazione per 21Shares, Bitwise, BlackRock, Fidelity, Franklin Templeton, VanEck e Invesco Galaxy. Anche i moduli di registrazione del Grayscale Ethereum Trust e dell’Ethereum Mini Trust sono stati approvati lo stesso giorno.</p>
<p>L’ETF Bitcoin spot è stato approvato all’inizio di quest’anno e ha generato miliardi di dollari di rendimenti. Eric Balchunas, un analista senior di ETF presso Bloomberg, ritiene che la domanda di ETF Ethereum potrebbe essere inferiore a quella degli ETF Bitcoin, che riceveranno dal 10% al 15% degli asset del prodotto Bitcoin, o un valore di $5 miliardi a $8 miliardi, che è anche molto obiettivo.</p>
<p>Cynthia Lo Bessette, capo della gestione degli asset digitali presso Fidelity, ha dichiarato che l’ETF Ethereum spot della società fornirà agli investitori un “design di indice e prodotto ponderato supportato da team operativi e di trading dedicati” per un accesso più sicuro a Ethereum. Ha aggiunto: ‘Questo riflette la lunga storia di Fidelity e l’impegno nel soddisfare le mutevoli esigenze dei clienti’.</p>
<p>Dopo l’approvazione del Bitcoin ETF spot, l’exchange ha iniziato a considerare le opzioni di trading per questi prodotti, ma non ha ancora ricevuto l’approvazione regolamentare. La SEC ha messo in discussione il servizio di staking di ETH e ha stabilito che gli Ethereum ETF non includono lo staking. Tuttavia, gli analisti ritengono che le aziende potrebbero incorporare lo staking nei loro prodotti ETF in futuro.</p>
<p><strong>USDY di Ondo è stato lanciato in modo nativo nell’ecosistema di Cosmos</strong></p>
<p>Il team di Ondo ha lanciato Ondo US dollar yield (USDY) su Cosmos. USDY è una nota tokenizzata, un prodotto stablecoin garantito da obbligazioni del tesoro statunitense a breve termine e depositi correnti delle banche statunitensi. È il primo stablecoin originale in dollari USA nell’ecosistema Cosmos. Questa mossa introduce USDY in oltre 90 blockchain Cosmos specifiche dell’applicazione.</p>
<p>USDY consente agli investitori individuali e istituzionali globali (non statunitensi) di ricevere rendimenti, con un valore totale di oltre 300 milioni di dollari attualmente bloccati su diverse blockchain. USDY sarà adottato in modo particolare su Injective. Helix, un exchange di derivati basato su Injective, lancerà USDY come garanzia per asset spot e mercati perpetui. Ciò consentirà agli utenti di ottenere profitti tramite USDY mentre fanno trading sulla catena per la prima volta. Inoltre, un altro protocollo su Injective, Hydro, incorporerà USDY nei suoi asset strutturati, consentendo agli utenti di ottenere profitti on-chain. Secondo i dati di CoinGecko, il valore di mercato di USDY supera i 222 milioni di dollari.</p>
<p>Noble è una blockchain appositamente creata conosciuta come rete di emissione di asset nativi per la stablecoin USDC di Circle nell’ecosistema Cosmos. Dall suo primo lancio nel settembre 2023, l’emissione nativa di USDC su Noble ha superato i 243 milioni di dollari.</p>
<p>Anche se USDY è stato lanciato attraverso la blockchain Noble, diversi altri chain Cosmos e progetti DeFi, tra cui Injective, <a href="/price/osmosis-osmo" rel="nofollow noopener noreferrer" target="_blank">Osmosi</a>, Kujira e Pyth utilizzeranno anche USDY.</p>
<p><strong>Hong Kong lancerà i primi ETF Bitcoin inversi dell’Asia</strong></p>
<p>Il 23 luglio, Hong Kong lancerà il primo prodotto inverso sui futures del Bitcoin in Asia - CSOP Bitcoin Futures Daily (-1x) Prodotto inverso.</p>
<p>Una delle più grandi società di gestione patrimoniale della Cina, CSOP Asset Management Limited, ha lanciato un nuovo fondo negoziato in borsa (ETF). Prima di questo, il CSOP Bitcoin Futures ETF è stato lanciato con successo nel dicembre 2022, proseguendo l’espansione dell’azienda nella regione Asia-Pacifico. Il nuovo Bitcoin ETF mira a fornire agli investitori un modo per trarre profitto dal calo dei prezzi del Bitcoin.</p>
<p>Il prodotto inverso giornaliero (-1x) dei future sul Bitcoin CSOP mira a fornire risultati di investimento che corrispondano strettamente alle prestazioni giornaliere inverse dell’indice dei future sul Bitcoin S&amp;P. Questo prodotto inverso raggiunge questo obiettivo attraverso una strategia di replica basata sui future, investendo direttamente nei future sul Bitcoin del Chicago Mercantile Exchange del mese spot.</p>
<p>Secondo Southern Dongying, il prodotto sarà quotato alla Borsa di Hong Kong (HKEX) a circa 7,8 HKD per unità il 22 luglio. Ciò riflette anche la complessità dei prodotti finanziari crypto globali.</p>
<h2 id="h2-Tendenze20di20mercato20ETF20ETH20ufficialmente20approvato20settore20dei20meme20ancora20in20buona20forma912242"><a name="Tendenze di mercato: ETF ETH ufficialmente approvato, settore dei meme ancora in buona forma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: ETF ETH ufficialmente approvato, settore dei meme ancora in buona forma</h2><p>BTC: I prezzi del BTC si stanno consolidando orizzontalmente a livelli alti e gli ETF spot continuano a registrare afflussi netti, ma l’entità degli afflussi è relativamente piccola. Con l’aumentare dei prezzi del BTC, l’entusiasmo di mercato per i fondi si è indebolito.</p>
<p>ETH: ETH ha mostrato una performance relativamente forte, con un forte slancio verso l’alto nel prezzo. Stamattina, l’ETF di ETH è stato ufficialmente approvato e inizierà a essere scambiato domani, aumentando ulteriormente il sentiment di mercato.</p>
<p>Altcoin: La maggior parte degli Altcoin ha registrato cali di prezzo e il mercato manca di nuovi punti caldi. Ad eccezione delle Meme coin, gli altri settori hanno mostrato una performance deludente.</p>
<h3 id="h3-Indicatori20di20dati589871"><a name="Indicatori di dati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indicatori di dati</h3><p>Indice AHR999: L’indice AHR999 di oggi è a 0,93 e il mercato ha superato la zona inferiore, ma è comunque adatto per gli investimenti regolari.</p>
<p>Indice della paura e dell’avidità: Attualmente l’Indice della paura e dell’avidità è 71. Il sentimento di mercato è stato avido per due giorni consecutivi, con un ottimistico sentimento degli investitori.</p>
<h3 id="h3-Macroeconomia450386"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Performance delle azioni statunitensi: i tre principali indici azionari statunitensi hanno chiuso in rialzo, riprendendosi da una situazione di ipervenduto. Le principali aziende nel campo dell’IA, NVIDIA e Tesla, hanno entrambe registrato forti aumenti, trainando l’intero settore tecnologico. Musk ha fortemente promosso xAI su Twitter, attirando ulteriormente l’attenzione del mercato sull’IA.</p>
<h3 id="h3-Punti20caldi20del20mercato724092"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p><strong>Il token del concetto politico di Trump e le monete Meme a tema gatto nel settore Meme hanno ottenuto buoni risultati con buoni guadagni:</strong><br>DMAGA, DELON: Dopo che Musk ha sostituito il suo avatar Twitter con Laser Eye, i token correlati come DMAGA e DELON sono aumentati. Secondo i feedback della comunità, si sospetta che gli indirizzi di emissione di questi token siano stati preparati da un deposito di topi.</p>
<p>MEW e MANEKI: Le criptovalute a tema gatto hanno ottenuto risultati eccezionali. MEW ha superato un massimo storico e ha subito un calo a breve termine, mentre MANEKI, che rappresenta l’immagine di un gatto alla ricerca di denaro, è salito di quasi il 50% nel corso della giornata.</p>
<p><strong>Ton Ecosistema:</strong><br>Pixelverse: L’account Twitter ufficiale del popolare gioco Pixelverse sulla catena Ton è stato vietato, portando a una significativa caduta di oltre il 60% in PIXFI entro la giornata.</p>
<p>Cani: Anche l’account Twitter ufficiale è stato bandito. Ciò ha causato incertezza riguardo all’airdrop dei popolari progetti dell’ecosistema di Ton e il mercato potrebbe non pagare più.</p>
<h3 id="h3-Per20riassumere728923"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h3><p>Il sentimento attuale del mercato è ottimista, ma va esercitata cautela contro la possibilità di un rischio di ritorno causato da un trading laterale ad alto livello. L’approvazione dell’ETF ETH è una notizia positiva importante che aumenterà ulteriormente il sentimento di mercato nel breve termine. Tuttavia, il settore Altcoin ha mostrato una performance debole e la Meme coin rimane il settore dei token più performante in questa fase di mercato.</p>
<h2 id="h2-Macro20Gli20investitori20tornano20alle20azioni20a20grande20capitalizzazione20Wall20Street20chiude20in20rialzo20Le20azioni20dei20chip20si20riprendono20i20mercati20azionari20asiatici20pongono20fine20alla20tendenza20al20ribasso20continua864375"><a name="Macro: Gli investitori tornano alle azioni a grande capitalizzazione, Wall Street chiude in rialzo; Le azioni dei chip si riprendono, i mercati azionari asiatici pongono fine alla tendenza al ribasso continua" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gli investitori tornano alle azioni a grande capitalizzazione, Wall Street chiude in rialzo; Le azioni dei chip si riprendono, i mercati azionari asiatici pongono fine alla tendenza al ribasso continua</h2><p>Lunedì 22 luglio gli investitori sono tornati ai grandi titoli di crescita, spingendo i tre principali indici di riferimento di Wall Street a chiudere in rialzo. L’S&amp;P 500 e il Nasdaq Composite Index si sono significativamente ripresi dalla loro precedente performance lenta. Anche il Dow Jones Industrial Average è tornato con successo nella zona positiva, ponendo fine ai suoi due giorni consecutivi di declino dopo aver raggiunto un nuovo massimo storico alla chiusura mercoledì scorso.</p>
<p>Le performance specifiche dell’indice sono le seguenti: il Dow Jones Industrial Average è salito dello 0,32%, l’S&amp;P è salito dell’1,08%, e il Nasdaq è salito dell’1,58%.</p>
<p>Il rimbalzo delle azioni a grande capitalizzazione è la principale forza trainante di questo rimbalzo di mercato. I prezzi delle azioni di giganti come Alphabet, Meta Platforms e Tesla sono saliti del 2,2% al 5,1%.</p>
<p>La situazione politica continua a influenzare il mercato. L’uscita di Biden potrebbe spingere gli investitori a liquidare le loro posizioni, poiché scommettono che la vittoria del repubblicano Trump aumenterà le pressioni fiscali e inflazionistiche negli Stati Uniti. Nel frattempo, alcuni analisti ritengono che se ci sarà una spaccatura nel prossimo governo, il mercato potrebbe trarne vantaggio.</p>
<p>Il 23 luglio, i mercati azionari asiatici hanno registrato un rimbalzo da un minimo di un mese, e il mercato azionario di Taiwan ha concluso il suo trend al ribasso di cinque giorni. Il recupero del mercato azionario di Wall Street ha portato alla crescita delle azioni dei semiconduttori. L’indice Shanghai e Shenzhen 300 è salito dello 0,55%, mentre l’indice Nikkei in Giappone è salito dell’1,6% a causa della stabilizzazione delle azioni dei chip.</p>
<p>L’indice di riferimento TWII a Taiwan è salito di circa il 1,7% nelle prime contrattazioni, con il produttore di chip TSMC in rialzo del 2%. In precedenza, a causa dell’atteggiamento ambiguo del candidato presidenziale americano Donald Trump durante un’intervista nei confronti della protezione di Taiwan e della sua industria dei chip, la capitalizzazione di mercato di TSMC è evaporata di circa $100 miliardi la scorsa settimana.</p>
<p>Il produttore di chip sudcoreano Samsung è anche ripartito poiché gli operatori si sono concentrati sulla forte domanda e hanno ignorato i rischi politici.</p>
<p>In termini di mercato valutario, il mercato si aspetta che gli Stati Uniti taglino i tassi di interesse due volte nella seconda metà di quest’anno, il che ha cominciato a mettere pressione sul dollaro statunitense. Nonostante l’incertezza delle elezioni presidenziali degli Stati Uniti impedisca un significativo calo del dollaro statunitense, il tasso di cambio euro/dollaro è rimasto stabile a 1,089 martedì, mentre il tasso di cambio yen/dollaro è salito leggermente a 156,8. Il dollaro australiano è sceso a un minimo di tre settimane contro il dollaro statunitense, e il dollaro neozelandese è sceso a un minimo di quasi tre mesi di $0,5966 contro il dollaro statunitense, ma gli analisti si aspettano che i dollari australiano e neozelandese si riprendano presto.</p>
<p>Per quanto riguarda il mercato delle materie prime, la Cina ha tagliato inaspettatamente i tassi di interesse lunedì, unitamente ai dati sulle prospettive economiche più bassi del previsto della scorsa settimana, che hanno sollevato preoccupazioni sull’outlook economico. I prezzi dei futures del minerale di ferro di Dalian sono scesi ai minimi da aprile, e i prezzi del rame di Shanghai sono diminuiti di conseguenza.</p>
<p>I future del petrolio Brent hanno raggiunto un minimo di un mese durante la notte, con l’ultimo prezzo a $82,59 al barile.</p>
<p>Poiché il dollaro statunitense si è rafforzato e i trader hanno atteso ulteriori dati economici degli Stati Uniti e commenti da parte dei funzionari della Federal Reserve questa settimana, i prezzi dell’oro sono scesi ai minimi da oltre una settimana lunedì. L’oro spot è sceso dello 0,2% a $2394,18 per oncia. Il prezzo di liquidazione dei futures sull’oro statunitense è sceso dello 0,1% a $2.394,70 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 suggerimenti 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 citato 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>