RGFpbHkgTmV3cyB8IElsIGxpdmVsbG8gZGkgc3VwcG9ydG8gQlRDIHBvdHJlYmJlIGVzc2VyZSBjb21wcmVzbyB0cmEgJDMwLjAwMCBlICQzNS4wMDA7IE10LiBHb3ggc2Jsb2NjaGVyw6AgMjAwLjAwMCBCVEMgbmVpIHByb3NzaW1pIDIgbWVzaTsgQWx0TGF5ZXIgbGFuY2Vyw6AgcHJlc3RvIEFpcmRyb3Bz

2024-01-24, 03:36

<p><img src="https://gimg2.gateimg.com/image/article/17060671691_19.png" alt=""></p>
<h2 id="h2-Riepilogo20quotidiano20delle20criptovalute20il20livello20di20supporto20di20BTC20potrebbe20essere20compreso20tra203000020e203500020AltLayer20sta20per20lanciare20gli20Airdrop239964"><a name="Riepilogo quotidiano delle criptovalute: il livello di supporto di BTC potrebbe essere compreso tra $30.000 e $35.000, AltLayer sta per lanciare gli Airdrop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo quotidiano delle criptovalute: il livello di supporto di BTC potrebbe essere compreso tra $30.000 e $35.000, AltLayer sta per lanciare gli Airdrop</h2><p>Ieri, Arthur Hayes ha pubblicato che il primo argomento per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Il recente forte calo è stato l’afflusso di fondi dal fondo fiduciario <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Grayscale (GBTC). Questa affermazione è falsa perché quando si calcola l’importo netto dei fondi che escono da GBTC rispetto ai fondi che entrano nei nuovi ETF Bitcoin spot quotati, il risultato è un afflusso netto di 820 milioni di dollari al 22 gennaio.</p>
<p>Il secondo argomento è che il trend del Bitcoin prevede che il Piano di Finanziamento a Termine Bancario (BTFP) non verrà rinnovato. Questo evento non sarà positivo, perché la Federal Reserve non ha ancora abbassato il tasso di interesse al livello che spinge il rendimento dei titoli di stato americani a 10 anni nella fascia del 2% al 3%. Credo che la cessazione del BTFP porterà ad una piccola crisi finanziaria e costringerà la Federal Reserve a smettere di parlare, spingendo Yellen ad iniziare a tagliare i tassi di interesse, ridurre la QT e/o ripristinare la stampa di denaro attraverso il quantitative easing (QE).</p>
<p>Hayes ha continuato: ‘In un articolo precedente, pensavo che Bitcoin sarebbe sceso prima della decisione di rinnovo del BTFP l’12 marzo. Non mi aspettavo che succedesse così velocemente, ma credo che Bitcoin troverà un minimo locale tra i 30.000 e i 35.000 dollari. Poiché l’indice S&amp;P (SPX) e il New York Stock Exchange (NDX) sono crollati a causa della piccola crisi finanziaria di marzo, Bitcoin salirà perché sarà in anticipo rispetto ai tagli dei tassi della Federal Reserve e alla retorica della stampa che alla fine si trasformerà in azione per premere il pulsante ‘Brrrr’.’</p>
<p>Riguardo alla sua strategia di trading, Hayes ha dichiarato: ‘Bitcoin si è ritirato del 30% dal suo massimo approvato ETF di $48.000 a $33.600. Pertanto, credo che il livello di supporto di Bitcoin si trovi tra i $30.000 e i $35.000. Ecco perché ho acquistato opzioni put di esercizio per $35.000 il 29 marzo 2024. Ho anche venduto le mie posizioni di trading in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e Bonk a un leggero calo. Se BTFP non rinnoverà davvero, una volta che Bitcoin scenderà sotto i $35.000, inizierò ad acquistare in fondo.”</p>
<p>Il direttore degli investimenti di Bitwise, Matt Hougan, ha pubblicato sulla piattaforma X affermando che strettamente parlando, questo non è un ETF che vende. Gli ETF sono acquirenti netti di Bitcoin (incluso GBTC). Si tratta di una vendita scatenata dalle aspettative sugli ETF. Il mercato ha anticipato l’approvazione degli ETF acquistando una grande quantità di spot Bitcoin e derivati del Bitcoin. Il mercato aveva precedentemente previsto che l’afflusso netto di fondi negli ETF sarebbe stato maggiore di quanto abbiamo ricevuto finora, e il mercato sta ora annullando questa scommessa. Proprio come il mercato sovrastima l’impatto a breve termine degli ETF, sottovaluta anche l’impatto a lungo termine.</p>
<p>Inoltre, Hougan ha anche inoltrato e concordato con David Lawant, direttore delle ricerche di FalconX, che “i due principali fattori trainanti del netto <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> negli ETF BTC spot (GBTC perde oltre 500 milioni di dollari, mentre IBIT e FBTC registrano ingressi di centinaia di milioni di dollari al giorno) diminuiranno gradualmente. Anche se GBTC sarà dominante nel breve termine, IBIT e FBTC lo saranno nel medio/lungo termine.</p>
<p>Secondo i dati delle istituzioni di ricerca, l’ETF Bitcoin spot degli Stati Uniti ha registrato un deflusso netto di 487 milioni di dollari l’8 giorno, con un afflusso cumulativo di 602 milioni di dollari negli ultimi 8 giorni. L’8 giorno, il deflusso netto di fondi di GBTC è stato di 515 milioni di dollari, con un deflusso cumulativo di 3,963 miliardi di dollari entro 8 giorni.</p>
<p>Ieri, il fondatore di dForce Yang Mindao ha twittato che il signor Gox sbloccherà 200000 Bitcoin nei prossimi due mesi per pagare i creditori, e il canale di valuta fiduciaria PayPal ha già iniziato il pagamento. Inoltre, l’atteso dimezzamento di Bitcoin nell’aprile del 2024 ridurrà l’offerta annuale di 160.000 monete.</p>
<p>JPMorgan Chase ha dichiarato in un recente rapporto di ricerca che il lancio degli ETF Bitcoin spot potrebbe deludere gli investitori nel 2024. La SEC ha approvato gli ETF Bitcoin spot il mese scorso, il che è ampiamente atteso per annunciare una nuova era per le criptovalute, con il flusso previsto di fondi principali in questo settore.</p>
<p>Ma secondo un rapporto di JPMorgan Chase, “Ci preoccupa che qualsiasi deludente performance possa indebolire l’entusiasmo per guidare un rimbalzo, dato l’entusiasmo delle persone per gli ETF spot e l’afflusso di nuovi fondi nell’ecosistema delle criptovalute.” La banca ha sottolineato che i prezzi del Bitcoin sono stati sotto pressione, scendendo al di sotto dei $40.000, “l’entusiasmo per gli ETF spot potrebbe ulteriormente affievolirsi, portando a cali dei prezzi, riduzione del volume di scambi e riduzione delle opportunità di ricavi accessori per aziende come Coinbase.”</p>
<p>Dopo che la popolarità degli ETF spot di Bitcoin è svanita, l’attenzione del mercato si è gradualmente spostata su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETFs.</p>
<p>La giornalista di Fox Business, Eleanor Terrett, ha rivelato che gli emittenti di ETF, le società di gestione degli investimenti e le fonti vicine alla SEC hanno opinioni diverse sul potenziale calendario di approvazione degli ETF spot di Ethereum. Una fonte ha detto che in questo momento, la posizione della SEC è quella di “rigettare con forza”, ma attualmente ci sono “alcuni ostacoli interni” a questa idea.</p>
<p>Un emittente di ETF BTC spot che richiede ETF ETH spot ha espresso fiducia che l’approvazione e il lancio senza problemi degli ETF BTC spot costringeranno la SEC ad approvare gli ETF ETH spot. Alcune persone dicono anche che l’elenco degli ETF futures ETH e il precedente di BlackRock nell’ottenere l’approvazione degli ETF li fa pensare che gli ETF ETH spot potrebbero essere lanciati entro la fine dell’estate.</p>
<p>Inoltre, la CFTC ritiene che l’ETH sia una merce, unita alla vittoria parziale di Ripple in tribunale nel trading <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> nel mercato secondario, il che porterà ad una dura battaglia per Gensler. La commissaria della SEC Hester Peirce ha dichiarato che l’agenzia non vuole ripetere lo stesso errore di ritardo sugli ETF ETH. Eleanor Terrett ha concluso che se il personale della SEC si addentrerà maggiormente nel documento S-1, vedranno dei progressi nei prossimi mesi.</p>
<p>Inoltre, l’offerta di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> potrebbe essere influenzata dal prossimo aggiornamento Denchun.</p>
<p>Secondo Luke Nolan, assistente di ricerca di Ethereum presso CoinShares, l’aggiornamento a Denchun consentirà alle transazioni L2 di essere inviate alla rete Ethereum tramite blobspace, che è un’alternativa al meccanismo attuale di calldata delle transazioni. Il calldata delle transazioni rappresenta il 90% delle commissioni Gas pagate da Layer 2. Ma dopo l’aggiornamento di Denchun, il Layer 2 può utilizzare il nuovo meccanismo di blobspace anziché pubblicare dati attraverso calldata, riducendo notevolmente i costi Gas.</p>
<p>Gli analisti dicono: “Se ci si aspetta che il Layer 2 si sposterà gradualmente verso l’uso del nuovo meccanismo di spazio dei blob, i prezzi del Gas potrebbero stabilizzarsi a livelli più bassi, il che significa che meno token Ethereum verranno distrutti, influenzando così la crescita dell’offerta di Ethereum.”</p>
<p>Infine, diamo un’occhiata ad AltLayer, un roll up di restaking molto atteso sul mercato. Ieri, AltLayer ha annunciato ufficialmente su Twitter, Discord e Telegram che annuncerà il sito web di richiesta di ALT airdrop. Il periodo di richiesta va dal 25 gennaio al 25 febbraio 2024, con un’offerta totale di 300 milioni di ALT airdrop, pari al 3% dell’offerta totale.</p>
<p>Il 35,47% dei 300 milioni di ALT airdrop sarà allocato ai detentori di NFT, il 37,07% sarà allocato ai partecipanti alla Campagna Altitude, il 13,05% sarà allocato agli utenti che partecipano di EigenLayer, il 4,49% sarà allocato ai partner dell’ecosistema EigenLayer, il 9,92% sarà allocato agli stakeholder di Celestia, ecc. Tutti i tempi degli snapshot dell’airdrop sono stati completati il 17 gennaio alle 20:00:11 ora di Pechino. Anche i detentori di Ottie e OG Badge NFT in circolazione, così come i partecipanti alle Campagne Altitude di AltLayer, riceveranno gli airdrop.</p>
<h2 id="h2-Macro20Loro20si20riprende20Brad20sollecita20la20Federal20Reserve20a20ridurre20i20tassi20di20interesse20il20prima20possibile642627"><a name="Macro: L’oro si riprende, Brad sollecita la Federal Reserve a ridurre i tassi di interesse il prima possibile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’oro si riprende, Brad sollecita la Federal Reserve a ridurre i tassi di interesse il prima possibile</h2><p>Martedì, l’indice del dollaro americano ha registrato un significativo rimbalzo dopo aver testato il livello di 103 e ha brevemente raggiunto un massimo intraday di 103,81. Tuttavia, ha ridotto parte dei suoi guadagni durante la sessione statunitense e alla fine ha chiuso in rialzo dello 0,2% a 103,56; Il rendimento del Tesoro USA a 10 anni si è stabilizzato al livello del 4,1% e ha chiuso a 4,139%; Il rendimento del Tesoro USA a 2 anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso a 4,378%.</p>
<p>L’oro spot ha ripreso a salire e ha raggiunto un massimo intraday di $2037.90 nel breve termine nel mercato europeo, ma poi ha ceduto parte dei suoi guadagni e non è riuscito a stabilizzarsi sopra il livello di 2030, chiudendo infine in rialzo dello 0.37% a $2029.27 per oncia. L’argento spot è salito dell’1.57% chiudendo a $22.44 per oncia.</p>
<p>Il petrolio greggio internazionale è in montagne russe. Il petrolio greggio WTI è sceso a un minimo intraday di $73,38 durante la sessione degli Stati Uniti, ma successivamente ha riguadagnato un po’ di terreno perso e ha raggiunto i $75, senza riuscire infine a stabilizzarsi su questo punto, chiudendo in ribasso dello 0,19% a $74,44 al barile; Il petrolio greggio Brent è tornato più volte al livello di $80 nel mercato, ma ha comunque fallito nel stabilizzarsi al di sopra di questo livello, chiudendo infine in ribasso dello 0,29% a $79,63 al barile. L’indice azionario statunitense ha chiuso in ribasso dello 0,25%, il Nasdaq è salito dello 0,43% e l’indice S&amp;P 500 è salito dello 0,29%.</p>
<p>L’ex funzionario della Federal Reserve, Brad, ritiene che se la Fed inizia a tagliare i tassi d’interesse troppo lentamente, potrebbe essere costretta a tagliare i tassi di 50 punti base in future riunioni. Si aspetta che la Federal Reserve inizi a tagliare i tassi di interesse prima che l’inflazione raggiunga il 2%, forse già a marzo.</p>
<p>In una recente intervista al podcast “Outlook for the Week” del Wall Street Journal, Brad ha previsto che il tasso di inflazione di base, escludendo i prezzi alimentari ed energetici, si ridurrà a circa il 2% entro ottobre e il PCE scenderà al 2,6% a novembre.</p>
<p>Brad ha sottolineato le sfide che la Federal Reserve deve affrontare e l’importanza di non ritardare gli aggiustamenti di politica. Ha detto che la Federal Reserve non vuole modificare la sua politica prima che il tasso di inflazione raggiunga il 2% nella seconda metà dell’anno. Se il tasso di inflazione è compreso tra il 2% e il 2,5%, ma la Federal Reserve non ha ancora regolato i tassi di politica, potrebbe essere costretta ad agire, ad esempio abbassando i tassi di interesse di 50 punti base in una riunione, il che sarà un compito difficile.</p>
<p>Al contrario, la maggior parte degli economisti intervistati da Reuters ritiene che la Federal Reserve aspetterà il secondo trimestre per tagliare nuovamente i tassi di interesse, con una maggiore probabilità di un taglio dei tassi a giugno piuttosto che a maggio e un taglio dei tassi previsto inferiore rispetto alle attuali aspettative di mercato.</p>
<p>Reuters ha intervistato 123 economisti, tutti i quali hanno previsto che la Federal Reserve manterrà invariati i tassi di interesse al prossimo incontro, ma la maggior parte degli 86 intervistati crede che i tagli ai tassi inizieranno dal prossimo trimestre. Quasi il 45% o 55 economisti scommettono su un taglio dei tassi a partire da giugno, mentre 31 credono che inizierà a maggio. Solo 16 credono che sarà a marzo, mentre il resto prevede che inizierà solo nella seconda metà dell’anno.</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 il punto di vista 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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>