Rzcgc3RyZWVmdCBuYWFyIHZlcnN0ZXJraW5nIHZhbiBjcnlwdG9yZWd1bGVyaW5n

2023-05-06, 01:25

<p><img src="https://gimg2.gateimg.com/image/article/1682586049RDZZ.jpeg" alt=""><br>De G7-landen en de Europese Unie werken aan een wereldwijde samenwerkingsstrategie voor digitale activa die in mei 2023 zal worden onthuld.</p>
<p>Canada en Japan zijn voorbeelden van landen met crypto-vriendelijke regelgeving.</p>
<p>Het Verenigd Koninkrijk is van plan om een crypto-belastingcategorie in te voeren in zijn belastingaangifteformulieren voor 2024 tot 2025.</p>
<p>BIS, FSB en IMF zijn internationale organisaties die tot doel hebben standaarden in te voeren voor digitale activa.</p>
<p><strong>Trefwoorden</strong>: Crypto belastingen, crypto regulatie, crypto activa, digitale valuta, digitale activa, cryptocurrency wetgeving, IMF, FSB, BIS, MiCA</p>
<h2 id="h2-Introductie560334"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De implosies van verschillende cryptoprojecten zoals <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA en FTX hebben nationale regeringen gewaarschuwd voor de noodzaak om wetgeving te creëren en af te dwingen die hun burgers beschermt tegen soortgelijke toekomstige misstanden in de sector. Naast nationale regeringen zijn er internationale instanties zoals het Internationaal Monetair Fonds (IMF) die het voortouw nemen bij het creëren van standaard cryptowetgeving die hun lidstaten kunnen overnemen. Vandaag richten we ons op hoe de Groep van Zeven belangrijke geïndustrialiseerde landen (G7) de crypto-sector willen reguleren.</p>
<h2 id="h2-De20rol20van20G720bij20het20reguleren20van20cryptocurrencies846146"><a name="De rol van G7 bij het reguleren van cryptocurrencies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rol van G7 bij het reguleren van cryptocurrencies</h2><p>De groep van zeven geïndustrialiseerde landen, bestaande uit Groot-Brittannië, Duitsland, Italië, Japan, Canada, Frankrijk en de Verenigde Staten, werkt aan een raamwerk van crypto-regelgeving met als doel consumentenbescherming en transparantie te verbeteren.</p>
<p>Het belangrijkste doel is om de potentiële risico’s die cryptocurrencies hebben op het wereldwijde financiële systeem te verminderen of te voorkomen. Over het algemeen willen toezichthouders omgaan met slecht bestuur dat wijdverbreid is in de cryptosector. Deze landen geloven dat het instorten van crypto-reuzen FTX en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna was het resultaat van slecht bestuur.</p>
<p>Het initiatief van de G7 en de Europese Unie komt enkele maanden na het faillissement van de drie Amerikaanse banken, Signature Bank, Silvergate Bank en Silicon Valley Bank, die cryptodiensten aanboden aan instellingen en particulieren.</p>
<p>Opmerkelijk is dat sommige leden van de G7, zoals Canada, bestaande crypto-regelgeving hebben. Echter, de G7 en de Europese Unie werken aan een wereldwijde samenwerkingsstrategie voor digitale activa die in mei 2023 zal worden onthuld.<br><img src="https://gimg2.gateimg.com/image/article/16833362071.png" alt=""><br>De lidstaten van de Europese Unie - BBC</p>
<h2 id="h2-Crypto20regelgeving20in20Japan571944"><a name="Crypto regelgeving in Japan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto regelgeving in Japan</h2><p>Na de ineenstorting van Mt Gox, een Japanse crypto-uitwisseling, heeft Japan maatregelen genomen om consumenten te beschermen tegen cryptorisico’s. Een deel van de wetgeving in Japan stelt individuen en organisaties in staat verdachte cryptotransacties te melden.</p>
<p>Daarnaast moeten crypto-gebruikers voldoen aan de Foreign Exchange and Foreign Trade Act, die bepaalt dat elke persoon of organisatie die een cryptotransactie wil uitvoeren met een waarde van 30 miljoen JPY of meer, het Ministerie van Financiën moet informeren.</p>
<p>Interessant is dat regelgevers het mensen toestaan om cryptocurrencies te kopen en verkopen op cryptobeurzen. Japan heeft ook duidelijke regels voor Anti-Money Laundering (AML) procedures en een belastingbeleid dat van toepassing is op digitale activa zoals cryptocurrencies.</p>
<p>Over het algemeen werkt de Japanse Financial Services Agency (FSA) samen met de Japan Virtual Currency Exchange Association (JVCEA) en de Japan Security Token Offering Association (JSTOA) om cryptocurrencies te reguleren.</p>
<h2 id="h2-Cryptoregulering20in20Canada53923"><a name="Cryptoregulering in Canada" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptoregulering in Canada</h2><p>Canada is een ander land met functionele wetgeving die van toepassing is op de crypto sector. Het is zelfs een van de landen met goed gedefinieerde cryptoregels. Zo heeft het duidelijke openbaarmakingsregels voor alle bedrijven of projecten die met cryptocurrencies te maken hebben.</p>
<p>Ook vereist de Canadian Securities Administrators (CSA), een wettelijk orgaan, dat alle cryptobedrijven zich bij haar registreren. Het is belangrijk om te beseffen dat het land cryptocurrencies als effecten behandelt. Daarom zorgen provinciale en regionale autoriteiten ervoor dat entiteiten die digitale activa beheren, zich aan deze wetten houden.</p>
<p>Hoewel cryptobeurzen zijn toegestaan ​​om in het land te opereren, moeten ze zich registreren bij de relevante Canadese effectenregulator. Belangrijk is dat de Canadese belastingwetten cryptocurrencies behandelen als grondstoffen zoals goud en olie.</p>
<h2 id="h2-Cryptoregelgevingsontwikkelingen20in20het20Verenigd20Koninkrijk20en20de20Europese20Unie818839"><a name="Crypto-regelgevingsontwikkelingen in het Verenigd Koninkrijk en de Europese Unie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto-regelgevingsontwikkelingen in het Verenigd Koninkrijk en de Europese Unie</h2><p>Andere landen en regionale organisaties zoals de Europese Unie zijn ook bezig met het opstellen van hun crypto-regelgeving. Zo introduceert het Verenigd Koninkrijk bijvoorbeeld een aparte categorie van crypto-belastingen in de belastingaangifteformulieren voor de periode 2024 tot 2025. Dit toont aan dat het voorbereid is om cryptocurrencies op te nemen in zijn budgettaire vereisten.<br><img src="https://gimg2.gateimg.com/image/article/16833362352.png" alt=""><br>Crypto-regelgeving in het VK - Coingpedia</p>
<p>Bovendien werd er een rapport gepubliceerd door het Britse ministerie van Financiën <a href="https://www.gov.uk/government/publications/spring-budget-2023/spring-budget-2023-html#cost-of-living-and-public-services" rel="nofollow noopener noreferrer" target="_blank">aankondigt</a> een wijziging in de aangifteformulieren voor crypto-activa. Als zodanig zullen cryptocurrencies worden vermeld in de kosten- en opbrengstenrubriek van de nationale begroting voor de periode 2025 tot 2026.</p>
<p>Het Chartered Institute of Taxation (CIOT) heeft de veranderingen in het belastingstelsel en de nationale begroting gewaardeerd, waarbij rekening wordt gehouden met digitale activa zoals cryptocurrencies. <a href="https://www.tax.org.uk/crypto-assets-changes-to-tax-return-welcomed" rel="nofollow noopener noreferrer" target="_blank">Het zei</a>“Door de noodzaak te benadrukken om transacties met crypto-activa in de belastingaangifte te vermelden, zal het bewustzijn van de verplichtingen op dit gebied bij mensen worden vergroot.”</p>
<p>In een gerelateerde ontwikkeling heeft de Europese Unie’s <a href="https://www.gate.io/learn/articles/what-is-markets-in-crypto-assets/459 &quot;Markets in Crypto-Assets (MiCA" rel="nofollow noopener noreferrer" target="_blank">Markten in Crypto-Assets (MiCA)</a> De regelgeving zal in 2024 van kracht worden. In feite hebben wetgevers in de EU een reeks crypto-regelgeving genaamd de Markets in Crypto Act (MiCA) opgesteld en aangenomen, die tot doel heeft crypto risico’s te verminderen en te beperken die consumenten kunnen beïnvloeden, evenals het aansprakelijk stellen van de digitale dienstverleners voor het verliezen van de crypto-activa van investeerders.</p>
<p>De set regels zal <a href="https://www.europarl.europa.eu/news/en/press-room/20230414IPR80133/crypto-assets-green-light-to-new-rules-for-tracing-transfers-in-the-eu" rel="nofollow noopener noreferrer" target="_blank">eisen stellen aan verschillende entiteiten</a> zoals tokenuitgevers en cryptoplatforms. Ze benadrukken de noodzaak van ‘openbaarmaking, autorisatie en toezicht op transacties.’</p>
<p>Andere instanties die werken aan het standaardiseren van regels en voorschriften voor cryptovaluta zijn de Financial Stability Board (FSB), het Internationaal Monetair Fonds (IMF) en de Bank voor Internationale Betalingen (BIS). Deze instanties zullen regelgevende kaders presenteren aan de betreffende landen of regionale blokken.</p>
<p>De verwachte regelgevingskaders zullen betrekking hebben op activiteiten met crypto-activa, de markten en het toezicht op de verschillende entiteiten en handhaving van de wetten. Zo dringt het IMF er bij lidstaten op aan om het accepteren van cryptocurrencies als wettig betaalmiddel af te wijzen.</p>
<h2 id="h2-Voorspellingen20voor20cryptoregulering20voor2020232024326386"><a name="Voorspellingen voor cryptoregulering voor 2023-2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voorspellingen voor cryptoregulering voor 2023-2024</h2><p>We verwachten dat verschillende landen en internationale instanties in 2023 en 2024 cryptowetten zullen invoeren. Bijvoorbeeld, cryptowetten zullen strenger worden als gevolg van de impact van de ineenstorting van FTX.</p>
<p>Diverse internationale organisaties zoals het IMF en de International Organization of Securities Commissions (IOSCO) zullen waarschijnlijk hun regelgeving opstellen. Opnieuw zullen veel landen hun bestaande financiële wetten afstemmen of nieuwe juridische kaders creëren om de activiteiten van cryptobedrijven binnen hun rechtsgebied te reguleren.</p>
<h2 id="h2-Conclusie777432"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De G7 en de Europese Unie werken aan voorstellen voor regelgeving voor cryptovaluta die naar verwachting tussen 2023 en 2025 worden aangenomen. Verschillende landen, zoals Canada en Japan, hebben al duidelijke regels die de activiteiten van crypto-bedrijven controleren. FSB, IMF en BIS zijn andere internationale organisaties die streven naar het opzetten van standaard crypto-juridische kaders.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>