Tm90aXppZSBnaW9ybmFsaWVyZSB8IFNFQyBoYSBhcHByb3ZhdG8gdHJlIEVURiBmdXR1cmVzIFhSUCwgaWwgdG9rZW4gTGF5ZXIxIFNVSSBpbiB0ZW5kZW56YSBhY2NvZ2xpZXLDoCB1biBncmFuZGUgc2Jsb2Njbw==

2025-04-28, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/17458120984.26.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20ETF20BTC20ha20afflussi20di20oltre20320miliardi20in20una20sola20settimana20e20SUI20sbloccher20quasi2026020milioni20in20token20questa20settimana868613"><a name="Crypto Daily Digest: ETF BTC ha afflussi di oltre $3 miliardi in una sola settimana, e SUI sbloccherà quasi $260 milioni in token questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: ETF BTC ha afflussi di oltre $3 miliardi in una sola settimana, e SUI sbloccherà quasi $260 milioni in token questa settimana</h2><p>Secondo i dati degli investitori di Farside, la settimana scorsa, gli Stati Uniti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno ricevuto un flusso totale di $3.033 miliardi, con un aumento totale di 33.462 BTC. Tra questi, BlackRock IBIT ha aumentato le proprie partecipazioni di 15.380 e Fidelity FBTC ha aumentato le proprie partecipazioni di 6.412. Da febbraio di quest’anno, gli ETF BTC hanno mostrato un trend unilaterale di deflusso netto. La scorsa settimana, il flusso di capitale si è invertito per la prima volta e il sentiment di mercato futuro è relativamente ottimista.</p>
<p>La settimana scorsa, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF ha ricevuto un afflusso di $205 milioni, con un aumento totale di 88.400 ETH. Tra questi, BlackRock ETHA ha aumentato la propria partecipazione di 35.000 ETH e Grayscale ETH ha aumentato la propria partecipazione di 19.500 ETH. Dopo nove settimane consecutive di afflussi netti, l’ETF ETH ha ottenuto un grande afflusso netto per la prima volta.</p>
<p><strong>Opinione: Il basso volume di ricerca di Google su <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> mostra che il mercato attuale non è guidato dagli investitori al dettaglio</strong></p>
<p>Hunter Horsley, CEO di Bitwise, ha pubblicato sulla piattaforma X che il prezzo del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha raggiunto $94,000, ma il numero di ricerche per “Bitcoin” su Google è vicino a un minimo di lungo termine. I dati mostrano che questa fase di aumento del BTC non è guidata dagli investitori al dettaglio. I tipi di investitori che <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquistare Bitcoin</a> stanno diventando sempre più diversificati, con istituzioni, consulenti di investimento, aziende e entità nazionali che entrano nel mercato.</p>
<p>Inoltre, secondo Cointelegraph, la capitalizzazione di mercato delle stablecoin è aumentata di $4.58 miliardi in soli una settimana, avvicinandosi al traguardo dei $240 miliardi. Le principali stablecoin come USDT e USDC continuano a guidare la crescita del mercato.</p>
<p><strong>La SEC degli Stati Uniti ha approvato tre <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> futures ETFs from ProShares Trust</strong></p>
<p>In precedenza, la SEC degli Stati Uniti ha approvato l’<a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> ETF di ProShares Trust, che è una serie di tre ETF futures: ProShares UltraShort <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> ETF, ProShares Ultra XRP ETF e ProShares Short XRP ETF, che forniranno agli investitori un modo per ottenere esposizione ai rendimenti XRP senza detenere direttamente token XRP.</p>
<p>Il fondo negoziato in borsa ProShares Ultra XRP fornirà il doppio del rendimento dei prezzi dei future di XRP, il fondo negoziato in borsa ProShares UltraShort XRP fornirà il doppio del rendimento inverso dei prezzi dei future di XRP e il fondo negoziato in borsa ProShares Short XRP fornirà il rendimento inverso dei prezzi dei future di XRP. Questi tre ETF futures sono programmati per essere ufficialmente quotati e scambiati il 30 aprile 2025.</p>
<p><strong>Riepilogo dei dati di sblocco di questa settimana: SUI sbloccherà token del valore di $259 milioni</strong></p>
<p>Secondo i dati di sblocco dei token, questa settimana i token come SUI, OP e ZETA avranno uno sblocco su larga scala una tantum, compreso:</p>
<p>Sui (SUI) sbloccherà 74 milioni di token alle 8:00 del 1° maggio, del valore approssimativo di $259 milioni, corrispondente al 2,28% della circolazione;</p>
<p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> (OP) sbloccherà 31,34 milioni di token alle 8:00 del 30 aprile, del valore approssimativo di $24,32 milioni, pari al 1,89% della circolazione;</p>
<p>ZetaChain (ZETA) sbloccherà 44,26 milioni di token alle 8:00 del 1 maggio, del valore approssimativo di $11,1 milioni, corrispondenti al 5,67% della circolazione;</p>
<p>Ethena (ENA) sbloccherà 40,63 milioni di token alle 15:00 del 2 maggio, del valore approssimativo di $13,98 milioni, corrispondenti al 0,73% della circolazione.</p>
<h2 id="h2-Tendenze20di20mercato20PENGU2020salito20di20oltre20il2030020questo20mese20e20BTC2020ancora20adatto20per20investimenti20fissi253123"><a name="Tendenze di mercato: PENGU è salito di oltre il 300% questo mese, e BTC è ancora adatto per investimenti fissi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: PENGU è salito di oltre il 300% questo mese, e BTC è ancora adatto per investimenti fissi</h2><h3 id="h3-Punti20Caldi20del20Mercato542748"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>La criptovaluta meme PENGU è in costante aumento da diversi giorni, con un aumento massimo di oltre il 300% rispetto al punto più basso all’inizio del mese, diventando una delle migliori criptovalute meme delle ultime volte; PENGU è il token airdrop del noto progetto NFT Pudgy Penguins, con una capitalizzazione di mercato circolante attuale di $780 milioni, classificandosi al 84° posto nell’intero mercato; i token emessi dal progetto NFT stesso non hanno altre utilità di token e scenari di consumo oltre agli airdrop, ed è quasi impossibile uscire dalla spirale positiva in aumento. Il futuro di PENGU rimane da vedere;</p>
<p>Il token del <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Strumento on-chain Chain Bubblemaps, BMT, è aumentato di oltre il 50% nella giornata, per poi ridurre i guadagni al 20%; la capitalizzazione di mercato circolante attuale di BMT è solo di $37 milioni, posizionandosi al 604° posto nell’intero mercato; BMT è stato lanciato alla fine di marzo e il suo prezzo attuale è sceso di oltre il 60% rispetto al suo massimo storico.</p>
<h3 id="h3-Monete20principali332249"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è entrato nell’intervallo di correzione. La settimana scorsa, l’ETF BTC ha avuto un afflusso settimanale di oltre 3 miliardi di dollari, e il sentiment di mercato è ottimista. L’indice AHR999 di oggi è 0,91, indicando che il prezzo attuale è adatto per gli investitori a lungo termine;</p>
<p>ETH è leggermente sceso a seguito del mercato. Anche se ETH è salito di più di $500 dal suo punto più basso all’inizio del mese, il trend al ribasso di ETH/BTC non si è invertito;</p>
<p>Le altcoin in generale hanno fatto marcia indietro. Il mercato di oggi non è riuscito a formare una crescita diffusa nel settore. TRUMP e MELANIA sono entrambi indietreggiati.</p>
<h2 id="h2-Macro20News20le20azioni20statunitensi20hanno20registrato20un20forte20rimbalzo20con20attenzione20al20rapporto20sui20salari20non20agricoli20di20venerd826665"><a name="Macro News: le azioni statunitensi hanno registrato un forte rimbalzo, con attenzione al rapporto sui salari non agricoli di venerdì" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: le azioni statunitensi hanno registrato un forte rimbalzo, con attenzione al rapporto sui salari non agricoli di venerdì</h2><p>La scorsa settimana, mentre il discorso di Trump ha attenuato le preoccupazioni degli investitori sull’escalation della guerra commerciale tra Cina e Stati Uniti e sul danno all’indipendenza della Federal Reserve, le azioni statunitensi hanno registrato un forte rimbalzo. L’indice S&amp;P 500 è salito del 4,5% nella settimana, il Dow Jones Industrial Average è salito del 2,5% e il Nasdaq Composite Index, dominato dalle azioni tecnologiche, ha avuto una performance particolarmente positiva, salendo del 6,6%.</p>
<p>Dopo che gli indici azionari principali hanno praticamente recuperato le perdite prima dell’annuncio dei dazi dell’2 aprile, il mercato si prepara a una settimana di intensa pubblicazione di dati economici e relazioni sugli utili delle aziende. L’occupazione ADP negli Stati Uniti ad aprile e l’indice dei prezzi al consumo PCE core negli Stati Uniti a marzo verranno pubblicati il 30 aprile ora di Pechino; le buste paga non agricole e il tasso di disoccupazione negli Stati Uniti ad aprile saranno pubblicati il 2 maggio.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing T.</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. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripost del articolo sarà consentito a condizione che Gate.io venga citato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>