SG9uZyBLb25nIHZlcnNuZWx0IFdlYjMgSW5ub3ZhdGllIG1ldCBISyQ1MCBtaWxqb2Vu

2023-03-08, 08:32

<p><img src="https://gimg2.gateimg.com/image/article/16782639741.18.jpeg" alt=""></p>
<h2 id="h2-TLDR932629"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Hong Kong heeft HK$50 miljoen begroot om cryptocurrency-investeringen in het land te leiden.</p>
<p>De investering evenals relevante wetgeving zal naar verwachting meer <a href="/web3" target="_blank" class="blog_inner_link">web3</a> bedrijven naar de stad trekken.</p>
<p>Diverse grote crypto-bedrijven zoals <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global, ShucangCN en BSC Spartan Network hebben beloofd om in de nabije toekomst te investeren in de stad.</p>
<p>Het vasteland van China gebruikt Hong Kong misschien als een pilotprogramma voor zijn toekomstige web3-economie.</p>
<h2 id="h2-Introductie399066"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Als de huidige opkomende trends zoals de injectie van overheidsfondsen in de cryptosector en de invoering van crypto-vriendelijke regelgeving aanhouden, zal de algemene acceptatie van digitale activa zoals cryptocurrencies en NFT toenemen. Hong Kong is een land dat een redelijke hoeveelheid geld heeft gereserveerd om zijn blockchain-technologie uit te breiden. In dit artikel wordt de huidige inspanning van Hong Kong in de blockchain-industrie besproken.</p>
<h2 id="h2-Groei20van20de20blockchainindustrie20in20Hong20Kong981422"><a name="Groei van de blockchain-industrie in Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Groei van de blockchain-industrie in Hong Kong</h2><p>Hongkong heeft HK$50 miljoen vrijgemaakt om het vertrouwen in de kracht van blockchain te tonen en zijn web3-bedrijven te ontwikkelen om te concurreren in de mondiale digitale economie. Een deel van de fondsen zal echter worden gebruikt om cryptoreguleringen in te voeren, wat het vertrouwen in de blockchain-infrastructuur van Hongkong kan vergroten en web3-bedrijven aantrekken om hun activiteiten in de stad te starten.</p>
<p>Gerelateerd nieuws: <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 zal Hong Kong betreden na de toewijzing van $6.4M aan Web3 door de stad.</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/167826407310831678263809_.pic.jpg" alt=""><br>Hong Kong- Coindesk</p>
<p>In de begrotingstoespraak voor 2023-2024 zei Paul Chan, de Financieel Secretaris van de stad: “Het Internet van de derde generatie (Web3), dat momenteel in zijn opstartfase zit, heeft net zoveel potentieel. We moeten met de tijd meegaan en deze gouden kans grijpen om innovatieve ontwikkeling te stimuleren.”</p>
<p>Hij voegde eraan toe: “Ik zal $50 miljoen toewijzen om de ontwikkeling van het Web3-ecosysteem te versnellen door onder andere het organiseren van belangrijke internationale seminars, om de industrie en bedrijven in staat te stellen beter inzicht te krijgen in de grensverleggende ontwikkeling en het bevorderen van samenwerking tussen sectoren, evenals het regelen van een breed scala aan workshops voor jongeren.”</p>
<p>Lees ook: <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">Gate.io CEO zegt dat Hong Kong mogelijk het nieuwe Crypto Mecca kan worden</a></p>
<p>Daarnaast beloofde Chan een taskforce op te richten die zou onderzoeken hoe het best de web3-innovatie in Hongkong kan worden aangevoerd. Een van de belangrijkste ambities van de stad is om crypto-investeerders uit het vasteland van China terug te lokken die naar andere landen zoals Singapore zijn verhuisd. Onder de verwachte investeerders bevindt zich Justin Sun, die via een tweet heeft aangegeven dat hij binnenkort naar Hongkong zal verhuizen.</p>
<p>Sun gaf ook aan dat de huidige houding de steun van de Chinese regering voor web3 in Hong Kong laat zien. Hij <a href="https://www.bangkokpost.com/business/2511770/beijing-quietly-backing-hk-crypto-plans" rel="nofollow noopener noreferrer" target="_blank">zei</a>, “De veranderende houding van de Hong Kongse regering ten opzichte van crypto geeft een knikje van de Chinese centrale regering om pilotstatus aan HK te verlenen voor enkele vooruitstrevende experimenten over hoe crypto het beste kan worden aangenomen en gelokaliseerd voor de grote Chinese markt als geheel.”</p>
<p>Er is geen twijfel dat de $50 miljoen gereserveerd voor de ontwikkeling van de blockchain sector in het land een ‘gouden kans’ biedt voor bedrijven die zich richten op <a href="https://www.gate.io/blog_detail/1745/hong-kong-new-crypto-policy-will-spring-come-to-hong-kong-again" target="_blank">hun crypto projecten vestigen in Hong Kong</a>.</p>
<p>Sun, die een vertegenwoordiger van de Wereldhandelsorganisatie is, voegde eraan toe dat er verschillende grote crypto-bedrijven zijn zoals <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Naast cryptobeurzen zullen ook market makers en hedgefondsen waarschijnlijk naar Hong Kong trekken.</p>
<p>Er is ook een hoge verwachting dat NFT- en metaversebedrijven waarschijnlijk naar Hong zullen komen. Als voorbeeld, ShucangCN, een toonaangevend NFT-bedrijf, <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">verteld</a> Forkast heeft als doel om een filiaal te openen in Hong Kong. Een andere grote speler in crypto die heeft beloofd om een filiaal te openen in Hong Kong is BSN Spartan Network, een Chinese blockchain die momenteel buiten China opereert.</p>
<h2 id="h2-Regulering20van20cryptovaluta20in20Hong20Kong356458"><a name="Regulering van cryptovaluta in Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regulering van cryptovaluta in Hong Kong</h2><p>Naast de investering van $50 miljoen in web3 werkt Hong Kong ook aan het opzetten van een crypto-vriendelijke omgeving. <a href="https://www.hkma.gov.hk/media/eng/doc/key-information/guidelines-and-circular/2022/20221207e1.pdf" rel="nofollow noopener noreferrer" target="_blank">regelgeving</a> in het land. Onlangs heeft de Securities and Futures Commission (SFC) van Hong Kong richtlijnen gepubliceerd voor virtuele activahandelplatforms. Het heeft echter om feedback gevraagd van het publiek.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826425410841678263820_.pic.jpg" alt=""><br>Cryptoregulering- Thenewscrypto</p>
<p>Een deel van de wetgeving zal de eisen vaststellen voor het licentiëren van cryptohandelplatforms en de registratie van digitale activa. De voorgestelde voorschriften zullen vanaf juni dit jaar van kracht zijn, wat betekent dat bedrijven in de getroffen sector tegen die tijd aan de wet moeten voldoen. De SFC zal ook controleren op de liquiditeit van de betrokken entiteiten zoals beurzen.</p>
<p>Lees ook: <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 verbindt zich met de lokale Web3-gemeenschap op BlockMountain 2023</a></p>
<p>Bovendien zullen de voorgestelde voorschriften een clausule bevatten die het plaatsen van misleidende crypto-advertenties verbiedt. Als gevolg daarvan zullen er straffen zijn voor personen en bedrijven die frauduleuze transacties uitvoeren. Zo kunnen overtreders aansprakelijk worden gesteld voor een boete van $10.000.000 en een gevangenisstraf van 10 jaar.</p>
<h2 id="h2-Is20Hong20Kong20een20pilotprogramma20voor20het20vasteland20van20China173806"><a name="Is Hong Kong een pilotprogramma voor het vasteland van China?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Hong Kong een pilotprogramma voor het vasteland van China?</h2><p>Verschillende analisten hebben erop gewezen dat de vriendelijke houding die Hong Kong aanneemt ten opzichte van cryptocurrencies en andere digitale activa een teken van goedkeuring is van China. Als zodanig zou China de cryptocurrency-investering in Hong Kong kunnen beschouwen als een pilotprogramma. Dit komt omdat functionarissen uit het vasteland de afgelopen maanden hebben deelgenomen aan enkele bijeenkomsten.</p>
<p>Naar aanleiding van hun vriendelijke en coöperatieve gebaren naar crypto-investeerders, hebben analisten geconcludeerd dat China een verandering van hart heeft, van zijn harde houding ten opzichte van cryptocurrency die heeft geleid tot het verbieden van de handel in cryptocurrencies in 2021. In feite begon zijn harde aanpak van cryptocurrencies al in 2017.</p>
<p>Op dit moment fungeert de versoepeling van China als een signaal voor het vasteland van cryptobedrijven en web3-start-ups in Hong Kong om cryptobedrijven in de stad te openen. Daarom kan de stad optreden als tussenpersoon voor web3-bedrijven die in de toekomst van plan zijn te investeren in China.</p>
<h2 id="h2-Conclusie777559"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De HK$50 miljoen die door de stad is gereserveerd, zal worden gebruikt om de ontwikkeling van het blockchain-ecosysteem van Hong Kong te financieren in haar streven om concurrerend te worden op het wereldtoneel. Bovendien is de stad bezig met het opstellen van de relevante cryptoregulering. Beide ontwikkelingen zouden de stad in staat moeten stellen om veel cryptoinvesteringen aan te trekken.</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 mening van de onderzoeker en vormt geen enkele beleggingsadvies.<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 schending van het auteursrecht.<br></div><p></p><br></div></div></div>