Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgY2FwaXRhbGl6emF6aW9uZSBkaSBtZXJjYXRvIGRpIFhSUCBoYSBzdXBlcmF0byBVU0RUIGVkIMOoIHRvcm5hdGEgYWwgdGVyem8gcG9zdG8sIGxhIEZlZCBwcmV2ZWRlIGRpIHRhZ2xpYXJlIGkgdGFzc2kgZCdpbnRlcmVzc2UgZHVlIHZvbHRlIHF1ZXN0J2Fubm8=

2025-03-20, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/174244200914.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20Fed20prevede20di20ridurre20i20tassi20di20interesse20due20volte20questanno20e20i20market20maker20di20Shell20hanno20ricomprato20quasi202020milioni20di20token482456"><a name="Crypto Daily Digest: La Fed prevede di ridurre i tassi di interesse due volte quest’anno, e i market maker di Shell hanno ricomprato quasi 20 milioni di token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La Fed prevede di ridurre i tassi di interesse due volte quest’anno, e i market maker di Shell hanno ricomprato quasi 20 milioni di token</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> ETF sul mercato spot ieri è stato di 11,8 milioni di dollari, di cui Bitwise BITB ha ricevuto 12,1 milioni di dollari. I dati di BlackRock non sono ancora stati aggiornati. L’ingresso e l’uscita di fondi in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot ieri erano praticamente trascurabili.</p>
<p><strong>Punto Fed: prevede ancora 2 tagli dei tassi nel 2025</strong></p>
<p>La Fed ha mantenuto invariato il tasso di interesse di riferimento al 4,25%-4,50%, in linea con le aspettative del mercato. Inoltre, secondo il grafico a punti pubblicato dalla Fed, sono previsti due tagli dei tassi d’interesse nel 2025 (due tagli dei tassi d’interesse erano previsti anche a dicembre dello scorso anno). È previsto un taglio dei tassi d’interesse di 50 punti base nel 2026.</p>
<p>Quattro dei 19 funzionari non si aspettano un taglio dei tassi nel 2025, quattro si aspettano uno, nove si aspettano due e due si aspettano tre.</p>
<p><strong>Analisi: Un ambiente finanziario favorevole potrebbe aiutare <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> a raggiungere nuovi massimi prima della fine del Q2</strong></p>
<p>La Federal Reserve ha annunciato questa mattina che rallenterà il ritmo di riduzione del suo bilancio di $6.8 trilioni, riducendo il limite mensile sulla riduzione del Tesoro da $25 miliardi a $5 miliardi. Il miglioramento delle condizioni finanziarie sembra stimolare l’appetito per il rischio. Il dollaro ha registrato il terzo calo più grande in tre giorni dal 2015, mentre i rendimenti dei titoli del Tesoro statunitense e la volatilità del mercato obbligazionario sono diminuiti nettamente.</p>
<p>Jamie Coutts, chief crypto analyst at Real Vision, ha detto che questi cambiamenti potrebbero preparare il terreno per un significativo aumento del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> nei prossimi 90 giorni. Storicamente, questi segnali hanno spesso preceduto movimenti significativi del Bitcoin. Ora, con la Banca Popolare Cinese che intensifica le misure di liquidità, il mercato potrebbe sottovalutare quanto rapidamente il Bitcoin potrebbe crescere, potenzialmente stabilendo un nuovo massimo storico prima della fine del secondo trimestre, nonostante le preoccupazioni persistenti riguardo alle tariffe di Trump e una possibile recessione.</p>
<p><strong>I market maker di SHELL hanno pubblicamente riacquistato 19,95 milioni di SHELL, del valore di $5,92 milioni</strong></p>
<p>Secondo il monitoraggio dell’analista dei dati on-chain @ai_9684xtpa, il saldo attuale dell’indirizzo di riacquisto pubblico del market maker di SHELL è cresciuto fino a 19,95 milioni di token, che si stima valgano $5,92 milioni al prezzo proposto, ciò significa che il 74% del progresso di riacquisto è stato completato (l’ultima proposta è stata fatta 11 ore fa). Tuttavia, il prezzo di SHELL non è aumentato significativamente.</p>
<h2 id="h2-Tendenze20di20mercato20la20meme20coin20KOMA20della20catena20BNB2020aumentata20XRP2020tornata20al20terzo20posto20per20capitalizzazione20di20mercato331879"><a name="Tendenze di mercato: la meme coin KOMA della catena BNB è aumentata, XRP è tornata al terzo posto per capitalizzazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: la meme coin KOMA della catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> è aumentata, <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> è tornata al terzo posto per capitalizzazione di mercato</h2><h3 id="h3-Punti20Caldi20del20Mercato439044"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Settore agenti di intelligenza artificiale FARTCOIN, AVAAI, GRAIFFAIN e altri token sono saliti. Diversi token concettuali di agenti di intelligenza artificiale che sono saliti oggi hanno ottenuto buoni risultati nei rimbalzi passati. Anche se la maggior parte dei token di agenti di intelligenza artificiale è scesa di quasi il 90% rispetto ai massimi storici di inizio gennaio, l’IA è ancora una delle tracce più degne di nota nell’industria crittografica.</p>
<p><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> le catene di meme coin KOMA, WHY e altre sono aumentate. Con la forte spinta di CZ, l’ecosistema di <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain è stato caldo di recente. Anche i vecchi meme coin hanno guadagnato un certo favore finanziario quando il mercato sta cambiando.</p>
<p><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> è aumentato del 10%. La SEC ha rinunciato a citare in giudizio Ripple e le aspettative di mercato per l’IPO futura di Ripple e l’emissione di ETF <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> sono state ravvivate. La capitalizzazione di mercato attuale di XRP è di $145 miliardi, superando USDT e classificandosi al terzo posto nell’intero mercato.</p>
<h3 id="h3-Criptovalute20principali724961"><a name="Criptovalute principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute principali</h3><p>BTC è rimbalzato a $87,500, superando la linea di mezzo giornaliera. Se riesce a mantenere il livello di prezzo attuale per diversi giorni consecutivi, avrà l’opportunità di sfidare quota $92,000. L’indice AHR999 di oggi è 0.87, indicando che il prezzo attuale è adatto per gli investitori a lungo termine.</p>
<p>ETH ha ripreso e superato i $2.000 ed attualmente è vincolato dalla linea media giornaliera; ETH ha avuto una performance migliore di BTC nelle ultime 24 ore e il tasso di cambio ETH/BTC è aumentato di più del 5%.</p>
<p>Le altcoin sono generalmente aumentate, ma i guadagni sono stati modesti. Il mercato non aveva ancora settori in crescita concentrata. MUBARAK, un progetto di ecosistema popolare di BNB Chain, è sceso del 50% dal suo punto più alto.</p>
<h2 id="h2-Macro20News20La20riunione20sui20tassi20dinteresse20della20Fed2020rimasta20invariata20e20le20aspettative20per20un20taglio20dei20tassi20a20giugno20sono20leggermente20aumentate935282"><a name="Macro News: La riunione sui tassi d’interesse della Fed è rimasta invariata e le aspettative per un taglio dei tassi a giugno sono leggermente aumentate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: La riunione sui tassi d’interesse della Fed è rimasta invariata e le aspettative per un taglio dei tassi a giugno sono leggermente aumentate</h2><p>Nelle prime ore di questa mattina è stata tenuta la tanto attesa riunione sul tasso di interesse della Federal Reserve. La Fed ha mantenuto invariata la sua politica, mantenendo il range target del tasso dei fondi federali al 4,25% - 4,5%, in linea con le aspettative. Allo stesso tempo, ha annunciato che rallenterà il ritmo di riduzione del bilancio a partire da aprile. Inoltre, la Fed ha significativamente abbassato le sue previsioni economiche per quest’anno e ha aumentato le previsioni sull’inflazione, riflettendo la vigilanza della Fed contro l’economia che potrebbe cadere nella stagflazione.</p>
<p>Il grafico a punti della Federal Reserve mostra che tra i 19 funzionari, 4 funzionari ritengono che non dovrebbe esserci alcun taglio dei tassi di interesse nel 2025 (1 funzionario a dicembre), 4 funzionari ritengono che il taglio cumulativo dei tassi di interesse dovrebbe essere di 25 punti base nel 2025, cioè un taglio dei tassi di interesse (3 funzionari a dicembre), 9 funzionari ritengono che il taglio cumulativo dei tassi di interesse dovrebbe essere di 50 punti base nel 2025, cioè due tagli dei tassi di interesse (10 funzionari a dicembre), 2 funzionari ritengono che il taglio cumulativo dei tassi di interesse dovrebbe essere di 75 punti base nel 2025, cioè tre tagli dei tassi di interesse (3 funzionari a dicembre), nessun funzionario ritiene che il taglio cumulativo dei tassi di interesse dovrebbe essere di 100 punti base nel 2025 (1 funzionario a dicembre), e nessun funzionario ritiene che il taglio cumulativo dei tassi di interesse dovrebbe essere di 125 punti base nel 2025 (1 funzionario a dicembre).</p>
<p>I dati sui futures hanno mostrato che i trader vedono una probabilità del 62,1 percento che la Fed riprenderà a tagliare i tassi alla sua riunione di giugno, rispetto a una probabilità del 57 percento prima della decisione della Fed.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing T.</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 alcuna 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. Sarà consentito il ripostare dell'articolo 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>