Tm90aXppZSBxdW90aWRpYW5lIHwgSSBkYXRpIHN1bGwnb2NjdXBhemlvbmUgbm9uIGFncmljb2xhIHNvbm8gbWlnbGlvcmF0aSwgaWwgY2FsbyBkZWwgQlRDIHNpIMOoIHJpZG90dG8gZSBzaSDDqCBzdGFiaWxpenphdG8gYSAkNjAuMDAw

2024-10-03, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/172792733510.3.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Gli20ETF20BTC20hanno20registrato20deflussi20netti20di20circa209220milioni20mentre20gli20ETF20ETH20hanno20registrato20ingressi20netti20di20quasi2020320milioni276649"><a name="Crypto Daily Digest: Gli ETF BTC hanno registrato deflussi netti di circa $92 milioni, mentre gli ETF ETH hanno registrato ingressi netti di quasi $20.3 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Gli ETF BTC hanno registrato deflussi netti di circa $92 milioni, mentre gli ETF ETH hanno registrato ingressi netti di quasi $20.3 milioni</h2><p>Secondo i dati di monitoraggio del Trader T, gli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot ha avuto un deflusso netto di $92,03 milioni ieri, mentre il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato un afflusso netto di 20,35 milioni di dollari ieri.</p>
<p><strong>Il ricavato dei minatori di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è sceso a circa 815 milioni di dollari a settembre, mentre il ricavato dallo staking di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è sceso a circa 200 milioni di dollari</strong></p>
<p>Secondo i dati di The Block Pro, i ricavi dei minatori di Bitcoin hanno continuato a diminuire a settembre, scendendo a 815,3 milioni di dollari, una diminuzione del 4,2%. Inoltre, i ricavi dello staking di Ethereum sono diminuiti del 4% a 209,4 milioni di dollari. Inoltre, a settembre, la rete Ethereum ha distrutto un totale di 26874 ETH, equivalente a 68,2 milioni di dollari.</p>
<p><strong>La probabilità che la Fed tagli i tassi di interesse di 25BP a novembre è del 62,8%</strong></p>
<p>Secondo il “FedWatch” del CME, la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base entro novembre è del 62,8%, e la probabilità di ridurre i tassi di interesse di 50 punti base è del 37,2%. La probabilità di un taglio cumulativo dei tassi di interesse di 50 punti base entro dicembre è del 36,8%, mentre la probabilità di un taglio cumulativo dei tassi di interesse di 75 punti base è del 47,8%; La probabilità di un taglio cumulativo dei tassi di interesse di 100 punti base è del 15,7%.</p>
<p><strong>SEC fa appello alla sentenza del caso Ripple</strong></p>
<p>Secondo The Block, la Securities and Exchange Commission (SEC) degli Stati Uniti sta facendo appello alla precedente sentenza della Corte d’Appello del Secondo Circuito degli Stati Uniti contro il <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> la società di pagamento Ripple. Inoltre, il Chief Legal Officer di Ripple ha dichiarato che stanno valutando se presentare una controdenuncia contro la SEC degli Stati Uniti.</p>
<p><strong>Il Giappone valuterà le normative sulle criptovalute, creando potenzialmente le condizioni per il lancio di ETF cripto</strong></p>
<p>Secondo quanto riferito, il Giappone prevede di valutare l’efficacia della sua regolamentazione crittografica, che verrà condotta nei prossimi mesi e potrebbe spianare la strada per il lancio di fondi negoziati in borsa (ETF) nel paese.</p>
<p><strong>Abu Dhabi ha proposto un quadro normativo per i token di riferimento fiat e ha sollecitato pubblicamente pareri</strong></p>
<p>L’agenzia di regolamentazione finanziaria di Abu Dhabi ha in programma di regolamentare il token di riferimento fiat (FRT) e ha invitato il pubblico a fornire feedback sul quadro regolamentare proposto. L’Autorità di regolamentazione dei servizi finanziari del Mercato Globale di Abu Dhabi (FSRA) ha stabilito il 3 ottobre 2024 come scadenza per fornire commenti sulla proposta.</p>
<h2 id="h2-Tendenze20di20mercato20il20declino20di20BTC20si2020ridotto20e20stabilizzato20a206000020con20focolai20locali20che20emergono20nel20mercato309343"><a name="Tendenze di mercato: il declino di BTC si è ridotto e stabilizzato a $60.000, con focolai locali che emergono nel mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il declino di BTC si è ridotto e stabilizzato a $60.000, con focolai locali che emergono nel mercato</h2><h3 id="h3-Punti20Caldi20del20Mercato206983"><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 token della catena pubblica Layer1 ad alte prestazioni SUI continua a mantenere una tendenza al rialzo, con il suo prezzo che ha superato i $ 2 questa mattina e un aumento di quasi il 9% nelle 24 ore. Il suo valore di mercato circolante ha raggiunto i 5,4 miliardi di dollari e sta per superare il valore di mercato di 5,7 miliardi di dollari <a href="/price/near-protocol-near" rel="nofollow noopener noreferrer" target="_blank">NEAR Protocol</a>(NEAR), che è strettamente dietro di esso.</p>
<p>-Diversi scambi, tra cui Gate.io, hanno lanciato i contratti perpetui DIA ieri. DIA è una piattaforma dati e oracolo open-source <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> cross-chain che ha recentemente lanciato Lumina, uno stack oracolare che supporta Rollup. Successivamente, verrà lanciata una rete di test e verrà condotta una completa distribuzione della mainnet e l’espansione della rete.</p>
<p>-Grazie al lancio del trading spot sulla borsa coreana, Wormhole (W) è salito contro la tendenza, con un aumento del 10% nelle ultime 24 ore e un valore di mercato circolante totale di $3.488 miliardi. Wormhole è una soluzione che supporta la comunicazione multi-chain ed è evoluta in un protocollo di messaggistica universale. È uno dei tre protocolli in tendenza nel campo dell’astrazione della catena.</p>
<h3 id="h3-Monete20mainstream4614"><a name="Monete mainstream" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete mainstream</h3><p>-BTC è stato in ribasso per 4 giorni consecutivi, riducendo temporaneamente l’impatto delle tensioni in Medio Oriente. Sebbene sia salito e sceso ieri, non si è ancora rivelato ribassista a livello tecnico. L’effetto di supporto del livello intero di $60000 è evidente e gli investitori devono monitorare il segnale di rottura dopo aver accumulato slancio;</p>
<p>-ETH è in calo da 5 giorni consecutivi, con una diminuzione del 4.06% in 24 ore. Sulla base di dati come una diminuzione del 22% nel volume di trading degli NFT e una diminuzione del 4% dei guadagni dello staking a settembre, i fondamentali dell’ETH in effetti non sono migliorati;</p>
<p>-Con il restringimento del declino di Bitcoin, si assiste a una tendenza al rialzo localizzata delle Altcoin, guidata dai settori dei meme, del gioco d’azzardo e dell’ecosistema SUI. SUI, POPCAT, DOGS, DEGEN, MANTA e altri settori sono tutti favoriti dai fondi, con guadagni impressionanti.</p>
<h2 id="h2-Macroeconomia20I20dati20sugli20occupati20non20agricoli20sono20migliorati20il20mercato20delle20criptovalute2020ancora20in20tendenza20di20adeguamento899160"><a name="Macroeconomia: I dati sugli occupati non agricoli sono migliorati, il mercato delle criptovalute è ancora in tendenza di adeguamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: I dati sugli occupati non agricoli sono migliorati, il mercato delle criptovalute è ancora in tendenza di adeguamento</h2><p>Recentemente, il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha sperimentato molteplici disturbi, con tensioni nel Medio Oriente che si sono leggermente attenuate e l’impatto sul mercato che si è ridotto.</p>
<p>Il presidente degli Stati Uniti Biden ha annunciato sanzioni contro l’Iran, mentre Israele minacciava di lanciare una grande rappresaglia contro l’Iran, prendendo di mira le sue strutture di produzione petrolifera. Questa serie di rischi geopolitici ha portato a una diffusa vendita di asset rischiosi e ad un aumento significativo della volatilità di mercato.</p>
<p>Tuttavia, in un contesto di banche centrali globali che entrano in un ciclo di tagli dei tassi di interesse, tali contraccolpi avranno un impatto relativamente breve sul mercato. Il rapporto ADP rilasciato ieri negli Stati Uniti ha mostrato un rimbalzo nel mercato del lavoro, con opportunità di lavoro in aumento in tutte le industrie tranne che nell’industria dell’informazione e dati positivi per i settori piccoli e non agricoli. Dopo l’apertura del mercato azionario statunitense, l’indice S&amp;P 500 e l’indice Nasdaq sono leggermente diminuiti, e anche le azioni concetto crypto sono scese.</p>
<p>Tuttavia, l’ufficiale della Federal Reserve Barkin ha dichiarato che il taglio dei tassi di interesse dello 0,5 percento a settembre è in linea con l’attuale ambiente economico, poiché il livello dei tassi di interesse non corrisponde alla tendenza al ribasso dell’inflazione e dei tassi di disoccupazione, influenzando ulteriormente il sentiment di mercato e le prestazioni a breve termine del mercato delle criptovalute.</p>
<p>Nel contesto di un rimbalzo dei dati sui piccoli salari non agricoli e della situazione in corso in Medio Oriente, il mercato delle criptovalute è ancora in fase di adeguamento.</p>
<h3 id="h3-Conclusion805320"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h3><p>Nonostante BTC sia in calo da 4 giorni consecutivi, l’effetto delle tensioni in Medio Oriente si è attenuato e il livello di $60.000 ha fornito supporto. Il mercato è in attesa di segnali di una svolta.</p>
<p>Da diverse fonti di dati, si può vedere che il nuovo indirizzo del balena sta accumulando una grande quantità di BTC, e questo raro comportamento di accumulazione non è strettamente correlato agli afflussi di ETF. Sebbene i prezzi stiano ancora diminuendo, questo potrebbe essere un fenomeno temporaneo e non un precursore di un mercato ribassista a lungo termine.</p>
<p>Nei prossimi mesi, ci si aspetta che Bitcoin trarrà beneficio da eventi come i tagli dei tassi di interesse della Federal Reserve, la fine della stagione delle elezioni negli Stati Uniti e il ritorno dei fondi dagli ETF spot.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore Gate.io<br><div>Traduttore:Gioia 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 relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>