Tm90aXppZSBxdW90aWRpYW5lIHwgU2kgcHJldmVkZSBjaGUgZ2xpIEVURiBzcG90IEJUQyB2ZXJyYW5ubyBhcHByb3ZhdGkgZW50cm8gbGEgZmluZSBkZWwgMjAyMywgUmVkZGl0IGNoaXVkZSBpIHNlcnZpemkgZGkgcHVudGkgZGVsbGEgY29tbXVuaXR5LCBpIHRva2VuIGNvcnJlbGF0aSBjcm9sbGFubw==

2023-10-18, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/16976074061018.jpg" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20si20prevede20che20gli20ETF20Bitcoin20spot20saranno20approvati20entro20la20fine20del20202320Reddit20chiude20i20servizi20dei20punti20della20comunit20e20i20token20correlati20crollano529728"><a name="Riassunto giornaliero delle criptovalute: si prevede che gli ETF Bitcoin spot saranno approvati entro la fine del 2023, Reddit chiude i servizi dei punti della comunità e i token correlati crollano" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: si prevede che gli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot saranno approvati entro la fine del 2023, Reddit chiude i servizi dei punti della comunità e i token correlati crollano</h2><p>Nonostante le notizie false di ieri <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli ETF hanno creato scalpore, l’amministratore delegato di Ark Invest, Cathie Wood, ha dichiarato in un’intervista con CNBC che ritiene che la probabilità che la SEC degli Stati Uniti approvi gli ETF Bitcoin potrebbe aumentare.</p>
<p>Il fatto che la SEC abbia scelto di porre domande anziché respingere i documenti di domanda pertinenti presentati da persone indica la sua volontà di continuare ad avanzare in questa materia. Wood ha sottolineato la crescita <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> della comunità cripto rispetto all’ETF Bitcoin.</p>
<p>Wood prevede che potrebbero essere approvati più ETF Bitcoin entro la fine del 2023 o all’inizio del 2024, e aggiunge che la SEC deve decidere sulla domanda di ARK entro il 10 gennaio 2024. Wood prevede che Ark Invest sarà approvato nel primo gruppo e ‘potrebbero essere approvati contemporaneamente più ETF Bitcoin (società)’.</p>
<p>In precedenza, Eric Balchunas, un analista di Bloomberg ETF, ha twittato sull’applicazione X affermando che Cathie Wood credeva che il personale della SEC “avesse compreso Bitcoin e i suoi vantaggi”, ma che Gary Gensler, il presidente della SEC degli Stati Uniti, interferisse costantemente nel mezzo (cosa che anche noi sentivamo).</p>
<p>Secondo TechCrunch, Reddit ha deciso di terminare il suo servizio di punti comunitari basato su blockchain, che esiste da quasi tre anni. Tim Rathschmidt, Direttore delle comunicazioni per i consumatori e i prodotti presso Reddit, ha detto: ‘Anche se vediamo alcune opportunità future per i punti comunitari, l’investimento di risorse richiesto è troppo alto per essere sostenibile. Inoltre, l’ambiente normativo ha aumentato anche la difficoltà in questo senso’. Reddit cancellerà i punti comunitari l’8 novembre.</p>
<p>Dopo la diffusione della notizia, il prezzo del token nativo Moons (MOON) nella community Reddit r/CryptoCurrency è diminuito dell’85%, il token Bricks (BRICK) nella sotto-sezione r/Fortnite è diminuito del 67%, e il token Donut (DONUT) che rappresenta i punti della community della sotto-sezione r/ethtrader è diminuito del 66%.</p>
<p>Secondo Cointelgraph, la Commissione per le Risorse Ambientali ed Energetiche della Camera dei Rappresentanti della Pennsylvania ha approvato a stretta maggioranza il Cryptocurrency Energy Conservation Act (13 favorevoli, 12 contrari). La Camera dei Rappresentanti della Pennsylvania ha tolto dalla loro proposta di legge per regolare il consumo energetico nell’industria, un divieto biennale sull’estrazione di criptovalute, sostenendo che i sindacati abbiano esercitato pressioni per questo cambiamento.</p>
<p>Secondo le fonti citate dal Financial Times, Israele ha ordinato il congelamento dei conti di criptovaluta per prevenire il <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> di fondi ad Hamas. Dall’attacco di Hamas del 7 ottobre, oltre 100 account su Binance, la più grande criptovaluta al mondo, sono stati congelati. Le autorità hanno inoltre richiesto informazioni su fino a 200 account di criptovalute aggiuntivi, con persone informate sulla questione che affermano che la maggior parte di essi sono stati effettuati su Binance.</p>
<p>Le persone familiari con le azioni delle forze dell’ordine israeliane dicono che dal 7 ottobre sono state scoperte circa 150 attività di raccolta fondi legate ad Hamas e ad altre organizzazioni. La settimana scorsa, la polizia israeliana ha pubblicato sui social media di aver congelato gli account utilizzati da Hamas per la raccolta fondi, ma il numero esatto è sconosciuto.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi843686"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC796852"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1697607442BTC.png" alt=""><br>Nel corso degli ultimi due giorni, il prezzo è salito a $30.000 e ha cercato di mantenersi sopra il livello di supporto cruciale di $28.125. Nel breve termine, c’è il potenziale per ulteriori guadagni fino a $29.500. Il target di rottura chiave a medio termine è a $33.085. Se non supera questo livello, la tendenza al rialzo dell’anno potrebbe giungere al termine. Si consiglia di prestare attenzione ai livelli di resistenza.</p>
<h3 id="h3-ETH422534"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1697607474ETH.png" alt=""><br>Questa settimana, insieme al mercato più ampio, c’è stato un significativo rimbalzo. Tuttavia, nel breve termine, il trend complessivo di rimbalzo rimane debole. Anche se l’obiettivo di $1,631 è stato raggiunto, continua a oscillare al di sotto di $1,570. L’obiettivo al ribasso rimane a $1,465. È consigliabile mantenere per il lungo termine.</p>
<h3 id="h3-BIGTIME902360"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1697607508BIGTIME.png" alt=""><br>La scorsa notte, a parte Amber Group e FBG, c’è stata un’importante trasferimento di token BIGTIME sulla blockchain, con un totale di 23,5 milioni di token BIGTIME di origine sconosciuta ancora da determinare. Questi token sembrano essere entrati nel mercato secondario degli scambi.</p>
<p>Dopo il loro ingresso nel mercato secondario, il mercato nel complesso è rapidamente sceso nell’intervallo da $0.1835 a $0.15, con un calo sostanziale del 32,33%. È difficile determinare se ciò è dovuto ai market maker o a fonti sconosciute. Dal punto di vista dell’analisi tecnica, è difficile individuare trend indipendenti a breve termine. È consigliabile concentrarsi sull’osservazione dopo aver impostato gli ordini di stop-loss.</p>
<h2 id="h2-Macro20I20dati20terroristici20superano20le20aspettative20in20attesa20della20decisione20sui20tassi20della20Fed20di20novembre276518"><a name="Macro: I dati terroristici superano le aspettative, in attesa della decisione sui tassi della Fed di novembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I dati terroristici superano le aspettative, in attesa della decisione sui tassi della Fed di novembre</h2><p>Il mercato azionario statunitense è stato misto, con l’indice S&amp;P 500 in calo di meno dello 0,1%, l’indice Dow Jones in aumento di meno dello 0,1% e l’indice Nasdaq Composite in calo dello 0,3%. Il prezzo dell’oro ha chiuso sopra i $1920, vicino all’alto registrato lo scorso venerdì, con una fluttuazione giornaliera di meno di $20. Il petrolio greggio statunitense è rimasto stabile dopo essere fluttuato nell’intervallo di quasi $2 durante tutta la giornata. Nell’attuale contesto, molti investitori sono riluttanti a scommettere direttamente sul petrolio greggio. L’indice del dollaro statunitense è sceso per il secondo giorno di negoziazione consecutivo, scendendo al di sotto del livello 106.</p>
<p>Il tasso mensile delle vendite al dettaglio negli Stati Uniti ha registrato lo 0,7% a settembre, superando l’aspettativa dello 0,3%. Il valore precedente è stato rivisto al rialzo dallo 0,6% all’0,8%. Gli altri dati economici pubblicati ieri sera erano misti. Tuttavia, i dati più importanti ‘spaventosi’ hanno superato di gran lunga le aspettative, indicando che il consumo negli Stati Uniti è ancora elevato e che la probabilità di scommesse di mercato su un aumento dei tassi a dicembre è aumentata. I dati inaspettati sull’inflazione e sul consumo potrebbero aggravare ulteriormente i problemi affrontati dalla Federal Reserve.</p>
<p>Verbali della riunione sui tassi di sconto della Federal Reserve: il consiglio di amministrazione della Federal Reserve di Cleveland ha chiesto un aumento di 25 punti base del tasso di sconto a settembre; il presidente della Federal Reserve Barkin ha dichiarato che la Federal Reserve ha il tempo di osservare i dati prima di prendere la sua prossima decisione di adeguamento del tasso di interesse. Tende a mantenere i tassi di interesse invariati, dicendo che c’è tempo per attendere e vedere se sono necessari ulteriori aumenti dei tassi.</p>
<p>Il membro del FOMC e presidente della Federal Reserve di Minneapolis, Kashkari, ha dichiarato che l’inflazione è ancora troppo alta.</p>
<p>Attualmente, ci sono ancora disaccordi all’interno della Federal Reserve, ma questi disaccordi non sono così significativi come prima, compreso se la Federal Reserve aumenterà i tassi di interesse a novembre.</p>
<p>Quindi, quando i dati e tutte le opinioni pubbliche sul mercato si uniscono, la Federal Reserve sa naturalmente se aumentare i tassi di interesse o di quanto, il che è il fascino del sistema. Pertanto, dovremmo partecipare attivamente alle discussioni ogni giorno e, durante le discussioni, aumentare anche il nostro sistema di conoscenza.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</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 alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita 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>