SG9uZyBLb25nIG9udGtldGVudCBkZSBjcnlwdG8tZ29sZiBpbiBoZXQgb29zdGVuLCB6YWwgZGUgdm9sZ2VuZGUgY3J5cHRvLXN0aWVyZW5sb29wIGJlZ2lubmVuIGluIENoaW5hPw==

<p><img src="https://gimg2.gateimg.com/image/article/167704613620230222-140829.jpeg" alt=""></p>
<h2 id="h2-TLDR572589"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>🔹 Op 20 februari lanceerde de Hong Kong Securities and Futures Commission (SFC) consultaties over de regulering van het cryptohandelplatform.</p>
<p>🔹 Hong Kong kan de handel in mainstream cryptovaluta openen voor particuliere beleggers.</p>
<p>🔹 Het positieve nieuws in Hong Kong zorgde voor een sterke stijging van de ‘Hong Kong concept sector’, waarbij CFX met meer dan 500% steeg.</p>
<p>🔹 Het reguleringsbeleid van Hong Kong en het beleid op het Chinese vasteland zijn gepolariseerd, wat mogelijk een complementaire kracht kan vormen om China te helpen een nieuw crypto-verhaal te openen.</p>
<h2 id="h2-Hong20Kong20Securities20and20Futures20Commission20van20plan20om20cryptohandel20te20openen20voor20particuliere20beleggers725163"><a name="Hong Kong Securities and Futures Commission van plan om cryptohandel te openen voor particuliere beleggers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hong Kong Securities and Futures Commission van plan om cryptohandel te openen voor particuliere beleggers</h2><p>Uitbreiding van het lezen: <a href="https://www.gate.io/blog_detail/1745/hong-kong-new-crypto-policy-will-spring-come-hong-kong" target="_blank">Nieuw Crypto Beleid Hong Kong | Zal de Lente Opnieuw Naar Hong Kong Komen?</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/16770456519771677045490_.pic.jpg" alt=""><br>Bron: officiële website van de Securities and Futures Commission van Hong Kong</p>
<p>Op 20 februari lanceerde de Hong Kong Securities and Futures Commission consultaties over de aanbevelingen voor de regulering van het handelsplatform voor virtuele activa. De gepubliceerde Consultatiepaper raadpleegde voornamelijk de Hong Kongse industrie over tien vragen:</p>
<p>🔹 Zal het gelicentieerde platform diensten mogen verlenen aan niet-professionele beleggers op basis van het nemen van de aanbevolen passende maatregelen ter bescherming van de belegger?<br>🔹 Heeft u suggesties voor de opnamecriteria voor algemene tokens en specifieke tokens?<br>🔹 Als de SFC retailbeleggers toestaat het gelicentieerde handelsplatform te gebruiken, welke andere bepalingen moeten dan worden toegepast vanuit het oogpunt van de bescherming van beleggers?<br>🔹 Heeft u een mening over het voorstel om het gebruik toe te staan van middelen die zijn toegewezen door de exploitanten van externe verzekeringen en gelicentieerde platforms of de ondernemingen die verbonden zijn met dezelfde bedrijvengroep? Heb je nog andere suggesties?<br>🔹 Heeft u suggesties over de manier waarop de vergunninghoudende platformexploitant dergelijke middelen moet toewijzen (bijvoorbeeld aan de bedrijfsrekening van de vergunninghoudende platformexploitant of om escrowregelingen op te zetten)? Leg in detail uit welke regeling u hebt voorgesteld en hoe de bescherming die door de desbetreffende regeling wordt geboden, hetzelfde beschermingsniveau kan bieden als de WA-verzekering.<br>🔹 Welke technische oplossingen kunnen de risico’s in verband met de bewaring van virtuele activa van klanten (met name het aanhouden van virtuele activa via online opslag) effectief verminderen? Heeft u suggesties?<br>🔹 Als de gelicentieerde platformexploitant handelsdiensten voor virtuele activaderivaten kan aanbieden, welk bedrijfsmodel zou u dan aanbevelen? Wat voor soort derivaten van virtuele activa raadt u beleggers aan om te kopen en verkopen? Op wat voor soort beleggers zal het doelwit zijn?<br>🔹 Heeft u een mening over hoe u de andere bepalingen in de algemene voorwaarden van het Virtual Asset Trading Platform kunt verbeteren en deze kunt opnemen in de Guidelines for Virtual Asset Trading Platform?<br>🔹 Heeft u een mening over de bepalingen inzake de overdracht van virtuele activa of andere bepalingen in hoofdstuk 12 van de richtsnoeren inzake de bestrijding van het witwassen van geld die van toepassing zijn op ondernemingen met een vergunning en aanbieders van virtuele activadiensten met een vergunning van de SFC?<br>🔹 Heeft u opmerkingen over de Leidraad Tuchtboetes van de SFC?</p>
<p>De bovenstaande tien vragen richten zich voornamelijk op “het al dan niet aanbieden van cryptohandelsservices voor particuliere beleggers” en “hoe investeerders te beschermen”. De consultatie eindigde op 31 maart. Twee maanden later (1 juni) werd het nieuwe licentiesysteem voor cryptohandelplatforms geïmplementeerd in Hongkong. Alle cryptohandelplatforms die actief zijn in Hongkong of die adverteren voor Hongkongse investeerders moeten een vergunning hebben van de Hong Kong Securities and Futures Commission.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770456949781677045507_.pic.jpg" alt=""><br>Op dit moment staat China op de eerste plaats en Hong Kong op de tweede plaats in de “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zoekpopulariteit - Bron: Google Trends</p>
<h2 id="h2-Als20Hongkong20de20mainstream20leidt20zal20het20project20viraal20gaan710442"><a name="Als Hongkong de mainstream leidt, zal het project viraal gaan." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Als Hongkong de mainstream leidt, zal het project viraal gaan.</h2><p>Op dit moment stijgt het marktsentiment snel en zijn verschillende projecten die verband houden met het Hong Kong-concept begonnen aan de ‘golf’ modus, waarin de prestaties van CFX het meest opvallend zijn. Volgens CoinGecko-gegevens is CFX de grootste winnaar van alle cryptocurrencies in de afgelopen 7 dagen, met een stijging van maar liefst 500,1%. Op 21 februari om 17:00 uur werd CFX genoteerd op $0,31 en bedroeg het handelsvolume in 24 uur $909854679.</p>
<p>De berenmarkt van vorig jaar heeft investeerders te lang onderdrukt en het positieve sentiment heeft zelfs de lokale projecten in China verbrand. Tokens voor oude projecten zoals <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>, en KEY hebben de afgelopen twee dagen verrassend goed gepresteerd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770457809791677045521_.pic.jpg" alt=""></p>
<p>Echter is momenteel de definitie van de “Hong Kong concept sector” onduidelijk. Veel mensen grijpen de kans om de projectachtergrond te vervagen en te proberen om <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> het met het “Hong Kong-concept”. In feite zijn de belangrijkste cryptoprojecten in Hong Kong verspreid over CeFi, games, servicevoorzieningen en andere gebieden. Onderstaande figuur toont enkele cryptoprojecten in Hong Kong.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458159801677045545_.pic.jpg" alt=""><br>Belangrijkste projecten in Hong Kong - bron RootData</p>
<p>Vanuit de staking sector van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> aan het begin van het jaar, naar de AI-sector geleid door chatGPT en naar de huidige conceptsector in Hong Kong, lijkt de markt geen moment stil te durven staan, uit angst om terug te keren naar de sfeer van de dood in 2022. Sentiment kan noch industriële ontwikkeling brengen, noch langetermijnvoordelen voor het project brengen. Voor investeerders kan het de belangrijkste manier zijn om onderscheid te maken tussen emotionele speculatie en toekomstige trends.</p>
<h2 id="h2-Wanneer20het20donker20is20in20het20westen20is20het20licht20in20het20oosten372838"><a name="Wanneer het donker is in het westen, is het licht in het oosten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wanneer het donker is in het westen, is het licht in het oosten</h2><p>De Amerikaanse overheid aarzelt nog steeds over de kwestie van hoe ze de cryptomarkt moet reguleren. Toen de SEC optrad tegen Kraken, BUSD-uitgevers Paxos en Binance, wekte deze stap in Hong Kong ongetwijfeld hoop op voor de chaotische cryptomarkt, waardoor investeerders opnieuw hun oog op Hong Kong, Singapore en andere oosterse landen/regio’s begonnen te houden. Uit de marktveranderingen na de publicatie van het Consultatiedocument kunnen we ook zien hoe het vertrouwen van investeerders zich verplaatst.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458459811677045557_.pic.jpg" alt=""></p>
<p>Op 21 februari bereikte de marktwaarde van de cryptomarkt de hoogste waarde sinds het midden van augustus vorig jaar - Bron: CoinGecko</p>
<p>De stap van Hong Kong heeft zonder twijfel een belangrijke stap gezet om een Aziatische crypto-hub te worden. Cameron Winklevoss, mede-oprichter van Gemini, tweette: “De volgende bull run van cryptocurrency gaat beginnen in het Oosten.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458679821677045569_.pic.jpg" alt=""><br>Bron: Twitter@Cameron Winklevoss</p>
<p>De oprichter van <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> ook voorspelde dat China de volgende crypto-stier rechtstreeks op Twitter zou brengen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16770458829831677045583_.pic.jpg" alt=""><br>Bron: Twitter@Scott_eth</p>
<p>Singapore, een ander land dat concurreert met het cryptocurrencycentrum van het Oosten, heeft ongeveer dezelfde beleidslijn als Hong Kong, dat voornamelijk open en inclusief is, aangevuld met ondersteunende regulerende maatregelen. Hong Kong wordt echter gesteund door het Chinese vasteland, dat in 2021 de handel in crypto heeft verboden. Het is moeilijk voor te stellen wat zo’n ander beleid zal betekenen voor de markt en het ‘Oosten’. De moeilijkheid van het huidige wereldwijde crypto-reguleringsbeleid is grotendeels te wijten aan de ‘mate’ van regulering. Het beleidsverschil tussen het Chinese vasteland en Hong Kong kan een goede aanvulling vormen: terwijl het belangrijke ontwikkelingskansen grijpt, zorgt het voor een soepele werking van de markt en minimaliseert het risico’s, zodat China voldoende concurrentievermogen heeft bij deze technologische verandering.</p>
<p>Misschien begint de volgende fase van het crypto-verhaal in China.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Jill Ma</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 gevallen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>