Tm90aXppZSBxdW90aWRpYW5lIHwgTGUgdGFyaWZmZSByZWNpcHJvY2hlIGNvbHBpc2Nvbm8gaSBtZXJjYXRpIGdsb2JhbGkgZGVnbGkgYXNzZXQgYSByaXNjaGlvLCBCVEMgc2kgYXZ2aWNpbmEgc2VtcHJlIGRpIHBpw7kgYWxsYSBmYXNjaWEgaW5mZXJpb3Jl

2025-04-09, 03:59

<p><img src="https://gimg2.gateimg.com/image/article/17441707844.9.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Strategy20potrebbe20vendere20BTC20Aave20ha20lanciato20un20meccanismo20di20riacquisto20dei20token444695"><a name="Crypto Daily Digest: Strategy potrebbe vendere BTC, Aave ha lanciato un meccanismo di riacquisto dei token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Strategy potrebbe vendere BTC, <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> ha lanciato un meccanismo di riacquisto dei token</h2><p>Secondo i dati degli investitori di Farside, il totale deflusso netto degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gli spot ETF ieri erano $326 milioni, di cui BlackRock IBIT aveva un deflusso di $253 milioni, e gli altri ETF BTC avevano principalmente piccoli deflussi netti. Ieri, solo Fidelity FETH ha avuto un deflusso di $3.29 milioni da <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot e gli altri ETF ETH non hanno avuto afflussi o deflussi.</p>
<p>Secondo i dati alternativi, l’attuale indice di paura e avidità delle criptovalute è 18 (ieri era 24), e il sentiment di mercato continua ad essere frustrato ed è in uno stato di panico estremo.</p>
<p><strong>La strategia potrebbe essere costretta a vendere <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> per ripagare i debiti, violando la promessa di “mai vendere”</strong></p>
<p>Secondo il modulo 8-K presentato da Strategy (ex MicroStrategy) alla Securities and Exchange Commission degli Stati Uniti (SEC) il 7 aprile, se il prezzo del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> continua a diminuire, Strategy potrebbe essere costretta a vendere le sue riserve di Bitcoin per ripagare i debiti, violando la promessa di Michael Saylor di ‘mai vendere Bitcoin’. Nel suo modulo 8-K, Strategy ha dichiarato: ‘Poiché il Bitcoin costituisce una parte sostanziale degli attivi nel nostro bilancio, se non siamo in grado di ottenere finanziamenti patrimoniali o debitori a condizioni vantaggiose (o affatto) in modo tempestivo, potremmo essere costretti a vendere Bitcoin per soddisfare i nostri obblighi finanziari e potremmo doverlo vendere a un prezzo inferiore al costo o a altri prezzi sfavorevoli’.</p>
<p>Dal momento in cui Trump ha vinto le elezioni nel novembre 2024, Strategy ha acquistato 275.965 BTC (25,73 miliardi di dollari) a un prezzo medio di 93.228 dollari, e questa parte ha subito una perdita fluttuante di 4,6 miliardi di dollari. Secondo i dati di StrategyTracker, Strategy attualmente detiene 528.185 BTC, con un prezzo di costo medio di 67.458 dollari e un valore di 40,119 miliardi di dollari.</p>
<p><strong><a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> meccanismo di riacquisto del token lanciato, con un budget di riacquisto del primo mese che raggiunge $4 milioni</strong></p>
<p>Secondo la pagina ufficiale di governance di <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a>, la proposta di Aave DAO di autorizzare il Comitato Finanziario (AFC) a concedere $4 milioni in aEthUSDT per lanciare la prima fase del programma di buyback e distribuzione Aavenomics è stata approvata. Il programma mira a riacquistare AAVE dal mercato aperto e distribuirlo alla riserva dell’ecosistema, migliorando così gli incentivi di governance e la salute del protocollo.</p>
<p>Questa autorizzazione iniziale supporterà le operazioni di riacquisto per circa un mese, lasciando tempo di margine per il futuro dispiegamento dei nuovi contratti di Aave Swapper. Ci si aspetta che il programma completo continui ad avanzare a un ritmo fino a $1 milione a settimana per sei mesi. La proposta consente all’AFC di iniziare ad eseguire la prima fase del programma di riacquisto, approvando $4 milioni in aEthUSDT per circa un mese di riacquisti di AAVE.</p>
<p><strong>L’impatto dei dazi reciproci ha causato una contrazione del valore complessivo dei mercati azionari globali di 10 trilioni di dollari</strong></p>
<p>Secondo le statistiche di Bloomberg, i cosiddetti “dazi reciproci” annunciati dagli Stati Uniti hanno fortemente colpito il mercato internazionale del capitale. Dal 3 di questo mese, la capitalizzazione di mercato delle azioni globali è diminuita di $10 trilioni, leggermente più della metà del PIL dell’UE. Tra queste, il mercato azionario statunitense stesso ha subito pesanti perdite, e la capitalizzazione di mercato dei sette giganti della tecnologia nel mercato azionario statunitense è evaporata di circa $1,65 trilioni durante questo periodo. Tra questi, la produzione di prodotti Apple è fortemente dipendente dalla catena di approvvigionamento oltremare degli Stati Uniti. Negli ultimi quattro giorni di contrattazione, il suo prezzo delle azioni è diminuito di quasi il 23%.</p>
<p>Colpiti dall’impatto della politica, il panico si diffuse nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato criptovalute</a>. Il settore delle criptovalute è generalmente sceso di circa il 3% al 10% nelle ultime 24 ore. Tra questi, ETH è sceso sotto i $1,400, toccando il punto più basso da marzo 2023. BTC è sceso nuovamente sotto la soglia dei $75,000.</p>
<h2 id="h2-Tendenze20di20mercato20la20capitalizzazione20di20mercato20di20RFC20ha20superato20i206020milioni20di20dollari20e20BTC20si20avvicina20sempre20di20pi20alla20fascia20inferiore529371"><a name="Tendenze di mercato: la capitalizzazione di mercato di RFC ha superato i 60 milioni di dollari e BTC si avvicina sempre di più alla fascia inferiore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: la capitalizzazione di mercato di RFC ha superato i 60 milioni di dollari e BTC si avvicina sempre di più alla fascia inferiore</h2><h3 id="h3-Punti20Caldi20del20Mercato452254"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> La catena meme coin RFC è recentemente decollata, con la sua capitalizzazione di mercato che ha superato i 60 milioni di dollari in un certo momento. RFC sta per Retard Finder Coin. Il token è stato emesso su Pumpfun alla fine di marzo e finora è aumentato più di mille volte. Il conto ufficiale di Twitter di RFC ha ricevuto molte interazioni da Musk stesso nei giorni recenti, il che ha portato una breve esposizione al token RFC. Le meme coin di per sé non hanno valore e affidarsi esclusivamente all’esposizione generata dalle celebrità non può ottenere un supporto di valore a lungo termine.</p>
<p>Il token concetto RWA PLUME ha avuto una forte performance durante la giornata. Secondo le notizie di mercato, l’agenzia di gestione patrimoniale Apollo ha annunciato un investimento strategico in Plume. Questo investimento è stato effettuato dopo che Plume ha annunciato un finanziamento di Serie A da 20 milioni di dollari alla fine dello scorso anno. Inoltre, il co-fondatore di Plume ha dichiarato che il mainnet della rete Plume è programmato per essere lanciato questo trimestre.</p>
<h3 id="h3-Valute20principali565918"><a name="Valute principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Valute principali</h3><p>BTC’s volatilità intraday si è intensificata, scendendo da $81,000 a circa $75,000 di nuovo, e l’ETF BTC ha registrato deflussi netti per quattro giorni consecutivi; l’indice AHR999 di oggi è 0,63, avvicinandosi alla fascia di pesca in basso dell’indice;</p>
<p>ETH ha seguito le fluttuazioni del mercato, scendendo sotto la soglia di $1.400 durante la giornata, e il tasso di cambio ETH/BTC è sceso sotto lo 0,019, continuando a segnare un nuovo minimo in quasi quattro anni;</p>
<p>Le altcoin sono generalmente scese e il mercato è stato privo di punti caldi.</p>
<h2 id="h2-Macro20News20le20azioni20statunitensi20hanno20aperto20in20rialzo20e20poi20sono20scese20Nasdaq20e20SampP2050020sono20entrati20in20un20mercato20ribassista806835"><a name="Macro News: le azioni statunitensi hanno aperto in rialzo e poi sono scese, Nasdaq e S&amp;P 500 sono entrati in un mercato ribassista" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: le azioni statunitensi hanno aperto in rialzo e poi sono scese, Nasdaq e S&amp;P 500 sono entrati in un mercato ribassista</h2><p>Sebbene i tre principali indici azionari statunitensi siano aumentati di circa il 4% durante la sessione, alla fine non sono riusciti a rompere la tendenza di apertura alta e chiusura bassa. Al momento della chiusura, il Dow Jones Industrial Average è sceso dello 0,84% a 37.645,59 punti; l’S&amp;P 500 è sceso dell’1,57% a 4.982,77 punti, chiudendo al di sotto dei 5.000 punti per la prima volta da aprile dello scorso anno; e il Nasdaq Composite è sceso del 2,15% a 15.267,91 punti.</p>
<p>Questa settimana, sia il Nasdaq che l’S&amp;P 500 sono entrati in un mercato ribassista. A medio e lungo termine, Wall Street si chiede se si tratti di un mercato ribassista una tantum o dell’inizio di un mercato ribassista ciclico. Gli analisti del team strategico di Goldman Sachs hanno affermato che, con l’aumento del rischio di recessione economica, è probabile che il sell-off delle azioni statunitensi si evolva in un mercato ribassista ciclico più persistente. A differenza di uno shock una tantum guidato da eventi, un mercato ribassista ciclico riflette i cambiamenti nel ciclo economico stesso.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Glassa 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>