Tm90aXppZSBnaW9ybmFsaWVyZSB8IEJUQyBoYSBvc2NpbGxhdG8gZSBzaSDDqCByaXRpcmF0byBkaSBudW92bywgbGEgY3Jlc2NpdGEgZGVpIG5vbiBhZ3JpY29saSBuZWdsaSBTdGF0aSBVbml0aSBoYSBzdXBlcmF0byBsZSBhc3BldHRhdGl2ZQ==

2025-05-05, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/17464158275.5.webp" alt="">
</p><h2 id="h2-Crypto20Daily20Digest20Gli20analisti20dicono20che20Bitcoin20potrebbe20superare20la20dominanza20delloro20in20qualsiasi20momento20Trump20ha20ribadito20il20suo20sostegno20alle20criptovalute990566"><a name="Crypto Daily Digest: Gli analisti dicono che Bitcoin potrebbe superare la dominanza dell’oro in qualsiasi momento, Trump ha ribadito il suo sostegno alle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Gli analisti dicono che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> potrebbe superare la dominanza dell’oro in qualsiasi momento, Trump ha ribadito il suo sostegno alle criptovalute</h2><p>Secondo i dati degli investitori di Farside, l’ingresso totale di US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gli ETF spot lo scorso venerdì sono stati di $674 milioni. Tra di essi, l’afflusso di BlackRock IBIT è stato di $674 milioni, mentre l’afflusso e deflusso degli altri ETF erano trascurabili. Lo scorso venerdì, l’afflusso degli ETF ETH è stato di $20,1 milioni, di cui BlackRock ETHA ha avuto un afflusso netto di $20,1 milioni, e gli altri ETF non hanno avuto dati di afflusso e deflusso.</p>
<p><strong>Fedelta: Il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> potrebbe superare la dominanza dell’oro in qualsiasi momento</strong></p>
<p>Fidelity ha recentemente lasciato intendere che Bitcoin potrebbe presto prendere il testimone dell’oro. Jurrien Timmer, direttore macro globale di Fidelity Investments, ha recentemente pubblicato un’analisi dettagliata della relazione dinamica tra Bitcoin e l’oro. Ha citato dati da Fidelity Management and Research Company (FMR Co) e Bloomberg, analizzato i cambiamenti delle tendenze del rapporto di Sharpe (un indicatore dei rendimenti corretti per il rischio) dei due asset, e ha sottolineato che le loro performance relative potrebbero essere a un punto di svolta.</p>
<p>Il grafico che ha condiviso mostra che il ritorno recente dell’oro è di $22.51, mentre quello del Bitcoin è di $13.22, dove il ritorno dell’oro è moltiplicato per 4 volte per riflettere la sua minore volatilità, mentre il ritorno del Bitcoin non è proporzionalmente regolato e rimane a 1 volta. Il suo commento dice: “Sembra che questo possa essere il momento principale del Bitcoin, poiché il suo rapporto di Sharpe è attualmente -0.40, mentre quello dell’oro è 1.33. Pertanto, potremmo essere testimoni di un passaggio di testimone dall’oro al Bitcoin.”</p>
<p><strong>Trump ha ribadito il sostegno alle criptovalute</strong></p>
<p>Trump ha recentemente ribadito il suo sostegno alle criptovalute, affermando che gli asset crittografici sono stati resilienti durante i ribassi di mercato e ora sono ampiamente accettati. Ha detto che gli Stati Uniti devono rimanere in testa all’innovazione degli asset digitali, altrimenti rimarranno indietro rispetto a paesi come la Cina.</p>
<p>Trump ha detto in un’intervista a “Meet the Press” di NBC News: “Penso che le criptovalute siano importanti perché se non lo facciamo, la Cina lo farà. È qualcosa di nuovo, molto popolare e molto caldo.” Ha aggiunto che le criptovalute hanno avuto prestazioni “molto migliori rispetto al resto del mercato” durante il ribasso di mercato.</p>
<p><strong>Michael Saylor potrebbe suggerire di aumentare nuovamente le proprie detenzioni di BTC</strong></p>
<p>Michael Saylor, fondatore di Strategy, ha nuovamente rilasciato informazioni sul Bitcoin Tracker. Ha detto: “Troppo blu, non abbastanza arancione”. Secondo le regole precedenti, Strategy divulga sempre informazioni sull’aumento delle sue partecipazioni in Bitcoin il giorno dopo la pubblicazione delle notizie rilevanti.</p>
<h2 id="h2-Tendenze20di20mercato20BTC2020fluttuato20al20ribasso20e20in20generale20le20Altcoins20sono20diminuite373813"><a name="Tendenze di mercato: BTC è fluttuato al ribasso e in generale le Altcoins sono diminuite" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC è fluttuato al ribasso e in generale le Altcoins sono diminuite</h2><h3 id="h3-Punti20Caldi20del20Mercato587400"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Token come ENA, SPEC e MOVE verranno sbloccati in grandi quantità la prossima settimana, tra cui ENA vale approssimativamente $50 milioni. Lo sblocco dei fondi potrebbe mettere pressione su alcuni token correlati;</p>
<p>SXT ha annunciato che il 28% dei token totali SXT sarà utilizzato per premi della comunità, inclusi reclami retroattivi e premi di staking. Il 51,7% dei token totali è allocato ai partecipanti che contribuiscono all’ecosistema, che utilizzino la rete, sviluppino progetti o supportino la sua crescita.</p>
<h3 id="h3-Criptovalute20mainstream232314"><a name="Criptovalute mainstream" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute mainstream</h3><p>BTC ha oscillato al ribasso e, dopo una diminuzione, è rimasto sopra i $94.000 durante la sessione. La settimana scorsa, il rally di Bitcoin è ripartito, ma l’opinione generale del mercato è che si tratti più di un’inversione che di un rimbalzo. Secondo i dati di Alternative.me, l’indice di paura e avidità delle criptovalute di oggi è sceso a 52 (ieri era 64), indicando che il mercato si trova in uno stato “neutro”. Tuttavia, secondo i dati di Coinglass, i tassi di finanziamento attuali delle principali piattaforme CEX e DEX mostrano che il mercato si è ribaltato al ribasso in generale;</p>
<p>ETH ha seguito i movimenti del mercato senza alcuna tendenza indipendente, continuando a consolidarsi intorno ai $1.800;</p>
<p>Le altcoin in generale sono scese e non hanno sviluppato un trend indipendente. La tanto attesa stagione delle altcoin non si vede ancora da nessuna parte.</p>
<h2 id="h2-Macro20news20le20azioni20statunitensi20hanno20continuato20a20salire20per20diversi20giorni20e20la20crescita20dei20salari20non20agricoli20ha20superato20le20aspettative53293"><a name="Macro news: le azioni statunitensi hanno continuato a salire per diversi giorni e la crescita dei salari non agricoli ha superato le aspettative" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro news: le azioni statunitensi hanno continuato a salire per diversi giorni e la crescita dei salari non agricoli ha superato le aspettative</h2><p>Le azioni statunitensi hanno esteso il loro rally plurigiornaliero venerdì, con il Dow, lo S&amp;P 500 e il Nasdaq Composite in aumento di almeno l’1,4%. Lo S&amp;P 500 ha chiuso più in alto per la nona sessione consecutiva, la sua serie vincente più lunga dal 2004 e ha recuperato un forte calo dopo che il presidente Trump ha annunciato ampie restrizioni commerciali all’inizio di aprile.</p>
<p>La notizia è arrivata dopo che i salari non agricoli statunitensi sono aumentati più del previsto, suggerendo che il mercato del lavoro rimane resiliente nonostante le turbolenze causate dalle politiche commerciali dell’amministrazione Trump. I dati hanno mostrato che l’occupazione è aumentata di 177.000 posti di lavoro il mese scorso dopo che la crescita occupazionale di marzo è stata revisionata al ribasso a 185.000. Gli economisti avevano previsto un aumento di 138.000 posti di lavoro. Nel frattempo, la Cina ha detto la settimana scorsa che stava valutando la possibilità di colloqui commerciali con gli Stati Uniti, aggiungendo che ogni dialogo deve essere basato sulla sincerità e sulla rimozione dei dazi unilaterali.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Orisi 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><div></div>Gate.io si riserva tutti i diritti su questo articolo. Il repost dell’articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br><p></p><br></em></div></div></div></div>