RGFpbHkgTmV3cyB8IENyeXB0byBzY29zc28gZGFsbGUgY2F1c2UgbGVnYWxpIGRlbGxhIFNFQywgbCdhdW1lbnRvIGRlaSB0YXNzaSBkZWxsYSBCYW5jYSBkZWwgQ2FuYWRhIGF1bWVudGEgbCdpbmNlcnRlenphIGRpIG1lcmNhdG8=

2023-06-08, 00:47

<p><img src="https://gimg2.gateimg.com/image/article/16861849200608.jpg" alt=""></p>
<h2 id="h2-Criptovaluta20Digest20quotidiano20Cause20della20SEC20Servizio20di20Staking20di20Coinbase20e20Regole20Pubblicitarie20del20Regno20Unito20Scuotono20il20Mondo20delle20Criptovalute102743"><a name="Criptovaluta Digest quotidiano: Cause della SEC, Servizio di Staking di Coinbase e Regole Pubblicitarie del Regno Unito Scuotono il Mondo delle Criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovaluta Digest quotidiano: Cause della SEC, Servizio di Staking di Coinbase e Regole Pubblicitarie del Regno Unito Scuotono il Mondo delle Criptovalute</h2><p>Le recenti cause intentate dalla Securities and Exchange Commission degli Stati Uniti (SEC) contro le principali borse di criptovalute Binance e Coinbase hanno avuto un impatto significativo sul mercato delle criptovalute. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(BTC) ha subito un calo del 3,3%, ma è rimasto relativamente stabile rispetto ad altre criptovalute. Altcoin come <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, ADA, MATIC e SOL hanno subito forti cali, con una media di circa l’8%. Queste cause hanno creato incertezza e limitato le opzioni di trading per gli investitori statunitensi. L’aumento dei rendimenti obbligazionari globali e le indicazioni di ulteriori restrizioni da parte delle banche centrali hanno inoltre influenzato negativamente i mercati degli asset digitali, contribuendo ad aumentare le preoccupazioni tra gli investitori e Wall Street.</p>
<p>Nel frattempo, nonostante le sfide legali affrontate da Coinbase, il CEO Brian Armstrong ha annunciato che l’exchange continuerà ad operare il suo servizio di staking di criptovalute. Armstrong ha sottolineato che il servizio di staking rappresenta circa il 3% del fatturato netto complessivo di Coinbase. La SEC ha citato in giudizio Coinbase per varie presunte violazioni, tra cui la vendita di titoli non registrati. Inoltre, una coalizione di dieci stati ha accusato il programma di staking di Coinbase di violare le leggi statali sui titoli.</p>
<p>Nel Regno Unito, l’Autorità di Condotta Finanziaria (FCA) si sta preparando a introdurre regole rigorose per la pubblicità di criptovalute una volta che la legislazione pertinente sarà finalizzata. Ai sensi di tali regole, le criptovalute saranno classificate come “investimenti di massa limitati”. Gli annunci e le promozioni per gli asset crittografici dovranno includere avvisi chiari sui rischi, mentre incentivi come i bonus di riferimento saranno proibiti. L’obiettivo della FCA è fornire ai consumatori le informazioni necessarie per prendere decisioni informate e prevenire danni. Nonostante alcune divergenze durante il processo di consultazione, la FCA procederà con le misure proposte. La FCA ha anche rilasciato linee guida per garantire che le aziende comprendano le implicazioni dei requisiti per le promozioni di asset crittografici. La mancata conformità alle nuove regole potrebbe comportare l’imprigionamento, multe o entrambi. A partire dall’8 ottobre, le aziende crittografiche avranno la possibilità di approvare le proprie pubblicità.</p>
<h2 id="h2-Bitcoin20BTC2026347200012020Prospettiva20neutra170204"><a name="Bitcoin (BTC) $26,347 (+0.01%) - Prospettiva neutra" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $26,347 (+0.01%) - Prospettiva neutra</h2><p><img src="https://gimg2.gateimg.com/image/article/1686185217Untitled0608 1.png" alt=""></p>
<p>Sulla base dell’osservazione precedente fatta ieri, c’è stato un lieve calo del volume. Tuttavia, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) è riuscito a trovare supporto vicino al livello di ritracciamento di Fibonacci del 61,8%, calcolato dai dati della giornata precedente e ammontante a 26.280. Questa scoperta suggerisce che le imprevedibili fluttuazioni del mercato sono probabilmente destinate a persistere finché la media mobile esponenziale giornaliera (200EMA) non sarà stata sottoposta a un’attenta verifica. Inoltre, vale la pena notare che esiste una sostanziale zona di domanda che va da 25.180 a 24.570, situata appena al di sotto della 200EMA.</p>
<p><strong>Panoramica:</strong></p>
<ul>
<li><strong><em>Zona di supporto giornaliero più vicina: 26380 - 25818</em></strong></li><li><strong><em>Zona di resistenza giornaliera più vicina: 26700 - 27260</em></strong></li><li><strong><em>Livello chiave: 25243 (200EMA giornaliero)</em></strong></li></ul>
<p><strong>Zone di resistenza giornaliera</strong></p>
<ol>
<li>26700 - 27260</li><li>27790 - 28420</li><li>29096 - 29885</li></ol>
<p><strong>Zone di supporto giornaliere</strong></p>
<ol>
<li>26380 - 25818</li><li>25360 - 25240</li><li>24570 - 24270</li></ol>
<h2 id="h2-Macro20laumento20dei20tassi20della20Banca20del20Canada20scuote20Wall20Street20e20i20mercati20asiatici967729"><a name="Macro: l’aumento dei tassi della Banca del Canada scuote Wall Street e i mercati asiatici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: l’aumento dei tassi della Banca del Canada scuote Wall Street e i mercati asiatici</h2><p>Le azioni asiatiche sono pronte a partire al ribasso a seguito di un calo di Wall Street. Il sentiment di mercato è stato influenzato dall’aumento sorpresa dei tassi da parte della Banca del Canada, portando i trader a speculare che anche la Federal Reserve potrebbe stringere le politiche. Le azioni tecnologiche sono state colpite duramente, facendo registrare un secondo giorno consecutivo di calo per il S&amp;P 500 e la peggiore giornata dal mese di aprile per il Nasdaq 100.</p>
<p>Il calo delle azioni statunitensi è stato accompagnato da una diminuzione dei titoli del Tesoro degli Stati Uniti lungo la curva dei rendimenti. Il rendimento di riferimento a 10 anni è aumentato di 14 punti base raggiungendo il 3,8%. Questo aumento dei rendimenti è stato guidato dalle aspettative elevate dei trader per un aumento dei tassi della Federal Reserve. In un certo momento, gli swap sui tassi di interesse hanno completamente prezzato un aumento di un quarto di punto per la riunione di luglio, mentre le probabilità di un aumento nella prossima decisione erano ancora al di sotto del 40%.</p>
<p>La decisione della Banca del Canada di alzare i tassi inaspettatamente ha sorpreso il mercato e si è aggiunta all’incertezza recente derivante dall’aumento dei tassi della Reserve Bank of Australia. La decisione di queste banche centrali evidenzia le sfide che i responsabili delle politiche monetarie devono affrontare nel trovare il giusto equilibrio per le politiche monetarie in mezzo alle incertezze economiche globali.</p>
<p>Ray Dalio, il miliardario fondatore di Bridgewater Associates, ha condiviso la sua prospettiva sul panorama economico. Pur non prevedendo significativi aumenti dei tassi d’interesse, ritiene che l’economia peggiorerà poiché l’eccessivo debito e la scarsità di acquirenti segnalano l’inizio di una crisi del debito in fase tardiva.</p>
<p>Guardando avanti, i partecipanti al mercato stanno osservando attentamente la Reserve Bank of India, che si prevede manterrà i tassi invariati. Tuttavia, potrebbe esserci un cambiamento nella posizione di politica della banca centrale verso la neutralità, accompagnato da un linguaggio aggressivo che riflette i crescenti rischi inflazionistici. In Giappone, sarà pubblicata la lettura finale del PIL del primo trimestre, con aspettative di una revisione al rialzo rispetto alla stima preliminare. L’area dell’euro pubblicherà anche la sua lettura finale più tardi nella giornata.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Peter L. </strong>, Ricercatore Gate.io<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 ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>