Tm90aXppZSBnaW9ybmFsaWVyZXwgSSBmb25kaSBuZWdvemlhdGkgaW4gYm9yc2EgQml0Y29pbiBlZCBFdGhlcmV1bSByZWdpc3RyYW5vIGRlZmx1c3NpIG5ldHRpIG1pbm9yaSBpZXJpOyBBdW1lbnRhIGxhIHByb2JhYmlsaXTDoCBkaSB1biB0YWdsaW8gZGVpIHRhc3NpIGRpIDUwIHB1bnRpIGJhc2UgZGVsbGEgRmVkOyBJbml6aWEgaWw

2024-09-17, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/17265550049.17.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20i20Bitcoin20e20gli20ETF20Ethereum20hanno20registrato20ieri20piccoli20deflussi20netti20aumenta20la20probabilit20di20un20taglio20dei20tassi20della20Fed20di205020punti20base20inizia20il20secondo20airdrop20di20EigenLayer199952"><a name="Crypto Daily Digest: i Bitcoin e gli ETF Ethereum hanno registrato ieri piccoli deflussi netti; aumenta la probabilità di un taglio dei tassi della Fed di 50 punti base; inizia il secondo airdrop di EigenLayer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: i <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e gli ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> hanno registrato ieri piccoli deflussi netti; aumenta la probabilità di un taglio dei tassi della Fed di 50 punti base; inizia il secondo airdrop di EigenLayer</h2><h3 id="h3-ETF20Spot20Sia20i20Bitcoin20che20gli20ETF20Ethereum20hanno20registrato20piccoli20deflussi20netti813660"><a name="ETF Spot: Sia i Bitcoin che gli ETF Ethereum hanno registrato piccoli deflussi netti." class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETF Spot: Sia i Bitcoin che gli ETF Ethereum hanno registrato piccoli deflussi netti.</h3><p>Secondo i dati di Coinglass, il 16 settembre, U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato rispettivamente deflussi netti di $3 milioni e $13,6 milioni.</p>
<p>EigenLayer: È previsto che la seconda stagione delle richieste di airdrop continui fino a marzo dell’anno prossimo.<br>La Fondazione Eigen ha annunciato sulla piattaforma X che la seconda stagione delle richieste di airdrop durerà dal 16 settembre 2024 al 16 marzo 2025. Inoltre, lanceranno un piano di incentivi programmato, distribuendo settimanalmente EIGEN per ricompensare stakeholder e operatori.</p>
<h3 id="h3-Se20Bitcoin20scende20sotto20i205600020la20pressione20cumulativa20delle20liquidazioni20long20sulle20principali20CEXs20raggiunger20i2048720milioni281501"><a name="Se Bitcoin scende sotto i $56.000, la pressione cumulativa delle liquidazioni long sulle principali CEXs raggiungerà i $487 milioni." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Se Bitcoin scende sotto i $56.000, la pressione cumulativa delle liquidazioni long sulle principali CEXs raggiungerà i $487 milioni.</h3><p>Al contrario, se supera i $60.000, la pressione delle liquidazioni short raggiungerà i $526 milioni.</p>
<h3 id="h3-DeltaPrime20ha20subito20una20perdita20di20chiave20privata20con20una20stima20di20perdita20di205920milioni20Beosin2020ha20rilevato20una20possibile20perdita20di20chiave20privata20nel20progetto20DeltaPrime20portando20a20aggiornamenti20maligni20di20diversi20contratti20critici20e20causando20il20furto20di20circa205920milioni20di20asset538666"><a name="DeltaPrime ha subito una perdita di chiave privata, con una stima di perdita di $5,9 milioni. Beosin  ha rilevato una possibile perdita di chiave privata nel progetto DeltaPrime, portando a aggiornamenti maligni di diversi contratti critici e causando il furto di circa $5,9 milioni di asset." class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeltaPrime ha subito una perdita di chiave privata, con una stima di perdita di $5,9 milioni. Beosin  ha rilevato una possibile perdita di chiave privata nel progetto DeltaPrime, portando a aggiornamenti maligni di diversi contratti critici e causando il furto di circa $5,9 milioni di asset.</h3><h3 id="h3-CME20Fed20Watch20La20probabilit20di20un20taglio20dei20tassi20di205020punti20base2020pi20alta20rispetto20a20quello20di20un20taglio20di202520punti20base467194"><a name="CME “Fed Watch”: La probabilità di un taglio dei tassi di 50 punti base è più alta rispetto a quello di un taglio di 25 punti base." class="reference-link"></a><span class="header-link octicon octicon-link"></span>CME “Fed Watch”: La probabilità di un taglio dei tassi di 50 punti base è più alta rispetto a quello di un taglio di 25 punti base.</h3><p>I dati del CME indicano una probabilità più alta di un taglio dei tassi di 50 punti base da parte della Federal Reserve questa settimana rispetto a un taglio di 25 punti base, con un taglio cumulativo di 75 punti base entro novembre che è lo scenario più probabile.</p>
<h3 id="h3-Audizione20della20SEC20sulla20regolamentazione20delle20criptovalute352013"><a name="Audizione della SEC sulla regolamentazione delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Audizione della SEC sulla regolamentazione delle criptovalute</h3><p>La sottocommissione della Camera degli Stati Uniti terrà un’audizione per discutere della politicizzazione della regolamentazione degli asset digitali da parte della SEC, con l’ex commissario della SEC Dan Gallagher e Michael Liftik pronti a testimoniare.</p>
<h3 id="h3-MicroStrategy20MicroStrategy20ha20intenzione20di20emettere20privatamente2070020milioni20di20dollari20in20obbligazioni20convertibili20senior20MicroStrategy20ha20annunciato20piani20di20emettere20privatamente2070020milioni20di20dollari20in20obbligazioni20convertibili20senior20concedendo20agli20acquirenti20iniziali20unopzione20per20acquistare20ulteriori20obbligazioni20Le20obbligazioni20scadranno20nel202028470724"><a name="MicroStrategy: MicroStrategy ha intenzione di emettere privatamente 700 milioni di dollari in obbligazioni convertibili senior. MicroStrategy ha annunciato piani di emettere privatamente 700 milioni di dollari in obbligazioni convertibili senior, concedendo agli acquirenti iniziali un’opzione per acquistare ulteriori obbligazioni. Le obbligazioni scadranno nel 2028." class="reference-link"></a><span class="header-link octicon octicon-link"></span>MicroStrategy: MicroStrategy ha intenzione di emettere privatamente 700 milioni di dollari in obbligazioni convertibili senior. MicroStrategy ha annunciato piani di emettere privatamente 700 milioni di dollari in obbligazioni convertibili senior, concedendo agli acquirenti iniziali un’opzione per acquistare ulteriori obbligazioni. Le obbligazioni scadranno nel 2028.</h3><h3 id="h3-Bhutan20detiene20una20quantit20significativa20di20Bitcoin987358"><a name="Bhutan detiene una quantità significativa di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bhutan detiene una quantità significativa di Bitcoin</h3><p>Arkham ha rivelato che il Bhutan è il quarto maggior detentore governativo di Bitcoin, con 13.011 BTC del valore di circa $780 milioni, principalmente da operazioni minerarie.</p>
<h3 id="h3-La20base20utenti20di20Ethereum20L220raggiunge20un20nuovo20record267873"><a name="La base utenti di Ethereum L2 raggiunge un nuovo record" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La base utenti di Ethereum L2 raggiunge un nuovo record</h3><p>La base utenti delle soluzioni di livello 2 di Ethereum ha raggiunto un nuovo record, con un aumento degli indirizzi attivi del 35,23% la scorsa settimana. Questa crescita rafforza il dominio di L2 e accelera <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> adozione.</p>
<p>CoinShares: i prodotti di investimento in asset digitali hanno registrato un aumento degli afflussi di 436 milioni di dollari. CoinShares ha segnalato che i prodotti di investimento in asset digitali hanno registrato afflussi per 436 milioni di dollari la scorsa settimana, attribuiti a un cambiamento delle aspettative di mercato in merito a un taglio dei tassi della Federal Reserve.</p>
<p>Analisi di mercato: Bitcoin si mantiene stabile sul grafico a 4H in vista della decisione del Pre-Fed</p>
<p>Tendenza generale: Bitcoin (BTC) ha concluso la scorsa settimana con un rimbalzo del 10%, ma questa settimana è iniziata con il proseguimento del trend al ribasso del fine settimana. BTC ha registrato tre declini consecutivi, attualmente scambiando intorno ai 58.000 dollari. Anche le altcoin hanno seguito il trend al ribasso, mostrando guadagni limitati. Gli investitori preferiscono scambi a breve termine e rimangono cauti.</p>
<p>Dal punto di vista tecnico, BTC è temporaneamente stabile sul grafico a 4 ore, supportato dalla media mobile a 60 periodi. Se questo supporto dovesse fallire, il prezzo probabilmente scenderebbe verso i $55.000 per il prossimo livello di supporto. Questa settimana, l’attenzione dovrebbe essere concentrata sulla resistenza psicologica a $60.000 e sull’impatto della prossima decisione sui tassi di interesse della Federal Reserve.</p>
<p>Ieri, sia i fondi ETF Bitcoin che Ethereum hanno registrato deflussi netti minori, che hanno avuto un impatto trascurabile sui prezzi recenti. I fondi continuano a preferire Bitcoin rispetto a Ethereum, che non ha beneficiato dell’introduzione degli ETF spot e continua a registrare deflussi netti. Negli ultimi sette giorni, Bitcoin ed Ethereum hanno registrato deflussi netti rispettivamente di 365 milioni di dollari e 243 milioni di dollari, tra le prime 20 criptovalute per capitalizzazione di mercato. Ripple è stata l’unica a registrare un afflusso netto, seppur modesto, di 1,33 milioni di dollari. Ciò indica un’appetibilità al rischio conservatrice tra gli investitori, con la speculazione di mercato ancora da scatenarsi.</p>
<p>Dal punto di vista macroeconomico, la decisione sui tassi di interesse della Federal Reserve di giovedì è molto attesa. Attualmente, il mercato scommette su un taglio dei tassi di 50 punti base, che ha una probabilità più alta di un taglio dei tassi di 25 punti base. Questo potrebbe avere un impatto significativo sui prezzi degli asset a rischio come il Bitcoin. Sebbene ci si aspetti miglioramenti a lungo termine nella liquidità macro, che dovrebbero stimolare il sentiment rialzista nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>, la volatilità al ribasso a breve termine è inevitabile.</p>
<p><strong>Punti caldi del mercato:</strong><br>Settore MEME: Nonostante il generale calo del mercato, il settore MEME ha registrato una variazione del 0% nelle ultime 24 ore. L’attività del settore è sostenuta dalla quotazione di token importanti come Turbo, BabyDoge e Neiro su importanti exchange, avvenuta ieri, e dalle imminenti quotazioni di giochi blockchain come Catizen (CATI) e Hamster Kombat (HMSTR) su piattaforme, tra cui Gate.io. I principali token di questo settore, come Turbo, BabyDoge e Neiro, hanno registrato impressionanti guadagni settimanali del 21,8%, dell’81,3% e del 977,8% rispettivamente.<br>Settore Social: Con una capitalizzazione di mercato attuale di 2,3 miliardi di dollari, il settore Social ha registrato un lieve calo dello 0,3% nelle ultime 24 ore, ma ha mantenuto un guadagno del 3,4% nell’ultima settimana. Recentemente, il token di infrastruttura sociale <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> UXLINK ha ottenuto il supporto di diversi exchange, generando un certo interesse. Tuttavia, lo sviluppo a lungo termine del settore rimane moderato, con la sfida di integrare efficacemente i social network e la tecnologia blockchain. I principali token di questo settore, come GAL, UXLINK e HIVE, hanno mostrato una performance resiliente con guadagni del 4,3%, del 21,0% e dello 0,2% rispettivamente.<br>Settore Privacy: Anche il settore Privacy ha dimostrato una relativa resilienza nelle ultime 24 ore, con <a href="/price/dash-dash" rel="nofollow noopener noreferrer" target="_blank">DASH</a> ZANO e OXEN registrano guadagni rispettivamente del 1,0%, 1,1% e 3,3%. La performance della settimana scorsa nel settore della privacy è stata simile alla resistenza delle declinazioni del mercato più ampio. Tuttavia, il settore rimane contenuto nel lungo termine a causa delle pressioni regolamentari sulle criptovalute incentrate sulla privacy. I recenti guadagni sono probabilmente il risultato di un rimbalzo dalle condizioni ipervendute.</p>
<h2 id="h2-Macro20Il20mercato20scommette20su20un20taglio20dei20tassi20della20Fed20pi20ampio20il20Bitcoin20rimane20debole379937"><a name="Macro: Il mercato scommette su un taglio dei tassi della Fed più ampio, il Bitcoin rimane debole" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato scommette su un taglio dei tassi della Fed più ampio, il Bitcoin rimane debole</h2><p>La Federal Reserve è pronta a decidere un taglio dei tassi durante il suo incontro di politica questa settimana, con l’ampia aspettativa di mercato che un taglio dei tassi sia imminente a causa del deterioramento dell’economia statunitense e delle crescenti paure di recessione.</p>
<p>Sebbene ci siano analisi varie sulle prospettive di un taglio dei tassi, i dati più recenti mostrano un significativo aumento delle aspettative di mercato di un taglio di 50 punti base. Questa anticipazione ha spinto al ribasso i rendimenti dei bond e messo pressione sull’indice del dollaro statunitense, creando un ambiente relativamente favorevole per il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<p>Ad esempio, i trader di bond stanno ora inclinandosi verso la probabilità di un taglio dei tassi di interesse di 50 punti base da parte della Fed questa settimana, un netto contrasto rispetto a qualche giorno fa quando questa opzione era quasi interamente scartata. Questa rapida inversione delle aspettative si riflette nei contratti di swap legati alla decisione sui tassi della Fed, spingendo il rendimento dei titoli del Tesoro statunitense a due anni al suo punto più basso in quasi due anni, e trascinando l’indice del dollaro al suo livello più basso quest’anno.</p>
<p>La volatilità di mercato di questa settimana dipenderà fortemente dalle aspettative degli investitori riguardo alla decisione di taglio dei tassi della Fed. Che il taglio sia di 25 o 50 punti base, causerà oscillazioni significative tra sentimenti rialzisti e cautela nell’evitare rischi. La crescente correlazione tra Bitcoin e il mercato azionario significa che le dinamiche dei mercati finanziari tradizionali avranno un impatto maggiore su <a href="/price" rel="nofollow noopener noreferrer" target="_blank">prezzi delle criptovalute</a>. Inoltre, il distacco del Bitcoin dall’oro indica che gli investitori preferiscono asset tradizionali rifugio sicuro in ambienti a basso rischio.</p>
<p>In sintesi, nelle attuali condizioni macroeconomiche che dominano le tendenze di mercato, l’attacco recente a Trump non ha causato alcuna grande interruzione. Il focus del mercato rimane sulla prossima riunione della Fed questa settimana. Indipendentemente dalla magnitudine del taglio dei tassi, è probabile che il mercato oscillerà tra ottimismo rialzista e de-risking cauto, ponendo sfide per i movimenti dei prezzi di Bitcoin e altre criptovalute.</p>
<p>Il mercato delle criptovalute, in particolare Bitcoin, si trova ad un bivio. Da un lato, è guidato dalle aspettative di liquidità globali e dall’attesa di tagli dei tassi. Dall’altro, si trova di fronte a potenziali impatti dalle dinamiche dei mercati finanziari tradizionali. Gli investitori dovrebbero essere cauti nei confronti dei rapidi cambiamenti nel sentiment di mercato e flessibili nell’adattare le proprie strategie di investimento per far fronte alla potenziale volatilità di mercato.</p>
<h3 id="h3-Sommario968554"><a name="Sommario:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario:</h3><p>Bitcoin è diminuito per tre giorni consecutivi ed attualmente mostra una stabilità a breve termine sul grafico a 4 ore. A causa delle incertezze macroeconomiche, il livello di supporto chiave da tenere d’occhio è di $55.000, mentre la resistenza rimane al livello psicologico di $60.000.<br>Nel complesso, il sentiment ribassista nel mercato delle criptovalute non si è ancora dissolto, con una rapida rotazione nei settori speculativi. La dominanza di mercato di Bitcoin rimane alta e gli investitori dovrebbero monitorare attentamente la decisione della Federal Reserve questa settimana per il suo potenziale impatto sul mercato.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Carl Y.</strong><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. Il ripostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno adottate azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>