Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgcHJlc2lkZW50ZSBkZWxsYSBTRUMgaGEgZmF0dG8gdW5hIGRpY2hpYXJhemlvbmUgc3VpIEJpdGNvaW4gU3BvdCBFVEY6IGlsIEJyYXNpbGUgcGlhbmlmaWNhIGRpIGltcG9ycmUgdW5hIHRhc3NhIGRlbCAxNSUgc3VsbGUgY3JpcHRvdmFsdXRlOyB1bmEgYmFsZW5hIGhhIHRyYXNmZXJpdG8gb2x

2023-11-30, 04:04

<p><img src="https://gimg2.gateimg.com/image/article/17013241031_30.png" alt=""></p>
<h2 id="h2-Riassunto20quotidiano20delle20criptovalute20il20presidente20della20SEC20ha20rilasciato20una20dichiarazione20verso20gli20ETF20Bitcoin20spot20il20Brasile20pianifica20di20applicare20una20tassa20del201520sulle20criptovalute418597"><a name="Riassunto quotidiano delle criptovalute: il presidente della SEC ha rilasciato una dichiarazione verso gli ETF Bitcoin spot, il Brasile pianifica di applicare una tassa del 15% sulle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto quotidiano delle criptovalute: il presidente della SEC ha rilasciato una dichiarazione verso gli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot, il Brasile pianifica di applicare una tassa del 15% sulle criptovalute</h2><p>Recentemente, il presidente della SEC Gary Gensler è rimasto in silenzio quando gli è stato chiesto delle prospettive di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF e ha dichiarato che non “anticipa” questa questione. Gensler ha dichiarato nel suo discorso alla riunione dell’Associazione dei mercati sani che non farà previsioni sulle domande di Bitcoin spot ETF in fase di revisione. Ha definito il processo di revisione dell’istituzione come un “processo collaudato nel tempo”.</p>
<p>Il settore delle criptovalute ha atteso con impazienza l’approvazione della SEC per il primo ETF spot di Bitcoin, con società di gestione del patrimonio come Black Rock e Fidelity che hanno presentato diverse domande nei mesi scorsi, ma tutte sono state finora rinviare. Gensler ha ribadito la sua convinzione che il Bitcoin sia una merce e ha espresso preoccupazione per l’intero settore delle criptovalute. La SEC ha intrapreso azioni di contrasto contro le società di criptovalute, tra cui Coinbase e Binance, la più grande borsa di criptovalute al mondo, nell’ultimo anno.</p>
<p>Gensler ha anche espresso il suo sostegno a Rostin Behnam, presidente della Commodity Futures Trading Commission (CFTC), per aumentare il potere delle agenzie di regolamentazione dei derivati per regolare le criptovalute.</p>
<p>Inoltre, d’altro canto, il vice segretario del Tesoro degli Stati Uniti, Wally Adeyemo, ha dichiarato che l’amministrazione Biden sta chiedendo al Congresso di considerare la riforma più rigorosa del potere di sanzioni del Tesoro dal 2001 attacchi terroristici per aiutare a combattere l’uso di asset digitali nella finanza illegale.</p>
<p>Adeyemo ha detto: “Chiediamo al Congresso di istituire un sistema di sanzioni secondarie, che non solo escluderà un’azienda dal sistema finanziario degli Stati Uniti, ma esporrà anche che qualsiasi azienda che continui ad avere rapporti commerciali con entità soggette a sanzioni sarà tagliata fuori. Martedì, il Dipartimento del Tesoro ha fornito al Congresso una serie di raccomandazioni sensate per espandere il nostro potere, strumenti e risorse per perseguire attori illegali nel campo degli asset digitali.</p>
<p>Secondo Cointelgraph, il Senato brasiliano ha approvato nuove regole fiscali sul reddito il 29 novembre, secondo le quali i cittadini brasiliani potrebbero presto essere tenuti a pagare fino al 15% di tasse sul reddito cripto detenuto su exchange stranieri. Il disegno di legge è stato approvato dalla Camera dei Rappresentanti e si prevede che riceverà l’approvazione del presidente Luiz Inácio Lula da Silva, poiché il suo governo ha avviato una modifica delle regole fiscali sul reddito.</p>
<p>Secondo il disegno di legge, ogni cittadino brasiliano che guadagna più di $1.200 (6000 real brasiliani) sugli scambi esteri sarà soggetto a questa tassa a partire dal 1° gennaio 2024. Ma i redditi ottenuti prima del 31 dicembre di quest’anno continueranno ad essere tassati all’attuale aliquota fiscale del 8%.</p>
<p>Arthur Hayes ha dichiarato nel suo ultimo post sul blog che le autorità cinesi potrebbero essere in procinto di iniettare una grande quantità di credito nell’economia per stimolare i mercati di Bitcoin e delle criptovalute in generale.</p>
<p>Hayes ha affermato che gli Stati Uniti hanno di recente “indebolito il dollaro statunitense emettendo più Treasury bill” e con l’indice del dollaro statunitense in calo per tutto novembre, questo impatto è ora molto evidente. Egli ritiene che ciò abbia creato condizioni più favorevoli per le autorità cinesi di emettere una “grande quantità” di nuovo credito per l’industria immobiliare in difficoltà.</p>
<p>Queste dinamiche globali delle valute potrebbero beneficiare i mercati Bitcoin e cripto. Ha detto che se la Cina aumenta la stampa di denaro, questi fondi entreranno nel mercato globale e supporteranno l’aumento dei prezzi di tutti i tipi di asset rischiosi.</p>
<p>In primo luogo, potrebbero esserci flussi di fondi verso asset rischiosi dalla Cina continentale attraverso Hong Kong. Hayes ha detto che se esiste un modo per trasferire legalmente denaro dalla Cina continentale a Hong Kong, Bitcoin diventerà uno dei tanti asset rischiosi acquistati. In secondo luogo, a causa dell’abbondanza di credito RMB, la domanda globale di credito e liquidità in USD diminuirà.</p>
<p>Dato che il dollaro statunitense è la valuta di finanziamento più grande al mondo, se i prezzi dei crediti diminuiscono, i prezzi di tutti gli asset a offerta fissa come Bitcoin e l’oro aumenteranno. Hayes ha concluso che poiché questa previsione è vantaggiosa per gli asset a rischio, ha intenzione di concentrarsi sugli investimenti in criptovalute anziché investire in obbligazioni del Tesoro statunitense. Ha dichiarato che continuerà a trasferire fondi dai titoli del Tesoro statunitense alle criptovalute.</p>
<p>Secondo gli ultimi dati del browser on-chain, un indirizzo di balena Bitcoin inattivo da quasi 4 anni ha trasferito tutti i 3623 BTC il 30 novembre alle 09:01:48, risultando in un profitto fluttuante di circa 100 milioni di dollari in base ai prezzi di mercato attuali. Tra questi, 2000 BTC sono stati trasferiti all’indirizzo 1AW1h4us8j5gnJRbhBndgjdx2vkfSe1iV8; 1623,12 BTC sono stati trasferiti all’indirizzo 1Jo518BnukxJtha4eCJE3kJHp8dxorzVTo.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi317883"><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-BTC968528"><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/1701324157BTC.png" alt=""><br>Entrambi i BTC hanno cercato di salire sopra il livello di $38.250 questa settimana senza successo. Attualmente, sta scambiando appena sotto la neckline a $37.980. Nel breve termine, il mercato è ancora in uno stato di indecisione tra tori e orsi. È consigliabile attendere una direzione chiara prima di stabilire posizioni. Segni di un potenziale massimo nel medio termine stanno emergendo, e si consiglia cautela contro potenziali condizioni di mercato volatile.</p>
<h3 id="h3-ETH764349"><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/1701324177ETH.png" alt=""><br>Il grafico a 4 ore mostra una svolta, stabilizzando il significativo trend al ribasso. I prezzi di chiusura hanno mantenuto il livello di resistenza di $2.000 per due giorni. Osservare una svolta al di sopra di $2.135, con una resistenza obiettivo a $2.317. Le sequenze di Fibonacci possono essere utilizzate per valutare i movimenti verso l’alto. Una rottura al di sotto del livello di supporto di $1.957 potrebbe segnalare un cambiamento verso un trend ribassista.</p>
<h3 id="h3-OGN491402"><a name="OGN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OGN</h3><p><img src="https://gimg2.gateimg.com/image/article/1701324197OGN.png" alt=""><br>OGN, un progetto veterano, ha mantenuto un forte supporto a $0.0745 e, nonostante la mancanza di movimenti di prezzo significativi quest’anno, ha visto un volume di trading anomalo. Nel breve termine, si sta formando un modello a tazza e manico, e una rottura sopra $0.1345 potrebbe portare a obiettivi a $0.2247 e $0.2986, con un massimo storico a $2.86.</p>
<h2 id="h2-Macro20il20PIL20ha20superato20le20aspettative20nel20terzo20trimestre20tre20funzionari20del20comitato20di20voto20del20FOMC20hanno20opinioni20diverse796908"><a name="Macro: il PIL ha superato le aspettative nel terzo trimestre, tre funzionari del comitato di voto del FOMC hanno opinioni diverse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: il PIL ha superato le aspettative nel terzo trimestre, tre funzionari del comitato di voto del FOMC hanno opinioni diverse</h2><p>Mercoledì, a causa della crescita economica del terzo trimestre degli Stati Uniti che ha superato le aspettative, l’indice del dollaro statunitense è rimbalzato da un minimo di oltre tre mesi e ha continuato a testare il livello 103 nel mercato statunitense, ma non è riuscito a stabilizzarsi sopra questo livello, chiudendo infine in rialzo dello 0,10% a 102,84. Il rendimento del Tesoro degli Stati Uniti è continuamente in calo, con il rendimento del Tesoro a 10 anni che scende sotto la soglia del 4,3% e chiude infine al 4,259%; Il rendimento del Tesoro a due anni degli Stati Uniti, che è più sensibile ai tassi di interesse della politica della Federal Reserve, è sceso al 4,646%.</p>
<p>L’oro spot è rimasto stabile sopra il livello di 2.040 ed è brevemente salito sopra il livello di 2.050 nella sessione asiatica, chiudendo alla fine in rialzo dello 0,16% a $2.044,17 l’oncia; l’argento spot ha oscillato intorno ai $25 e alla fine è sceso dello 0,02% a $25,02 l’oncia.</p>
<p>Il petrolio greggio ha mostrato un trend altalenante, con il WTI che è sceso fino a un minimo intraday di $75,65 prima di recuperare tutto il terreno perduto e risalire, chiudendo infine in rialzo dello 1,52% a $77,67 al barile; il petrolio Brent è sceso di quasi l’1% in un momento e ha raggiunto quota $80, per poi salire vigorosamente fino a circa $83, chiudendo infine in rialzo del 1,5% a $82,61 al barile.</p>
<p>I tre principali indici azionari statunitensi hanno aperto in rialzo e chiuso in ribasso, con il Dow Jones in rialzo dello 0,04%, lo S&amp;P 500 in calo dello 0,09% e il Nasdaq in calo dello 0,19%.</p>
<p>I dati della scorsa notte sono stati rilasciati e il PIL per il terzo trimestre è stato rivisto al rialzo al 5,2%, superando non solo il valore iniziale del 4,9%, ma anche le aspettative di mercato del 5,0%. Questo è il tasso di espansione più veloce dal quarto trimestre del 2021. Si può dire che i dati sembrano davvero rialzisti, molto più alti del livello di ‘1,8%’ che la Federal Reserve ritiene non scatenerà inflazione - dovrebbe ridurre significativamente le aspettative di mercato per i tagli dei tassi d’interesse l’anno prossimo. Tuttavia, la situazione non è così semplice come immaginiamo.</p>
<p>Il rapporto conferma un trend al ribasso dell’inflazione, con il tasso di crescita anno su anno dell’indicatore di inflazione preferito dalla Federal Reserve, l’indice dei prezzi PCE, rivisto al ribasso al 2,8% nel terzo trimestre, e l’indice dei prezzi PCE core (escludendo alimentari ed energia) rivisto al ribasso al 2,3% nel terzo trimestre.</p>
<p>Tuttavia, Wall Street crede che questo rapporto sia diventato una “cosa del passato”, riflettendo la situazione del terzo trimestre, mentre la situazione del quarto trimestre è stata molto negativa, soprattutto in ottobre quando le vendite al dettaglio hanno registrato il loro primo calo in sette mesi. Goldman Sachs ha ridotto la sua previsione di PIL del quarto trimestre per gli Stati Uniti al 1,4% la scorsa notte.</p>
<p>Inoltre, mercoledì due funzionari della Federal Reserve hanno fornito motivazioni per mantenere invariati i tassi di interesse, mentre un altro ha avvertito che il rischio di un’alta inflazione dovrebbe portare a mantenere l’opzione di ulteriori rialzi dei tassi di interesse.</p>
<p>Il presidente della Federal Reserve di Cleveland, Mester, che ha sostenuto aumenti dei tassi di interesse quest’anno, ha dichiarato che la politica monetaria è in una buona posizione, lasciando intendere che appoggia nuovamente la decisione di non intervenire alla prossima riunione del mese prossimo.</p>
<p>Il presidente della Fed di Atlanta, Bostic, ha dichiarato di essere sempre più convinto che la traiettoria al ribasso dell’inflazione possa continuare, mentre il presidente della Fed di Richmond, Barkin, ha affermato che l’opzione di aumentare i tassi d’interesse dovrebbe essere mantenuta per evitare che l’inflazione diventi ostinata.</p>
<p>Bostic e Balgin hanno opinioni diverse sulle prospettive dell’inflazione. Balgin ha sottolineato che la pressione persistente sui prezzi nel settore immobiliare e dei servizi è un motivo di cautela.</p>
<p>Ieri sera, questi tre funzionari della Federal Reserve hanno tenuto discorsi, mantenendo ancora una posizione falco. Uno sostiene di mantenere i tassi di interesse invariati, uno avverte di mantenere l’opzione di aumento dei tassi di interesse, mentre l’altro non discute il percorso dei tassi di interesse, ma la dichiarazione di questa persona è più importante.</p>
<p>Bostic aveva precedentemente affermato di non credere che fosse necessario ulteriori aumenti dei tassi di interesse. Inoltre, ha preceduto i suoi colleghi nel chiedere di interrompere gli aumenti dei tassi di interesse. La Federal Reserve di Atlanta prevede che il tasso di inflazione scenderà al 2,5% entro la fine del 2024 e si avvicinerà al 2% entro la fine del 2025.</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. Sarà consentito il ripost del articolo a condizione che sia 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>