SG9uZyBLb25nIHNjYXRlbmEgbCdvbmRhIGNyaXB0byBuZWxsJ0VzdCwgaW5pemllcsOgIGlsIHByb3NzaW1vIGJ1bGwgcnVuIGNyaXB0byBpbiBDaW5hPw==

<p><img src="https://gimg2.gateimg.com/image/article/167704613620230222-140829.jpeg" alt=""></p>
<h2 id="h2-TLDR174954"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>🔹 Il 20 febbraio, la Securities and Futures Commission (SFC) di Hong Kong ha avviato consultazioni sulla regolamentazione della piattaforma di trading di criptovalute.</p>
<p>🔹 Hong Kong potrebbe aprire il trading di criptovalute mainstream per gli investitori al dettaglio.</p>
<p>🔹 Le notizie positive a Hong Kong hanno spinto il settore “concetto di Hong Kong” in forte aumento, con CFX in aumento di oltre il 500%.</p>
<p>🔹 La politica regolamentare di Hong Kong e la politica del continente cinese sono polarizzate, il che potrebbe costituire una potenza complementare per aiutare la Cina a dare vita a una nuova narrazione crittografica.</p>
<h2 id="h2-La20Securities20and20Futures20Commission20di20Hong20Kong20pianifica20di20aprire20il20trading20di20criptovalute20per20gli20investitori20al20dettaglio993406"><a name="La Securities and Futures Commission di Hong Kong pianifica di aprire il trading di criptovalute per gli investitori al dettaglio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Securities and Futures Commission di Hong Kong pianifica di aprire il trading di criptovalute per gli investitori al dettaglio</h2><p>Estensione della lettura: <a href="https://www.gate.io/blog_detail/1745/hong-kong-new-crypto-policy-will-spring-come-hong-kong" target="_blank">Nuova politica criptata di Hong Kong | Tornerà ancora la primavera a Hong Kong?</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/16770456519771677045490_.pic.jpg" alt=""><br>Fonte: sito ufficiale della Commissione per i Valori Mobiliari e i Futures di Hong Kong</p>
<p>Il 20 febbraio la Securities and Futures Commission di Hong Kong ha lanciato consultazioni sulle raccomandazioni per la regolamentazione della piattaforma di trading di asset virtuali. La Consultation Paper pubblicata ha principalmente consultato l’industria di Hong Kong su dieci domande:</p>
<p>🔹 La piattaforma autorizzata sarà autorizzata a fornire servizi agli investitori al dettaglio con la premessa di adottare le misure raccomandate di protezione degli investitori?<br>🔹 Hai qualche suggerimento sui criteri di inclusione per i token generali e per i token specifici?<br>🔹 Se la SFC consente agli investitori al dettaglio di utilizzare la piattaforma di trading autorizzata, quali altre disposizioni dovrebbero essere attuate dal punto di vista della protezione degli investitori?<br>🔹 Ha un’opinione sulla proposta di consentire l’utilizzo dei fondi stanziati dai gestori di piattaforme assicurative e autorizzate di terze parti o dalle società affiliate allo stesso gruppo di società? Hai altri suggerimenti?<br>🔹 Avete suggerimenti su come il gestore della piattaforma autorizzato dovrebbe allocare tali fondi (ad esempio, sul conto aziendale del gestore della piattaforma autorizzato o per istituire accordi di deposito a garanzia)? Spiega in dettaglio l’accordo che hai proposto e in che modo la protezione fornita dall’accordo in questione può fornire lo stesso livello di protezione dell’assicurazione di responsabilità civile.<br>🔹 Quali soluzioni tecniche possono ridurre efficacemente i rischi legati alla custodia degli asset virtuali dei clienti (in particolare la detenzione di asset virtuali tramite storage online)? Hai qualche suggerimento?<br>🔹 Se l’operatore della piattaforma autorizzato è in grado di fornire servizi di trading di derivati su asset virtuali, quale modello di business consiglieresti di adottare? Che tipo di derivati su asset virtuali consigliate agli investitori di acquistare e vendere? A quali tipi di investitori ci si rivolgerà?<br>🔹 Hai qualche opinione su come migliorare le altre disposizioni dei Termini e Condizioni della Piattaforma di Trading di Asset Virtuali incorporandole nelle Linee Guida per la Piattaforma di Trading di Asset Virtuali?<br>🔹 Ha un’opinione sulle disposizioni sul trasferimento di asset virtuali o su qualsiasi altra disposizione del capitolo 12 delle Linee guida sulla lotta al riciclaggio di denaro applicabili alle società autorizzate e ai fornitori di servizi di asset virtuali autorizzati dalla SFC?<br>🔹 Avete qualche commento sulle linee guida per le multe disciplinari della SFC?</p>
<p>Le dieci domande sopra si concentrano principalmente su “se fornire servizi di trading di criptovalute per gli investitori al dettaglio” e “come proteggere gli investitori”. La consultazione è terminata il 31 marzo. Due mesi dopo (1° giugno), il nuovo sistema di licenze per le piattaforme di trading di criptovalute è stato implementato a Hong Kong. Tutte le piattaforme di trading di criptovalute che operano a Hong Kong o che promuovono agli investitori di Hong Kong devono essere autorizzate dalla Commissione per i titoli e i contratti a termine di Hong Kong.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770456949781677045507_.pic.jpg" alt=""><br>Attualmente, la Cina si posiziona al primo posto e Hong Kong al secondo nella classifica del “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> popolarità della ricerca - Fonte: Google Trends</p>
<h2 id="h2-Se20Hong20Kong20guida20il20mainstream20il20progetto20diventer20virale404791"><a name="Se Hong Kong guida il mainstream, il progetto diventerà virale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Se Hong Kong guida il mainstream, il progetto diventerà virale</h2><p>Attualmente, il sentiment di mercato sta salendo rapidamente e vari progetti legati al concetto di Hong Kong hanno avviato la modalità “surge”, in cui le prestazioni di CFX sono le più evidenti. Secondo i dati di CoinGecko, CFX è il vincitore più grande di tutte le criptovalute degli ultimi 7 giorni, con un aumento di fino al 500,1%. Alle 17:00 del 21 febbraio, CFX quotava $0,31 e il volume di trading delle ultime 24 ore era di $909854679.</p>
<p>Il mercato dell’orso dell’anno scorso ha depresso troppo a lungo gli investitori, e il sentimento positivo ha persino bruciato i progetti locali in Cina. Token per vecchi progetti come <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, VET, <a href="/price/qtum-qtum" rel="nofollow noopener noreferrer" target="_blank">Qtum</a>, e KEY hanno sorprendentemente performano nei giorni scorsi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770457809791677045521_.pic.jpg" alt=""></p>
<p>Tuttavia, al momento, la definizione del settore del “concetto di Hong Kong” non è chiara. Molte persone approfittano dell’occasione per offuscare lo sfondo del progetto e cercare di <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> con il concetto di “Hong Kong”. Infatti, i principali progetti di criptovalute a Hong Kong sono distribuiti in CeFi, giochi, strutture di servizio e altri settori. La figura qui sotto mostra alcuni progetti di criptovalute a Hong Kong.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458159801677045545_.pic.jpg" alt=""><br>Principali progetti a Hong Kong - sorgente RootData</p>
<p>Dal settore dello staking di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> all’inizio dell’anno, al settore dell’IA guidato da chatGPT e al settore dei concetti attuali di Hong Kong, sembra che il mercato non osi fermarsi nemmeno per un momento, per paura di tornare all’atmosfera di morte del 2022. Il sentimento non può portare sviluppo all’industria né benefici a lungo termine al progetto. Per gli investitori, potrebbe essere il modo più importante per distinguere tra speculazione emotiva e tendenze future,</p>
<h2 id="h2-Quando2020buio20a20ovest2020chiaro20a20est357529"><a name="Quando è buio a ovest, è chiaro a est" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quando è buio a ovest, è chiaro a est</h2><p>Il governo degli Stati Uniti sta ancora esitando sulla questione di come regolare il mercato crittografico. Quando la SEC ha colpito Kraken, gli emittenti di BUSD Paxos e Binance, questa mossa ad Hong Kong ha senza dubbio alimentato le speranze per il caotico mercato crittografico, consentendo agli investitori di tornare a tenere d’occhio Hong Kong, Singapore e altri paesi/regioni dell’est. Dai cambiamenti di mercato dopo la pubblicazione del Libro Bianco di Consultazione, possiamo anche vedere la migrazione della fiducia degli investitori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458459811677045557_.pic.jpg" alt=""></p>
<p>Il 21 febbraio, la capitalizzazione di mercato del mercato delle criptovalute ha raggiunto il valore più alto dall’inizio di agosto dello scorso anno - Fonte: CoinGecko</p>
<p>La mossa di Hong Kong ha senza dubbio compiuto un passo importante verso l’obiettivo di diventare un centro cripto asiatico. Cameron Winklevoss, il co-fondatore di Gemini, ha twittato: ‘la prossima corsa al rialzo delle criptovalute inizierà in Oriente’.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458679821677045569_.pic.jpg" alt=""><br>Fonte: Twitter@Cameron Winklevoss</p>
<p>Il fondatore di <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> ha anche espresso la previsione che la Cina porterà il prossimo toro cripto direttamente su Twitter in cinese.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458829831677045583_.pic.jpg" alt=""><br>Fonte: Twitter@Scott_eth</p>
<p>Singapore, un altro paese che compete con il centro criptovalutario dell’Est, ha approssimativamente la stessa linea di politica di Hong Kong, che è principalmente aperta e inclusiva, integrata da misure regolamentari di supporto. Tuttavia, Hong Kong è sostenuta dal Continente Cinese, che ha vietato il trading di criptovalute nel 2021. È difficile immaginare quali effetti potrà portare al mercato e all’“Est” una politica così diversa. La difficoltà della attuale politica regolamentare cripto globale è in gran parte dovuta al “grado” di regolamentazione. La differenza di politica tra il Continente Cinese e Hong Kong potrebbe costituire un buon completamento: mentre si afferrano importanti opportunità di sviluppo, si assicura il regolare funzionamento del mercato e si minimizzano i rischi, al fine di garantire che la Cina abbia una sufficiente competitività in questo cambiamento tecnologico.</p>
<p>Forse il prossimo round della narrativa sulle criptovalute inizierà in Cina.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Jill Ma</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. La ripubblicazione dell'articolo sarà consentita a condizione che Gate.io sia citato. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>