Tm90aXppZSBxdW90aWRpYW5lIHwgU0VDIHJlc3BpbmdlIEVURiwgYXVtZW50YW5vIGxlIGxpcXVpZGF6aW9uaSwgcmlubm92byBkaSBBenVraSBORlQ7IEF6aW9uaSBnbG9iYWxpIGluIGF1bWVudG8gY29uIGNhdXRlbGE=

2023-07-03, 01:21

<p><img src="https://gimg2.gateimg.com/image/article/16883467830703.jpg" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20volatilit20delle20criptovalute20sviluppi20normativi20e20sfide20NFT966449"><a name="Riepilogo giornaliero delle criptovalute: volatilità delle criptovalute, sviluppi normativi e sfide NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: volatilità delle criptovalute, sviluppi normativi e sfide NFT</h2><p>Il mercato delle criptovalute ha vissuto un fine settimana relativamente tranquillo, con <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) e Ether (ETH) che hanno registrato guadagni marginali. Tuttavia,<br><strong>Venerdì ha portato significativa volatilità e una ondata di liquidazioni, per un valore di $216 milioni</strong>. Questo è stato scatenato dalla notizia che la Securities and Exchange Commission (SEC) degli Stati Uniti ha respinto le domande per la posizione <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fondi negoziati in borsa, portando ad una rapida reazione del mercato.</p>
<p>Bitcoin inizialmente è salito sopra i 31.200 dollari, ma è rapidamente sceso fino a 29.470 dollari. La successiva stabilizzazione intorno ai 30.000 dollari ha permesso un certo recupero. Purtroppo,<br><strong>la volatilità ha portato alla liquidazione di oltre 68.000 operatori, con le posizioni lunghe che hanno registrato una perdita di 116 milioni di dollari e le posizioni corte di 100 milioni di dollari</strong>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347126Untitled0703 1.png" alt=""><br>Liquidazione delle posizioni corte in forte aumento venerdì - Dati per Coinglass</p>
<p>I trader di Bitcoin sono stati i più colpiti, seguiti dai trader di Ether. <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a> Anche (BCH) ha contribuito alle liquidazioni con perdite per 22 milioni di dollari. L’exchange Bybit ha registrato l’ordine di liquidazione singolo più grande, coinvolgendo una posizione BTC-USD del valore di 4,57 milioni di dollari.</p>
<p>Nelle notizie regolamentari, la BZX Exchange di Cboe ha scelto Coinbase come mercato per il suo accordo di condivisione di sorveglianza nella riformulazione delle sue domande di fondo negoziato in borsa (ETF) per bitcoin spot. Degno di nota, altri grandi attori come Fidelity, WisdomTree, VanEck, ARK Invest, Galaxy/Invesco e BlackRock hanno anche presentato domande per ETF bitcoin spot, in collaborazione con Cboe o Nasdaq.<br><strong>La SEC aveva precedentemente giudicato le domande iniziali “inadeguate” a causa della mancanza di specifiche relative agli accordi di condivisione della sorveglianza. Nominando Coinbase, Cboe mira a fornire un accesso supplementare ai dati sulle transazioni in Bitcoin spot che avvengono sullo scambio.</strong> Tuttavia, il riconoscimento formale della SEC di Coinbase come un importante mercato regolamentato per Bitcoin rimane incerto.</p>
<p>In Corea del Sud, è stata approvata una legge autonoma sugli asset digitali finalizzata a migliorare la protezione degli investitori. La legislazione sulla protezione degli utenti di asset virtuali unifica 19 leggi relative alle criptovalute e stabilisce definizioni per gli asset digitali mentre impone sanzioni per reati come la manipolazione del mercato e pratiche commerciali sleali.<br><strong>La Commissione per i servizi finanziari superviserà gli operatori di criptovalute e i custodi di asset, con la Banca di Corea autorizzata ad indagare su tali piattaforme. La legislazione richiede inoltre una copertura assicurativa, fondi di riserva e una corretta tenuta dei registri.</strong> Questa mossa arriva dopo il crollo dei token creati da Do Kwon, che ha scatenato una flessione del mercato cripto di $2 trilioni. Nonostante la diminuzione del volume mensile di trading di criptovalute spot, la Corea del Sud è nota per le manie periodiche di asset virtuali.</p>
<p>Rivolgendoci all’ambito dei token non fungibili (NFT), il marchio di alta qualità Azuki ha affrontato critiche e problemi tecnici a seguito della recente creazione dell’NFT “Elementals”. La collezione è stata prontamente esaurita, generando 38 milioni di dollari di ricavi. Tuttavia, i collezionisti hanno espresso frustrazione a causa di difficoltà tecniche durante il processo di creazione e presunte somiglianze tra la nuova opera d’arte e la collezione originale, portando a un calo del 44% nel prezzo di base. In risposta,<br><strong>Azuki ha tenuto una chiamata privata con la sua comunità per affrontare le preoccupazioni e delineare i suoi piani per il futuro. Il team ha riconosciuto i propri errori ed ha espresso l’intenzione di aggiornare l’artwork degli Elementals per distinguerlo ulteriormente dalla collezione originale.</strong>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347184Untitled0703 2.png" alt=""><br>Modifiche proposte agli elementi di Azuki - Versione iniziale - Cortesia dell’utente di Twitter Arcanic</p>
<p>Azuki ha anche rivelato piani per una serie anime che presenta l’universo dei loro personaggi, incorporando tecnologie <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> ed elementi interattivi con NFT. La chiamata della comunità ha menzionato ricompense potenziali per i detentori a lungo termine e quelli con tratti rari.</p>
<p>Nonostante le sfide affrontate, i membri della comunità rimangono ottimisti sul futuro di Azuki e sulla sua capacità di riconquistare la fiducia. Attualmente, il prezzo minimo degli Azuki Elementals si attesta a 1,29 ETH, con un volume di scambi di circa 11.930 ETH, secondo OpenSea. Il prezzo minimo della collezione originale di Azuki si aggira intorno a 8,19 ETH, con un volume di scambi che supera i 596.900 ETH.</p>
<h2 id="h2-Bitcoin20BTC2030626200042020Outlook20neutro626547"><a name="Bitcoin (BTC) $30,626 (+0.04%) - Outlook neutro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $30,626 (+0.04%) - Outlook neutro</h2><p><img src="https://gimg2.gateimg.com/image/article/1688347145Untitled0703 3.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347155Untitled0703 4.png" alt=""></p>
<p><strong>Panoramica:</strong></p>
<ul>
<li><strong><em>Zona di supporto giornaliero più vicina: 30025 - 29475</em></strong></li><li><strong><em>Zona di resistenza giornaliera più vicina: 30690 - 31015</em></strong></li><li><strong><em>Livello chiave: 28420 (Massimo settimanale tra il 21 e il 28 dicembre 2020)</em></strong></li></ul>
<p><strong>Zone di resistenza quotidiana</strong></p>
<ol>
<li>30690 - 31015</li><li>31530 - 32255</li><li>33100 - 33600</li></ol>
<p><strong>Zone di supporto giornaliere</strong></p>
<ol>
<li>30025 - 29475</li><li>29095 - 28420</li><li>27970 - 27265</li></ol>
<h2 id="h2-Macro20azioni20globali20in20forte20crescita20ma20lavidit2020temperata20dalla20prudenza89"><a name="Macro: azioni globali in forte crescita ma l’avidità è temperata dalla prudenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: azioni globali in forte crescita ma l’avidità è temperata dalla prudenza</h2><p>I mercati globali stanno mostrando segnali di positività poiché le azioni asiatiche dovrebbero aprire al rialzo a seguito di un rally a Wall Street e segnali di un’inflazione statunitense in calo. I contratti futures per le azioni in Giappone, Australia e Hong Kong indicano guadagni iniziali, mentre le aziende cinesi quotate negli Stati Uniti hanno registrato un aumento del 1%. Le buone notizie sul record delle consegne di auto Tesla nel secondo trimestre probabilmente beneficeranno i suoi fornitori in Asia.</p>
<p>Il Nasdaq 100 e l’S&amp;P 500 hanno avuto una forte performance nella prima metà dell’anno, con Apple che ha raggiunto un importante traguardo di capitalizzazione di mercato di $3 trilioni. I trader stanno guadagnando fiducia dai dati che mostrano una moderazione dell’inflazione, anche se ciò è avvenuto a spese della crescita. L’attività del mercato obbligazionario è rimasta contenuta, e le principali valute hanno mantenuto la stabilità rispetto al dollaro. I prezzi del petrolio hanno registrato variazioni minime, poiché l’attenzione rimane focalizzata sulle sfide della domanda e sul complesso panorama dell’offerta.</p>
<p>Gli investitori sono avvisati di non diventare eccessivamente avidi poiché le azioni globali si sono scollegate dal peggioramento dello sfondo economico, avendo già ottenuto guadagni a doppia cifra nel 2023.<br><strong>Alcuni gestori patrimoniali stanno avvertendo di un potenziale inaspettato calo nella seconda metà dell’anno a causa dell’aumento delle avvertenze sui profitti aziendali e della retorica restrittiva delle banche centrali.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347295Untitled0703 5.png" alt=""></p>
<p>L’aumento dei tassi di interesse e le potenziali tensioni nei mercati finanziari sono particolarmente preoccupanti per il settore tecnologico sensibile ai tassi.<br><strong>Sebbene i dati storici suggeriscano che le azioni potrebbero non invertire completamente i loro guadagni, la combinazione di un volume di scambi basso e la calma estiva stagionale potrebbe amplificare le correzioni di mercato se i trader decidono di disfarsi delle loro posizioni rialziste.</strong> Pertanto, si consiglia prudenza e un approccio conservativo per la seconda metà dell’anno.</p>
<p>In Cina, la nomina di Pan Gongsheng da parte del presidente Xi Jinping come massimo funzionario del Partito Comunista della Banca Popolare Cinese (PBOC) indica un impegno a mantenere l’approccio attuale nel contesto della continua lotta del paese per riprendere slancio economico.<br><strong>La nomina di Pan suggerisce una continuazione dei modesti tagli ai tassi di interesse e misure di prestito mirate.</strong> Mentre emergono richieste di maggiori stimoli, rimangono preoccupazioni per la debole spesa dei consumatori e il settore immobiliare. Il ruolo della PBOC sta venendo ripensato sotto la guida di Xi, con il ranking più debole del partito di Pan che potrebbe ridurre l’influenza della banca nelle decisioni economiche di alto livello. Le sfide di Pan includono la gestione dello yuan, la stabilizzazione della valuta e la navigazione delle misure regolamentari nel mercato immobiliare.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Peter L. </strong>, Ricercatore di 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 repostaggio dell'articolo a patto che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>