Q3J5cHRvIGluIFp1aWQtS29yZWE6IEdhbWluZyBoZWVyc3QgaW4gZGUgd2VyZWxkIHZhbiBXZWIzIHRlIG1pZGRlbiB2YW4gZGUgVGVycmEtY29udHJvdmVyc2U=

2023-09-27, 08:18

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR219964"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De <a href="/web3" target="_blank" class="blog_inner_link">web3</a> gamingsector in Zuid-Korea groeit de afgelopen maanden.</p>
<p>Verschillende crypto-beurzen in Zuid-Korea hebben partnerschappen gevormd met traditionele banken.</p>
<p>Zuid-Korea heeft een goed ontwikkeld crypto-regelgevingskader dat zowel investeerders als cryptocurrency-bedrijven beschermt.</p>
<h2 id="h2-Introductie573139"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Zuid-Korea, een land met een technisch onderlegde bevolking, proactieve crypto-regelgeving en een dynamische digitale industrie, groeit uit tot een belangrijke speler in de blockchainsector. Vandaag kijken we naar hoe het land zich klaarmaakt om een web3-hub te worden ondanks de uitdagingen van vorig jaar. <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> instorting die veel cryptoliefhebbers in het land heeft getroffen.</p>
<h2 id="h2-ZuidKorea20herstelt20zich20van20het20Terradebacle669295"><a name="Zuid-Korea herstelt zich van het Terra-debacle" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zuid-Korea herstelt zich van het Terra-debacle</h2><p>Binnen de afgelopen maanden heeft Zuid-Korea bewezen een hub van blockchain-activiteit te zijn, ondanks <a href="https://www.gate.io/explore/terra-luna" target="_blank">het ervaren van de ineenstorting van Terra</a>, een van de grootste crypto-projecten van die periode. Recentelijke activiteiten in het land hebben aangetoond dat Zuid-Koreanen veerkrachtig zijn en veel grote initiatieven nemen om de cryptosector in het land naar een hoger niveau te tillen.</p>
<p>De Korea Blockchain Week (KBW) 2023 heeft bewezen dat het land veel lopende en zich ontwikkelende web3-projecten heeft. Het toonde hoeveel lokale ontwikkelaars en andere spelers in de gamingsector actief zijn in de digitale sector.</p>
<p>Helaas heeft de ineenstorting van <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> nog steeds invloed op verschillende investeerders- en overheidsbeslissingen in het land. In feite blijven veel individuen en cryptoprojecten voorzichtig bij het doen van investeringen.</p>
<p>Hoon Kim, CTO bij blockchainproject <a href="/price/astar-astr" rel="nofollow noopener noreferrer" target="_blank">Astar</a>, zei onlangs dat de ineenstorting van Terra crypto-projecten en ontwikkelaars in staat heeft gesteld zich te richten op bedrijven met echte gebruiksglen. Ze ontwikkelen niet langer digitale projecten waarvan de prestaties alleen maar afhankelijk zijn van markthype.</p>
<p>Voornamelijk de ineenstorting van Terra, het blockchain-project <a href="https://www.gate.io/ja/blog_detail/2430/terra-luna-tokens-fall-steeply-on-do-kwon-s-arrest" target="_blank">opgericht door Do Kwon</a>, met een marktkapitalisatie van meer dan $40 miljard, heeft de nieuwe koers van crypto in Korea bepaald. Desondanks blijkt uit de huidige ontwikkelingen in de blockchainsector dat hoewel de meeste partijen veel hebben geleerd van de ondergang van Terra, zij deze mislukking achter zich hebben gelaten.<br>Lees ook: <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">Do Kwon bereikt 5-sterren gezocht niveau terwijl SEC meer fraude aanklachten brengt</a></p>
<h2 id="h2-Nieuwe20cryptotraject20van20ZuidKorea20na20ineenstorting20van20Terra974947"><a name="Nieuwe cryptotraject van Zuid-Korea na ineenstorting van Terra" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nieuwe cryptotraject van Zuid-Korea na ineenstorting van Terra</h2><p>Bijna een jaar na de ineenstorting van Terra is de digitale sector in Zuid-Korea levendiger dan ooit tevoren. Als voorbeeld ziet het land een nieuwe golf van crypto-handel, een grotere deelname van de traditionele financiële sector in DeFi en een toename van onderzoek en ontwikkeling op het gebied van blockchain. Laten we kort naar deze ontwikkelingen kijken.</p>
<h2 id="h2-Participatie20van20traditionele20banken20in20de20cryptosector438433"><a name="Participatie van traditionele banken in de crypto-sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Participatie van traditionele banken in de crypto-sector</h2><p>Verschillende Zuid-Koreaanse banken werken samen met verschillende web3-projecten zoals gamingplatforms. Zo heeft Hana Bank, een Zuid-Koreaanse commerciële bank, samengewerkt met BitGo, een in Californië gevestigd cryptoproject dat cryptocurrency bewaardiensten aanbiedt. De twee bedrijven zullen samenwerken bij de ontwikkeling van beveiligingsoplossingen en bewaar-diensten.</p>
<h2 id="h2-Toename20van20handelsactiviteit828594"><a name="Toename van handelsactiviteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toename van handelsactiviteit</h2><p>Ondanks de impact van de ineenstorting van de handelsactiviteit van Terra is de handel in Zuid-Korea de afgelopen maanden toegenomen. Als voorbeeld heeft Upbit, de grootste beurs van het land, tijdens 2023 hoge handelsvolumes geregistreerd.</p>
<h2 id="h2-Een20toename20in20gameactiviteit976845"><a name="Een toename in game-activiteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een toename in game-activiteit</h2><p>Presentaties tijdens de Korea Blockchain Week (KBW) in 2023 toonden een toename van gamingactiviteiten in Zuid-Korea. Als voorbeeld kondigde Neowiz, een lokale game-uitgever, aan dat het via zijn Web3-tak, IntellaX, enkele games zal ontwikkelen op de <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> blockchain. Een grote gepassioneerde gaming gemeenschap in het land heeft geleid tot een grotere interesse in het ontwikkelen van blockchain games.</p>
<h2 id="h2-Indrukwekkende20technologische20verbeteringen627971"><a name="Indrukwekkende technologische verbeteringen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indrukwekkende technologische verbeteringen</h2><p>De technologie die de ontwikkeling van web3 in Korea faciliteert, blijft verbeteren. Deze infrastructuur omvat snelle internetdiensten, IT-infrastructuur en onderzoeks- en ontwikkelingscentra.</p>
<p>Zowel particuliere als openbare instellingen in het land zoals universiteiten en hogescholen werken samen om mogelijke toepassingen van blockchaintechnologie te verkennen in verschillende sectoren zoals financiën, gezondheidszorg en supply chain.</p>
<h2 id="h2-Educatie20in20Crypto20en20Betrokkenheid20van20de20Gemeenschap470413"><a name="Educatie in Crypto en Betrokkenheid van de Gemeenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Educatie in Crypto en Betrokkenheid van de Gemeenschap</h2><p>Het land was ook getuige van een toename van onderwijs en belangenbehartiging op het gebied van cryptocurrency. Verschillende gemeenschappen, projecten en platforms hebben online seminars, cursussen en conferenties gehouden om individuen te leren over cryptocurrency en blockchain-technologie. Er zijn ook verschillende online communities voor blockchain-enthousiastelingen zoals ontwikkelaars, handelaren en investeerders in het algemeen.</p>
<h2 id="h2-Belangrijke20spelers20drijvende20ZuidKoreas20digitale20revolutie876352"><a name="Belangrijke spelers drijvende Zuid-Korea’s digitale revolutie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke spelers drijvende Zuid-Korea’s digitale revolutie</h2><p>Zoals gezegd zijn er verschillende spelers zoals investeerders, ontwikkelaars, cryptovaluta-uitwisselingen en banken actief in de digitale sector van het land. Er is geen twijfel dat cryptovaluta-uitwisselingen een belangrijke rol spelen in de ontwikkeling van de Koreaanse cryptovaluta.</p>
<p>Coinone, Upbit, Bithumb, Gopax en Korbit zijn de toonaangevende cryptocurrency-beurzen in Zuid-Korea die gediversifieerde crypto-portefeuilles aanbieden en de omvang van de Koreaanse crypto-markt hebben uitgebreid. Upbit heeft echter een monopoliepositie in het land omdat het ongeveer 75% van het totale handelsvolume in cryptocurrency afhandelt.</p>
<h2 id="h2-Traditionele20banken20vergroten20hun20deelname20in20de20cryptosector435878"><a name="Traditionele banken vergroten hun deelname in de cryptosector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Traditionele banken vergroten hun deelname in de cryptosector</h2><p>Veel banken nemen nu deel aan crypto-projecten via partnerschappen met crypto fintech- en gamingbedrijven. Het is echter belangrijk om op te merken dat internet-only banken in Korea, zoals K Bank, KakaoBank en Toss Bank, actief betrokken zijn bij blockchain-activiteiten via actieve partnerschappen.</p>
<p>Als voorbeeld heeft K Bank samengewerkt met Upbit en Mirae Asset Securities, terwijl KakaoBank onlangs een partnerschap heeft gevormd met Coinone. Met de huidige ontwikkelingen in de blockchainsector zullen naar verwachting meer banken deelnemen in de komende maanden of jaren.</p>
<h2 id="h2-Toename20in20Web320Gaming20Activiteit304889"><a name="Toename in Web3 Gaming Activiteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toename in Web3 Gaming Activiteit</h2><p>Waarschijnlijk heeft de op blockchain gebaseerde gamingsector een grotere groei laten zien dan de meeste digitale sectoren in het land. Tijdens de Korea Blockchain Week (KBW) conferentie in 2023 presenteerden thuisspelprojecten hun ontwikkelingen in de Metaverse en in de blockchain-gok- en gamingsectoren. De meeste van deze lokale crypto-bedrijven hebben hun protocollen ontwikkeld op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Cosmos en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchains. Lees ook over <a href="https://www.gate.io/blog_detail/531/nft-in-blockchain-in-korea" target="_blank">NFT in Blockchain in Korea</a></p>
<p>Bovendien hebben enkele grote game-ontwikkelings- en uitgeefbedrijven zoals Com2us, Neopin, Neowiz, NCSOFT, Kakao Games en Netmarble verschillende play-to-earn (P2E) spellen uitgebracht.</p>
<p>Bij het bekijken van de marktkapitalisatie van grote gamingplatforms zoals Com2uS (KRW 832,5 miljard), Kakao Games (KRW 3,69 biljoen), WEMADE (KRW 1,96 biljoen), Neowiz (KRW 816,3 miljard), Nexon (KRW 1,23 biljoen) en NCSOFT (KRW 10,14 biljoen) zien we een opkomende goed gefinancierde gamingsector in Zuid-Korea.</p>
<h2 id="h2-ZuidKorea20Cryptoregulering22394"><a name="Zuid-Korea Crypto-regulering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zuid-Korea Crypto-regulering</h2><p>Zuid-Korea is een land dat een goed ontwikkeld en proactief regelgevingskader voor cryptovaluta heeft. Het heeft een balans gevonden tussen consumentenbescherming en het bevorderen van innovatie in de blockchain sector.</p>
<p>Ten eerste heeft het uitgebreide maatregelen geïmplementeerd om witwassen van geld tegen te gaan, transparantie te bevorderen en de beveiliging van cryptocurrency-uitwisselingen te verbeteren.</p>
<p>Bijvoorbeeld moeten alle Virtual Asset Service Providers (VASP’s) die diensten aanbieden zoals crypto transfers, handel, bewaring en administratie, zich registreren bij de overheid. Als gevolg hiervan houdt de Financial Supervisory Service of South Korea (FSS) toezicht op hen.</p>
<p>Hoewel het land het eigendom, het bezit en de overdracht van digitale activa zoals cryptocurrencies goedkeurt, moeten individuen hun echte bankrekeningen gebruiken om ze te kopen. In dit g moeten zowel de handelaren als de banken dergelijke gegevens verifiëren. Bovendien moeten gebruikers hun echte namen gebruiken bij het aanmaken van hun accounts op crypto-uitwisselingen en andere DeFi-platforms.</p>
<p>Cryptocurrency exchanges en andere DeFi-platforms moeten zich houden aan de vereiste anti-witwas- / ken-uw-klant (AML / KYC) procedures. Op dezelfde manier moeten ze certificaten hebben van het Korea Internet &amp; Security Agency voor het Information Security Management  (KISA) die hun beveiligingsvoorbereiding certificeren.</p>
<p>Bovendien moeten banken met crypto-uitwisselingsrekeningen gedetailleerde tijdige rapporten verstrekken aan de Financial Services Commission (FSC). Met dit alles gezegd, is het duidelijk dat Zuid-Korea wettelijk eigendom, overdracht en handel in digitale activa zoals cryptocurrencies toestaat.</p>
<h2 id="h2-Conclusie560681"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De huidige ontwikkelingen in de blockchainsector in Zuid-Korea tonen aan dat individuen en instellingen nog steeds veel interesse hebben in cryptocurrencies, ondanks de controverse rond de ineenstorting van Terra in 2022. Er is een toename geweest van blockchain-gebaseerde game-ontwikkeling en gerelateerde activiteiten. Dit komt doordat de Zuid-Koreaanse regering eigendom en overdracht van digitale activa zoals cryptocurrencies toestaat.</p>
<h2 id="h2-Veelgestelde20vragen20over20crypto20in20ZuidKorea587529"><a name="Veelgestelde vragen over crypto in Zuid-Korea" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over crypto in Zuid-Korea</h2><h3 id="h3-Is20crypto20legaal20in20ZuidKorea277002"><a name="Is crypto legaal in Zuid-Korea?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is crypto legaal in Zuid-Korea?</h3><p>Cryptocurrency is legaal in Zuid-Korea, aangezien individuen ze kunnen kopen, vasthouden en overmaken. Om echter cryptocurrency te kopen en verhandelen in het land, moeten individuen hun bankrekeningen en echte namen gebruiken bij het registreren op cryptocurrency-beurzen.</p>
<h3 id="h3-Is20crypto20populair20in20ZuidKorea392124"><a name="Is crypto populair in Zuid-Korea?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is crypto populair in Zuid-Korea?</h3><p>Cryptocurrency is erg populair in Zuid-Korea omdat het grote cryptobeurzen heeft zoals Upbit, BitHumb, CoinOne, Korbit en Gopax. Het heeft ook <a href="https://www.gate.io/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">proactieve cryptoregulering</a> die zowel consumenten als cryptobedrijven beschermen. Verder is er veel educatie en belangenbehartiging over cryptocurrencies en andere digitale activa zoals niet-vervangbare tokens.</p>
<h3 id="h3-Wat20is20de20naam20van20de20Koreaanse20cryptocurrency901399"><a name="Wat is de naam van de Koreaanse cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de naam van de Koreaanse cryptocurrency?</h3><p>Bitcoin is de meest populaire cryptocurrency in Zuid-Korea, hoewel mensen andere tokens en munten kunnen verhandelen. Ondertussen is Zuid-Korea bezig met het ontwikkelen van zijn eigen digitale valuta van de centrale bank. <a href="https://www.gate.io/learn/articles/what-are-central-bank-digital-currencies/363" target="_blank">CBDC</a>).</p>
<h3 id="h3-Wat20is20de20meest20populaire20cryptocurrency20in20ZuidKorea863290"><a name="Wat is de meest populaire cryptocurrency in Zuid-Korea?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de meest populaire cryptocurrency in Zuid-Korea?</h3><p>De meeste mensen in Zuid-Korea kopen, houden vast en handelen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Zuid-Korea is het tweede land waar <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> in grote hoeveelheden wordt verhandeld. Het nummer één land waar bitcoin het meest wordt verhandeld, is de Verenigde Staten.</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 opvattingen 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 zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>