RGFpbHkgTmV3cyB8IFNPTCBQb3J0ZXLDoCBJbCBTYmxvY2NvIFN1IFNjYWxhIE1hZ2dpb3JlIE5lbGxhIFN0b3JpYSwgSSAyIE1pbGlhcmRpIERpIFNPTCBJbmNpZGVyYW5ubyBTdWwgTWVyY2F0bz8=

2025-02-25, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/174045569017.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20pi20grande20sblocco20nella20storia20di20SOL20si20avvicina20Strategy20ha20annunciato20che20aumenter20il20suo20portafoglio20di20BTC20di20altri20220miliardi204155"><a name="Crypto Daily Digest: Il più grande sblocco nella storia di SOL si avvicina, Strategy ha annunciato che aumenterà il suo portafoglio di BTC di altri $2 miliardi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il più grande sblocco nella storia di SOL si avvicina, Strategy ha annunciato che aumenterà il suo portafoglio di BTC di altri $2 miliardi</h2><p>Secondo i dati degli investitori di Farside, gli Stati Uniti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli spot ETF hanno avuto un deflusso netto di $519 milioni ieri, di cui Fidelity FBTC ha avuto un deflusso di $247 milioni e BlackRock IBIT ha avuto un deflusso di $159 milioni. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ETF spot ha avuto un deflusso di $79,4 milioni, di cui BlackRock ETHA ha avuto un deflusso di $49,5 milioni, Grayscale ETHE ha avuto un deflusso di $15,4 milioni e Bitwise ETHW ha avuto un deflusso di $9,7 milioni. Dal 2025, gli afflussi di ETF BTC ed ETH si sono rallentati settimana dopo settimana e l’ETF BTC ha avuto un deflusso netto di oltre $500 milioni per due settimane consecutive, indicando un debole outlook di mercato.</p>
<p><strong>Il più grande sblocco nella storia di SOL si avvicina, e molti VC detengono miliardi di dollari di profitti non realizzati</strong></p>
<p>Secondo Cointelegraph, <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> Il maker Wintermute ha prelevato 38,2 milioni di dollari di SOL da CEX nelle ultime 24 ore. Resta ancora una settimana prima che <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Lo sblocco di token più grande della storia (valore di 2 miliardi di dollari), con 11,2 milioni di SOL sbloccati per la circolazione l’1 marzo. I prezzi di SOL sono stati sotto pressione recentemente, scendendo di oltre il 15% nelle ultime 24 ore a un minimo di quasi tre mesi di $140.</p>
<p>L’analista di criptovalute Artchick.eth ha detto: “Più di 15 milioni di SOL (circa 2,5 miliardi di dollari) entreranno in circolazione nei prossimi tre mesi, la maggior parte dei quali sarà acquistata da istituzioni come Galaxy Digital, Pantera Capital e Figure attraverso aste FTX a 64 dollari per SOL, e molti VC realizzeranno comunque enormi profitti.”</p>
<p>Il trader RunnerXBT ha sottolineato che “Galaxy Digital, Pantera e Figure detengono profitti non realizzati rispettivamente di 3 miliardi di dollari, 1 miliardo di dollari e 150 milioni di dollari su SOL. Il mercato ipotizza che queste istituzioni possano vendere le loro posizioni, e la recente truffa della moneta meme LIBRA approvata dal presidente argentino Milley ha esacerbato il panico del mercato”.</p>
<p><strong>Bernstein: Liquidità sarà <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> dal meme al DeFi, GameFi e NFT, ottimista riguardo alle stablecoin e RWA</strong></p>
<p>La società di ricerca criptografica Bernstein ha rilasciato un rapporto di analisi affermando che “in precedenza, il mercato delle criptovalute era costretto a rivolgersi a monete meme ‘inutili’ per evitare repressioni regolamentari su token di utilità e progetti NFT, ma poiché l’amministrazione Trump allenta le regolamentazioni, gli analisti si aspettano che la liquidità torni a tracciati basati sull’utilità come DeFi (finanza decentralizzata), GameFi e NFT.”</p>
<p>“Stablecoin e tokenizzazione di asset del mondo reale (RWA) sono un altro focus, specialmente con l’attesa implementazione del quadro normativo per stablecoin e titoli di attività digitali. Le stablecoin avranno un impatto iniziale sui pagamenti transfrontalieri B2B, compensi interbancari e rimesse. Con il chiarimento della regolamentazione dei titoli crittografici, la tokenizzazione di azioni e debiti aprirà nuove vie per il finanziamento aziendale e la domanda di stablecoin come valute di regolamento aumenterà. Si prevede che le stablecoin espanderanno il potenziale mercato per piattaforme di trading e broker: l’elenco di azioni tokenizzate stimolerà la crescita del volume di trading e la domanda di stablecoin aumenterà il reddito della piattaforma.”</p>
<p><strong>La strategia ha aumentato le sue partecipazioni di 20.356 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> a un prezzo medio di $97.514</strong></p>
<p>La scorsa notte, Strategy (ex MicroStrategy) ha aumentato le sue disponibilità di 20.356 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> a un prezzo medio di $97.514, spendendo circa $2 miliardi. In precedenza, il fondatore di Strategy, Michael Saylor, ha affermato in un post che Strategy aveva completato l’emissione di $2 miliardi in obbligazioni convertibili con un tasso di interesse del 0%, un premio del 35% e un prezzo di esercizio implicito di circa $433,43.</p>
<p>Le note convertibili sono obbligazioni senior non garantite di Strategy. Non è previsto alcun interesse periodico sulle note e il capitale delle note non si accumula. Le note scadono il 1 marzo 2030, a meno che non siano riacquistate, riscattate o convertite in precedenza. Prima del 3 dicembre 2029, i detentori avranno il diritto di convertire le loro note in azioni solo in caso di determinati eventi. Strategy intende utilizzare il ricavato netto dall’offerta per scopi aziendali generali, inclusi l’acquisto di bitcoin e il capitale di lavoro.</p>
<h2 id="h2-Tendenze20di20mercato20il20prezzo20di20KAITO20ha20registrato20una20forte20performance20SOL2020sceso20di20pi20del205020rispetto20al20suo20massimo20storico12075"><a name="Tendenze di mercato: il prezzo di KAITO ha registrato una forte performance, SOL è sceso di più del 50% rispetto al suo massimo storico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il prezzo di KAITO ha registrato una forte performance, SOL è sceso di più del 50% rispetto al suo massimo storico</h2><h3 id="h3-Punti20Caldi20del20Mercato6209"><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 nuova moneta IP è salita contro la tendenza. A metà di questo mese, i token IP sono aumentati di quasi 6 volte in 4 giorni e i fondi di mercato sono stati spremuti. I token IP sono i token nativi del protocollo Story Protocol della blockchain Layer1, utilizzati per transazioni on-chain, sicurezza e governance. La capitalizzazione di mercato attuale di IP è di $1.2 miliardi, classificandosi al 63º posto nell’intero mercato. La maggior parte del volume di scambi di IP avviene in transazioni contrattuali, che sono più a rischio di manipolazione da parte dei fondi;</p>
<p>La nuova moneta KAITO ha registrato una performance relativamente forte, raggiungendo un massimo di $2 per diversi giorni consecutivi, ed è rimasta stabile intorno a $1.65 nonostante una brusca correzione del mercato. Kaito AI ha lanciato tre livelli di carte sociali, e gli utenti devono bloccare una certa quantità di token KAITO per ottenere il livello di carta corrispondente, il che ha stimolato in qualche misura l’acquisto di token KAITO.</p>
<h3 id="h3-Criptovalute20principali538813"><a name="Criptovalute principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute principali</h3><p>Il BTC ha concluso il suo shock ed è sceso bruscamente al di sotto di $91.000. Negli ultimi due mesi, il BTC è sceso in questa zona molte volte per poi riprendersi. L’indice AHR 999 di oggi è 1,02, indicando che il BTC è attualmente adatto per gli investimenti a lungo termine in investimenti a termine fisso;</p>
<p>ETH è sceso sotto la soglia dei $2.500, seguendo il declino del mercato generale;</p>
<p>Le altcoin in generale sono scese, SOL è sceso sotto i $140, più del 50% rispetto al suo massimo storico. L’entusiasmo per i concetti meme sta svanendo, e il mercato è entrato in un periodo di ripresa.</p>
<h2 id="h2-Macro20News20Le20azioni20statunitensi20sono20generalmente20scese20e20ci20si20aspetta20che20linflazione20continui20a20essere20superiore20allobiettivo20della20Fed202897"><a name="Macro News: Le azioni statunitensi sono generalmente scese, e ci si aspetta che l’inflazione continui a essere superiore all’obiettivo della Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: Le azioni statunitensi sono generalmente scese, e ci si aspetta che l’inflazione continui a essere superiore all’obiettivo della Fed</h2><p>I tre principali indici azionari statunitensi hanno oscillato, con lo S&amp;P 500 in calo dello 0,50% a 5.983,25 punti, il Dow Jones Industrial Average in rialzo dello 0,08% a 43.461,21 punti e il Nasdaq in calo dell’1,21% a 19.286,92 punti. Il rendimento del titolo di Stato decennale di riferimento era del 4,40%, mentre il rendimento del titolo di Stato a 2 anni, il più sensibile al tasso di politica della Fed, era del 4,13%.</p>
<p>Stifel, una nota banca d’investimento statunitense, ha avvertito che gli Stati Uniti probabilmente esperimenteranno la peggiore situazione economica nel 2025 e, in questo caso, il mercato azionario statunitense potrebbe crollare. Nel suo ultimo rapporto, il principale stratega patrimoniale di Stifel, Barry Bannister, ha previsto che l’indice S&amp;P 500 chiuderà intorno ai 5.500 punti alla fine del 2025. Ciò significa che l’indice scenderà di circa il 10% rispetto al suo livello attuale. Bannister ha dichiarato che è probabile che l’economia statunitense entri in un periodo di leggera stagflazione nella seconda metà di quest’anno. Il piano tariffario di Trump potrebbe far passare aumenti di prezzo ai consumatori.</p>
<p>Altri analisti di Stifel hanno dichiarato in una nota che si aspettano che l’inflazione core delle spese per consumi personali, la misura preferita dall Fed per l’inflazione, si ‘fermerà’ intorno al 2,75% nel 2025, al di sopra dell’obiettivo del 2% della Fed. Bannister ha avvertito che un’alta inflazione potrebbe impedire alla Fed di abbassare i tassi. Non si aspetta che la Fed riduca ulteriormente i tassi quest’anno.</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 relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>