Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGhhIHRvY2NhdG8gJDY0LDAwMCwgRVRIIMOoIHRvcm5hdG8gYSAkMyw0MDA7IElsIGdvdmVybm8gZGVnbGkgU3RhdGkgVW5pdGkgaGEgdHJhc2Zlcml0byAxIG1pbGlhcmRvIGRpIEJUQyBkYSBwb3J0YWZvZ2xpIGhhY2tlciBzZXF1ZXN0cmF0aSBwZXIgc2NvcGkgc2Nvbm9zY2l1dGk=

2024-02-29, 06:45

<p><img src="https://gimg2.gateimg.com/image/article/17091888141_20.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Bitcoin20ha20raggiunto206400020il20volume20di20trading20degli20ETF20ha20raggiunto20un20nuovo20record20Il20governo20degli20Stati20Uniti20ha20trasferito20120miliardo20di20BTC20dai20portafogli20dei20hacker20sequestrati20per20scopi20sconosciuti31961"><a name="Riepilogo giornaliero delle criptovalute: Bitcoin ha raggiunto $64.000, il volume di trading degli ETF ha raggiunto un nuovo record; Il governo degli Stati Uniti ha trasferito 1 miliardo di BTC dai portafogli dei hacker sequestrati per scopi sconosciuti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha raggiunto $64.000, il volume di trading degli ETF ha raggiunto un nuovo record; Il governo degli Stati Uniti ha trasferito 1 miliardo di BTC dai portafogli dei hacker sequestrati per scopi sconosciuti</h2><p>Il 29 febbraio, il prezzo del BTC ha toccato i 64.000 USDT, per poi tornare a 59.000 USDT, attualmente oscillando intorno ai 61.400 USDT, con una quota di mercato del 50,42% (fonte dati: CoinGecko); ETH è tornato sopra i 3.400 USDT, con un aumento del 24 ore di circa il 5%; Attualmente, Microstrategy è la società quotata con le maggiori partecipazioni di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nel mondo, con un possesso totale di circa 193.000 Bitcoin del valore di oltre 10 miliardi di dollari, il che ha portato a un aumento del prezzo delle sue azioni.</p>
<p>In termini di attività di trading di Bitcoin ETF, secondo i dati degli investitori di Farsid, il 28 febbraio, l’uscita di GBTC è stata di circa 216 milioni di dollari, l’ingresso di ARK 21Shares Bitcoin spot ETF (ARKB) è stato di 23,8 milioni di dollari ieri e l’ingresso netto di WisdomTree Bitcoin spot ETF (BTCW) è stato di 2,2 milioni di dollari. Fidelity Bitcoin spot ETF (FBTC) ha avuto un ingresso di 245 milioni di dollari ieri.</p>
<p>L’analista ETF di Bloomberg James Seyfart ha pubblicato sulla piattaforma X che il volume di trading degli ETF spot di Bitcoin ha raggiunto ieri un massimo storico di $7,69 miliardi.</p>
<p>Secondo il monitoraggio di Arkham, il governo degli Stati Uniti ha intrapreso azioni on-chain inspiegabili. Nell’infame incidente di hacking di Bitfinex, il governo degli Stati Uniti ha confiscato portafogli Bitcoin. Almeno tre portafogli contrassegnati da Arkham rappresentano il sequestro da parte del governo dei fondi di hacking di Bitfinex, con un portafoglio che ha inizialmente trasferito 1 BTC intorno alle 18:39 World Standard Time. Circa mezz’ora dopo, i restanti 2.817 BTC nel portafoglio sono stati inviati, lasciando il portafoglio vuoto, il che significa che hanno inviato circa 173 milioni di dollari di Bitcoin.</p>
<p>Successivamente, un altro portafoglio contenente circa 12.300 BTC ha trasferito 0,01 BTC a un altro indirizzo non identificato e poco dopo anche il resto dei BTC è stato inviato. Sulla base dei prezzi attuali delle principali criptovalute, questi trasferimenti valgono circa 750 milioni di dollari, portando il valore totale dei trasferimenti di Bitcoin dai due portafogli a quasi 1 miliardo di dollari.</p>
<p>Attualmente, lo scopo e la motivazione di questo trasferimento di fondi non sono noti.</p>
<p>C’è un nuovo progresso nel caso di fallimento di Gemini, un exchange di criptovalute. Come parte del protocollo di transazione con il Dipartimento dei Servizi Finanziari di New York (NYDFS), Gemini restituirà almeno 1,1 miliardi di dollari ai clienti che hanno subito perdite a causa del fallimento del suo piano di prestiti e pagherà 37 milioni di dollari di multe regolamentari per pratiche non sicure e non sane.</p>
<p>Gemini Trust ha pubblicato sulla piattaforma X affermando che se approvato dal tribunale fallimentare, tutti gli utenti di Gemini Earn riceveranno il 100% dei loro asset digitali restituiti in forma fisica.</p>
<p>Il programma Earn è stato fornito in collaborazione con l’istituzione di prestiti di criptovalute Genesis Global Capital ma è stato interrotto durante il crollo del mercato delle criptovalute nel novembre 2022. Questo caos ha portato Genesis a presentare istanza di fallimento e a una diffusa contesa legale tra Genesis, Gemini e la sua società madre.</p>
<h2 id="h2-Tendenze20di20mercato20esplosione20doppia20di20lunga20e20corta20durata20il20sentimento20del20mercato20delle20criptovalute20accoglie20FOMO652566"><a name="Tendenze di mercato: esplosione doppia di lunga e corta durata, il sentimento del mercato delle criptovalute accoglie FOMO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: esplosione doppia di lunga e corta durata, il sentimento del mercato delle criptovalute accoglie FOMO</h2><p>La scorsa notte di trading, i prezzi del BTC sono saliti a $64.000, ma poi sono rapidamente scesi, con posizioni lunghe e corte che superano i $700 milioni. Rispetto al volume di liquidazione giornaliero precedente di $100-$200 milioni, questo numero indica chiaramente che il sentiment di mercato sta iniziando a mostrare segni di FOMO.<br><img src="https://gimg2.gateimg.com/image/article/1709188957mlbCsT4cP4.jpg" alt=""><br>Sorgente: Coinglass</p>
<p>L’aumento giornaliero di BTC supera il 10%, portando ad un rapido aumento dei tassi contrattuali, e i tassi contrattuali complessivi del mercato hanno raggiunto un punto alto in un mercato rialzista di 21 anni. Allo stesso tempo, il calo complessivo delle azioni statunitensi ha portato il mercato ad aspettare il rilascio dei dati sull’inflazione alle 21:30 di stasera, che potrebbe avere un ulteriore impatto sul sentiment di mercato.</p>
<h3 id="h3-Punti20caldi20del20mercato336717"><a name="Punti caldi del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato</h3><ol>
<li><p>Il mercato vampiro di BTC, con continuo afflusso di ETF spot: Recentemente, i prezzi del BTC sono aumentati, attirando oltre 600 milioni di dollari di afflussi di capitale per diversi giorni consecutivi. La quota di mercato del BTC (BTCD) ha raggiunto anche un nuovo massimo del 55%. Quando il BTCD diminuirà, spesso indica l’arrivo del mercato delle Altcoin.<br><img src="https://gimg2.gateimg.com/image/article/1709188879bFKgeUD0Bh.jpg" alt=""><br>Fonte: Bloomberg</p>
</li><li><p>Il concetto di AI continua a essere caldo: ARKM, AR, FET, WLD e altri token correlati hanno visto un significativo aumento, con ARKM che ha superato i $2,3 e raggiunto un massimo storico. Nonostante un forte calo durante la notte, il rimbalzo a V diretto del 50% di ARKM ha stabilito la posizione di leadership del concetto di AI in questa fase. Il mese scorso, solo i concetti di AI e Meme hanno superato il tasso di crescita di BTC.</p>
</li><li><p>Il concetto di Meme continua ad essere attivo: i token del concetto di Meme come PEPE, WIF e BONK continuano a salire. Il mercato sta gradualmente iniziando a prestare attenzione alle potenziali opportunità di passaggio degli ETF ETH, indicando che potrebbero esserci più opportunità per il concetto di Meme su ETH.</p>
</li><li><p>Fine e ripresa dell’aggiustamento del SOL: l’aggiustamento del prezzo del SOL termina e riprende la salita, il che spinge anche la salita di BONK. BONK è il leader dei Meme su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain, mentre WIF si classifica al secondo posto.</p>
</li></ol>
<p>Il trend di mercato mostra che il sentiment di mercato si sta spostando verso uno stato di FOMO. Allo stesso tempo, i concetti di AI e Meme continuano ad essere attivi. Gli utenti di Gate.io dovrebbero monitorare attentamente i trend di questi concetti popolari e cercare possibili opportunità di investimento.</p>
<h2 id="h2-Macro20Oggi20sono20stati20pubblicati20i20dati20chiave20sullinflazione20negli20Stati20Uniti20la20Fed20afferma20che20c20ancora20la20possibilit20di20tagli20ai20tassi20di20interesse20pi20avanti20questanno945215"><a name="Macro: Oggi sono stati pubblicati i dati chiave sull’inflazione negli Stati Uniti, la Fed afferma che c’è ancora la possibilità di tagli ai tassi di interesse più avanti quest’anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Oggi sono stati pubblicati i dati chiave sull’inflazione negli Stati Uniti, la Fed afferma che c’è ancora la possibilità di tagli ai tassi di interesse più avanti quest’anno</h2><p>Il prezzo dell’oro è rimasto stabile giovedì. Gli operatori stanno aspettando che venga rilasciato più tardi quel giorno l’indicatore di inflazione preferito dalla Federal Reserve, il che potrebbe fornire nuovi spunti su quando la Fed inizierà a tagliare i tassi di interesse. L’oro spot è rimasto stabile a $2.035,78 per oncia. I futures statunitensi sono saliti dello 0,1% a $2.044,20.</p>
<p>In termini di materie prime, l’improvviso aumento delle scorte di petrolio grezzo negli Stati Uniti ha sollevato preoccupazioni riguardo alla diminuzione della domanda, un calo dei prezzi del petrolio e segnali che i tassi di interesse negli Stati Uniti potrebbero rimanere alti per un periodo più lungo hanno aggiunto pressione. I future del petrolio greggio Brent sono scesi di 22 centesimi, o dello 0,3%, a $83,46 al barile. I future del petrolio greggio West Texas Intermediate negli Stati Uniti sono scesi di 30 centesimi, o dello 0,4%, a $78,24 al barile.</p>
<p>I dati pubblicati mercoledì hanno mostrato che grazie alla forte spesa dei consumatori, l’economia degli Stati Uniti è cresciuta costantemente nel quarto trimestre; John Williams, presidente della Federal Reserve Bank di New York, ha affermato che sebbene ci sia ancora un po’ di strada da fare per raggiungere l’obiettivo di inflazione del 2% della Federal Reserve, i tassi di interesse potrebbero ancora essere tagliati quest’anno, a seconda dei dati futuri.</p>
<p>La presidente della Federal Reserve di Boston, Susan Collins, ha dichiarato che la Federal Reserve potrebbe dover iniziare a tagliare i tassi di interesse più tardi quest’anno, e almeno altri sette funzionari della Fed terranno discorsi giovedì e venerdì.</p>
<p>A differenza delle aspettative all’inizio dell’anno che la Federal Reserve avrebbe tagliato i tassi di interesse per la prima volta a marzo. Questa aspettativa è stata ora posticipata a giugno.</p>
<p>I mercati azionari asiatici sono principalmente deboli giovedì, mentre il dollaro americano e i titoli del Tesoro statunitensi rimangono in gran parte stabili. Gli Stati Uniti rilasceranno dati chiave sull’inflazione, che potrebbero fornire nuovi indizi su quando la Federal Reserve ridurrà i tassi di interesse. Tuttavia, il mercato azionario cinese ha recuperato dal brusco calo di mercoledì e si prevede che raggiunga la sua migliore performance mensile da novembre 2022. L’incontro annuale del Congresso Nazionale del Popolo della prossima settimana stabilirà gli obiettivi di crescita per quest’anno e svilupperà piani per raggiungerli, fornendo i segnali più chiari delle misure di stimolo governative.</p>
<p>L’Hang Seng Index di Hong Kong (HSI) è salito dello 0,44%, mentre l’indice MSCI Minsheng Asia Pacific (escluso il Giappone) (. MIAPJ0000PUS) è salito leggermente dello 0,06%.</p>
<p>Nel frattempo, lo yen è salito mentre i funzionari della Banca del Giappone hanno lasciato intendere la necessità di ritirarsi dalla politica monetaria estremamente accomodante. Gli analisti e gli investitori si aspettano che la Banca del Giappone si ritiri dalla sua politica di tassi di interesse negativi in aprile, ma c’è anche la possibilità di agire a marzo.</p>
<p>Dopo che tutti e tre i principali indici azionari statunitensi sono scesi durante la notte, i future sugli indici azionari statunitensi sono leggermente diminuiti. I future sull’indice Standard &amp; Poor’s 500 sono scesi dello 0,04%, mentre i future sull’indice Nasdaq sono scesi dello 0,06%. Gli investitori rimangono cauti fino alla pubblicazione dell’indice dei prezzi delle spese per il consumo personale (PCE) core in seguito oggi.</p>
<p>I dati sull’inflazione per Germania, Francia e Spagna saranno resi noti anche giovedì, e i dati sull’inflazione della zona euro saranno resi noti venerdì.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</strong>, Ricercatore presso 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 sia fatto riferimento a Gate.io. In tutti i casi, saranno adottate azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>