Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgRmVkIGFubnVuY2Vyw6AgbGEgc3VhIGRlY2lzaW9uZSBzdWkgdGFzc2kgZGkgaW50ZXJlc3NlIGRvbWFuaSBtYXR0aW5hLCBsJ2F1bWVudG8gaW50cmFkYXkgcGnDuSBhbHRvIGRpIEJNVCBoYSBzdXBlcmF0byBpbCAxMDAl

2025-03-19, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/174235503813.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20trading20dei20future20CME20SOL20nel20primo20giorno2020stato20freddo20la20Fed20annuncer20la20decisione20sui20tassi20di20interesse20domattina938539"><a name="Crypto Daily Digest: Il trading dei future CME SOL nel primo giorno è stato freddo, la Fed annuncerà la decisione sui tassi di interesse domattina" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il trading dei future CME SOL nel primo giorno è stato freddo, la Fed annuncerà la decisione sui tassi di interesse domattina</h2><p>Secondo i dati degli investitori di Farside, l’ingresso netto totale degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot ieri erano di $208 milioni, di cui BlackRock IBIT aveva un afflusso di $217 milioni e ARKB aveva un deflusso di $9 milioni. Gli ETF BTC hanno avuto un afflusso netto di oltre $200 milioni per due giorni consecutivi, ma il BTC è ancora in un’intervallo ristretto di fluttuazioni.</p>
<p>Ieri, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF sul mercato spot ha avuto un deflusso totale di $52.4 milioni, di cui BlackRock ETHA ha avuto un deflusso di $39.8 milioni e Grayscale ETHE ha avuto un deflusso di $9.3 milioni. Il tasso di cambio ETH/BTC è attualmente a 0.0233, che rimane vicino al minimo di quasi 4 anni.</p>
<p><strong>La Federal Reserve annuncerà la sua decisione sui tassi di interesse domani mattina, con solo una probabilità del 1% di un taglio dei tassi a marzo</strong></p>
<p>Secondo i dati di “FedWatch” del CME, la Federal Reserve annuncerà la sua decisione sui tassi di interesse alle 2 del mattino ora di Pechino domani. La probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base a marzo è solo dell’1%, mentre la probabilità di mantenere inalterati è del 99%.</p>
<p>La probabilità che la Federal Reserve taglierà i tassi di interesse di 50 punti base entro maggio è dello 0,2%, la probabilità di tagliare i tassi di interesse di 25 punti base è dell’18,6%, e la probabilità di mantenere invariati i tassi di interesse è dell’81,2%.</p>
<p><strong>Analisi dei livelli chiave dei prezzi prima della riunione sui tassi d’interesse della Fed: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> bloccato al di sotto di $85,000</strong></p>
<p>Secondo i dati di mercato di Gate.io, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo Bitcoin</a> non è riuscito a raggiungere nuovamente il livello di resistenza di $ 85.000 il 17 marzo. Negli ultimi cinque giorni i massimi intraday si sono sempre attestati tra gli 84.000$ e gli 85.200$, ma non sono riusciti a superare gli 84.600$. Con l’avvicinarsi della riunione del FOMC della Federal Reserve (la decisione sui tassi di interesse sarà annunciata alle 2 del mattino ora di Pechino del 20 marzo), il mercato è entrato in una “<a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> di nessuno”: le fluttuazioni dei prezzi sono piene di incertezza e il gioco long-short si è intensificato. Secondo lo strumento FedWatch del CME, la probabilità di mantenere l’attuale tasso di interesse dal 4,25% al 4,50% è del 99% e la probabilità di un taglio dei tassi di 25 punti base è solo dell’1%. Sebbene l’IPC (2,8%) e il PCE (2,5%-2,6%) siano ancora al di sopra dell’obiettivo del 2%, gli ultimi dati non raggiungono la soglia per un taglio immediato dei tassi; il tasso di disoccupazione (4,1 %) e il PIL (2,3 % nel quarto trimestre del 2024) dimostrano ancora la resilienza dell’economia. Polymarket prevede che la Fed porrà fine al quantitative tightening prima del 30 aprile, il che potrebbe aprire la strada a un taglio dei tassi estivo.</p>
<p>Gli analisti hanno punti di vista diversi. L’analista anonimo SuperBitcoinBro ha sottolineato che nel peggiore dei casi, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> potrebbe testare la fascia di supporto tra $71,300 e $73,800. L’analista Nebraskangooner ritiene che il risultato del FOMC sia imprevedibile e che Bitcoin debba recuperare $86,250 per confermare la tendenza rialzista a breve termine, altrimenti potrebbe tornare a $70,000. Powell terrà una conferenza stampa dopo aver annunciato la decisione sui tassi di interesse alle 2 del mattino ora di Pechino del 20 marzo e il mercato è concentrato sulle sue dichiarazioni sull’inflazione e sul percorso dei tagli ai tassi d’interesse.</p>
<p><strong>CME <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> I future primo giorno di trading è stato freddo, l’approvazione ETF potrebbe essere difficile da replicare il successo di Bitcoin</strong></p>
<p>Secondo TheBlock, i future di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> del Chicago Mercantile Exchange (CME) sono stati lanciati silenziosamente il 17 marzo, con un volume di scambi di soli 12,3 milioni di dollari il primo giorno e un interesse aperto di 7,8 milioni di dollari, molto meno della precedente brillante performance dei future di Bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>. Gli analisti di K33 Research, Vetle Lunde e David Zimmerman, hanno sottolineato nel loro ultimo rapporto che questi dati riflettono l’atteggiamento freddo delle istituzioni verso le altcoin. Anche se l’ETF di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> verrà approvato in futuro, il suo effetto di stimolo sui prezzi di SOL potrebbe essere più debole rispetto alle aspettative di mercato.</p>
<p>Il lancio dei futures CME è spesso visto come un preludio all’approvazione degli ETF spot, ma gli analisti ritengono che anche se viene lanciato Solana ETF, sarà difficile replicare la frenesia di Bitcoin ETF nel 2024. Bitcoin ETF è nato nel periodo di risonanza delle aspettative di dimezzamento e dell’attenuazione macroeconomica, e il mercato attuale manca di narrazioni simili. Oltre a Bitcoin ed Ethereum, il mercato dei derivati istituzionali di altre altcoin ha una crescita debole, il che riflette che, in un contesto di incertezza macroeconomica, le istituzioni preferiscono allocare “oro digitale” piuttosto che asset ad alto rischio. Il posizionamento di Bitcoin come “merce” offre un percorso di conformità chiaro, mentre le altcoin sono ancora in una zona grigia. Nonostante i contrattempi a breve termine, l’attività degli sviluppatori e l’innovazione tecnologica dell’ecosistema Solana sono ancora all’avanguardia rispetto a molte catene pubbliche. Ci aspettiamo che raggiunga brillanti risultati dopo l’approvazione dell’ETF spot. Tuttavia, al momento, la strada verso l’”istituzionalizzazione” delle altcoin è ancora piena di difficoltà.</p>
<h2 id="h2-Tendenze20di20mercato20EOS2020salito20del203020dopo20il20cambio20di20nome20e20laumento20intraday20pi20alto20di20BMT20ha20superato20il2010014525"><a name="Tendenze di mercato: EOS è salito del 30% dopo il cambio di nome, e l’aumento intraday più alto di BMT ha superato il 100%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> è salito del 30% dopo il cambio di nome, e l’aumento intraday più alto di BMT ha superato il 100%</h2><h3 id="h3-Punti20Caldi20del20Mercato476144"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Il progetto di una catena pubblica ben consolidato <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a> La rete ha ufficialmente cambiato il suo nome in Vaulta. La notizia ha stimolato <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> a salire del 30% in un giorno. Secondo l’introduzione ufficiale, Vaulta si concentrerà su <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> attività bancaria. Vaulta manterrà l’infrastruttura tecnica originale di EOS Network. Inoltre, Vaulta pianifica inizialmente di effettuare lo scambio di token nel mese di maggio di quest’anno. A giudicare dal feedback attuale del mercato, gli investitori sono pieni di aspettative per il cambio di nome di EOS e il cambiamento della direzione dello sviluppo. Tuttavia, le continue performance solide del prezzo di EOS nei prossimi mesi rappresentano una scommessa precoce sul futuro sviluppo di Vaulta.</p>
<p>BMT, il token di Bubblemaps, uno strumento su <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, è aumentata di più del 100% nella giornata. È stato annunciato che sarà quotata su una serie di piattaforme di trading mainstream tra cui Gate.io, che ha stimolato l’impennata di BMT. Il valore di mercato circolante attuale di BMT è solo di $64 milioni, classificandosi al 439º posto nell’intero mercato. Alcune comunità ritengono che BMT dovrebbe essere considerato un meme con una certa utilità su <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain. Si tratta di una nuova criptovaluta con una certa popolarità di mercato e scenari di utilizzo, e potrebbe continuare a essere seguita in futuro.</p>
<h3 id="h3-Criptovalute20principali42877"><a name="Criptovalute principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute principali</h3><p>Il BTC è ancora in un range stretto di fluttuazioni e non ci sarà nessuna inversione importante nel breve termine. Inoltre, l’indice AHR999 mostra che il prezzo attuale è adatto agli investitori a lungo termine.</p>
<p>ETH è anche in un range ristretto intorno a $1,900, con la linea giornaliera quasi piatta, e ETH si sta convergendo e fluttuando, aspettando di scegliere una direzione.</p>
<p>Le altcoin hanno performance miste e i progetti di <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain generalmente si comportano meglio rispetto ad altre chain pubbliche.</p>
<h2 id="h2-Macro20News20Le20azioni20statunitensi20hanno20chiuso20in20ribasso20la20Federal20Reserve20annuncer20la20sua20decisione20sui20tassi20di20interesse20di20marzo625536"><a name="Macro News: Le azioni statunitensi hanno chiuso in ribasso, la Federal Reserve annuncerà la sua decisione sui tassi di interesse di marzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: Le azioni statunitensi hanno chiuso in ribasso, la Federal Reserve annuncerà la sua decisione sui tassi di interesse di marzo</h2><p>I tre principali indici azionari statunitensi hanno chiuso in calo collettivo, con lo S&amp;P 500 in ribasso dell’1,07% a 5.614,66 punti, il Dow Jones in ribasso dello 0,62% a 41.581,31 punti e il Nasdaq in ribasso dell’1,71% a 17.504,12 punti. Il rendimento del titolo di Stato statunitense decennale di riferimento era del 4,29%, mentre il rendimento del titolo di Stato a 2 anni, che è il più sensibile al tasso di politica della Fed, era del 4,04%.</p>
<p>Alle 2 del mattino ora di Pechino di giovedì, la Federal Reserve concluderà la sua riunione di politica monetaria di due giorni e il presidente Powell annuncerà la decisione sui tassi di interesse e il riassunto delle ultime previsioni economiche. Gli investitori sono particolarmente preoccupati riguardo alla possibilità di una “stagnazione” in cui tassi di inflazione e disoccupazione aumentano contemporaneamente. Le attuali preoccupazioni di mercato sono principalmente dovute al fatto che le politiche tariffarie potrebbero frenare la crescita economica e far aumentare i prezzi al consumo.</p>
<p>Alcuni analisti hanno detto che se Powell inviasse un segnale accomodante, indicando che la Fed era disposta a tagliare rapidamente i tassi di interesse quando l’economia rallentava, il mercato potrebbe reagire positivamente, ma la realtà è che l’ambiente ad alta inflazione ha messo la Fed in una posizione difficile. “Il livello attuale dell’inflazione è significativamente più alto dell’obiettivo. In questo caso, è difficile per Powell mostrare una posizione eccessivamente accomodante.”</p>
<p>È ampiamente previsto che la Fed mantenga invariato il suo tasso di interesse di riferimento tra il 4,25% e il 4,5% questa settimana. Secondo lo strumento CME FedWatch, i trader si aspettano che la Fed tagli i tassi di interesse due o tre volte alla fine del 2025.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing T.</strong>, Ricercatore Gate.io<br><div>Translator: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 su questo articolo. Il repost dell'articolo sarà permesso a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>