SlBNb3JnYW4gc2xhYXQgYWxhcm0gb3ZlciBkZSBuYWRlcmVuZGUgJDEwMCBtaWxqYXJkIGluIG9tbG9vcCB2YW4gVGV0aGVy

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""></p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De marktkapitalisatie van ‘s kan binnenkort $100 miljard overschrijden.</p>
<p>JPMorgan heeft bezorgdheid geuit over de toenemende marktdominantie van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> USDT.</p>
<p>De EU zou binnenkort MiCA kunnen aannemen, terwijl het Amerikaanse congres mogelijk de Clarity for Payment Stablecoins Act goedkeurt, die Stablecoins reguleert.</p>
<p>Trefwoorden: Stablecoin-markt, USDT en Tether, crypto-ecosysteem, houd crypto vast, crypto-houders, koop crypto. <a href="/how-to-buy/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">koop Tether</a>, koop USDT, USDT token</p>
<h2 id="h2-Introductie226731"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p><a href="https://www.gate.io/price/view/stablecoins" target="_blank">Stablecoins zijn een van de meest gezochte</a> na cryptocurrencies op de markt omdat ze waarde opslaan voor een lange periode. Tether USD (USDT) is de toonaangevende cryptocurrency met een marktkapitalisatie van bijna $100 miljard.</p>
<p>In deze analyse kijken we naar de mogelijke negatieve effecten van de toenemende groei van Tether USDT. We zullen ook de visie van JPMorgan op de uitbreiding van Tether beoordelen. <a href="https://www.gate.io/learn/course/stablecoin-fundamentals-video" target="_blank">en dominantie in de stablecoin</a> en DeFi-markten.</p>
<h2 id="h2-JPMorgan20benadrukt20risicos20bij20Tetherdominantie20en20regelgevingsuitdagingen216897"><a name="JPMorgan benadrukt risico’s bij Tether-dominantie en regelgevingsuitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JPMorgan benadrukt risico’s bij Tether-dominantie en regelgevingsuitdagingen</h2><p>Onlangs sloeg JPMorgan Chase &amp; Co alarm over de toenemende groei van Tether USDT, aangezien het streeft naar $100 miljard in omloop. Het is voor het eerst dat USDT, de nummer één Stablecoin, op het punt staat om de marktkapitalisatie van $100 miljard te overschrijden.</p>
<p>De Stablecoin heeft de afgelopen twee jaar een astronomische groei doorgemaakt als gevolg van de toenemende vraag naar Stablecoins. Zo heeft Tether bijvoorbeeld in de laatste twee weken van januari USDT-tokens ter waarde van $1 miljard aangemaakt. In totaal heeft het in de afgelopen vier maanden $13 miljard aan zijn marktkapitalisatie toegevoegd.</p>
<p><a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">Stablecoins zijn een integraal onderdeel van het cryptosysteem</a> omdat ze minder vluchtig zijn dan de andere crypto-activa zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH. Als zodanig geven de meeste cryptohouders die de waarde van digitale activa willen behouden, de voorkeur aan het bezitten van Stablecoins, waaronder de USDT-token.</p>
<p>Als de toonaangevende Stablecoin op de markt heeft USDT verschillende concurrentievoordelen. Mensen die crypto willen vasthouden, kunnen profiteren van de stabiliteit van deze munt. <a href="https://www.gate.io/how-to-buy/tether-usdt" target="_blank">kan USDT kopen op verschillende beurzen zoals Gate.io</a> en Binance. Nogmaals, aangezien USDT op verschillende netwerken bestaat, is het voor beleggers handig om Tether te kopen en te gebruiken.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/491/tether-losing-dominance-in-the-stablecoin-space" target="_blank">Tether verliest dominantie in de stablecoin-ruimte</a></p>
<p>Hoewel de groei van USDT en Tether een positieve ontwikkeling is in de DeFi-sfeer die ook bepaalde risico’s kan inhouden. In zijn <a href="https://www.bloomberg.com/news/articles/2024-02-01/stablecoin-tether-s-usdt-market-dominance-may-jeopardize-crypto-jpmorgan-says" rel="nofollow noopener noreferrer" target="_blank">publicatie</a>, Bloomberg benadrukt de zorgen van JPMorgan over de uitbreiding van USDT.</p>
<p>Het gebrek aan wettelijke naleving en transparantie van Tether brengt risico’s met zich mee voor de gebruikers van de USDT-token. Hierdoor <a href="https://www.theblock.co/post/275643/jpmorgan-tether-negative-crypto" rel="nofollow noopener noreferrer" target="_blank">JPMorgan-analisten, geleid door Nikolaos Panigirtzoglou, zeiden</a>“Tether loopt voornamelijk risico vanwege het gebrek aan regelgevende naleving en transparantie. We beschouwen de toenemende concentratie in Tether in het afgelopen jaar dan ook als negatief voor het Stablecoin-universum en het bredere cryptosysteem.”</p>
<p>De analisten zeiden ook dat er geen zekerheid is of Tether altijd voldoende reserves heeft om aan de vereisten voor inwisseling te voldoen. Op dit moment heeft Tether nog geen uitgebreide controle gepubliceerd van haar activa en passiva.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-are-algorithmic-stablecoins/182" target="_blank">Wat zijn algorithmische stablecoins?</a></p>
<p>In plaats daarvan stelt BDO Italia, een accountantskantoor, van tijd tot tijd zijn financiële verklaringen op. Op basis van de laatste verklaring, per 31 december 2023, heeft Tether activa ter waarde van $97 miljard en totale verplichtingen van $92 miljard.</p>
<p>Echter, Tether heeft onlangs gezegd dat haar USDT-token veel waarde creëert voor de gehele cryptomarkt. In dit verband citeert Coingape <a href="https://coingape.com/tether-paolo-ardoino-jpmorgan-usdt/" rel="nofollow noopener noreferrer" target="_blank">Paolo Ardoino, een Tether utive, zoals gezegd</a>, ‘Tether’s marktdominantie kan een ‘negatief’ zijn voor concurrenten, inclusief degenen in de banksector die streven naar vergelijkbaar succes, maar het is nooit negatief geweest voor de markten die ons het meest nodig hebben. We hebben altijd nauw samengewerkt met wereldwijde toezichthouders om hen te informeren over de technologie en begeleiding te bieden over hoe ze erover moeten denken.’</p>
<p>Het is de moeite waard om op te merken dat de recente uitbreiding van USDT en Tether te wijten is aan het voortdurende marktaandeelverlies van USDC als gevolg van verschillende redenen, waaronder de reguliere aanpak van cryptocurrencies in de Verenigde Staten. De volgende grafiek vergelijkt de USDT-markt met die van USDC.<br><img src="https://gimg2.gateimg.com/image/article/17083356221.png" alt=""><br>Tether marktdominantie - JPMorgan op CoinMarketCap</p>
<p>Zoals de afbeelding laat zien, is de marktdominantie van Tether toegenomen, terwijl die van USDC is afgenomen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2859/jpmorgans-jpm-coin-ushering-in-euro-denominated-payments" target="_blank">JPM Coin van JPMorgan: Inleiding van Euro-gedenomineerde betalingen</a></p>
<h2 id="h2-Tether20CEO20verdedigt20marktleiderschap20van20USDT504055"><a name="Tether CEO verdedigt marktleiderschap van USDT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether CEO verdedigt marktleiderschap van USDT</h2><p>Paolo Ardoino, CEO van Tether, is positief over de toekomst van USDT, ongeacht de veranderende regelgeving. Hij benadrukte dat de toenemende dominantie van USDT geen risico’s met zich meebrengt op de markt, maar essentieel is voor de gebruikers die erop vertrouwen.</p>
<p>Wat betreft dit, <a href="https://www.theblock.co/post/275388/tether-q4-attestation-report-excess-reserves?utm_source=rss&amp;utm_medium=rss" rel="nofollow noopener noreferrer" target="_blank">Ardoino vertelde The Block</a> Volgens hem hebben Tether en USDT de eigenschappen die nodig zijn om te overleven in het huidige crypto-ecosysteem. Hij zei specifiek: “Het succes van Tether USDT wordt gedreven door zijn financiële betrouwbaarheid, sterke reserves en zijn toewijding aan opkomende markten en ontwikkelingslanden, waar hele gemeenschappen USDT gebruiken als een levenslijn om hun families te beschermen tegen hoge inflatie en de duatie van hun nationale valuta.”</p>
<p>Hij voegde eraan toe: “Ik ben blij om te lezen dat JPMorgan het belang van Tether en de Stablecoin-technologie die door ons bedrijf is gecreëerd erkent. Maar het lijkt me een beetje hypocriet om te praten over concentratie die afkomstig is van JPMorgan, de grootste bank ter wereld.”</p>
<h2 id="h2-Aankomende20regelgeving20voor20crypto20in20de20VS20en20de20EU20duidt20op20belangrijke20veranderingen20in20het20landschap20van20stablecoins506160"><a name="Aankomende regelgeving voor crypto in de VS en de EU duidt op belangrijke veranderingen in het landschap van stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aankomende regelgeving voor crypto in de VS en de EU duidt op belangrijke veranderingen in het landschap van stablecoins</h2><p>De opkomende wereldwijde regelgevingsomgeving bedreigt Stablecoins en andere crypto-activa. Zo wacht de Clarity for Payment Stablecoins Act op goedkeuring van het Amerikaanse Congres. Als het wordt goedgekeurd, worden verschillende eisen gesteld aan Stablecoins zoals USDT.</p>
<p>Volgens de CRS <a href="https://crsreports.congress.gov/product/pdf/IN/IN12249#:~:text=The%20bill%20would%20establish%20rules,union%20supervisor%20could%20safeguard%20stablecoins" rel="nofollow noopener noreferrer" target="_blank">verslag</a> de Clarity for Payment Stablecoins Act vereist dat alle Stablecoin-uitgevers “één dollar aan toegestane reserves aanhouden per Stablecoin ter waarde van één dollar” en “verboden zijn om reserves te gebruiken, behalve voor het creëren van liquiditeit voor inwisselingen.”</p>
<p>Daarnaast zullen de regelgevers stabiele munten licentiëren die voldoen aan drie principes, zoals hieronder vermeld: “Het vermogen van de aanvrager om aan “basisvereisten” te voldoen; het “algemene karakter en de geschiktheid van het management van de aanvrager”; en bijbehorende consumentenrisico’s en -voordelen.</p>
<p>In Europa zal de Markets in Crypto Assets (MiCA) regelgeving, indien goedgekeurd, het licentiëren en exploiteren van Stablecoins in lidstaten reguleren. MiCA zal bijvoorbeeld algoritmische Stablecoins verbieden en fiat-gebackte Stablecoins vereisen om 1:1 reserves te hebben.</p>
<p>Daarnaast stelt deze crypto-regelgeving bepaalde procedures vast die de uitgevers moeten implementeren. Zo moeten bijvoorbeeld de uitgevers van Stablecoins hun reserves mogelijk rapporteren aan mensen die crypto willen kopen in de vorm van Stablecoins.</p>
<p>MiCA wordt naar verwachting op elk moment na juni van dit jaar van kracht. Daarom moeten Stablecoin-uitgevers zoals Tether zich voorbereiden op deze en andere crypto-wetten. Dit komt doordat ze bij het niet naleven van de nieuwe regelgeving mogelijk worden gesloten of zware boetes kunnen krijgen.</p>
<h2 id="h2-Conclusie58684"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In de afgelopen vier maanden heeft Tether de marktkapitalisatie van USDT met ongeveer $13 miljard verhoogd, wat heeft geleid tot een opmerkelijke stijging van zijn marktdominantie. Als gevolg hiervan hebben JPMorgan-analisten alarm geslagen over de marktdominantie van Tether in het licht van het veranderende regelgevingslandschap. Ondertussen kan het Amerikaanse Congres de Clarity for Payment Stablecoins Act goedkeuren, terwijl in de Europese Unie MiCA mogelijk vanaf medio 2024 van kracht wordt.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/uk/blog_detail/3537/jpmorgan-forecasts-2.7-b-outflows-from-gbtc-etf-conversion" target="_blank">JPMorgan voorspelt een uitstroom van $2,7 miljard uit de GBTC ETF-conversie</a> <a href="/how-to-buy/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">hoe Toncoin te kopen</a></p>
<h3 id="h3-Wat20zijn20stablecoins750221"><a name="Wat zijn stablecoins?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn stablecoins?</h3><p>Een <a href="https://www.gate.io/blog_detail/1066/what-is-a-stable-coin" target="_blank">stablecoin is een cryptocurrency</a> dat gekoppeld is aan de waarde van een activum of fiatvaluta. USDT, de nummer één Stablecoin, is gekoppeld aan de Amerikaanse dollar.</p>
<h3 id="h3-Wat20is20Tether741429"><a name="Wat is Tether?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Tether?</h3><p><a href="https://www.gate.io/learn/articles/what-is-tether-usdt/205" target="_blank">Tether is een op blockchain gebaseerd platform</a> die het gebruik van fiatgeld op digitale wijze vergemakkelijkt. Over het algemeen definiëren sommige mensen Tether echter als een Stablecoin die gekoppeld is aan de waarde van de Amerikaanse dollar.</p>
<h3 id="h3-Tether20vs20USDT2020wat20is20het20verschil270298"><a name="Tether vs. USDT - wat is het verschil?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether vs. USDT - wat is het verschil?</h3><p>Tether is een op blockchain gebaseerd platform dat het gebruik van fiatvaluta in digitale vorm vergemakkelijkt. Aan de andere kant is USDT een Stablecoin die gekoppeld is aan de Amerikaanse dollar.</p>
<h3 id="h3-Welke20zijn20de20meest20populaire20stablecoins796453"><a name="Welke zijn de meest populaire stablecoins?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke zijn de meest populaire stablecoins?</h3><p>USDT, DAI, <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>, USDC, <a href="https://www.gate.io/learn/articles/what-is-trueusd/429" target="_blank">TrueUSD</a> en <a href="https://www.gate.io/learn/articles/what-is-pax-dollar/469" target="_blank">Pax Dollar</a> zijn de meest populaire Stablecoins. Hoewel de meeste van deze Stablecoins gekoppeld zijn aan fiatvaluta, baseren sommige van hen hun waarden op activa zoals goud. Lees ook: <a href="https://www.gate.io/learn/articles/what-is-pegging-in-crypto/802" target="_blank">Wat is pegging in crypto</a></p>
<h3 id="h3-Wie20bezit20USDT755284"><a name="Wie bezit USDT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie bezit USDT?</h3><p>Tether Limited, opgericht door iFinex - een in Hong Kong geregistreerd bedrijf - bezit USDT, een door fiat gedekte Stablecoin. Verschillende ondernemers, waaronder Jean-Louis van Der Velde, Stuart Hoegner, Christopher Harborne, Chakrit Sakunkrit en Giancarlo Devasini, hebben Tether Limited opgericht en bezitten daarmee USDT.</p>
<h3 id="h3-Is20USDT20gedekt20door20echt20geld885406"><a name="Is USDT gedekt door echt geld?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is USDT gedekt door echt geld?</h3><p>USDT wordt ondersteund door de Amerikaanse dollar. Dit betekent dat Tether Limited een reserve van Amerikaanse dollars heeft die gelijk is aan het aantal USDT-tokens dat het op elk moment heeft.</p>
<h3 id="h3-Is20het20veilig20om20USDT20vast20te20houden852269"><a name="Is het veilig om USDT vast te houden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het veilig om USDT vast te houden?</h3><p>Het is erg veilig om USDT vast te houden, omdat het in de meeste glen de waarde van de Amerikaanse dollars behoudt. Het kan echter tijdelijk losgekoppeld worden als bepaalde externe factoren van invloed zijn. Het is ook vatbaar voor andere risico’s zoals hacking.</p>
<h3 id="h3-Is20de20USDThandelsplatform20veilig287483"><a name="Is de USDT-handelsplatform veilig?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is de USDT-handelsplatform veilig?</h3><p>USDT wordt verhandeld op veel crypto-uitwisselingen die verschillende beveiligingsnormen hebben. Sommige uitwisselingen zoals Gate.io, Coinbase en Binance staan bekend om hun hoge beveiligingsnormen.</p>
<h3 id="h3-Waar20is20de20veiligste20plek20om20USDT20te20bewaren751905"><a name="Waar is de veiligste plek om USDT te bewaren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar is de veiligste plek om USDT te bewaren?</h3><p>Mensen kunnen hun USDT-tokens veilig opslaan in cold wallets en veilige cryptocurrency-beurzen. Gate.io is een toonaangevende crypto-beurs die hoge veiligheidsnormen handhaaft.</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 standpunten 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 wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>