Tm90aXppZSBxdW90aWRpYW5lIHwgRmx1c3NpIEVURiBCVEMgc3VwZXJpb3JpIGEgMSw1IG1pbGlhcmRpIGRpIGRvbGxhcmkgaW4gdW5hIHNldHRpbWFuYSwgRElBIHNhbGUgb2x0cmUgaWwgNDAwJSBkYSBzZXR0ZW1icmU=

2024-10-18, 04:25

<p><img src="https://gimg2.gateimg.com/image/article/172922534010.18.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20lETF20BTC20ha20ricevuto20grandi20afflussi20netti20per20420giorni20consecutivi20Worldcoin20viene20lanciato20sulla20mainnet285226"><a name="Crypto Daily Digest: l’ETF BTC ha ricevuto grandi afflussi netti per 4 giorni consecutivi, Worldcoin viene lanciato sulla mainnet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: l’ETF BTC ha ricevuto grandi afflussi netti per 4 giorni consecutivi, Worldcoin viene lanciato sulla mainnet</h2><p>Secondo i dati degli investitori di Farside, gli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno registrato un afflusso netto di 473 milioni di dollari ieri. BlackRock IBIT ha registrato un afflusso netto di 311,7 milioni di dollari e Ark ARKB ha registrato un afflusso netto di 100 milioni di dollari. Ieri, negli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF hanno registrato un afflusso netto di 48,03 milioni di dollari. Tra questi, BlackRock ETHA ha registrato un afflusso netto di 23,7 milioni di dollari.</p>
<p><strong>Worldcoin è stato rilanciato come World Network e ha annunciato che World Chain è stato lanciato sulla mainnet</strong></p>
<p>Secondo The Block, Worldcoin supportato da Sam Altman ha ufficialmente cambiato nome in World Network (abbreviato come World), e la sua mainnet World Chain della rete Layer2 è stata lanciata. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>, Alchimia, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, Safe, Dune e Etherscan supporteranno il rilascio di questa blockchain. La blockchain è costruita utilizzando OP Stack e World Network afferma che le transazioni degli utenti rappresentano circa il 44% dell’attività di OP Mainnet, rendendola l’applicazione più grande della rete.</p>
<p><strong>La SEC ha ufficialmente impugnato la decisione del caso Ripple</strong></p>
<p>La Securities and Exchange Commission (SEC) degli Stati Uniti ha ufficialmente appellato il <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> la decisione presa dal giudice Analisa Torres. Giovedì, l’agenzia di regolamentazione ha presentato il Modulo C alla Corte d’Appello del Secondo Circuito degli Stati Uniti. Questo ha nuovamente scatenato una controversia legale su se <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> le vendite su piattaforme di trading di criptovalute soddisfano i requisiti di sicurezza. Le autorità di regolamentazione hanno posto delle domande su aspetti chiave della sentenza, compresa l’assoluzione degli esecutivi di Ripple e le distribuzioni non in contanti di XRP. L’esito di questo caso potrebbe avere un impatto significativo sulla futura regolamentazione delle criptovalute.</p>
<p>Il 3 ottobre, la SEC degli Stati Uniti sta facendo appello alla precedente sentenza della Corte d’Appello del Secondo Circuito degli Stati Uniti riguardante il <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> la società di pagamento Ripple, secondo i documenti di mercoledì. Il portavoce della SEC ha dichiarato: “Riteniamo che la sentenza del tribunale di distretto nel caso Ripple sia in contrasto con decenni di precedenti stabiliti dalla Corte Suprema e dalle leggi sui titoli, e non vediamo l’ora di presentare le nostre ragioni al Secondo Circuito.”</p>
<p>In precedenza, l’8 agosto, il giudice ha ordinato a Ripple di pagare una multa civile di 125 milioni di dollari, molto al di sotto dei 2 miliardi di dollari inizialmente richiesti dalla SEC. La sentenza ha anche parzialmente approvato e respinto la richiesta preliminare di azione risarcitoria della SEC riguardo alla vendita dei token <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> da parte di Ripple.</p>
<p><strong>All’avvicinarsi delle elezioni negli Stati Uniti, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> entra in una fase di alta volatilità</strong></p>
<p>QCP ha pubblicato un rapporto quotidiano affermando che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è salito del 2,20% la scorsa notte, tornando brevemente a quota $68.000 grazie a una forte domanda spot, per poi stabilizzarsi nell’intervallo di $67.000. Durante la sessione di trading negli Stati Uniti, è stato acquistato un gran numero di opzioni a lungo termine con scadenza il 28 marzo sul mercato, con 600 contratti con un prezzo di esercizio di $120.000.</p>
<p>Questo indica che gli acquirenti ottimisti a lungo termine sono tornati in questo rimbalzo. Ieri, gli ETF di Bitcoin sono aumentati di 456 milioni di dollari, continuando quattro giorni di afflussi netti. Questi forti e costanti afflussi di capitale potrebbero essere un indicatore principale per BTC per raggiungere nuovamente il suo massimo storico di $ 73.790.</p>
<p>Anche se le elezioni negli Stati Uniti sono il prossimo catalizzatore chiave per Bitcoin e le criptovalute, c’è ancora incertezza sul mercato riguardo alla tendenza di Bitcoin dopo le elezioni. Il prezzo di negoziazione delle opzioni in prossimità della scadenza delle elezioni è del 10% superiore rispetto ad altre opzioni di scadenza. Poiché le persone sono concentrate sulle elezioni, qualsiasi cambiamento nei sondaggi o nelle narrazioni delle campagne dei candidati verrà amplificato nei prezzi spot.</p>
<h2 id="h2-Tendenze20di20mercato20DIA2020salito20del204020gli20ETF20spot20di20BTC20hanno20registrato20un20forte20afflusso402921"><a name="Tendenze di mercato: DIA è salito del 40%, gli ETF spot di BTC hanno registrato un forte afflusso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: DIA è salito del 40%, gli ETF spot di BTC hanno registrato un forte afflusso</h2><h3 id="h3-Punti20Caldi20del20Mercato179573"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>DOGE è salito e, a livello di notizie, Musk ha twittato su D.O.G.E (Department of Government Efficiency), scatenando una corsa al capitale di mercato. Le elezioni presidenziali statunitensi si avvicinano e Trump, sostenuto da Musk, ha attualmente un alto tasso di vittoria. Il mercato ha forti aspettative per un presidente degli Stati Uniti che sia bullish sulle criptovalute;</p>
<p>Il protocollo DIA per le macchine Oracle è aumentato del 40%, con i prezzi DIA aumentati di oltre il 400% da settembre e altre macchine Oracle come UMA sono anche aumentate. La capitalizzazione di mercato circolante attuale di DIA è di $ 120 milioni, il che ha un certo potenziale al rialzo rispetto al valore di mercato del protocollo leader. <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, che equivale a 7 miliardi di dollari;</p>
<p>I meme politici statunitensi come FIGHT e FEARNOT sono aumentati, beneficiando delle notizie sulla posizione di Trump nelle elezioni presidenziali statunitensi, e i meme politici correlati a Trump sono generalmente aumentati.</p>
<h3 id="h3-Monete20di20tendenza121326"><a name="Monete di tendenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete di tendenza</h3><p>BTC ha superato i $68.000 e questa settimana gli ETF spot BTC continuano ad avere forti afflussi di oltre $1,5 miliardi, con il mercato generalmente ottimista;</p>
<p>ETH è leggermente aumentato insieme al mercato, ma le sue prestazioni complessive sono ancora relativamente lente rispetto ad altre catene pubbliche di livello1;</p>
<p>Le altcoin in generale sono diminuite e le prime monete forti sono entrate nella zona di correzione, con il mercato in attesa di nuovi token leader.</p>
<h2 id="h2-Macroeconomia20le20azioni20statunitensi20hanno20fluttuato20Buffett20ha20incassato20369920milioni20di20dollari20influenzando20il20sentiment20di20mercato746161"><a name="Macroeconomia: le azioni statunitensi hanno fluttuato, Buffett ha incassato 369,9 milioni di dollari, influenzando il sentiment di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: le azioni statunitensi hanno fluttuato, Buffett ha incassato 369,9 milioni di dollari, influenzando il sentiment di mercato</h2><p>I tre principali indici del mercato azionario statunitense hanno oscillato, con l’indice S&amp;P 500 in calo dello 0,02% a 5.841,47 punti; il Dow Jones Industrial Average è salito dello 0,37% a 43.239,05 punti; l’indice Nasdaq è salito dello 0,04% a 18.373,61 punti. Il rendimento del titolo di stato decennale di riferimento è del 4,09%, mentre il rendimento del titolo di stato biennale, che è più sensibile alla politica dei tassi della Federal Reserve, è del 3,96%.</p>
<p>JPMorgan Chase ha dichiarato che il mercato azionario statunitense ha iniziato a elaborare il risultato della vittoria del candidato repubblicano Trump, e persino la vittoria completa del Partito Repubblicano. Lo stratega di mercato Nikolaos Panigirtzoglou ha affermato che la recente crescita delle azioni statunitensi ai massimi storici, in particolare le eccezionali performance delle azioni delle banche statunitensi, indica che gli investitori stanno scommettendo sulla vittoria dell’ex presidente Trump alle elezioni di novembre e su un andamento simile a quello del 2016. A causa dell’aspettativa che l’amministrazione Trump condurrà meno controlli sulla regolamentazione bancaria rispetto all’amministrazione Biden, i prezzi delle azioni del settore bancario statunitense sono ripartiti al rialzo. L’SPDR S&amp;P Regional Banking ETF (KRE) è salito di quasi il 6% questo mese, con le azioni finanziarie che sono il settore dal rendimento migliore nell’indice S&amp;P 500 questo mese. Panigirtzoglou ha affermato che le recenti tendenze delle banche, del dollaro statunitense e dei rendimenti dei bond sono state moderate rispetto al 2016, e la probabilità che Trump vinca è significativamente aumentata, il che si prevede che alla fine sosterrà i prezzi di Bitcoin e oro.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Glassa</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. 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 ripostaggio dell'articolo a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>