Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgRmVkIGhhIG1vc3RyYXRvIHVuYSBwb3NpemlvbmUgZmFsY29uaWFuYSBzdWwgdGFnbGlvIGRlaSB0YXNzaSBkaSBpbnRlcmVzc2UsIGxhIGNhcGl0YWxpenphemlvbmUgZGkgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgw6ggZGltaW51aXRhIGRpIG9sdHJlIGlsIDcsNSUsIHR1dHRpIGUgdHJ

2024-12-19, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/173458041412.19.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Powell20ha20mostrato20unaffermazione20falconiana20Bitcoin2020sceso20sotto20la20soglia20dei2010000020dollari20con20la20capitalizzazione20di20mercato20delle20criptovalute20che2020scesa20sotto20i203720trilioni20di20dollari726691"><a name="Crypto Daily Digest: Powell ha mostrato un’affermazione falconiana, Bitcoin è sceso sotto la soglia dei 100.000 dollari, con la capitalizzazione di mercato delle criptovalute che è scesa sotto i 3,7 trilioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Powell ha mostrato un’affermazione falconiana, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è sceso sotto la soglia dei 100.000 dollari, con la capitalizzazione di mercato delle criptovalute che è scesa sotto i 3,7 trilioni di dollari</h2><p>Secondo i dati di Coinglass, i BTC ETF hanno avuto un deflusso netto di 84,3 milioni di dollari ieri, di cui GBTC ha avuto un deflusso di 35,9 milioni di dollari; gli outflow di BTCO sono stati di 25,2 milioni di dollari.</p>
<p>Ieri, gli ETF ETH hanno avuto un deflusso netto di $79.4 milioni, di cui $49.2 milioni provenienti da ETHE; deflusso di ETHW di $14.6 milioni.</p>
<p><strong>Powell: La Fed non ha intenzione di trattenere <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e non cercherà di cambiare la legge</strong></p>
<p>Il 18 dicembre, la Federal Reserve ha tagliato i tassi di interesse per la terza volta, segnando la fine della decisione annuale sui tassi di interesse del 2024. Ma poi Powell ha annunciato in una conferenza stampa che la Federal Reserve avrebbe tagliato i tassi di interesse solo altre due volte nel 2025, il che è indubbiamente una dichiarazione aggressiva per il mercato. Powell ha anche dichiarato che l’instabilità geopolitica rimane un rischio. Vi è una significativa incertezza nel prevedere l’economia per i prossimi tre anni.</p>
<p>Non solo c’è l’aspettativa di tagli dei tassi di interesse, ma Powell ha anche chiarito che la Federal Reserve non ha intenzione di detenere <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> quando si tratta di stabilire se Trump costituirà riserve di Bitcoin. Per quanto riguarda la questione legale del possesso di Bitcoin, Powell ha detto: “Questa è una questione che il Congresso deve prendere in considerazione, ma non abbiamo alcuna intenzione di cercare di modificare la legge.”</p>
<p>Le osservazioni falconiane di Powell hanno fortemente soppresso gli acquisti nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> Nelle ultime 24 ore, l’intera rete ha subito una vendita di $843 milioni, con molteplici ordini che hanno venduto $743 milioni; i prezzi del Bitcoin sono scesi del 4%, raggiungendo un minimo di $98.839,87; il prezzo di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è sceso del 5,2%, toccando un minimo di $3.564,24.</p>
<p><strong>La capitalizzazione di mercato totale delle criptovalute è scesa al di sotto dei 3,7 trilioni di dollari, con una diminuzione del 7,9% nelle ultime 24 ore.</strong></p>
<p>Secondo i dati di CoinGecko, la capitalizzazione di mercato totale delle criptovalute è scesa al di sotto di 3,7 bilioni di dollari, segnalando ora 3,579 bilioni di dollari, con una diminuzione del 7,9% nelle ultime 24 ore.</p>
<p><strong>MicroStrategy pianifica di passare a titoli di reddito fisso per raccogliere fondi per l’acquisto di Bitcoin</strong></p>
<p>Secondo Bloomberg, Michael Saylor, co-fondatore e presidente di MicroStrategy, ha affermato che una volta esaurito il piano attuale di raccolta fondi, l’azienda passerà da un programma Bitcoin a leva a un programma più focalizzato su titoli di reddito fisso per raccogliere fondi per l’acquisto di criptovalute.</p>
<p>Saylor ha detto: “Abbiamo obbligazioni convertibili del valore di $7.2 miliardi, ma $4 miliardi di esse sono essenzialmente azioni, scambiate a prezzi di strike e call, con un delta di circa il 100%, assomigliando a azioni. Speriamo di tornare indietro e stabilire un leverage più intelligente per beneficiare i nostri azionisti comuni.”</p>
<p><strong>Il progetto criptato di Trump WLFI ha collaborato con Ethena Labs</strong></p>
<p>Secondo The Block, World Liberty Financial, un progetto DeFi della famiglia Trump, ha annunciato una partnership con Ethena Labs, cercando una “partnership a lungo termine” che inizierà con il token di revenue sUSDe di Ethena.</p>
<h2 id="h2-Macro20La20Fed20ha20tagliato20i20tassi20di20interesse20come20previsto20il20dollaro20statunitense2020schizzato20in20alto20e20tutti20e20tre20i20principali20indici20delloro20e20delle20azioni20statunitensi20sono20crollati20in20generale297524"><a name="Macro: La Fed ha tagliato i tassi di interesse come previsto, il dollaro statunitense è schizzato in alto e tutti e tre i principali indici dell’oro e delle azioni statunitensi sono crollati in generale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La Fed ha tagliato i tassi di interesse come previsto, il dollaro statunitense è schizzato in alto e tutti e tre i principali indici dell’oro e delle azioni statunitensi sono crollati in generale</h2><p>Il 18 dicembre, la Federal Reserve ha tagliato i tassi di interesse di 25 punti base come previsto, e il Presidente della Federal Reserve Powell ha detto che la Fed taglierà i tassi di interesse due volte l’anno prossimo di fronte all’aumento dell’inflazione. Questa previsione è in linea con l’atteggiamento di Trump di attesa quando tornerà alla Casa Bianca il prossimo gennaio.</p>
<p>E il nuovo dot plot mostra che diversi funzionari si aspettano che il numero di tagli dei tassi di interesse l’anno prossimo sia inferiore rispetto a quanto stimato qualche mese fa. Secondo la stima mediana, i funzionari della Federal Reserve si aspettano ora che il tasso di interesse di riferimento raggiunga un intervallo compreso tra il 3,75% e il 4% entro la fine del 2025, il che significa due tagli dei tassi di interesse del 25 punti base ciascuno. La maggior parte degli economisti intervistati da Bloomberg aveva precedentemente previsto che la stima mediana nella matrice a punti avrebbe indicato tre tagli dei tassi di interesse da parte della Federal Reserve l’anno prossimo.</p>
<p>Dopo l’annuncio della decisione sui tassi di interesse, l’oro spot è crollato di oltre il 2% al minimo di un mese. I tre principali indici del mercato azionario statunitense hanno chiuso tutti nettamente al ribasso. L’indice Nasdaq è sceso del 3,56%, segnando il più grande calo giornaliero da luglio 25; l’indice S&amp;P 500 è sceso del 2,95%, segnando il suo più grande calo giornaliero da agosto 6; il Dow Jones Industrial Average è sceso del 2,58%, segnando il suo decimo giorno consecutivo di calo e il calo continuo più lungo da ottobre 1974.</p>
<p>Anche le grandi azioni tecnologiche sono scese in picchiata, con Tesla che è scesa oltre l’8%, Intel che è scesa oltre il 5%, Amazon che è scesa oltre il 4%, Google, Meta, Microsoft e Netflix che sono scese oltre il 3%, Apple che è scesa oltre il 2%, e Nvidia che è scesa oltre l’1%. Quantum Corporation, un’azione concetto di computer quantistico, è salita oltre il 150%, mentre Quantum Computing è salito circa il 53%.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Jiji M.</strong>, Ricercatore 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 prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>