Tm90aXppZSBxdW90aWRpYW5lIHwgQmxhY2tSb2NrIHNpIHBvc2l6aW9uYSBhbCBwcmltbyBwb3N0byBuZWxsYSBsaXN0YSBkZWkgZmx1c3NpIGRpIGZvbmRpIGRpIDUgQml0Y29pbiBTcG90IEVURjsgTWljcm9TdHJhdGVneSBjb21wcmEgcGnDuSBCaXRjb2luOyBBUEUsIElOSiwgSUQgZSBhbHRyaSB0b2tlbiBzYXJhbm5vIHNibG9jY2F

2024-01-15, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/17052994141_12.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20BlackRock2020al20primo20posto20nel20flusso20di20fondi20ETF20spot20su20Bitcoin20MicroStrategy20compra20pi20Bitcoin305738"><a name="Crypto Daily Digest: BlackRock è al primo posto nel flusso di fondi ETF spot su Bitcoin, MicroStrategy compra più Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: BlackRock è al primo posto nel flusso di fondi ETF spot su Bitcoin, MicroStrategy compra più Bitcoin</h2><p>Le cinque istituzioni di fondi più importanti in termini di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF cash <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> dopo l’elenco ci sono BlackRock ($497,7 milioni), Fidelity ($422,3 milioni), Bitwise ($237,9 milioni), ARK 21Shares ($105,2 milioni) e Franklin ($50,1 milioni).</p>
<p>D’altra parte, Michael Saylor, co-fondatore di MicroStrategy, sembra stia sviluppando la sua strategia Bitcoin. Ha iniziato a vendere azioni della società per acquisire più Bitcoin.</p>
<p>Si riferisce che Michael Saylor ha venduto da 3882 a 5000 azioni di MicroStrategy in determinati giorni prima che la SEC approvasse gli ETF Bitcoin, guadagnando oltre 20 milioni di dollari. Si dice che questa sia la sua prima vendita di azioni in quasi 12 anni. Saylor utilizzerà parte dei profitti di queste vendite per investire in Bitcoin. Secondo notizie precedenti, Michael Saylor venderà 315.000 azioni di MicroStrategy del valore di circa 216 milioni di dollari. Queste azioni fanno parte delle opzioni su azioni che Saylor ha acquisito dall’azienda nel 2014.</p>
<p>Secondo The Block, l’analista JPMorgan Nikolaos Panigirtzoglou ha dichiarato che la SEC deve classificare ETH come non-valori mobiliari prima di approvare la negoziazione spot. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF a maggio. “Riteniamo che affinché la SEC statunitense approvi l’ETF spot su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> a maggio, Ethereum debba essere classificato come una commodity (simile a Bitcoin) piuttosto che come un titolo”. “Questo è tutt’altro che certo, e credo che la probabilità che la SEC classifichi Ethereum come commodity prima di maggio non supererà il 50%”.</p>
<p>In precedenza, un altro responsabile dei mercati degli asset digitali presso Morgan Stanley, Andrew Peel, ha dichiarato in un rapporto agli investitori che l’approvazione degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot segna un momento importante per l’adozione di Bitcoin da parte del sistema finanziario globale. Si ritiene che l’approvazione degli ETF Bitcoin spot possa segnare un potenziale cambiamento di paradigma nella comprensione e nell’uso globale degli asset digitali.</p>
<p>Andrew Peel ha delineato le minacce allo stato attuale del dollaro statunitense come valuta di riserva mondiale, dato che il 60% del saldo globale delle riserve di cambio è detenuto in dollari statunitensi. Andrew Peel ha scritto che alcune minacce di “de-dollaroizzazione” potrebbero indebolire la posizione di leadership del dollaro statunitense, tra cui l’adozione “significativa” di Bitcoin a livello globale, e ha sottolineato che 100 milioni di persone in tutto il mondo detengono questa criptovaluta (Andrew Peel ha affermato che 82 paesi hanno bancomat Bitcoin) in collaborazione con grandi aziende come Tesla e il sovrano El Salvador.</p>
<p>Inoltre, Andrew Peel ha affermato che lo stablecoin potrebbe dimostrarsi una “killer application” della criptovaluta, sottolineando che negli ultimi anni il volume delle transazioni con stablecoin è stato paragonabile a quello delle tradizionali banche digitali come Visa e PayPal. Entrambe Visa e PayPal hanno preso provvedimenti per adottare gli stablecoin. Visa ha integrato USDC su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, mentre PayPal ha integrato stablecoin PYUSD.</p>
<p>Il 14 gennaio, secondo il rapporto di mining 2023 di CoinShares, la potenza di calcolo del mining di Bitcoin è aumentata del 104%, sollevando interrogativi sulla sua sostenibilità ambientale e sulla redditività, in particolare sull’efficienza della rete e sui costi energetici; il costo medio di produzione per Bitcoin è previsto essere di $37.856 dopo la riduzione a metà. La maggior parte dei minatori dovrà affrontare sfide in termini di vendite e spese amministrative, richiedendo una riduzione dei costi per mantenere la redditività. A meno che i prezzi di Bitcoin non rimangano sopra i $40.000, solo Bitarms, Iris, CleanSpark, TeraWulf e Cormint possono continuare a fare profitti.</p>
<p>Secondo i dati di The Block, la quota dell’emittente di stablecoin USDT <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> nel 2023 la quota globale dell’offerta di stablecoin è aumentata dal 50% al 71%. Inoltre, recentemente l’azienda ha oltre 95 miliardi di stablecoin in circolazione, che è più grande del prodotto interno lordo (PIL) di paesi come Guatemala e Bulgaria. Il suo attuale principale concorrente, Circle, ha una circolazione di soli 27 miliardi di USDC, rispetto a oltre 48 miliardi all’inizio del 2023.</p>
<p>Secondo i dati di sblocco del token, APE, INJ, ID e altri token esperimenteranno uno sblocco una tantum questa settimana, con un valore totale di rilascio di circa 203 milioni di dollari. Tra questi:</p>
<p>Alle 0:00 (UTC) del 16 gennaio, <a href="/price/flow-flow" target="_blank" class="blog_inner_link">Flow</a> sbloccherà 2,6 milioni di FLOW (approssimativamente 2,22 milioni di dollari), corrispondenti al 0,18% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 17 gennaio, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> sbloccherà 15,6 milioni di APE (circa 22,78 milioni di dollari), rappresentando il 4,23% dell’offerta circolante;</p>
<p>Alle 13:10 (UTC) del 18 gennaio, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> sbloccherà 3,43 milioni di AXS (circa 28,06 milioni di dollari), pari al 2,53% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 21 gennaio, Objective sbloccherà 3,67 milioni di INJ (circa 140 milioni di dollari), corrispondenti al 4,33% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 22 gennaio, SPACE ID sbloccherà 53,27 milioni di ID (circa 16,45 milioni di dollari), corrispondenti al 12,37% dell’offerta circolante.</p>
<h2 id="h2-Macro20I20dati20sul20terrorismo20determineranno20il20prezzo20di20mercato20per20il20taglio20dei20tassi20di20interesse20di20marzo20questo20mercoled394415"><a name="Macro: I “dati sul terrorismo” determineranno il prezzo di mercato per il taglio dei tassi di interesse di marzo questo mercoledì?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I “dati sul terrorismo” determineranno il prezzo di mercato per il taglio dei tassi di interesse di marzo questo mercoledì?</h2><p>La scorsa settimana, nonostante gli ufficiali della Federal Reserve abbiano frenato le aspettative di mercato per tagli dei tassi di interesse “in anticipo” e la pubblicazione di dati CPI leggermente superiori alle aspettative, il mercato è rimasto saldo nelle sue aspettative per i tagli dei tassi della Fed. Secondo lo strumento di osservazione della Federal Reserve utilizzato dalla Chicago Mercantile Exchange, il mercato si aspetta che la Fed tagli i tassi di interesse sei volte quest’anno, con una probabilità dell’83% che il primo taglio dei tassi avvenga a marzo.</p>
<p>Inoltre, il conflitto in corso da mesi tra Palestina e Israele continuerà a influenzare la visione del mercato. Giovedì, l’attacco aereo congiunto di Stati Uniti e Gran Bretagna contro le forze armate yemenite di Saddam Hussein ha sollevato preoccupazioni per le “interruzioni delle spedizioni” e l’ulteriore escalation delle tensioni in Medio Oriente. Il greggio Brent è tornato sopra gli 80 dollari, mentre l’oro è salito a 2.050 dollari a causa della domanda di beni rifugio e delle scommesse del mercato sui tagli dei tassi di interesse della Federal Reserve.</p>
<p>Questa settimana, gli investitori monitoreranno attentamente i “dati sul terrorismo” per continuare a “correggere” le proprie aspettative per il taglio dei tassi d’interesse della Federal Reserve, e l’inizio graduale della stagione degli utili del mercato azionario degli Stati Uniti continuerà ad attirare l’attenzione del mercato. Inoltre, se il governo degli Stati Uniti chiuderà veramente e se la tensione in Medio Oriente si intensificherà ulteriormente rimarranno al centro dell’attenzione degli investitori.</p>
<p>La scorsa settimana, nonostante diversi funzionari della Federal Reserve, inclusi diversi commissari del FOMC di voto quest’anno, sembrassero ‘gridare’ e continuassero a opporsi alle aspettative di mercato per il taglio dei tassi di interesse della Fed già a marzo, affermando che era ancora troppo presto per credere che l’inflazione stesse continuando a diminuire, queste parole dei funzionari della Federal Reserve sono state in gran parte ignorate.</p>
<p>Ciò che è ancora più eccitante è che i dati sull’IPC degli Stati Uniti a dicembre dello scorso anno hanno superato le aspettative, e le aspettative del mercato per un taglio dei tassi di interesse della Fed sono aumentate invece di diminuire. Dopo che i dati dell’IPP di venerdì sono stati molto al di sotto delle aspettative, i trader hanno nuovamente aumentato le loro scommesse su un taglio dei tassi di interesse della Fed quest’anno, con un previsto taglio annuale di 160 punti base.</p>
<p>Da notare che l’atteggiamento dei “tre leader” della Federal Reserve e del presidente della Federal Reserve di New York, Williams, si è ammorbidito rispetto a prima, ritenendo che i tassi di interesse siano già sufficientemente restrittivi. Quando c’è fiducia nel fatto che l’inflazione raggiunga il 2%, la Federal Reserve può abbassare i tassi di interesse e la velocità dei tagli dei tassi dipende dalle condizioni economiche.</p>
<p>Per quanto riguarda il percorso di politica della Federal Reserve quest’anno, Akerman, l’investitore miliardario che ha guadagnato profitto vendendo allo scoperto i titoli di stato statunitensi l’anno scorso e CEO di Panxing Plaza Capital Management Company, ritiene che la Federal Reserve debba abbassare i tassi di interesse il prima possibile. Ha detto:</p>
<p>“Attualmente, con l’inflazione che si sta raffreddando in modo significativo, i tassi di interesse reali sono molto alti. Pertanto, credo che debbano agire in anticipo e il numero di tagli dei tassi potrebbe certamente superare i tre”.</p>
<p>Secondo lo strumento di osservazione della Federal Reserve del Chicago Mercantile Exchange, i trader prevedono che la Federal Reserve taglierà i tassi di interesse sei volte quest’anno, con una probabilità dell’83% che il primo taglio dei tassi avvenga a marzo.</p>
<p>Tuttavia, c’è controversia su quanto questa prospettiva sia accurata. Larry Fink, CEO di BlackRock, la più grande società di gestione patrimoniale al mondo, ha dichiarato venerdì scorso di ritenere che i governatori delle banche centrali esiteranno ad agire troppo rapidamente.</p>
<p>Questa settimana, i prossimi funzionari della Federal Reserve probabilmente continueranno a sottolineare la dipendenza dai dati e a dichiarare che le aspettative del mercato sono troppo avanti. E il mercato sicuramente continuerà a concentrarsi sull’entità del taglio dei tassi di interesse della Federal Reserve. Per l’oro, trarrà beneficio dalla scommessa del mercato sul taglio dei tassi di interesse della Fed, ma l’analista Christopher Yates consiglia agli investitori di rimanere cauti.</p>
<p>Ha detto che dal punto di vista emotivo e di posizione, i prezzi dell’oro si aggirano sui massimi storici, ma le emozioni non sono così. Nel complesso, si tratta di una situazione molto rialzista, il che significa che gli investitori hanno più spazio rialzista prima che il mercato raggiunga un certo livello estremo. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>, che è un segno del picco del mercato.</p>
<p>Mercoledì, i dati sulle vendite al dettaglio degli Stati Uniti, noti come “dati terrificanti”, diventeranno presto il centro dell’attenzione del mercato.</p>
<p>Sebbene la spesa dei consumatori negli Stati Uniti si sia rallentata dopo l’impennata dell’estate scorsa, non crollerà. Le vendite al dettaglio a novembre sono aumentate dello 0,3% su base mensile e i dati di dicembre previsti per mercoledì dovrebbero mostrare un tasso di crescita simile.</p>
<p>Negli ultimi 12 mesi, i consumatori americani hanno dimostrato di essere una “bestia più resiliente”, con solo 3 mesi di dati negativi, l’ultimo dei quali è stato a ottobre con -0,2%.</p>
<p>Il rimbalzo nei dati sulle vendite al dettaglio a novembre è stato principalmente guidato dalle vendite dei servizi alimentari, dei bar e degli articoli sportivi, mentre le vendite nelle stazioni di servizio si sono rallentate del 2,9%. Nonostante la resilienza della spesa, i consumatori sembrano effettivamente rallentare rispetto ai modelli di spesa molto robusti che abbiamo visto nel terzo trimestre.</p>
<p>Tuttavia, se i dati sui “dati terroristici” registrano nuovamente tassi di crescita simili, il mercato potrebbe rivalutare la possibilità che la Federal Reserve riduca i tassi di interesse a marzo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</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.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripost del articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>