Tm90aXppZSBxdW90aWRpYW5lIHwgQ2lyY2xlIHBpYW5pZmljYSBkaSBhbmRhcmUgcHViYmxpY2EgbCdhbm5vIHByb3NzaW1vOyBsZSBhemlvbmkgZGkgY29udHJhc3RvIGFsbGUgbGVnZ2kgY3JpcHRhdGUgZGVnbGkgU3RhdGkgVW5pdGkgaGFubm8gcmFnZ2l1bnRvIHVuIGxpdmVsbG8gc3RvcmljbzsgbCdhZmZsdXNzbyBkaSBmb25kaSB

2023-11-08, 06:09

<p><img src="https://gimg2.gateimg.com/image/article/16994246581108.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Le20azioni20di20contrasto20alla20criptovaluta20negli20Stati20Uniti20hanno20raggiunto20un20livello20storico20nel20202320Circle20pianifica20di20quotarsi20in20borsa20lanno20prossimo289143"><a name="Crypto Daily Digest: Le azioni di contrasto alla criptovaluta negli Stati Uniti hanno raggiunto un livello storico nel 2023, Circle pianifica di quotarsi in borsa l’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Le azioni di contrasto alla criptovaluta negli Stati Uniti hanno raggiunto un livello storico nel 2023, Circle pianifica di quotarsi in borsa l’anno prossimo</h2><p>Secondo un rapporto del Wall Street Journal, il vice segretario del Tesoro degli Stati Uniti, Wally Adeyemo, ha dichiarato martedì durante l’assemblea annuale della Securities Industry and Financial Markets Association a Washington che l’amministrazione Biden spera che il Congresso conceda nuovi poteri per aiutare a combattere l’uso illegale delle criptovalute e ha menzionato che Hamas ha cercato pubblicamente di raccogliere fondi attraverso le criptovalute, il che ha suscitato “preoccupazione per l’uso illegale di attività digitali”.</p>
<p>Ha dichiarato che il Tesoro ha comunicato con i democratici e i repubblicani sulle possibili azioni che potrebbero intraprendere. Il Congresso deve intervenire in alcuni settori. Il Ministero delle Finanze continuerà a intervenire e a collaborare con i legislatori per spingere l’industria delle criptovalute a innovare in modo responsabile. Adeyemo ha anche chiesto l’autoregolamentazione nell’industria delle criptovalute.</p>
<p>Inoltre, secondo il Rapporto sull’attività di contrasto alla criminalità per l’anno fiscale 2023 pubblicato oggi dalla Commodity Futures Trading Commission (CFTC), il numero di casi nel settore degli asset digitali ha raggiunto un livello storico. Il Dipartimento dell’attività di contrasto alla criminalità della CFTC (DOE) ha attuato un totale di 96 azioni di contrasto nel 2023, che hanno portato a multe, risarcimenti e sequestri per un valore superiore a 4,3 miliardi di dollari. Tra queste, 47 azioni sono relative a merci digitali, rappresentando oltre il 49% di tutte le azioni. Al contrario, la CFTC ha attuato un totale di 18 azioni di contrasto relative agli asset digitali nell’anno fiscale 2022.</p>
<p>Secondo Bloomberg, il rapporto finanziario del terzo trimestre di Robin Hood ha mostrato un reddito netto di $467 milioni, inferiore alla previsione media degli analisti di $478.9 milioni, ma in aumento del 29% rispetto allo stesso periodo dell’anno scorso. Il ricavo basato su transazioni è stato di $185 milioni, in diminuzione del 11% su base annua, principalmente a causa di una diminuzione del volume di scambi di criptovalute del 55% anno su anno a $23 milioni.</p>
<p>Robinhood ha dichiarato in una dichiarazione che, mentre si espande a livello globale, prevede di lanciare attività di trading di criptovalute UE e di intermediazione nel Regno Unito nelle prossime settimane. Il prezzo delle azioni di Robin Hood è sceso di circa il 7% negli scambi tardivi nel mercato di New York, ma è comunque aumentato di quasi il 20% fino ad ora quest’anno.</p>
<p>L’8 novembre, secondo quanto riportato da Bloomberg citando fonti interne, Circle Internet Financial Ltd., l’emittente della stablecoin USDC, sta valutando una quotazione all’inizio del 2024. L’azienda sta negoziando con dei consulenti per prepararsi a una possibile offerta pubblica iniziale. Al momento, la revisione pertinente è ancora in corso e non è certo se Circle alla fine deciderà di proseguire con l’offerta pubblica.</p>
<p>Sebbene non sia chiaro quale valutazione Circle stia cercando nella sua IPO, la valutazione dell’azienda quando ha tentato di fondersi con la società di acquisizione di scopo speciale Concord Acquisition Corp. nel 2022 era di 9 miliardi di dollari. Un rappresentante di Circle ha dichiarato in una nota che diventare un’azienda quotata negli Stati Uniti fa da tempo parte della visione strategica di Circle, ma non commenteremo i rumors.</p>
<p>CoinShares, una società di gestione di asset digitali, ha riportato lunedì che mentre gli investitori continuano ad affluire sul mercato, i fondi crittografici hanno registrato i loro migliori afflussi dall’ultimo mercato rialzista delle criptovalute nel 2021. Secondo i dati di CoinShares, i veicoli di investimento che detengono criptovalute hanno registrato un afflusso netto di $261 milioni la scorsa settimana, registrando afflussi positivi per sei settimane consecutive, per un totale di $767 milioni.</p>
<p>James Butterfill, direttore della ricerca presso CoinShares, ha fatto notare che “questo round di afflussi è ora in linea con gli afflussi di luglio 2023 ed è il più grande dall’epoca della fine del mercato rialzista nel dicembre 2021.” <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> I fondi (BTC) dominano ancora la classe di attività, portando la maggior parte degli afflussi, con circa 229 milioni di dollari la scorsa settimana e 842 milioni di dollari quest’anno.</p>
<p>Butterfill ha spiegato che ciò potrebbe essere dovuto all’aumentare della probabilità che gli ETF di spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> vengano approvati negli Stati Uniti e a un debole supporto dei dati macroeconomici. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il fondo ha registrato il più grande afflusso di denaro dal agosto 2022, raggiungendo i 17,5 milioni di dollari.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi212994"><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-BTC904922"><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/1699424701BTC.png" alt=""><br>Nelle prime ore di ieri, il Bitcoin (BTC) è tornato alla linea di tendenza ascendente, rimanendo al di sotto della media mobile a breve termine. Successivamente è salito fino a quota $35,888 ma ha comunque faticato a superare il livello psicologico di $36,000. Nel breve termine, il BTC si mantiene stabile intorno alla media mobile, indicando che potrebbe verificarsi un movimento significativo la prossima settimana.</p>
<h3 id="h3-ETH369641"><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/1699424721ETH.png" alt=""><br>Lo scorso fine settimana, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) è riuscito a stabilizzarsi sopra i $1.857 e ha rotto il trend al ribasso generale, mettendo fine a sette mesi di calo. L’azione dei prezzi a breve termine sembra essere in fase di consolidamento, con $1.840 che funge da solido livello di supporto. Aspettare una chiara direzione è una strategia conservativa.</p>
<h3 id="h3-ID317339"><a name="ID" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ID</h3><p><img src="https://gimg2.gateimg.com/image/article/1699424739ID.png" alt=""><br>Il grafico a quattro ore per ID mostra un modello completo a testa e spalle, con la rottura della neckline a $0,2870. Un approccio conservativo sarebbe quello di attendere una rottura sostenuta al di sopra di $0,2870 e mirare a $0,3618 come obiettivo massimo. Le strategie di uscita possono utilizzare i livelli di estensione di Fibonacci (0,3045, 0,3154, ecc.).</p>
<h2 id="h2-Macro20Le20azioni20statunitensi20sono20in20aumento20da20720giorni20consecutivi20La20pressione20inflazionistica2020in20aumento20Il20Federal20Reserve20Bowman20ha20dichiarato20la20necessit20di20ulteriori20aumenti20dei20tassi20di20interesse566856"><a name="Macro: Le azioni statunitensi sono in aumento da 7 giorni consecutivi; La pressione inflazionistica è in aumento; Il Federal Reserve Bowman ha dichiarato la necessità di ulteriori aumenti dei tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le azioni statunitensi sono in aumento da 7 giorni consecutivi; La pressione inflazionistica è in aumento; Il Federal Reserve Bowman ha dichiarato la necessità di ulteriori aumenti dei tassi di interesse</h2><p>Martedì, i tre principali indici azionari statunitensi sono saliti per sette giorni consecutivi di negoziazione, con il Dow Jones Industrial Average in aumento dello 0,17%, il Nasdaq in aumento dello 0,9% e l’indice S&amp;P 500 in aumento dello 0,25%. L’indice Nasdaq China Golden Dragon ha chiuso in ribasso dello 0,7%.</p>
<p>L’indice del dollaro USA ha continuato a riprendersi dal brusco sell-off della scorsa settimana ed è finito in rialzo dello 0,209% a 105,52. I rendimenti dei bond USA hanno ripreso a diminuire, con i rendimenti dei bond USA a lungo termine in testa al calo. Il rendimento del Tesoro USA decennale ha chiuso al 4,571%; Il rendimento del Tesoro USA a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso al 4,915%.</p>
<p>L’oro spot è sceso per il secondo giorno consecutivo di negoziazione, chiudendo in ribasso dello 0,43% a 1969,26 dollari per oncia, il più basso da quasi tre settimane; l’argento spot ha chiuso in ribasso del 1,73% a 22,63 dollari per oncia.</p>
<p>Poiché i deboli dati economici globali hanno offuscato le preoccupazioni che la guerra tra Israele e Hamas potesse trasformarsi in un conflitto regionale più ampio, i prezzi internazionali del petrolio sono crollati, con entrambi i prezzi del petrolio che hanno toccato nuovi minimi da luglio 24. Il petrolio greggio WTI è sceso del 4,69% a $77,08 al barile; il petrolio greggio Brent ha chiuso in ribasso del 4,40% a $81,40 al barile.</p>
<p>La scorsa settimana si riteneva ampiamente che la Federal Reserve avesse terminato, e ora la Fed sta raccontando una storia completamente opposta. In effetti, questa situazione poteva essere prevista - la Fed ha bisogno di stringere il suo ambiente finanziario per combattere l’inflazione. Diamo un’occhiata a quello che hanno detto questi funzionari.</p>
<p>Il presidente della Federal Reserve di Minneapolis, Kashkari: Se necessario, la Federal Reserve prenderà ulteriori misure sui tassi di interesse e il FOMC non ha discusso il contenuto dei tagli dei tassi di interesse.</p>
<p>Presidente della Fed di Chicago Goolsbee: Se il rendimento dei titoli del Tesoro a lungo termine rimane elevato, è probabile che equivalga a una politica di restrizione. Il primo compito del cambiamento della posizione dei tassi di interesse è il progresso dell’inflazione;</p>
<p>La governatrice della Federal Reserve Bowman: ci si aspettano ulteriori aumenti dei tassi d’interesse.</p>
<p>Presidente della Fed di Dallas Logan: l’inflazione è ancora troppo alta, e i dati sembrano muoversi verso il 3% invece che il 2%.</p>
<p>Il governatore della Federal Reserve Waller: l’economia del terzo trimestre è in pieno boom e la Federal Reserve sta monitorando attentamente questa situazione. L’impennata dei rendimenti del Tesoro USA decennale è un ‘terremoto’.</p>
<p>Il modello GDPNow della Fed di Atlanta prevede che il tasso di crescita del PIL degli Stati Uniti nel quarto trimestre sarà del 2,1%, rispetto alla precedente stima del 1,2%.</p>
<p>I funzionari della Federal Reserve hanno sottolineato la loro vigilanza contro l’inflazione questa settimana, e in pochi giorni sembrano avere una tendenza collettiva a ribaltare i picchi dei tassi di interesse.</p>
<p>Secondo gli analisti, quando avviene questo cambiamento (simile a una colomba), potrebbe verificarsi improvvisamente e “ulteriori aumenti della disoccupazione o un altro impatto negativo potrebbero diventare un catalizzatore per questa situazione.”</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>