SG9uZyBLb25nIGFjY2VsZXJhIGwnaW5ub3ZhemlvbmUgZGkgV2ViMyBjb24gNTAgbWlsaW9uaSBkaSBISyQ=

2023-03-08, 08:32

<p><img src="https://gimg2.gateimg.com/image/article/16782639741.18.jpeg" alt=""></p>
<h2 id="h2-TLDR588551"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Hong Kong ha stanziato 50 milioni di HK$ per guidare gli investimenti in criptovalute nel paese.</p>
<p>L’investimento, nonché la legislazione pertinente, è probabile che attiri più aziende <a href="/web3" target="_blank" class="blog_inner_link">web3</a> nella città.</p>
<p>Diverse grandi aziende criptografiche come <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global, ShucangCN e BSC Spartan Network hanno promesso di investire nella città nel prossimo futuro.</p>
<p>La Cina continentale potrebbe utilizzare Hong Kong come programma pilota per la sua futura economia web3.</p>
<h2 id="h2-Introduzione799252"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’adozione mainstream di asset digitali come criptovalute e NFT è destinata ad aumentare se continueranno le attuali tendenze emergenti, come l’iniezione di fondi da parte del governo nel settore delle criptovalute e l’introduzione di normative favorevoli alle criptovalute. Hong Kong è un paese che ha messo da parte una ragionevole quantità di denaro per espandere la sua tecnologia blockchain. Questo articolo discuterà l’attuale spinta di Hong Kong nel settore blockchain.</p>
<h2 id="h2-La20crescita20dellindustria20blockchain20di20Hong20Kong738904"><a name="La crescita dell’industria blockchain di Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La crescita dell’industria blockchain di Hong Kong</h2><p>In una dimostrazione di fiducia nel potere della blockchain, Hong Kong ha svelato HK$50 milioni per sviluppare le sue imprese web3 al fine di competere nell’economia digitale globale. Tuttavia, parte dei fondi verrà utilizzata per stabilire regolamenti criptati che potrebbero aumentare la fiducia nell’infrastruttura blockchain di Hong Kong mirata ad attirare le imprese web3 per lanciare le loro attività nella città.</p>
<p>Notizie correlate: <a href="https://www.gate.io/de/blog_detail/2198/gate.io-to-enter-hong-kong-following-city-s-6.4m-budget-allocation-to-web3" target="_blank">Gate.io entrerà a Hong Kong a seguito dell’allocazione di bilancio di 6,4 milioni di dollari della città a Web3</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/167826407310831678263809_.pic.jpg" alt=""><br>Hong Kong- Coindesk</p>
<p>Nel discorso di bilancio 2023-2024, Paul Chan, Segretario finanziario della città, ha detto: “La terza generazione di Internet (Web3), attualmente nel suo periodo di avvio, ha lo stesso enorme potenziale. Dobbiamo stare al passo con i tempi e cogliere questa grande opportunità per guidare lo sviluppo dell’innovazione.”</p>
<p>Ha aggiunto: ‘Destinerò 50 milioni di dollari per accelerare lo sviluppo dell’ecosistema Web3 attraverso, tra le altre cose, l’organizzazione di importanti seminari internazionali, al fine di consentire all’industria e alle imprese di comprendere meglio lo sviluppo di frontiera e promuovere la cooperazione aziendale intersettoriale, oltre a organizzare una vasta gamma di workshop per i giovani’.</p>
<p>Leggi anche: <a href="https://www.gate.io/zh-tw/blog_detail/1730/gate-io-ceo-says-hong-kong-may-become-the-new-crypto-mecca" target="_blank">Il CEO di Gate.io afferma che Hong Kong potrebbe diventare la nuova Mecca delle criptovalute</a></p>
<p>Inoltre, Chan ha promesso di istituire un task force che si occuperebbe di studiare il modo migliore per guidare l’innovazione web3 a Hong Kong. Una delle principali aspirazioni della città è quella di attirare di nuovo gli investitori di criptovalute dalla Cina continentale che si sono trasferiti in altri paesi come Singapore. Tra gli investitori attesi c’è Justin Sun, che ha indicato attraverso un tweet che presto si trasferirà a Hong Kong.</p>
<p>Sun ha anche indicato che la posizione attuale mostra il supporto del governo cinese per il web3 a Hong Kong. <a href="https://www.bangkokpost.com/business/2511770/beijing-quietly-backing-hk-crypto-plans" rel="nofollow noopener noreferrer" target="_blank">detto</a>, “Il cambiamento di atteggiamento del governo di Hong Kong nei confronti delle cripto valute indica un segnale da parte del governo centrale cinese che concede lo status di pilota a HK per alcuni esperimenti innovativi su come le cripto valute possano essere meglio adottate e localizzate per l’enorme mercato cinese nel suo complesso.”</p>
<p>Non c’è dubbio che i $50 milioni destinati allo sviluppo del settore blockchain nel paese rappresentino una “golden opportunity” per le aziende che mirano a… <a href="https://www.gate.io/blog_detail/1745/hong-kong-new-crypto-policy-will-spring-come-to-hong-kong-again" target="_blank">stabilire i loro progetti criptati a Hong Kong</a>.</p>
<p>Sun, che è un rappresentante dell’Organizzazione Mondiale del Commercio, ha aggiunto che ci sono diverse grandi società di criptovalute come <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global che sono disposti a venire in città. Oltre agli scambi di criptovalute, è probabile che anche i market maker e i fondi speculativi affluiscano a Hong Kong.</p>
<p>C’è anche un’alta aspettativa che le società NFT e metaverse siano probabilmente in arrivo a Hong. Come esempio, ShucangCN, un’importante società NFT, <a href="https://forkast.news/china-nft-platforms-expand-into-hong-kong-in-face-of-compliance-risks-on-mainland/" rel="nofollow noopener noreferrer" target="_blank">detto</a> Forkast ha come obiettivo di aprire un filiale a Hong Kong. Un altro grande giocatore nel settore delle criptovalute che ha promesso di aprire una filiale a Hong Kong è BSN Spartan Network, una blockchain cinese che attualmente opera al di fuori della Cina.</p>
<h2 id="h2-Regolamentazione20delle20criptovalute20di20Hong20Kong920577"><a name="Regolamentazione delle criptovalute di Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione delle criptovalute di Hong Kong</h2><p>Oltre all’investimento di $50 milioni in web3, Hong Kong sta lavorando anche per stabilire un ambiente favorevole alle criptovalute. <a href="https://www.hkma.gov.hk/media/eng/doc/key-information/guidelines-and-circular/2022/20221207e1.pdf" rel="nofollow noopener noreferrer" target="_blank">regolamenti</a> nel paese. Di recente, la Securities and Futures Commission (SFC) di Hong Kong ha pubblicato linee guida regolamentari per le piattaforme di trading di asset virtuali. Tuttavia, ha chiesto un feedback dal pubblico.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826425410841678263820_.pic.jpg" alt=""><br>Regolamentazione delle criptovalute- Thenewscrypto</p>
<p>Parte della legislazione stabilirà i requisiti per la concessione di licenze alle piattaforme di trading criptato e la registrazione degli asset digitali. Le normative proposte saranno efficaci da giugno di quest’anno, il che significa che le società del settore interessato dovrebbero conformarsi alla legge entro tale data. La SFC controllerà anche la liquidità delle entità coinvolte come gli scambi.</p>
<p>Leggi anche: <a href="https://www.gate.io/pt-br/blog_detail/2207/gateio-to-connect-with-local-web3-community-at-blockmountain-2023" target="_blank">Gate.io si collegherà alla comunità locale Web3 a BlockMountain 2023</a></p>
<p>Inoltre, le normative proposte prevedranno una clausola che vieta la diffusione di pubblicità ingannevoli sui cripto. Di conseguenza, ci saranno sanzioni per individui e aziende che effettuano transazioni fraudolente. Ad esempio, gli autori di reati potrebbero essere soggetti a una multa di $10,000,000 e una pena detentiva di 10 anni.</p>
<h2 id="h2-Hong20Kong2020un20programma20pilota20per20la20Cina20continentale696121"><a name="Hong Kong è un programma pilota per la Cina continentale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hong Kong è un programma pilota per la Cina continentale?</h2><p>Diversi analisti hanno sottolineato che la posizione amichevole che Hong Kong sta assumendo nei confronti delle criptovalute e degli altri asset digitali è un segno di approvazione da parte della Cina. In tal senso, la Cina potrebbe considerare gli investimenti in criptovalute a Hong Kong come un programma pilota. Ciò perché funzionari del continente hanno partecipato a alcuni incontri nei mesi scorsi.</p>
<p>Alla luce dei loro gesti amichevoli e cooperativi con gli investitori di criptovalute, gli analisti hanno concluso che la Cina ha cambiato atteggiamento rispetto alla sua posizione rigida sulle criptovalute, che l’ha portata a vietare il trading di criptovalute nel 2021. In realtà, la sua repressione sulle criptovalute è iniziata già nel 2017.</p>
<p>Al momento, la posizione più morbida della Cina agisce come un segnale per le aziende criptate della Cina continentale e le start-up di web3 a Hong Kong per aprire attività criptate nella città. Pertanto, la città potrebbe agire come intermediario per le aziende web3 che pianificano di investire in Cina in futuro.</p>
<h2 id="h2-Conclusione878115"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>I 50 milioni di HK$ messi da parte dalla città verranno utilizzati per finanziare lo sviluppo dell’ecosistema blockchain di Hong Kong nel suo tentativo di diventare competitivo a livello globale. Inoltre, la città è nel processo di elaborazione della relativa regolamentazione crittografica. Entrambi gli sviluppi dovrebbero consentire alla città di attirare molti investimenti crittografici.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Mashell C. </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 ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>