SG9uZyBLb25nIHN0ZWx0IGVlbiBnZXphbWVubGlqa2UgdGFza2ZvcmNlIG9wIG9tIGNyeXB0b2N1cnJlbmN5LWJldXJ6ZW4gdGUgbW9uaXRvcmVuIGVuIGhldCBKUEVYLXNjaGFuZGFhbCB0ZSBvbmRlcnpvZWtlbg==

2023-10-18, 08:26

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR609340"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Hong Kong heeft een werkgroep opgericht om haar capaciteit te vergroten om te kunnen omgaan met bedreigingen die mogelijk bestaan in de cryptocurrencysector.</p>
<p>The Cyber Security and Technology Crime Bureau, Cyber Security and Technology Crime Bureau, the SFC’s Enforcement Division and Intermediaries Division as well as the police’s Commercial Crime Bureau have created a taskforce to coordinate their efforts to fight suspicious crypto activities.</p>
<p>Het JPEX-schandaal heeft zwakheden blootgelegd die nog steeds bestaan in de cryptowetgeving van Hong Kong.</p>
<h2 id="h2-Introductie772016"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De recente ontwikkelingen in Hong Kong laten zien dat een land om te floreren als een cryptohub een duidelijk regelgevend kader moet hebben dat blockchainbedrijven ondersteunt en investeerders beschermt. Het moet de cryptoregels op een sterke en effectieve manier handhaven.</p>
<p>Het crypto-uitwisselingsschandaal van JPEX duidt op een gebrek aan sterke regelgevende controle van de kant van de Hongkongse autoriteiten.</p>
<p>Dit artikel zal bespreken de gezamenlijke task force van Hong Kong en hoe het zal voorkomen dat soortgelijke schandalen zoals die met betrekking tot JPEX crypto-uitwisseling. We zullen ook kijken naar hoe het JPEX-schandaal zich heeft ontwikkeld.</p>
<h2 id="h2-Het20overzicht20van20cryptocurrency20regulering20in20Hong20Kong64109"><a name="Het overzicht van cryptocurrency regulering in Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het overzicht van cryptocurrency regulering in Hong Kong</h2><p>Hoewel China cryptocurrency-activiteiten op het vasteland heeft verboden <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 staat cryptoinvesteringen toe</a> zolang de deelnemers zich houden aan de regels, die medio 2023 zijn vastgesteld.</p>
<p>Er zijn verschillende bepalingen voor crypto-regulering die moeten worden gevolgd. Alleen beleggers die bijvoorbeeld ten minste 8 miljoen HKD (ongeveer $ 1 miljoen) kunnen investeren, kunnen investeren in crypto-activa.</p>
<p>Gecentraliseerde cryptocurrencies die actief zijn in de stad moeten zich registreren bij de Securities and Futures Commission (SFC) van Hong Kong. De stad behandelt crypto-beurzen op een vergelijkbare manier als geautomatiseerde handelsplatforms en effectenmakelaars. Daarom moeten deze platforms, waaronder crypto-beurzen, die populair worden aangeduid als virtuele activaplatforms (VA-platforms), de bepalingen van de Securities and Futures Ordinance 2023 volgen.</p>
<p>Cryptocurrency exchanges die de belangrijke spelers zijn in de crypto-sector in Hong Kong, moeten zich houden aan verschillende wettelijke richtlijnen, waaronder het veilig opslaan van de digitale activa van klanten, het naleven van de Know Your Customer (KYC) normen en strikt het volgen van de Anti-Money Laundering (AML) en de bepalingen ter voorkoming van financiering van terrorisme van de stad.</p>
<p>De stadsautoriteiten volgen de activiteiten van de virtuele activaplatforms nauwlettend om beleggers te beschermen tegen manipulatieve praktijken en illegale activiteiten. Daarom moet elke crypto-uitwisseling een schriftelijk beleid ontwikkelen en tools opzetten om illegale handelsactiviteiten te voorkomen en te rapporteren.</p>
<p>Bovendien moet elke virtuele-activaplatform maandelijks commerciële rapporten publiceren en jaarlijkse financiële auditrapporten indienen bij de SFC zoals voorgeschreven in de Hong Kong Securities and Futures Ordinance (SFO). Verder moet elke crypto-uitwisseling auditors hebben die goed op de hoogte zijn van digitale activiteiten die periodiek haar activiteiten bekijken.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2306/gateio-market-watch-hong-kong-sees-a-stronger-future-for-web3" target="_blank">Hong Kong Ziet Een Sterkere Toekomst Voor Web3</a></p>
<h2 id="h2-Samenwerking20tussen20de20Hong20Kong20Police20en20de20Securities20and20Futures20Commission20SFC191262"><a name="Samenwerking tussen de Hong Kong Police en de Securities and Futures Commission (SFC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenwerking tussen de Hong Kong Police en de Securities and Futures Commission (SFC)</h2><p>De Hong Kong Police en de SFC hebben een taskforce opgericht om de activiteiten van crypto-beurzen in de stad te volgen. Deze werkgroep bestaat uit leden van het Cyber Security and Technology Crime Bureau, Cyber Security and Technology Crime Bureau, de Enforcement Division en Intermediaries Division van de SFC en ook het Commercial Crime Bureau van de politie.</p>
<p>De belangrijkste focus van deze taskforce is om hun inspanningen te coördineren om informatie te delen met betrekking tot verdachte activiteiten met betrekking tot cryptohandel. Door dit te doen, zullen ze in staat zijn om risico’s op een gecoördineerde manier te identificeren en te beoordelen.</p>
<p>In dit verband zei Eve Chung, assistent commissaris van politie: “De implementatie van het nieuwe platform tussen de politie en de SFC is instrumenteel voor het versnellen van vitale uitwisseling van inlichtingen en gezamenlijke samenwerking bij het reageren op de uitdagingen die voortvloeien uit VATPs, om het algemene publiek van Hong Kong beter te beschermen.”</p>
<p>Met andere woorden zal de werkgroep niet alleen samenwerken om kritieke informatie te delen over de werking van cryptocurrency-beurzen, maar ook om illegale activiteiten te onderzoeken die zich in de sector kunnen voordoen. Over het algemeen richt het zich op het beschermen van consumenten en crypto-bedrijven.</p>
<p>Deze ontwikkeling komt na andere belangrijke initiatieven ter bescherming van investeerders. Als voorbeeld onthulde de Securities and Futures Commission van Hong Kong in september een programma gericht op het opleiden van potentiële crypto-investeerders door het delen van vitale informatie over Virtual Asset Trading Platform Operators (VATP’s).</p>
<p>Lees ook: <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 triggert de cryptogolf in het Oosten, zal de volgende crypto bull run in China beginnen?</a></p>
<p>Bovendien werkt de Securities and Futures Commission (SFC) van Hong Kong aan het vergroten van de transparantie in de crypto sector. Zo zal het bijvoorbeeld een lijst publiceren van gelicentieerde VATP’s en alle aanvraag-pending virtuele activa handelsplatforms.</p>
<p>Deze organisaties hebben de werkgroep opgericht naar aanleiding van het JPEX-schandaal dat heeft geleid tot het verlies van klanten van digitale activa door frauduleuze middelen.</p>
<h2 id="h2-Het20JPEXschandaal311893"><a name="Het JPEX-schandaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het JPEX-schandaal</h2><p>De Japanse beurs, algemeen bekend als de JPEX en gevestigd in Dubai, heeft naar verluidt duizenden gebruikers voor miljoenen dollars opgelicht via verschillende methoden. Deze cryptobeurs, die beweert samenwerkingen te hebben met gevestigde financiële instellingen zoals Alibaba en Standard Chartered, heeft veel individuen en instellingen verleid om erin te investeren vanwege hoge rendementen en lage kosten.</p>
<p>Bovendien gebruikte de beurs verschillende marketingstrategieën om mensen aan te moedigen erin te investeren. Zo werden er bijvoorbeeld veel online advertenties, billboards en influencer-campagnes gebruikt om mensen te overtuigen om in hun producten te investeren. Joseph Lam, beter bekend als de ‘Trolling King’ van Hong Kong, en Chan Yee, een YouTuber met meer dan 200.000 abonnees, hebben JPEX gepromoot.</p>
<p>Deze influencers gebruikten ongeverifieerde gegevens om hun volgers te laten zien hoe ze veel geld konden verdienen om huizen en voertuigen te kopen door te investeren in JPEX. Volgens het recente rapport hebben meer dan 2.305 mensen meer dan HK$1,43 miljard (ongeveer $182,9 miljoen) verloren die ze hebben geïnvesteerd in de cryptobeurs, waardoor het een van de grootste frauduleuze zaken in Hong Kong is geworden.</p>
<p>De implosie van JPEX begon toen de Securities and Futures Commission (SFC) van Hong Kong een waarschuwing uitgaf dat JPEX geen geregistreerd handelsplatform was. Later erkende de beurs openlijk dat het liquiditeitsuitdagingen ondervond, wat ertoe leidde dat het opnames bevroor.</p>
<p>Bovendien heeft de crypto exchange een controversieel dividendenplan waarbij het werkt aan het omzetten van de activa van klanten in aandelen waarmee ze dividenden kunnen verdienen. Klanten kunnen echter pas na twee jaar over de fondsen beschikken.</p>
<p>Dienovereenkomstig is dit het plan van JPEX om zijn kas te verbeteren. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> en behoudt zijn belangrijkste investeerders. JPEX beweert dat het een referendum heeft gehouden waar 68% van zijn klanten voor het dividendplan en de vorming van een gedecentraliseerde autonome organisatie (DAO) heeft gestemd.</p>
<p>Helaas reageerde het niet op de correspondentie van veel klanten die wilden weten waarom ze hun geld niet konden opnemen. De cryptobeurs verhoogde ook haar transactiekosten tot wel 999 USDT voor het opnemen van 1.000 USDT.</p>
<p>Na vele klachten van JPEX-investeerders bij de relevante autoriteiten begon de Hong Kong Police haar onderzoek, wat leidde tot de arrestatie van meer dan 11 mensen, waaronder Siu-lung, CEO van een over-the-counter (OTC) virtuele valutawisselaar, Li, een voormalig directeur, Lam en Chan op beschuldiging van witwassen, verdenking van fraude en samenzwering tot oplichting.</p>
<p>Als onderdeel van het onderzoek heeft de politie vele elektronische gadgets en andere waardevolle spullen in beslag genomen, waaronder computers, smartphones, bankpassen en andere gerelateerde documenten. De autoriteit van Hong Kong heeft ook de bankrekeningen van JPEX bevroren en verschillende activa in beslag genomen, waaronder luxe voertuigen en andere eigendommen.</p>
<h2 id="h2-JPEX20Reactie593922"><a name="JPEX Reactie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JPEX Reactie</h2><p>De JPEX Exchange heeft verschillende verduidelijkingen gegeven. Ten eerste beweert het dat de recente liquiditeitsuitdaging het gevolg was van de actie van een van zijn market makers die zijn fondsen heeft bevroren. Als gevolg hiervan werkt het samen met de verantwoordelijke partner om de fondsen vrij te geven.</p>
<p>Het zei: ‘We beloven om de liquiditeit van derde marktmakers zo snel mogelijk te herstellen en de opnamekosten geleidelijk terug te brengen naar normale niveaus.’</p>
<p>Echter zal het JPEX-schandaal waarschijnlijk de inspanningen van Hong Kong om een crypto-hub te worden vertragen. Carlton Lai, het hoofd van Daiwa Capital Markets, een onderzoeksbedrijf voor blockchain en cryptocurrency, zei: “Ik denk dat dit schandaal een behoorlijk grote negatieve invloed zal hebben op het sentiment onder de detailhandel, gezien de aanzienlijke lokale aanwezigheid en de verschillende betrokken beroemdheden.”</p>
<h2 id="h2-Uitdagingen20waarmee20de20autoriteiten20in20Hong20Kong20worden20geconfronteerd276602"><a name="Uitdagingen waarmee de autoriteiten in Hong Kong worden geconfronteerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitdagingen waarmee de autoriteiten in Hong Kong worden geconfronteerd</h2><p>De autoriteiten in Hong Kong staan voor verschillende uitdagingen bij het toezicht houden op crypto-activiteiten, waaronder een gebrek aan medewerking van blockchainbedrijven. Ook hebben ze problemen met het coördineren met lokale en internationale belanghebbenden. De oprichting van de taskforce in Hong Kong is de eerste stap naar het versterken van haar capaciteit.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2856" target="_blank">Azië’s overwinning: Amerikaanse crypto-crackdown profiteert van Azië</a></p>
<h2 id="h2-Conclusie810137"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Hong Kong heeft een taskforce met meerdere partijen gevormd om de activiteiten van de cryptocurrency-sector te coördineren. Het Cyber Security and Technology Crime Bureau, het Cyber Security and Technology Crime Bureau, de Enforcement Division and Intermediaries Division van de SFC en het Commercial Crime Bureau van de politie hebben een werkgroep gevormd die verdachte activiteiten in de cryptocurrency-sector zal identificeren.</p>
<h2 id="h2-Veelgestelde20vragen20over20cryptocurrency20in20Hong20Kong554069"><a name="Veelgestelde vragen over cryptocurrency in Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over cryptocurrency in Hong Kong</h2><h3 id="h3-Is20cryptocurrency20toegestaan20in20Hong20Kong702992"><a name="Is cryptocurrency toegestaan in Hong Kong?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is cryptocurrency toegestaan in Hong Kong?</h3><p>Cryptocurrency <a href="https://www.gate.io/blog_detail/2206/gateio-market-watch-hong-kongs-new-crypto-policy-triggers-market-rise" target="_blank">is legaal in Hong Kong</a>, wat betekent dat mensen het mogen kopen, vasthouden en verkopen. Cryptobeurzen en andere platforms die zich bezighouden met cryptocurrencies moeten zich echter registreren bij de relevante autoriteiten.</p>
<h3 id="h3-Investeert20Hong20Kong20in20crypto535521"><a name="Investeert Hong Kong in crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeert Hong Kong in crypto?</h3><p>Veel mensen in Hong Kong investeren in verschillende cryptocurrencies, waaronder <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH. Bovendien zijn er veel bedrijven die cryptocurrency diensten aanbieden in de stad.</p>
<h3 id="h3-Welke20cryptovaluta20kan20Hong20Kong20kopen630606"><a name="Welke cryptovaluta kan Hong Kong kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke cryptovaluta kan Hong Kong kopen?</h3><p>Mensen in Hong Kong kunnen verschillende cryptocurrencies kopen, waaronder bitcoin, ETH, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> en vele anderen. Echter, de stad heeft duidelijke voorschriften met betrekking tot de crypto-activa die de beurzen aan het publiek kunnen aanbieden.</p>
<h3 id="h3-Is20Gateio20beschikbaar20in20HK452885"><a name="Is Gate.io beschikbaar in HK?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Gate.io beschikbaar in HK?</h3><p>Gate.io, de gecentraliseerde beurs, biedt verschillende diensten aan inwoners van Hong Kong. Mensen kunnen vele cryptocurrencies verhandelen zoals bitcoin, ETH, USDT, Binance Coin en XRP, onder anderen.</p>
<h3 id="h3-Welk20cryptoplatform20is20het20beste20in20Hong20Kong150228"><a name="Welk cryptoplatform is het beste in Hong Kong?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welk cryptoplatform is het beste in Hong Kong?</h3><p>Er zijn veel goede platforms die zich bezighouden met cryptocurrencies in Hong Kong. Bijvoorbeeld bieden de topbeurzen zoals Gate.io, Binance, Bybit en OXK verschillende crypto-diensten in de stad aan.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>