Tm90aXppZSBxdW90aWRpYW5lIHwgQ1ogaGEgY29uZmVzc2F0byBlIHNpIMOoIGRpbWVzc287IFVuYSBiYWxlbmEgYmx1IGhhIHZlbmR1dG8gdHV0dGkgaSBCVEMgcHJpbWEgZGVsIGNyb2xsbzsgTGEgbGlxdWlkYXppb25lIGRpIG9yZGluaSBtdWx0aXBsaSBuZWxsYSByZXRlIGNyaXB0YXRhIMOoIHN0YXRhIGRpIHF1YXNpICQyMDBNIG5

2023-11-22, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/17006357211_22.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20CZ20Confessa20e20si20Dimette20Una20Balena20Blu20Vende20Tutti20i20Bitcoin20Prima20di20un20Crollo804994"><a name="Crypto Daily Digest: CZ Confessa e si Dimette, Una Balena Blu Vende Tutti i Bitcoin Prima di un Crollo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: CZ Confessa e si Dimette, Una Balena Blu Vende Tutti i <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Prima di un Crollo</h2><p>Secondo Bloomberg, Binance Holdings Limited e il suo CEO CZ hanno ammesso le accuse penali di riciclaggio di denaro e violazione delle sanzioni statunitensi, tra cui permettere transazioni con Hamas e altre organizzazioni terroristiche. Binance ha accettato di dichiararsi colpevole delle accuse penali e di pagare una multa superiore a 4,3 miliardi di dollari. CZ ha accettato di dimettersi e pagare una multa di 50 milioni di dollari.</p>
<p>In un documento pubblicato martedì, Binance è stato accusato di tre capi d’imputazione, tra cui la violazione delle normative antiriciclaggio, la cospirazione per svolgere attività di trasferimento non autorizzato e la violazione delle sanzioni statunitensi. Binance pagherà una multa penale di 1,8 miliardi di dollari e verrà confiscata una somma di 2,5 miliardi di dollari. La multa di 4,3 miliardi di dollari include 3,4 miliardi di dollari pagati alla Financial Crime Enforcement Network del Dipartimento del Tesoro degli Stati Uniti e 968 milioni di dollari pagati al dipartimento delle sanzioni del Dipartimento del Tesoro.</p>
<p>Il Dipartimento del Tesoro degli Stati Uniti ha dichiarato che le violazioni di Binance includono la mancata prevenzione e segnalazione di transazioni sospette con terroristi, tra cui Hamas, Jihad Islamica Palestinese, Al Qaeda e lo Stato Islamico dell’Iraq e della Siria. Secondo i documenti del tribunale, Binance ha consentito almeno 1,1 milioni di transazioni correlate, per un totale di oltre 898 milioni di dollari, riguardanti clienti iraniani.</p>
<p>Il segretario del Tesoro degli Stati Uniti Yellen ha dichiarato in un comunicato stampa che “Binance ha voltato le spalle ai suoi obblighi legali nella ricerca del profitto. Binance sceglie di dare priorità alla crescita invece di conformarsi ai requisiti legali degli Stati Uniti. Binance ha completato miliardi di dollari di transazioni senza raccogliere le informazioni necessarie dei clienti o monitorare le transazioni.” CZ affronterà anche fino a 10 anni di prigione. Il suo avvocato ha dichiarato in tribunale martedì che la sua sentenza sarà posticipata di sei mesi.</p>
<p>Il giudice ha dichiarato durante l’udienza di preghiera che l’accordo di transazione di CZ prevede la rinuncia al suo diritto di ricorso, a condizione che la sua condanna non superi i 18 mesi.</p>
<p>Inoltre, il Dipartimento del Tesoro degli Stati Uniti manterrà l’accesso ai libri, ai registri e ai sistemi di Binance per cinque anni.</p>
<p>Secondo una dichiarazione del Dipartimento del Tesoro degli Stati Uniti, per garantire che Binance rispetti i suoi termini di regolamento, compreso il divieto di fornire servizi agli americani, e per assicurare che le attività illegali siano risolte, il Dipartimento del Tesoro manterrà l’accesso ai libri, ai registri e ai sistemi di Binance tramite supervisori per un periodo di cinque anni.</p>
<p>Se Binance non riesce a adempiere a queste obbligazioni, potrebbe affrontare ulteriori multe significative, compresa una multa sospesa di 150 milioni di dollari. Se non riesce a rispettare gli impegni di conformità richiesti e le disposizioni regolamentari, FinCEN addebiterà questa multa.</p>
<p>L’ispettore superviserà le misure correttive necessarie per affrontare la mancata conformità di Binance agli obblighi di antiriciclaggio e sanzioni. L’autorità di regolamentazione condurrà anche revisioni regolari e riferirà i suoi risultati e le raccomandazioni a FinCEN, OFAC e CFTC per garantire che Binance continui a conformarsi ai termini del protocollo di regolamento.</p>
<p>Si comprende che CZ è stato rilasciato per pagare una garanzia personale di $175 milioni e l’udienza di condanna è prevista per le 9:00 ora del Pacifico del 23 febbraio 2024 (1:00 ora di Pechino del 24 febbraio).</p>
<p>La clausola di rilascio di CZ gli vieta di violare la legge, flirtare con testimoni o vittime, o assumere farmaci controllati da banco, che è una regola normale in cauzione. A CZ è stato permesso di lasciare gli Stati Uniti e ha dichiarato che deve tornare 14 giorni prima della condanna. Bloomberg ha riferito che la condanna di CZ non dovrebbe superare i 18 mesi.</p>
<p>Caroline Pham, membro della US Commodity Futures Trading Commission (CFTC), ha dichiarato che oltre alle multe inflitte a Binance e CZ, se un giudice federale approverà il piano di accordo proposto, l’ex Chief Compliance Officer di Binance, Samuel Lim, pagherà anche una multa di 1,5 milioni di dollari. Gli sarà inoltre vietato svolgere attività di brokeraggio di futures non registrati o gestire qualsiasi piattaforma di derivati criptati illegali. Caroline Pham ha dichiarato che questa è la prima volta che la CFTC persegue la responsabilità personale con gli esecutivi della conformità.</p>
<p>Secondo il monitoraggio di Lookonchain, una balena blu ha venduto tutti i 636 BTC (circa 23,46 milioni di dollari) prima che il Dipartimento di Giustizia degli Stati Uniti annunciasse un’importante azione di contrasto alle criptovalute. L’indirizzo della balena gigante aveva precedentemente guadagnato oltre 40 milioni di dollari in BTC comprando a prezzi bassi e vendendo a prezzi alti.</p>
<p>Influenzato dagli eventi sopra menzionati, i dati di Coinglass mostrano che nelle ultime 24 ore, la liquidazione del contratto dell’intera rete del mercato delle criptovalute ha raggiunto i 231 milioni di dollari, con un totale di 96943 persone liquidate.</p>
<p>Tra questi, la liquidazione di ordini multipli ammonta a $190 milioni, mentre la liquidazione degli ordini short è di $41,7498 milioni. Per valuta, la liquidazione di BTC è di circa $64,9583 milioni, rappresentando la proporzione più grande. La liquidazione di ETH è di circa $269,775 milioni, mentre la liquidazione di SOL è di circa $11,252 milioni. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> La liquidazione è di circa $6.0435 milioni e <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> La liquidazione di ‘s è di circa $5.9157 milioni.</p>
<p>C’era FTT prima e Binance dopo. Sebbene le circostanze degli incidenti sulle due piattaforme fossero diverse, l’esito finale è stato lo stesso, ovvero essere più conformi e servire gli utenti globali secondo rigorosi quadri regolatori.</p>
<p>Crediamo che le piattaforme di trading future come Gate.io saranno anche più responsabili e conformi, perché solo in questo modo gli utenti saranno più fiduciosi nel mantenere i propri fondi sulla piattaforma.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi26797"><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-BTC336103"><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/1700635777BTC.png" alt=""><br>Il tentativo di movimento verso l’alto di ieri mattina non è riuscito e con un sentimento ribassista prente nel mercato generale, si continua a registrare un trend al ribasso al di sotto del livello di supporto di $36.000. È importante notare che il grafico a quattro ore ha formato un modello testa e spalle, con un livello di supporto chiave a $36.000. Se scende al di sotto di $34.795, potrebbe segnare la fine del trend rialzista di quest’anno, aprendo la strada a una correzione del trend a medio termine. È consigliabile monitorare la stabilità della linea di tendenza al rialzo tratteggiata in bianco.</p>
<h3 id="h3-ETH515493"><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/1700635810ETH.png" alt=""><br>Il grafico a quattro ore è riuscito a rompere con successo una tendenza prentemente al ribasso, formando una struttura a forma di M nel breve termine con consolidamento e fluttuazioni in corso. Se si stabilisce una struttura ribassista, potrebbe testare il livello di supporto di $1.857 per la seconda volta. Le posizioni ribassiste aggressive possono continuare, ma si deve prestare attenzione a mantenere la pressione al rialzo. La tendenza al rialzo continua a monitorare se si ritira verso la neckline di $2.037. La mancata tenuta di questo livello questo mese potrebbe indicare una tendenza correttiva di medio termine.</p>
<h3 id="h3-BNB929425"><a name="BNB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BNB</h3><p><img src="https://gimg2.gateimg.com/image/article/1700635836BNB.png" alt=""><br>Nelle ultime 24 ore, si sono verificate quattro occorrenze di pattern di candele doji. Con il sentiment del mercato secondario in diffusione, il grafico a quattro ore ha colpito precisamente il livello di resistenza a $267.5, il punto più alto atteso per l’anno. Dopo aver toccato la linea di tendenza al ribasso a lungo termine, c’è stato un significativo pullback guidato dal volume. Se il breve termine non si riprende a $246, potrebbe emergere un trend ribassista di medio termine, con obiettivi ribassisti intermedi a $183.7 e $118.8.</p>
<h2 id="h2-Macro20Lento20progresso20nella20riduzione20dellinflazione20la20Federal20Reserve20potrebbe20ancora20aumentare20i20tassi20di20interesse559510"><a name="Macro: Lento progresso nella riduzione dell’inflazione, la Federal Reserve potrebbe ancora aumentare i tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Lento progresso nella riduzione dell’inflazione, la Federal Reserve potrebbe ancora aumentare i tassi di interesse</h2><p>Martedì, mentre i verbali della riunione della Federal Reserve indicavano che la Fed avrebbe mantenuto una politica restrittiva a lungo termine, l’indice del dollaro USA ha smesso di cadere. È brevemente sceso a un nuovo minimo dal 31 agosto, 103,17, durante la sessione. In seguito ha recuperato la maggior parte delle perdite ed è salito durante la sessione USA, chiudendo infine in rialzo dello 0,16% a 103,60. I rendimenti dei bond statunitensi sono leggermente diminuiti. Il rendimento del Treasury statunitense decennale è sceso al 4,398%; Il rendimento del Treasury statunitense biennale, che è più sensibile ai tassi di interesse della politica della Federal Reserve, non è riuscito a stabilizzarsi sopra il 4,9% ed è infine chiuso al 4,883%.</p>
<p>L’oro spot è salito significativamente durante la giornata, superando la soglia dei $2.000 durante la sessione statunitense e raggiungendo il massimo intraday di $2.007,63, ma non è riuscito a stabilizzarsi a questo punto e alla fine ha chiuso in rialzo dell’1,02% a $1.998,31 per oncia; L’argento spot ha brevemente superato la barriera dei $24 durante la giornata, ma non è riuscito a stabilizzarsi qui, chiudendo infine in rialzo dell’1,3% a $23,74 per oncia.</p>
<p>Dopo una lievitazione di due giorni consecutivi, i due oli hanno preso fiato. Il greggio WTI è rimasto sopra i 77 dollari e ha chiuso in rialzo dello 0,22% a 77,78 dollari al barile; Il greggio Brent ha recuperato parte delle perdite durante la sessione statunitense ed è salito, salendo dello 0,55% a 82,42 dollari al barile.</p>
<p>I tre principali indici azionari statunitensi hanno chiuso in calo, con il Dow Jones Industrial Average in calo dello 0,18%, il Nasdaq in calo dello 0,59% e l’indice S&amp;P 500 in calo dello 0,2%. Tesla (TSLA.O) ha chiuso in rialzo del 2%, mentre INVIDIA (NVDA.O) e Microsoft (MSFT.O) sono scesi dell’1%.</p>
<p>La Federal Reserve ha pubblicato i verbali della riunione del Federal Open Market Committee (FOMC) dal 31 ottobre al 1 novembre, durante la quale i partecipanti hanno discusso lo sviluppo dei mercati finanziari, le aspettative per la politica monetaria e lo sviluppo del mercato monetario. I verbali indicano che i partecipanti ritengono che, al fine di raggiungere l’obiettivo di massimizzare l’occupazione e mantenere l’inflazione al 2% nel lungo termine, concordano di mantenere il range target del tasso dei fondi federali tra il 5,25% e il 5,5%.</p>
<p>Tutti i membri del FOMC concordano nel “esercitare cautela” sulle questioni dei tassi di interesse e concordano che sia appropriato mantenere una politica monetaria restrittiva per un certo periodo di tempo fino a quando l’inflazione non scende chiaramente in modo significativo verso l’obiettivo. Se le informazioni ricevute indicano un progresso insufficiente nel raggiungimento degli obiettivi di inflazione, è opportuno stringere ulteriormente la valuta.</p>
<p>Nick Timiraos, un giornalista considerato la “voce” della Federal Reserve e conosciuto come la “Nuova Agenzia di Notizie della Federal Reserve”, ha commentato che quando l’ultima riunione ha deciso di sospendere i rialzi dei tassi di interesse, i funzionari della Federal Reserve non erano disposti a concludere che avevano completato l’aumento. Ma i verbali suggeriscono che i funzionari potrebbero essere disposti a mantenere i tassi di interesse invariati per almeno quest’anno.</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 re-postaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>