RGV1dHNjaGUgQmFuaydzIGFuYWx5c2UgdmVyb29yemFha3QgZGViYXQgb3ZlciBkZSBzdGFiaWxpdGVpdCBlbiB3ZXJraW5nIHZhbiBUZXRoZXI=

2024-05-22, 03:01

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR107432"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT moet zijn transparantie verbeteren om zijn levensvatbaarheid te vergroten.</p>
<p>Deutsche Bank en JPMorgan zijn het erover eens dat <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> USDT operationele risico’s loopt die de toekomstige levensvatbaarheid bedreigen.</p>
<p>De EU zal de MICA-regelgeving in het midden van het jaar implementeren, wat invloed zal hebben op stablecoins in de regio.</p>
<h2 id="h2-Introductie764204"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Deutsche Bank, uitgebracht op 7 mei, heeft veel discussie veroorzaakt in de cryptosector, omdat het voorspelt dat verschillende toonaangevende stablecoins, waaronder Tether USDT, zullen falen. Belangrijk is dat het rapport de prestaties van de <a href="https://www.gate.io/learn/articles/what-is-pegging-in-crypto/802" target="_blank">verschillende valutakoppelingen sinds 1800</a> Ondanks dergelijke speculaties beweren sommige analisten dat als nationale overheden passende regelgeving invoeren, de meeste stablecoins in staat zullen zijn om hun koppelingen te behouden.</p>
<p>De grootste risico’s waarmee stablecoins te maken hebben, zijn gerelateerd aan crypto-wetgeving en reserve-naleving. Dit artikel behandelt de analyse van Deutsche Bank van Tether USDT en de toekomst van stablecoins.</p>
<h2 id="h2-De20analyse20van20Deutsche20Bank20Research20over20Tethers20USDT459516"><a name="De analyse van Deutsche Bank Research over Tether’s USDT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De analyse van Deutsche Bank Research over Tether’s USDT</h2><p>Het Deutsche Bank-onderzoeksrapport dat 334 valutakoppelingen sinds 1800 onderzoekt, heeft de risico’s belicht waarmee stablecoins te maken hebben. Het ging echter veel dieper in op operationele risico’s die Tether kan tegenkomen.</p>
<p>Het onderzoek concludeerde dat van de 334 valutakoppelingen die Deutsche onderzocht, slechts 14% ervan nog op de markt zijn, wat de kwetsbaarheid van stablecoins aantoont. De prominente bedreigingen voor de bestaande stablecoins <a href="https://www.gate.io/blog_detail/2432/depegging-bank-runs-and-unstablecoins" target="_blank">inclusief dekoppeling</a> Als gevolg van speculatieve neigingen. Gebrek aan operationele transparantie van de stablecoin-uitgevers verergert hun risico’s.</p>
<p>Ten eerste heeft Deutsche Bank in zijn rapport de stabiliteit van Tether USDT in twijfel getrokken en de transparantie van Tether-praktijken met betrekking tot zijn in USD genoteerde reserves. Volgens een recente <a href="https://cointelegraph.com/news/tether-slams-deutsche-bank-over-suggestion-stablecoin-could-fail" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph-publicatie</a>, de analisten van de bank stellen ook vragen over de solvabiliteit van Tether USDT.</p>
<p>Desalniettemin is het vanwege de dominante positie van de Tether-markt mogelijk niet mogelijk om de bedreigingen die het ondervindt op te merken tot een ‘peso-moment’ dat waarschijnlijk de volatiliteit van de cryptomarkt zal beïnvloeden. Volgens het Deutsche Bank-rapport kan het peso-moment invloed hebben op de hele cryptomarkt.</p>
<p>Ter illustratie van zijn punt haalde het rapport het voorbeeld aan van de <a href="https://www.gate.io/blog_detail/2430/terra-luna-tokens-fall-steeply-on-do-kwons-arrest" target="_blank">instorting van TerraUSD (TUSD) die meer dan $40 miljard heeft weggevaagd</a>: ‘Hoewel sommigen het misschien overleven, zullen de meesten waarschijnlijk mislukken, vooral door het gebrek aan transparantie in stablecoin-operaties en de kwetsbaarheid voor speculatieve sentimenten.’</p>
<p>Lees ook: <a href="https://www.gate.io/explore/terra-luna" target="_blank">Zal het Terra Luna-project ooit herstellen?</a></p>
<p>Een punt dat Deutsche Bank aan de hele cryptomarkt heeft overgebracht, is dat er behoefte is aan transparantie van stablecoins. Bijvoorbeeld, alle cryptocurrency-gekoppelde valuta’s moeten voldoende reserves aanhouden die worden gecontroleerd en openbaar worden gemaakt om paniek onder gebruikers te voorkomen als er tekenen zijn van ontkoppeling.</p>
<p>Als onderdeel van haar onderzoek heeft Deutsche Bank een consumentenonderzoek uitgevoerd in verschillende landen, waaronder Spanje, Italië, Frankrijk, Duitsland, het Verenigd Koninkrijk en de Verenigde Staten. Van de 3.350 deelnemers had slechts 18% vertrouwen in de levensvatbaarheid en <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">duurzaamheid van stablecoins</a>. Integendeel, 42% geloofde dat stablecoins kunnen dalen als gevolg van verschillende risico’s in het crypto-ecosysteem.</p>
<h2 id="h2-Tether20USDTanalyse20zorgen20van20JPMorgan922392"><a name="Tether USDT-analyse: zorgen van JPMorgan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether USDT-analyse: zorgen van JPMorgan</h2><p>De marktanalyse van de Deutsche Bank Tether stablecoin lijkt overeen te komen met de scepsis van JPMorgan over de levensvatbaarheid van USDT op lange termijn. In februari produceerde JPMorgan een ander rapport waarin de marktdominantie van Tether wordt gepositioneerd als een bedreiging voor de cryptomarkt, omdat het de concurrentie en innovatie beperkt. Als gevolg van zijn dominantie kan het sterke operationele problemen ondervinden die een domino-effect kunnen hebben op de hele cryptomarkt.</p>
<p>Brad Garlinghouse, CEO van Ripple, uitte ook bezorgdheid over de levensvatbaarheid van Tether USDT. Zijn zorg is echter anders dan die van JPMorgan en Deutsche Bank. Garlinghouse vreest dat regelgeving voor stablecoins in de Verenigde Staten en de EU de prestaties van Tether USDT nadelig kan beïnvloeden. Sterker nog, de Ripple CEO is er sterk van overtuigd dat de Amerikaanse overheid Tether USDT op een manier aanpakt die de soepele werking ervan zou kunnen destabiliseren.</p>
<h2 id="h2-Vorige20Tetherregelgevingskwesties20en20boetes285048"><a name="Vorige Tether-regelgevingskwesties en boetes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vorige Tether-regelgevingskwesties en boetes</h2><p>Garlinghouse’s angsten kunnen realistisch klinken als we eerdere regelgevingskwesties van Tether overwegen. In feite legde de Amerikaanse Commodity Futures Trading Commission in 2021 een boete van $41 miljoen op aan Tether. In datzelfde jaar heeft Tether een schikking van $18,5 miljoen getroffen met de procureur-generaal van New York. Beide straffen kwamen voort uit de beschuldigingen dat Tether misleidende claims had gemaakt over zijn reserves. Kortom, de Amerikaanse autoriteiten hadden sterke twijfels over de naleving van Tether’s stablecoin wat betreft reserves. Het lijkt duidelijk dat Tether destijds niet slaagde voor de bewijslasttest.</p>
<p>Belangrijk is dat Tether in de toekomst voldoende reserves behoudt voor zijn USDT stablecoin. Het is nog belangrijker dat het hierin transparant is en te allen tijde aan de autoriteiten kan aantonen dat de reserves voldoende zijn. Het kan ook essentieel zijn voor Tether om externe accountants uit te nodigen. Op dit moment lijkt Tether te vertrouwen op zijn verklaring. Bijvoorbeeld, <a href="https://tether.io/news/tethers-2023-q4-attestation/" rel="nofollow noopener noreferrer" target="_blank">het is Q4, 2023 attestatie</a> geeft aan dat het $2,85 miljard winst heeft gegenereerd. Het heeft het volgende geproduceerd als onderdeel van de bevestiging.<br><img src="https://gimg2.gateimg.com/image/article/1716346764image.jpg" alt=""><br>2023 Tether Reserves – Tether</p>
<p>Hoewel dit indrukwekkend lijkt, kan een externe auditrapport veel goeds doen en het imago van het bedrijf verbeteren, omdat het de transparantie en verantwoording vergroot. Een volledige audit is begrijpelijker omdat het de risico’s, naleving en de momenteel onbekende gegevens van het bedrijf aangeeft.</p>
<p>Belangrijk om te weten: <a href="https://www.gate.io/learn/articles/commodities-vs-securities-key-differences/2478" target="_blank">Grondstoffen versus effecten: Belangrijkste verschillen</a></p>
<h2 id="h2-Reactie20van20Tether609604"><a name="Reactie van Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reactie van Tether</h2><p>Naar aanleiding van bovenstaande beschuldigingen en zorgen in de industrie heeft Tether de angst die de genoemde partijen hebben geuit, afgezwakt. Het verwierp het Deutsche Bank-rapport wegens gebrek aan geldigheid, aangezien het geen bewijs of duidelijkheid bevat. Aan de andere kant zei de stablecoin-gigant dat het mechanismen heeft om de stabiliteit van de stablecoin te handhaven.</p>
<p>Het verklaarde ook dat het irrelevant is voor Deutsche Bank om USDT, een door fiat gedekte stablecoin, te vergelijken met TerraUSD, een algoritmische stablecoin. In opmerkingen gedeeld met Cointelegraph, een <a href="https://cointelegraph.com/news/tether-slams-deutsche-bank-over-suggestion-stablecoin-could-fail" rel="nofollow noopener noreferrer" target="_blank">Een vertegenwoordiger van Tether zei</a> Bovendien is de vergelijking met Terra, een algoritmische stablecoin, misleidend en irrelevant voor de discussie over reserve-gesteunde munten. De reden hiervoor is dat de ineenstorting van <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USD niet direct verband hield met het ontbreken van reserves.</p>
<p>Het vervolgde: “Het in twijfel trekken van de geloofwaardigheid van een financiële instelling, vooral een met het trackrecord van Deutsche Bank, lijkt ironisch. De geschiedenis van boetes en straffen van Deutsche Bank roept twijfels op over haar eigen positie om anderen in de branche te bekritiseren.”</p>
<h2 id="h2-De20rol20en20marktkapitalisatiegroei20van20USDT20op20de20cryptomarkt439308"><a name="De rol en marktkapitalisatiegroei van USDT op de cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rol en marktkapitalisatiegroei van USDT op de cryptomarkt</h2><p>Gebaseerd op de huidige analyse van de stabielecoinmarkt <a href="https://www.gate.io/learn/articles/what-is-tether-usdt/205" target="_blank">Tether USDT speelt een cruciale rol in de hele cryptomarkt</a>. In feite stelt USDT handelaren in staat om de waarde van hun crypto-bezittingen te behouden. Tijdens een periode van marktvolatiliteit geven veel beleggers er bijvoorbeeld de voorkeur aan om hun crypto-assets om te zetten in Tether USDT. Het is ook belangrijk op te merken dat de stabiliteit van USDT duidelijk is, aangezien het nooit glen heeft gekend van scherpe ontkoppeling.</p>
<p>Tether, met een marktkapitalisatie van meer dan $100 miljard, heeft een stablecoin marktaandeel van meer dan 69%. In de meeste glen zijn de handelsvolumes van USDT groter dan die van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, de nummer één cryptocurrency. De belangrijkste reden hiervoor is dat USDT gekoppeld is aan veel crypto-activa. Op dezelfde manier gebruiken veel mensen en instellingen ook Tether USDT als ruilmiddel en voor internationale overboekingen. Bovendien biedt de stablecoin de broodnodige liquiditeit aan de cryptocurrency-markt en verhoogt het de populariteit van digitale activa.</p>
<h2 id="h2-Aankomende20reguleringen20van20stablecoins20in20de20VS20en20de20MiCA20van20de20EU821627"><a name="Aankomende reguleringen van stablecoins in de VS en de MiCA van de EU" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aankomende reguleringen van stablecoins in de VS en de MiCA van de EU</h2><p>Verschillende landen zijn van plan om cryptowetten in te voeren die verschillende klassen van cryptocurrencies, waaronder stablecoins, zullen reguleren. Zo zal de EU binnenkort de Verordening markten in crypto-activa (MiCA) tegen medio jaar implementeren. Aan de andere kant is de Verenigde Staten <a href="https://www.gate.io/blog_detail/469/stablecoin-regulation-is-coming-part-responses-and-opportunities" target="_blank">werkt aan de regulering van zijn stablecoin</a>, de Clarity for Payment stablecoins Act. Deze crypto-wetgevingen hebben verschillende overeenkomsten. Zo vereisen beide dat de uitgevers licenties krijgen voordat ze stablecoins uitgeven. De stablecoin-aanbieders moeten ook klantengelden scheiden en voldoende reserves aanhouden.</p>
<h2 id="h2-Conclusie418436"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Recent onderzoek van Deutsche Bank Research heeft aangetoond dat stablecoins te maken hebben met levensvatbaarheidsuitdagingen, vooral als ze gebrek aan transparantie hebben. Het wees er ook op dat stablecoins zoals USDT te maken kunnen krijgen met operationeel risico als gevolg van speculatieve neigingen van cryptocurrencies. In de afgelopen maanden heeft JPMorgan de dominantie van USDT als een bedreiging voor het banksysteem geïdentificeerd. De crypto-wetgeving die de Verenigde Staten en de EU binnenkort kunnen implementeren, zal waarschijnlijk extra risico’s creëren voor stablecoins.</p>
<div class="blog-details-info"><br><div>Auteur:<em> Mashell C.</em>, 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>