Tm90aXppZSBxdW90aWRpYW5lIHwgSEsgaGEgYXBwcm92YXRvIGdsaSBFVEYgc3BvdCBzdSBFVEggZSBCVEM7IElsIHByZXp6byBtaW5pbW8gZGVsbCdORlQgIkJvcmVkIEFwZSIgw6ggc2Nlc28gYWwgZGkgc290dG8gZGkgdW4gbnVvdm8gbWluaW1vOyBHYW1lRmkgSWxsdXZpdW0gbGFuY2Vyw6AgYWlyZHJvcCBkaSB0b2tlbiBkYSAyNSB

2024-04-16, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/171323895416.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20Crypto20gli20ultimi20ETF20spot20ETH20e20BTC20approvati20di20HK20il20prezzo20minimo20della20NFT20Bored20Ape2020sceso20al20di20sotto20di20un20nuovo20minimo20dal20202120GameFi20Illuvium20lancer20airdrop20di20token20da202520milioni328959"><a name="Riassunto giornaliero di Crypto: gli ultimi ETF spot ETH e BTC approvati di HK; il prezzo minimo della NFT “Bored Ape” è sceso al di sotto di un nuovo minimo dal 2021; GameFi Illuvium lancerà airdrop di token da $25 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di Crypto: gli ultimi ETF spot ETH e BTC approvati di HK; il prezzo minimo della NFT “Bored Ape” è sceso al di sotto di un nuovo minimo dal 2021; GameFi Illuvium lancerà airdrop di token da $25 milioni</h2><p>Prima di tutto, esaminiamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati dell’investitore Farside, il deflusso del fondo GBTC di Grayscale il 15 aprile è stato di 110,1 milioni di dollari; Il continuo deflusso dei fondi ETF spot di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> negli ultimi giorni è in qualche misura una risposta cauta dal mercato.</p>
<p>Negli ultimi tre mesi, l’afflusso netto cumulativo degli ETF Bitcoin spot negli Stati Uniti ha superato i $12,5 miliardi e il valore patrimoniale netto totale ha superato i $58 miliardi. Ora, l’attenzione del mercato è anche rivolta al trend di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF spot.</p>
<p>Hong Kong è diventata l’ultima regione a permettere gli spot ETF di BTC. Jiashi International, Boshi Fund e Huaxia Fund (Hong Kong) hanno annunciato successivamente di essere stati approvati dalla Commissione di Regolamentazione dei Titoli di Hong Kong per fornire servizi di gestione di asset virtuali agli investitori e pianificano di emettere prodotti ETF che possono investire in BTC spot e ETH spot.</p>
<p>Anche se le dimensioni del mercato degli ETF di Hong Kong sono relativamente ridotte, gli investitori mantengono comunque un atteggiamento positivo verso l’approvazione degli ETF spot di Bitcoin di Hong Kong e degli ETF spot di Ethereum, attirando un gran numero di acquirenti a unirsi. Attualmente ETH è scambiato a $3,086.99, probabilmente si riprenderà dopo diversi giorni consecutivi di ribassi.</p>
<p>Rispetto all’ecosistema generale in crescita del mercato cripto recentemente, il mercato NFT sembra piuttosto desolato, come dimostrato dalla serie di NFT Bored Ape Yacht Club rilasciata tre anni fa e promossa da molte celebrità. Anche se l’intero mercato NFT è stato debole per un periodo considerevole di tempo, BAYC spesso registra prestazioni positive. È considerato una delle storie di successo più importanti del mercato, con una comunità attiva e una serie di iterazioni popolari.</p>
<p>Sulla base dei dati storici, secondo CryptoSlam, BAYC è la serie NFT con il più alto ranking nel mercato dei collezionabili in termini di vendite, con vendite che superano i 3 miliardi di dollari.</p>
<p>A partire da lunedì, il prezzo più basso di Bored Ape NFT è sceso a 10,9 ETH (circa $34.000). Secondo i dati provenienti dal sito web dei dati NFT, da quando ha raggiunto i 9,5 ETH all’inizio di agosto 2021, il prezzo minimo del NFT non è mai sceso a un livello così basso.</p>
<p>Alcune celebrità hanno acquisito BAYC per poi venderlo a una frazione del prezzo originale. Secondo i dati di NFT Price Floor, il prezzo minimo attuale è più del 90% inferiore al massimo storico di BAYC di 128 ETH (attualmente intorno a $395.000) raggiunto nell’aprile 2022. Yuga Labs, fondatore della serie Bored Ape Yacht Club (BAYC), ha rifiutato di commentare su questo.</p>
<p>Illuvium ha annunciato il lancio di una campagna di distribuzione di token, offrendo un totale di 250.000 token ILV, equivalenti a circa $25 milioni. Tra questi, 50.000 ILV verranno utilizzati per distribuzioni di fedeltà e i restanti 200.000 ILV saranno distribuiti durante l’attività di Play-to-Airdrop di 6 mesi.</p>
<p>L’attività richiede agli utenti di partecipare attivamente e interagire nei giochi di Illuvium, inclusi combattimenti in arena, esplorazione del mondo virtuale, sviluppo del territorio, raccolta e scambio di NFT, ecc. I punti dell’attività determineranno il numero di ILV distribuiti gratuitamente. Il primo lotto di 20.000 ILV verrà distribuito durante la fase di prova Beta, e i restanti 180.000 ILV verranno distribuiti gradualmente entro 5 mesi dopo il lancio ufficiale della rete principale Beta.</p>
<p>Gli airdrop di fedeltà premieranno gli utenti che hanno partecipato attivamente all’ecosistema di Illuvium negli ultimi tre anni, compresi il blocco dei token ILV, la fornitura di liquidità LP, l’acquisto di terreni virtuali, la negoziazione di NFT, ecc., e sono previsti per la distribuzione nel secondo trimestre del 2024. Illuvium ha effettuato uno snapshot il 14 aprile.</p>
<p>Illuvium è un gioco di livello 3A di open world RPG costruito su Ethereum’s L2 <a href="/price/immutablex-imx" rel="nofollow noopener noreferrer" target="_blank">ImmutableX</a> Lo studio mira a costruire il primo universo di giochi blockchain interoperabili (IBG) al mondo, inclusi giochi di esplorazione open world, giochi di costruzione di città industriali e giochi di combattimento automatico, tutti giocati sulla blockchain di Ethereum. La beta privata 4 (PB4) inizierà il 30 aprile e il testnet beta pubblico inizierà il 28 maggio.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato20sta20cadendo20con20BTC20che20si20dimezzer20in20meno20di20520giorni645498"><a name="Tendenze di mercato: il mercato sta cadendo, con BTC che si dimezzerà in meno di 5 giorni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato sta cadendo, con BTC che si dimezzerà in meno di 5 giorni</h2><p>Il mercato ha continuato a diminuire dopo un breve rimbalzo ieri, meno di 5 giorni dopo la riduzione a metà di Bitcoin. Per quanto riguarda la macroeconomia, il mercato azionario statunitense ha subito un forte calo. I dati sulla vendita al dettaglio di marzo hanno superato le aspettative e le aspettative del mercato per il primo taglio dei tassi da parte della Federal Reserve sono state notevolmente ritardate.</p>
<h3 id="h3-Hotspot20di20mercato219372"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Settore delle monete dei fan: i token nei settori delle monete dei fan come JUV, CITY, BAR e PSG sono aumentati. La partita di calcio della Coppa Europea sta per iniziare e il mercato sta alimentando il hype intorno ai token concettuali correlati, che hanno attirato l’attenzione e la ricerca degli investitori.</p>
<p>Token concetto di Hong Kong: ACH, PHB e altri token concetto di Hong Kong sono aumentati, beneficiando della notizia che Hong Kong sta per adottare ETF spot di Bitcoin ed Ethereum.</p>
<p>Secondo Bloomberg, è previsto che l’afflusso di ETF Bitcoin spot a Hong Kong raggiunga i 500 milioni di dollari, il che sta anche guidando le performance dei token concettuali di Hong Kong.</p>
<p>Prestazione delle altre monete anti-caduta: in un mercato in calo, TON si comporta relativamente bene, mentre altre monete simili includono ONDO e PENDLE. TON è stato un token popolare ultimamente e la notizia dell’IPO di Telegram ne migliora notevolmente i fondamentali. Come token leader nel settore RWA, la performance del prezzo di ONDO è anche relativamente forte. Il valore totale bloccato (TVL) di PENDLE continua a crescere, arrivando attualmente a quasi $4,5 miliardi, con un aumento di oltre 7 volte dall’inizio di quest’anno.</p>
<p>In sintesi, il mercato continua a diminuire, ma alcuni settori e token specifici continuano a performare bene. Gli investitori dovrebbero monitorare attentamente le tendenze di mercato e adattare di conseguenza le loro strategie di investimento.</p>
<h2 id="h2-Macro20Lescalation20della20tensione20politica20sopprime20lappetito20per20il20rischio20i20mercati20azionari20globali20rimangono20cauti20e20i20prezzi20delloro20e20del20petrolio20aumentano959539"><a name="Macro: L’escalation della tensione politica sopprime l’appetito per il rischio, i mercati azionari globali rimangono cauti e i prezzi dell’oro e del petrolio aumentano" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’escalation della tensione politica sopprime l’appetito per il rischio, i mercati azionari globali rimangono cauti e i prezzi dell’oro e del petrolio aumentano</h2><p>Il mercato azionario statunitense ha chiuso nettamente al ribasso lunedì, principalmente perché il mercato era preoccupato per l’inasprimento delle tensioni tra Iran e Israele, mentre il rendimento dei bond del tesoro statunitense è aumentato nettamente, smorzando il sentiment di mercato.</p>
<p>Sebbene il forte rapporto sulle vendite al dettaglio nella sessione iniziale abbia aumentato il sentimento di mercato, la successiva forte crescita del rendimento dei bond del Tesoro USA e le crescenti tensioni geopolitiche tra l’Iran e Israele hanno suscitato preoccupazioni di mercato.</p>
<p>Per quanto riguarda i tre principali indici, il Dow Jones Industrial Average è sceso dello 0,65%, l’indice S&amp;P 500 è sceso dell’1,2% e l’indice Nasdaq è sceso dell’1,79%. Il mercato azionario ha recentemente registrato una debolezza, con l’indice S&amp;P 500 che è sceso per due settimane consecutive, segnando il più grande calo percentuale settimanale da ottobre dello scorso anno. Ciò è principalmente dovuto al ritardo degli investitori nelle loro aspettative per il tempismo e l’entità dei tagli ai tassi di interesse della Federal Reserve.</p>
<p>Il rapporto pubblicato la scorsa settimana ha sottolineato che l’inflazione rimane più alta delle aspettative di mercato, portando a una significativa riduzione dei tagli dei tassi di interesse quest’anno. Al momento, i trader si aspettano un taglio dei tassi di interesse di 45 punti base quest’anno, molto al di sotto dei previsti 160 punti base all’inizio dell’anno. Secondo i dati dello strumento FedWatch del Chishang Exchange, attualmente il mercato si aspetta che i tagli dei tassi di interesse inizino a settembre anziché a giugno.</p>
<p>Anche i mercati azionari asiatici hanno registrato un calo martedì, con il dollaro statunitense che ha raggiunto un massimo di oltre cinque mesi. Ciò è principalmente dovuto a vendite al dettaglio più forti del previsto negli Stati Uniti a marzo, rafforzando ulteriormente le aspettative di mercato che la Federal Reserve non si affretti ad agire. Allo stesso tempo, l’economia cinese è cresciuta del 5,3% su base annua nel primo trimestre, superando le aspettative degli analisti.</p>
<p>Il rendimento dei titoli di stato decennali in Asia era del 4,610%, che è schizzato al 4,663%, toccando così il massimo di cinque mesi lunedì. L’aumento di questo rendimento ha spinto il dollaro statunitense al rialzo e ha mantenuto lo yen giapponese vicino al minimo di 34 anni toccato nei giorni scorsi.</p>
<p>Il ministro delle finanze giapponese Junichi Suzuki ha dichiarato martedì di monitorare attentamente l’andamento del tasso di cambio dopo che il dollaro statunitense è balzato a un nuovo massimo in 34 anni e fornirà “misure di contrasto approfondite” secondo necessità.</p>
<p>Per quanto riguarda le materie prime, l’intensificazione continua delle tensioni geopolitiche in Medio Oriente ha soppresso l’appetito di rischio degli investitori e ha aumentato i prezzi dell’oro e del petrolio.</p>
<p>Il petrolio greggio statunitense è salito dello 0,76% a $86,06 al barile, mentre il petrolio greggio Brent è salito dello 0,69% a $90,72.</p>
<p>L’ultimo prezzo dell’oro fisico è di $2,381.50 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>