SG9uZyBLb25nIGlzdGl0dWlzY2UgdW4gdGFzayBmb3JjZSBjb25naXVudGEgcGVyIG1vbml0b3JhcmUgbGUgYm9yc2UgZGkgY3JpcHRvdmFsdXRlIGUgaW5kYWdhcmUgc3VsbG8gc2NhbmRhbG8gSlBFWA==

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR928859"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Hong Kong ha creato un gruppo di lavoro per potenziare la sua capacità di affrontare le minacce che potrebbero esistere nel settore delle criptovalute.</p>
<p>Il Cyber Security and Technology Crime Bureau, il Cyber Security and Technology Crime Bureau, la Divisione di applicazione della SFC e la Divisione degli intermediari, nonché il Commercial Crime Bureau della polizia, hanno creato un task force per coordinare i loro sforzi nella lotta alle attività cripto sospette.</p>
<p>Lo scandalo JPEX ha esposto le debolezze che ancora esistono nella legge sulla criptovaluta di Hong Kong.</p>
<h2 id="h2-Introduzione189362"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Lo sviluppo recente a Hong Kong mostra che per un paese che vuole prosperare come hub di cripto, deve avere un quadro regolamentare chiaro che supporti le aziende blockchain e protegga gli investitori. Dovrebbe far rispettare le regolamentazioni cripto in modo forte ed efficace.</p>
<p>Lo scandalo della borsa criptovalutaria JPEX indica una mancanza di una forte supervisione regolamentare da parte delle autorità di Hong Kong.</p>
<p>Questo articolo discuterà della task force congiunta di Hong Kong e di come eviterà scandali simili come quello che coinvolge l’exchange di criptovalute JPEX. Vedremo anche come si è evoluto lo scandalo JPEX.</p>
<h2 id="h2-Panoramica20della20regolamentazione20delle20criptovalute20a20Hong20Kong941015"><a name="Panoramica della regolamentazione delle criptovalute a Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica della regolamentazione delle criptovalute a Hong Kong</h2><p>Anche se la Cina ha vietato le attività criptovalutarie nella terraferma <a href="https://www.gate.io/blog_detail/1745/%E9%A6%99%E6%B8%AF-%E9%A6%99%E6%B8%AF" target="_blank">Hong Kong permette investimenti in criptovalute</a> a condizione che i partecipanti si attengano alle sue norme stabilite a metà del 2023.</p>
<p>Ci sono diverse disposizioni normative criptate che dovrebbero essere seguite. Ad esempio, solo gli investitori in grado di investire almeno 8 milioni di HKD (circa 1 milione di dollari) possono investire in criptoattività.</p>
<p>Le criptovalute centralizzate che operano in città dovrebbero registrarsi presso la Commissione per i valori mobiliari e i futures (SFC) di Hong Kong. La città tratta gli scambi di criptovalute in modo simile alle piattaforme di trading automatico e ai broker di titoli. Pertanto, queste piattaforme, compresi gli scambi di criptovalute, comunemente definiti come piattaforme di attività virtuali (VA), dovrebbero seguire le disposizioni dell’Ordinanza sui valori mobiliari e i futures del 2023.</p>
<p>Gli scambi di criptovalute che sono i principali attori nel settore delle criptovalute a Hong Kong dovrebbero attenersi a diverse linee guida regolamentari che includono la conservazione sicura degli asset digitali dei clienti, l’aderenza agli standard Conosci il tuo cliente (KYC) e il rigoroso rispetto delle disposizioni di Hong Kong in materia di antiriciclaggio (AML) e finanziamento del terrorismo.</p>
<p>Le autorità cittadine monitorano attentamente le attività delle piattaforme di asset virtuali per proteggere gli investitori da pratiche manipolative e attività illegali. Pertanto, ogni exchange di criptovalute dovrebbe sviluppare una politica scritta e stabilire strumenti per prevenire e segnalare attività di trading illegali.</p>
<p>Inoltre, ogni piattaforma di asset virtuali dovrebbe pubblicare rapporti commerciali mensili e presentare rapporti di revisione finanziaria annuali alla SFC come stabilito nell’Ordinanza sui valori mobiliari e sui futuri di Hong Kong (SFO). Inoltre, ogni cripto scambio dovrebbe avere revisori che conoscono bene le attività digitali e che periodicamente revisionano le sue operazioni.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2306/gateio-market-watch-hong-kong-sees-a-stronger-future-for-web3" target="_blank">Hong Kong vede un futuro più forte per Web3</a></p>
<h2 id="h2-Collaborazione20tra20la20polizia20di20Hong20Kong20e20la20Commissione20per20la20Sicurezza20e20i20Futures20SFC486649"><a name="Collaborazione tra la polizia di Hong Kong e la Commissione per la Sicurezza e i Futures (SFC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Collaborazione tra la polizia di Hong Kong e la Commissione per la Sicurezza e i Futures (SFC)</h2><p>La polizia di Hong Kong e la SFC hanno lanciato un Task Force per monitorare le operazioni degli scambi di criptovalute nella città. Questo gruppo di lavoro è composto da membri del Cyber Security and Technology Crime Bureau, del Cyber Security and Technology Crime Bureau, della Divisione di Applicazione delle Norme e della Divisione degli Intermediari della SFC, nonché del Commercial Crime Bureau della polizia.</p>
<p>Il focus principale di questo gruppo di lavoro è coordinare i propri sforzi al fine di condividere informazioni relative a attività sospette legate alle attività di trading di criptovalute. Facendo ciò, saranno in grado di identificare e valutare i rischi in modo coordinato.</p>
<p>A tal fine, Eve Chung, assistente commissario di polizia, ha dichiarato: “L’attuazione della nuova piattaforma tra la polizia e l’SFC è fondamentale per accelerare lo scambio di informazioni vitali e la collaborazione congiunta in risposta alle sfide derivanti dai VATP, in modo da proteggere meglio il pubblico in generale di Hong Kong”.</p>
<p>In altre parole, il gruppo di lavoro collaborerà non solo per condividere informazioni critiche sulle operazioni degli scambi di criptovalute, ma anche per indagare sulle attività illegali che possono verificarsi nel settore. Nel complesso, si concentra sulla protezione dei consumatori e delle aziende cripto.</p>
<p>Questo sviluppo arriva in seguito ad altre iniziative chiave per proteggere gli investitori. Ad esempio, a settembre la Securities and Futures Commission di Hong Kong ha svelato un programma mirato a educare potenziali investitori di criptovalute attraverso la condivisione di informazioni vitali riguardanti gli Operatori di Piattaforme di Trading di Asset Virtuali (VATPs).</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2191/hong-kong-triggers-the-crypto-wave-in-the-east-will-the-next-crypto-bull-run-start-in-china" target="_blank">Hong Kong scatena l’onda criptata in Oriente, inizierà la prossima corsa al toro cripto in Cina?</a></p>
<p>Inoltre, la Securities and Futures Commission (SFC) di Hong Kong sta lavorando per aumentare la trasparenza nel settore delle criptovalute. Ad esempio, pubblicherà un elenco di VATP con licenza e tutte le piattaforme di trading di asset virtuali in attesa di approvazione.</p>
<p>Queste organizzazioni hanno creato il gruppo di lavoro a seguito dello scandalo JPEX che ha portato alla perdita di asset digitali dei clienti attraverso mezzi fraudolenti.</p>
<h2 id="h2-Lo20scandalo20JPEX853904"><a name="Lo scandalo JPEX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo scandalo JPEX</h2><p>La Japan Exchange, popolarmente chiamata JPEX e con sede a Dubai, avrebbe truffato migliaia di utenti di milioni di dollari attraverso diversi mezzi. Questo exchange di criptovalute, che afferma di avere partnership con istituzioni finanziarie consolidate come Alibaba e Standard Chartered, ha attirato molti individui e istituzioni a investire in esso grazie a rendimenti elevati e commissioni basse.</p>
<p>Inoltre, l’exchange ha utilizzato varie strategie di marketing per invogliare le persone a investire in esso. Ad esempio, ha utilizzato molti annunci online, cartelloni pubblicitari e campagne di influencer per convincere le persone a investire nei suoi prodotti. Joseph Lam, meglio conosciuto come il “Re del Trolling” di Hong Kong, e Chan Yee, un Youtuber con più di 200.000 iscritti, hanno promosso JPEX.</p>
<p>Questi influencer hanno utilizzato dati non verificati per mostrare ai loro follower come potessero guadagnare molti soldi per comprare case e veicoli investendo in JPEX. Secondo il recente rapporto, più di 2.305 persone hanno perso oltre HK$1,43 miliardi (circa $182,9 milioni) investiti nello scambio di criptovalute, rendendolo uno dei casi di frode più grandi a Hong Kong.</p>
<p>L’implosione di JPEX è iniziata quando la Securities and Futures Commission (SFC) di Hong Kong ha emesso un avvertimento che JPEX non era una piattaforma di trading registrata. In seguito, lo scambio ha apertamente riconosciuto di essere di fronte a sfide di liquidità che lo hanno costretto a congelare i prelievi.</p>
<p>Inoltre, la borsa di criptovalute ha avviato un controverso piano di dividendi in cui sta lavorando per convertire gli asset dei clienti in azioni che daranno loro diritto a guadagnare dividendi. Tuttavia, i clienti potranno prelevare i fondi solo dopo due anni.</p>
<p>Di conseguenza, questo è il piano di JPEX per migliorare il suo denaro <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> e mantenere i suoi investitori chiave. JPEX sostiene di aver condotto un referendum in cui il 68% dei suoi clienti ha votato a favore del piano di dividendi e della formazione di un’organizzazione autonoma decentralizzata (DAO).</p>
<p>Purtroppo, non ha risposto alla corrispondenza di molti clienti che hanno richiesto di sapere perché non potevano prelevare i propri fondi. La piattaforma di scambio di criptovalute ha anche aumentato le commissioni di transazione fino a 999 USDT per prelevare 1.000 USDT.</p>
<p>Dopo che molti investitori di JPEX si sono lamentati con le autorità competenti, la polizia di Hong Kong ha iniziato a condurre le sue indagini che hanno portato all’arresto di più di 11 persone tra cui Siu-lung, CEO del cambio di denaro virtuale over-the-counter (OTC), Li, ex direttore, Lam e Chan con l’accusa di riciclaggio di denaro, sospetto di frode e cospirazione per truffa.</p>
<p>Nel contesto delle indagini, la polizia ha sequestrato molti dispositivi elettronici e altri oggetti di valore, tra cui computer, smartphone, carte bancarie e altri documenti correlati. L’autorità di Hong Kong ha anche congelato i conti bancari di JPEX e sequestrato vari beni, tra cui veicoli di lusso e altre proprietà.</p>
<h2 id="h2-Risposta20JPEX708055"><a name="Risposta JPEX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risposta JPEX</h2><p>L’Exchange JPEX ha fornito diverse precisazioni. In primo luogo, ha affermato che la recente sfida di liquidità è stata il risultato dell’azione di uno dei suoi market maker che ha bloccato i fondi. Di conseguenza, sta collaborando con il partner responsabile per rilasciare i fondi.</p>
<p>Si dice: “Promettiamo di recuperare la liquidità dai market maker di terze parti il prima possibile e di regolare gradualmente le commissioni di prelievo ai livelli normali.”</p>
<p>Tuttavia, lo scandalo JPEX è probabile che rallenti gli sforzi di Hong Kong nel diventare un polo criptovalutario. Carlton Lai, capo di Daiwa Capital Markets, una società di ricerca blockchain e criptovalute, ha dichiarato: “Credo che questo scandalo avrà un impatto negativo piuttosto significativo sul sentimento dei consumatori, considerata la sua significativa presenza locale e le varie celebrità coinvolte.”</p>
<h2 id="h2-Sfide20che20le20autorit20di20Hong20Kong20stanno20affrontando96279"><a name="Sfide che le autorità di Hong Kong stanno affrontando" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide che le autorità di Hong Kong stanno affrontando</h2><p>Le autorità di Hong Kong stanno affrontando diverse sfide nell’assicurare le attività crypto, tra cui la mancanza di cooperazione da parte delle aziende blockchain. Ha anche problemi nel coordinarsi con gli attori locali e internazionali. La creazione del gruppo di lavoro di Hong Kong è il primo passo verso il potenziamento delle sue capacità.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2856" target="_blank">La vittoria dell’Asia: la repressione delle criptovalute negli Stati Uniti beneficia dell’Asia</a></p>
<h2 id="h2-Conclusione48228"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Hong Kong ha istituito un task force multipartitico per coordinare le attività del settore delle criptovalute. Il Cyber Security and Technology Crime Bureau, il Cyber Security and Technology Crime Bureau, la Divisione dell’Enforcement della SFC e la Divisione degli Intermediari, nonché il Commercial Crime Bureau della polizia, hanno formato un gruppo di lavoro che individuerà le attività sospette nel settore delle criptovalute.</p>
<h2 id="h2-Domande20frequenti20sulle20criptovalute20a20Hong20Kong753703"><a name="Domande frequenti sulle criptovalute a Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulle criptovalute a Hong Kong</h2><h3 id="h3-Le20criptovalute20sono20consentite20a20Hong20Kong373044"><a name="Le criptovalute sono consentite a Hong Kong?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute sono consentite a Hong Kong?</h3><p>Criptovaluta <a href="https://www.gate.io/blog_detail/2206/gateio-market-watch-hong-kongs-new-crypto-policy-triggers-market-rise" target="_blank">è legale a Hong Kong</a>, il che significa che alle persone è consentito comprarlo, detenerlo e venderlo. Tuttavia, gli scambi di criptovalute e altre piattaforme che trattano criptovalute devono registrarsi presso le autorità competenti.</p>
<h3 id="h3-Hong20Kong20investe20in20criptovalute710048"><a name="Hong Kong investe in criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hong Kong investe in criptovalute?</h3><p>Molte persone a Hong Kong investono in diverse criptovalute che includono <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> E anche ETH. Inoltre, ci sono molte aziende che offrono servizi di criptovaluta nella città.</p>
<h3 id="h3-Quali20criptovalute20pu20acquistare20Hong20Kong92789"><a name="Quali criptovalute può acquistare Hong Kong?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali criptovalute può acquistare Hong Kong?</h3><p>Le persone a Hong Kong possono acquistare varie criptovalute che includono bitcoin, ETH, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> e molti altri. Tuttavia, la città ha regolamenti chiari riguardanti gli asset crittografici che gli scambi possono offrire al pubblico.</p>
<h3 id="h3-Gateio2020disponibile20a20HK925131"><a name="Gate.io è disponibile a HK?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gate.io è disponibile a HK?</h3><p>Gate.io, l’exchange centralizzato, offre vari servizi ai cittadini di Hong Kong. Le persone possono scambiare molte criptovalute come bitcoin, ETH, USDT, Binance Coin e <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> tra gli altri.</p>
<h3 id="h3-Qual2020la20migliore20piattaforma20di20criptovalute20a20Hong20Kong948297"><a name="Qual è la migliore piattaforma di criptovalute a Hong Kong?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la migliore piattaforma di criptovalute a Hong Kong?</h3><p>Ci sono molte piattaforme valide che si occupano di criptovalute a Hong Kong. Ad esempio, i principali scambi come Gate.io, Binance, Bybit e OXK offrono vari servizi crittografici nella città.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>