TmlldXcgQ3J5cHRvIEJlbGVpZCBIb25nIEtvbmcgfCBaYWwgZGUgTGVudGUgT3BuaWV1dyBLb21lbiBuYWFyIEhvbmcgS29uZz8=

2022-11-07, 02:57

<p><img src="https://gimg2.gateimg.com/image/article/1667956834%E9%A6%99%E6%B8%AF%E5%8A%A0%E5%AF%86%E6%96%B0%E6%94%BF%E6%98%A5%E5%A4%A9%E6%9C%83%E5%86%8D%E5%BA%A6%E9%99%8D%E8%87%A8%E9%A6%99%E6%B8%AF%E5%97%8E_web.jpeg" alt=""><br>In de afgelopen jaren hebben de strikte pandemiepreventiebeleid, de verandering in het politieke klimaat, de migratiegolf, de terugtrekking van buitenlands kapitaal en andere negatieve effecten blijven impact hebben op alle aspecten van het leven in Hong Kong.</p>
<p>31 oktober 2022 is een dag die het waard is om in de geschiedenis te worden opgenomen. Het Bureau voor Financiële Zaken en Schatkist van de Speciale Administratieve Regio Hongkong heeft op 31 oktober officieel de Beleidsverklaring betreffende de Ontwikkeling van Virtuele Activiteiten in Hongkong uitgebracht.</p>
<p>Hongkong is momenteel nog steeds een paradijs voor ondernemerschap op het gebied van Defi, Cefi, makelaardij, vermogensbeheer, tokenisatie van off-chain activa, derivateninnovatie en stortingen en opnames, evenals een verzamelplaats voor Web3-hedgefondsen en durfkapitaalfondsen.</p>
<p>Voor de SAR-regering staat Hongkong voor een unieke historische kans. Misschien kan Hongkong dit keer met behulp van <a href="/web3" target="_blank" class="blog_inner_link">web3</a> terugkeren naar de troon van het Aziatische financiële centrum.</p>
<p>Sinds Singapore zijn financiële positie in Azië heeft overtroffen, is Hongkong op zoek naar kansen om terug te keren naar zijn positie als het Aziatische financiële centrum. Misschien is Web 3.0 een goede kans.</p>
<h2 id="h2-Stilte762943"><a name="Stilte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stilte</h2><p>In de afgelopen jaren heeft het strenge pandemische preventiebeleid, de verandering in het politieke klimaat, de migratiegolf, de terugtrekking van buitenlands kapitaal en andere negatieve effecten blijven impact hebben op alle aspecten van het leven in Hong Kong.</p>
<p>Op 22 september 2022 kondigde de 32e Global Financial Center Index (GFCI 32) gezamenlijk uitgegeven door het Britse Think Tank Z/Yen en het China (Shenzhen) Institute of Comprehensive Development de nieuwste ranglijst aan. New York, Verenigde Staten, en Londen, Verenigd Koninkrijk bleven respectievelijk op de eerste en tweede plaats staan in de wereldwijde financiële centrumindex. Hongkong verloor zijn positie als het toonaangevende financiële centrum in Azië, zakte een plaats naar de vierde, en Singapore nam zijn plaats in. Laatstgenoemde klom naar de derde plaats vanaf de zesde plaats in de 31e uitgave die een half jaar geleden werd uitgebracht.</p>
<p>Het rapport vermeldde dat de voortdurende toeristische beperkingen in Hong Kong zich verdiepen en de normale zakelijke ontwikkeling van Hong Kong beïnvloeden.</p>
<p>Met name het politieke klimaat begon te veranderen in het midden van 2020. Het Verenigd Koninkrijk, Canada, Taiwan en andere plaatsen hebben ‘reddingsboten’ of ‘project’ plannen opgezet om Hongkongse inwoners in staat te stellen naar het lokale gebied te migreren door middel van studie, werk, enz. Hoewel ambtenaren ontkennen dat Hong Kong een grootschalige migratiegolf heeft, wordt de beroepsbevolking van Hong Kong numeriek gezien ‘afgeknabbeld’.</p>
<p>Volgens de nieuwste gegevens van het Statistisch Bureau van de Hong Kong regering in het tweede kwartaal van 2022 bedraagt de totale beroepsbevolking in Hong Kong 3,7502 miljoen, een daling van 135.500 of 3,49% vergeleken met dezelfde periode vorig jaar. Daarvan is het aantal werkenden tussen de 20 en 39 jaar afgenomen. Het aantal mensen tussen de 20 en 24 jaar is met 14,98% gedaald ten opzichte van dezelfde periode. Het aantal werkenden in de financiële sector in het tweede kwartaal van 2021 bedroeg ongeveer 210.000, maar is tot nu toe met meer dan 10.000 afgenomen.</p>
<p>Het cicade-effect bleef aanhouden en Hong Kong viel in een lange stilte.<br><img src="https://gimg2.gateimg.com/image/article/1676963450111.png" alt=""></p>
<h2 id="h2-Een20bom108219"><a name="Een bom" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een bom</h2><p>31 oktober 2022 is een dag die het waard is om in de geschiedenis te worden opgenomen.</p>
<p>Het Bureau voor Financiële Zaken en Schatkist van de Speciale Administratieve Regio Hongkong heeft op 31 oktober de Beleidsverklaring betreffende de Ontwikkeling van Virtuele Activa in Hongkong officieel uitgebracht, waarin de beleidsstandpunten en richtlijnen van de regering over de ontwikkeling van een bloeiende virtuele activa-industrie en ecosysteem in Hongkong worden verduidelijkt. Daarbij betekent de nadruk op door activa gedekte tokens (ABT) dat Hongkong, als internationaal financieel centrum, zich in de toekomst zal richten op de ontwikkeling van dergelijke virtuele activa producten.</p>
<p>Na het zorgvuldig lezen van de volledige tekst van de Verklaring, kunnen we vaststellen dat de volgende drie soorten virtuele activa zullen worden gelegaliseerd:</p>
<ol>
<li>NFT’s. Dit betekent dat de uitgifte van NFT’s in Hong Kong in de toekomst gelegaliseerd zal worden en onder toezicht van de overheid zal vallen (KYC, anti-witwassen, enz.).</li></ol>
<p>2 . Tokenized activa (d.w.z. ABT’s: asset-backed tokens). Door activa gedekte tokens vertegenwoordigen het eigendom van fysieke activa buiten de keten (zoals goud of olie), en de waarde van tokens wordt bepaald door hun onderliggende activa. De timeshare-onroerendgoedtokens die eerder in Thailand verschenen, evenals goud-, olie- en koolstofemissiequota die veel ondernemersprojecten in Hong Kong onderzoeken, evenals de tokenisatie van kunstwerken, verzamelobjecten en antiek, behoren tot deze categorie. De “tokenisatie van groene obligaties” die door de regering van Hong Kong is gelanceerd, is ook een soort tokenized activum en de waarde van tokens wordt bepaald door groene obligaties.</p>
<ol>
<li>Stablecoins en digitale Hong Kong dollars. De Stablecoin wordt uitgegeven door financiële instellingen en de digitale Hong Kong dollars kunnen worden uitgegeven onder toestemming van de overheid. We kunnen afwachten welke publieke blockchains de Hong Kongse overheid digitale Hong Kong dollars zal uitgeven, of het is mogelijk dat de Hong Kongse overheid een aparte publieke blockchain zal leiden.</li></ol>
<p>Het is buitengewoon goed nieuws voor de hele blockchainwereld, als een “bomshell”.<br><img src="https://gimg2.gateimg.com/image/article/1676963480222.png" alt=""></p>
<h2 id="h2-Waarom20Hong20Kong643684"><a name="Waarom Hong Kong?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom Hong Kong?</h2><p>In feite zijn we niet bang voor toezicht, maar voor incidenteel toezicht en de bepalingen zonder grenzen en wettelijke beperkingen.</p>
<p>Tegenwoordig is de ‘Crypto Declaration’ van Hong Kong officieel gelanceerd. We kunnen Hong Kong meer tijd en meer verwachtingen geven. Maar waarom Hong Kong?</p>
<p>Vanwege zijn rijke accumulatie als internationaal financieel centrum in de geschiedenis, heeft Hong Kong een groot aantal talenten verzameld op het gebied van financiën, handel en innovatie op het gebied van derivaten. Daarom is Hong Kong nog steeds een paradijs voor innovatie op het gebied van Defi, Cefi, makelaardij, vermogensbeheer, off-chain tokenisatie van activa, innovatie van derivaten en stortingen en opnames, evenals een verzamelplaats voor Web3-hedgefondsen en durfkapitaalfondsen.</p>
<p>Op het gebied van Web3-talent wordt Hong Kong gedomineerd door financieel talent. Maar er is ook een goede opeenstapeling van talent op het gebied van Web3-productontwikkeling en -exploitatie. Hoewel het niet te vergelijken is met het vasteland, lijkt het toch aanzienlijke voordelen te hebben ten opzichte van Zuidoost-Azië en het Midden-Oosten.</p>
<p>Ondanks dergelijke twijfels bestaat het rechtssysteem geworteld in het common law systeem nog steeds. Dit betekent dat zodra de wetgever relevante wetten en voorschriften uitvaardigt, de uitvoerende macht deze strikt zal uitvoeren in overeenstemming met de bepalingen, en de wetten en voorschriften niet zal veranderen en willekeurig zal handhaven als gevolg van de willekeurige interpretatie van de uitvoerende macht. Kortom, de voorspelbaarheid van voorschriften is nog steeds sterk, wat met name belangrijk is voor ondernemerschap in Web3.</p>
<p>Op het gebied van wet- en regelgeving verbiedt Hong Kong digitale activa niet, wat ook de reden is waarom Hong Kong veel DeFi- en digitale activa-financiële projecten heeft. De Hong Kong Securities Regulatory Commission en de Stock Exchange hebben ook veel onderzoek gedaan naar digitale activa-innovatie en toezicht, maar er worden momenteel niet veel voorschriften geïmplementeerd. Volgens het principe van geen expliciete bepalingen in de wet kan in theorie het Web3-project in Hong Kong worden gelanceerd, maar de industrie heeft over het algemeen twijfels, die later zullen worden besproken.</p>
<p>Hong Kong verwelkomt getalenteerde immigranten uit het vasteland. Hong Kong heeft immigratieprojecten voor vastelandbewoners, zoals het plan om talenten uit het vasteland te importeren, het toegangsplan voor uitstekende talenten, het plan voor wetenschappelijke en technologische talenten, en de verblijfsregeling voor afhankelijken. De immigratievoorwaarden voor internet-, IT- en financiële talenten zijn relatief relaxed, en het immigratieplan omvat echtgenoten en kinderen.</p>
<p>Hong Kong heeft een goed onderwijssysteem, met veel particuliere scholen en internationale scholen, en het is gemakkelijk voor kinderen om zich te vestigen en naar school te gaan. Naast de puur Chinese omgeving is de psychologische drempel voor de migratie van Web3-talenten uit het vasteland veel lager dan voor andere landen. Het kan worden gebruikt als een overgangsplaats of een ideale plek om permanent te wonen.</p>
<p>De regering van Hong Kong heeft vorig jaar de strategie voor de ontwikkeling van het Northern Metropolis-gebied uitgegeven. Het plan is om het noordelijke deel van Hong Kong te ontwikkelen als een metropoolgebied dat geschikt is voor wonen, zakendoen en toerisme, en wetenschappelijke creatie als de economische motor te nemen, met Yuen Long, Tin Shui Wai, Fanling en Sheung Shui als steunpunten. Naar verwachting zal de nieuwe SAR-regering beleid invoeren om talentwerving en de ontwikkeling van digitale technologie te ondersteunen.</p>
<p>Hong Kong heeft een eenvoudig belastingstelsel en lage belastingtarieven. Het progressieve belastingtarief is van toepassing op de persoonlijke loonbelasting, waarbij het maximale tarief niet hoger is dan 17%; Het belastingtarief voor bedrijfswinsten onder HK $2 miljoen is 8,25%, en het tarief voor het overschot is 16,5%. Er is geen belasting op vermogenswinsten, aandeelhoudersdividendbelasting en geen belasting op inkomsten uit het buitenland.</p>
<p>Dit kan de basis zijn om ervoor te zorgen dat web3.0 wortel schiet in Hong Kong.<br><img src="https://gimg2.gateimg.com/image/article/1676963548333.png" alt=""></p>
<h2 id="h2-Hong20Kong20VS20Singapore902804"><a name="Hong Kong VS Singapore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hong Kong VS Singapore</h2><p>Echter lijkt het erop dat in de afgelopen jaren veel ecoen die verloren zijn gegaan in Hong Kong, naar Singapore stromen.</p>
<p>Een paar dagen geleden werd TOKEN2049, de top cryptoconferentie van Azië, succesvol afgerond in Singapore, met meer dan 7.000 deelnemers en meer dan 2.000 wereldwijde bedrijven, waardoor het het grootste en meest bijgewoonde evenement in de geschiedenis van de crypto-industrie werd.</p>
<p>Terwijl mensen vrolijk Web3 promootten om zich te ontwikkelen in Singapore, lette bijna niemand op het grote evenement dat twee opeenvolgende jaren werd georganiseerd door Asia Crypto Week in Hong Kong.</p>
<p>Hong Kong had geen andere keuze dan toe te geven, en Singapore greep de kans om over te nemen. In de Web3-wereld is de ‘strijd tussen Hong Kong en Singapore’ in volle gang begonnen. <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> strijd.</p>
<p>Vanuit ontwikkelingsperspectief heeft Web3, dat zich in een woeste groeifase bevindt, een passende ruimte nodig voor fouttolerantie en innovatie, en voorspelbare regelgevingstrajecten en passende beheersregels zijn bijzonder belangrijk voor de ontwikkeling ervan. Vergeleken met Hongkong heeft Singapore een positieve houding ten opzichte van versleuteling en Web3, en stimuleert het krachtig de industriële ontwikkeling met een open beleid.</p>
<p>Wat betreft de regelgeving hanteert Singapore het principe dat risicogerichtheid, innovatie en inclusiviteit hand in hand gaan. Via de Payment Services Act, de Crypto Offering Guide en de Comprehensive Financial Industry Act heeft Singapore de basis gelegd voor cryptolicenties en duidelijke verantwoordelijkheden. Het biedt een verbeterde groenlichtregelgevingssandbox voor DeFi en andere gebieden. Zelfs zonder vergunning kan het legaal opereren in een vrijgestelde staat.</p>
<p>Vanuit het perspectief van de macro-omgeving is ook de concessie van Hong Kong al vooraf aangekondigd. Na het verbod van het vasteland is de cryptostatus van China geleidelijk afgenomen, de markt is verschoven en het Westen is sterker geworden. Gecombineerd met het Sino-Amerikaanse conflict en de twijfels van de buitenwereld over de neutraliteit van het beleid van Hong Kong, is het Aziatische Web3-centrum geleidelijk overgegaan van Hong Kong naar Singapore, en heeft het handels- en kapitaalcentrum vanuit Singapore naar het Westen gekeken.</p>
<p>Als we naar de algehele situatie kijken, is het Web3-ecosysteem van Singapore tijdelijk superieur aan dat van Hong Kong na enkele jaren van het vensterperiode. Vanuit het perspectief van cryptocurrency-beurzen zijn er ongeveer 47 cryptocurrency-beurzen in Singapore. In Hong Kong is FTX ver weg gegaan van de Bahama’s. BitMEX en CryptoCom, die ooit in Hong Kong waren gevestigd, kozen ook voor Singapore als hun uitvalsbasis. Er zijn slechts 30 lokale digitale activahandelinstellingen, die bekender zijn dan OSL en HashKey.</p>
<p>Dit jaar werd Asia Crypto Week gehouden in Singapore, wat opnieuw het gênante dilemma onthulde waarmee Hong Kong werd geconfronteerd.<br><img src="https://gimg2.gateimg.com/image/article/1676963589444.jpeg" alt=""></p>
<h2 id="h2-Conclusie353660"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Hong Kong is nog steeds het op twee na grootste financiële centrum ter wereld na New York en Londen, en de handelsvolumes van verschillende financiële activa zijn veel hoger dan die van Singapore. Azië, als een van de snelst groeiende regio’s ter wereld, heeft een enorme vraag naar digitale activa van institutionele beleggers en vermogende particuliere beleggers in de regio. Een groot aantal beleggers is van plan om deel te nemen aan de markt voor digitale activa via financiële instellingen in Hong Kong.</p>
<p>Hong Kong staat voor een unieke historische kans. Met de historische accumulatie van het internationale financiële centrum, moet Hong Kong de kans grijpen om Web2-technologietalenten van het vasteland aan te trekken om overzeese bedrijven te starten. Zolang Hong Kong de moed heeft om alle rivieren te omarmen en gedurfde doorbraken te maken in het regelgevingskader, is het waarschijnlijk dat het door de Web3-revolutie terugkeert naar de troon van het Aziatische financiële centrum!</p>
<p>We kijken weer uit naar de komst van de lente in Hong Kong op Gate.io.</p>
<div class="blog-details-info"><br><div>Auteur: Gate.io Observer: <strong>Byron B.</strong>Vertaler: <strong>Joy Z.</strong><br><div>Disclaimer:<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de waarnemers en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan het artikel te herposten op voorwaarde dat Gate.io wordt vermeld. In alle andere glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>