VGV0aGVyIGJyZWlkdCB6aWpuIGJlcmVpayB1aXQ6IFVTRFQgZW4gWEFVVCBTdGFibGVjb2lucyB3b3JkZW4gZ2VsYW5jZWVyZCBvcCBUZWxlZ3JhbSdzIFRPTiBCbG9ja2NoYWlu

2024-05-08, 10:09

<p><img src="https://gimg2.gateimg.com/image/article/1715162527sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR507029"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De integratie van USDT en XAUT met Ton Telegram zal waarschijnlijk leiden tot een grotere adoptie van digitale valuta dan voorheen.</p>
<p>De lage transactiekosten van het Ton-netwerk zullen waarschijnlijk het gebruik van USDT en XAUT bevorderen.</p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft nieuwe bedrijfsafdelingen geïntroduceerd, waaronder <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> Data, Tether Finance, Tether Power en Tether Edu.</p>
<h2 id="h2-Introductie258725"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Tether is een van de toonaangevende blockchains die cryptotechnologie bevordert doordat het internationale overschrijvingen vergemakkelijkt met behulp van digitale valuta. Er is geen twijfel dat Tether USDT, gerangschikt op nummer 3, een van de beste crypto-activa is vanwege zijn stabiliteit. Tether’s andere stablecoin, <a href="https://www.gate.io/learn/articles/what-is-tether-gold/1180" target="_blank">XAUT gesteund door goud</a>, zal waarschijnlijk ook een grote impact hebben op de digitale economie.</p>
<p>Deze analyse bekijkt de samenwerking tussen Tether en Telegram gericht op het bevorderen van het gebruik van cryptocurrencies zoals TON, XAUT en USDT. We zullen ook focussen op het voordeel dat voortvloeit uit de lancering van USDT en XAUT op de Ton Blockchain. Tot slot zullen we de nieuwe bedrijfslijnen van Tether verkennen, waaronder Tether Data, Tether Finance, Tether Power en Tether Edu.</p>
<h2 id="h2-USDT20en20XAUT20worden20gelanceerd20op20de20TON20blockchain67743"><a name="USDT en XAUT worden gelanceerd op de TON blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDT en XAUT worden gelanceerd op de TON blockchain</h2><p>Toonaangevende blockchain-projecten maken nu gebruik van partnerschappen om kwalitatief hoogwaardige diensten aan hun gebruikers te bieden. Met dit in gedachten heeft Tether, een van de toonaangevende blockchain-serviceproviders, aangekondigd dat het van plan is zijn twee stablecoins USDT en XAUT te integreren met de Telegram Open Network (TON) blockchain. Paolo Ardoino, CEO van Tether, bracht het goede nieuws tijdens het Token2049-evenement in Dubai.</p>
<p>De lancering van USDT, een op de Amerikaanse dollar gesteunde stablecoin, en XAUT, een op goud gesteunde stablecoin, op de TON blockchain zal waarschijnlijk veel voordelen opleveren voor Telegram-gebruikers, omdat ze de liquiditeit vergroten en een naadloze uitwisseling van waarde in het ecosysteem mogelijk maken. <a href="https://www.theblock.co/post/289798/tether-ton-blockchain-usdt-and-gold-xaut" rel="nofollow noopener noreferrer" target="_blank">In een verklaring, geciteerd door TheBlock, zei Ardoino</a>, “De lancering van USDT en XAUT op TON zal naadloze waardeoverdracht mogelijk maken, de activiteit en liquiditeit vergroten en gebruikers een financiële ervaring bieden die kan wedijveren met die van het traditionele financiële systeem.”</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/tether-gold-xaut" target="_blank">Tether Gold Prijsvoorspelling &amp; Voorspelling voor 2024, 2025, 2030</a></p>
<p>Hij voegde eraan toe: “Telegram heeft een indrukwekkend ecosysteem met 900 miljoen maandelijkse actieve gebruikers. Tether heeft wereldwijd meer dan 300 miljoen gebruikers. Tether en Telegram kunnen elkaars ecoen versterken.”</p>
<p>De integratie van TON met USDT en XAUT komt op een moment dat de USDT marktkapitalisatie is gestegen tot meer dan $109 miljard, terwijl die van XAUT meer dan $114 miljard bedraagt. Zoals je opmerkt, is XAUT de kleinere van de twee Tether stablecoins. Aan de andere kant, Ton Coin, <a href="https://www.theblock.co/price/248363/toncoin-ton-usd" rel="nofollow noopener noreferrer" target="_blank">de inheemse blockchain van Ton Telegram</a> De marktkapitalisatie van de cryptocurrency, is gestegen tot meer dan $24 miljard. De volgende grafiek toont de huidige marktkapitalisaties van cryptocurrencies.<br><img src="https://gimg2.gateimg.com/image/article/17151626621.jpeg" alt=""><br>Stablecoin Marktkapitalisatie - <a href="https://www.theblock.co/data/stablecoins/usd-pegged/total-stablecoin-supply" rel="nofollow noopener noreferrer" target="_blank">TheBlock</a></p>
<p>Zoals waargenomen, domineert Tether USDT de stablecoin markt, gevolgd door USDC. Het is strategisch van Tether om USDT en XAUT naar Telegram <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> te brengen, aangezien de stablecoin zal profiteren van de meer dan 900 miljoen gebruikers wereldwijd op dit socialemediaplatform. Door de fiat-naar-crypto overdrachtsfunctie op Ton Telegram zal de lancering van Tether’s stablecoin een financiële ervaring creëren die alleen vergelijkbaar is met die van het traditionele financiële systeem.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/tether-gold-xaut &quot;How to Buy Tether Gold (XAUT" rel="nofollow noopener noreferrer" target="_blank">Hoe Tether Gold (XAUT) te kopen</a>”)</p>
<p>Ondertussen is de waarde van de Ton coin aanzienlijk gestegen toen Telegram aankondigde dat het van plan was om Ton coin te gebruiken om kanaaleigenaars te belonen en de opbrengsten van advertenties op het platform te delen. Op dit moment, <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> gerangschikt op nummer 9 op basis van marktkapitalisatie, handelt tegen $5.25 na een stijging van 5.7% in de laatste 30 dagen. De volgende grafiek toont de huidige prijsprestaties van TON.<br><img src="https://gimg2.gateimg.com/image/article/17151627092.jpeg" alt=""><br>Toncoin Prijsgrafiek - <a href="https://www.coingecko.com/en/coins/toncoin" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Zoals u kunt zien in het diagram, is <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> sinds 11 april aan het kelderen sinds het zijn hoogste punt ooit van $7,63 bereikte. De prijs ligt momenteel 31,2% lager dan zijn ATH, maar 910% hoger dan zijn laagste punt ooit bereikt op 21 september 2021.</p>
<h2 id="h2-Keynote20Speeches20van20Paolo20Ardoino20en20Pavel20Durov575591"><a name="Keynote Speeches van Paolo Ardoino en Pavel Durov" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Keynote Speeches van Paolo Ardoino en Pavel Durov</h2><p>Zoals we hebben opgemerkt, heeft Tether op 19 april aangekondigd dat het van plan is om Tether USDT en XAUT op het Ton Network te lanceren om te profiteren van de cryptoinfrastructuur en blockchain-uitbreiding. Ardoino, CEO van Tether, en Pavel Durov, oprichter van Telegram, kondigden de integratie aan op Token2049, een crypto-evenement dat in Dubai werd gehouden. Tijdens het evenement noemden de twee leiders de voordelen van de samenwerking tussen Telegram en Tether.</p>
<p>Bijvoorbeeld, ze spraken over de invoegstrook- en uitvoegstrookfuncties die de Ton blockchain zal hebben. Dit betekent dat het voor Telegram en Ton blockchain gebruikers gemakkelijk zal worden om hun cryptocurrencies om te zetten naar fiatgeld en vice versa. Specifiek vertelde Jack Booth, hoofd marketing van de TON Foundation, dat <a href="https://cointelegraph.com/news/tether-usdt-stablecoin-ton-blockchain" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph over een dergelijke ontwikkeling</a>.</p>
<p><a href="https://cointelegraph.com/news/tether-usdt-stablecoin-ton-blockchain" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, ‘[Er zijn] ingebouwde toegangsroutes voor fiat bij de lancering en wereldwijde uitgangsroutes naar bankkaarten en rekeningen die binnenkort beschikbaar zullen zijn. Dit zal de eerste keer zijn dat een groot publiek crypto-infrastructuur kan gebruiken voor wereldwijde betalingen.’</p>
<p>Tether heeft ook de introductie van andere bedrijfsonderdelen aangekondigd, namelijk Tether Data, Tether Finance, Tether Power en Tether Edu. Elk van deze divisies zal zich specialiseren in een specifiek gebied met betrekking tot blockchaintechnologie. Zo zal Tether Data zich richten op de ontwikkeling van opkomende technologieën zoals kunstmatige intelligentie en peer-to-peer betalingsen die haar positie binnen de gedecentraliseerde financiële sector verder zullen versterken.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/4009/surpassing-tether-as-the-largest-stablecoin-everything-you-need-to-know-about-what-ethena-ena-is" target="_blank">Overtreft Tether als de grootste stablecoin?</a></p>
<p>Tether heeft zijn blog gebruikt om uit te leggen wat elke nieuwe zakelijke lijn zal bereiken. Wat betreft Tether Finance, bijvoorbeeld, staat dat het de “blockchaintechnologie zal benutten om een onstuitbare financiële infrastructuur te bouwen, inclusief het aankomende platform voor digital asset-tokenisatie, waardoor de mainstream adoptie van digitale activa wordt gekatalyseerd.”</p>
<p>Aan de andere kant zal Tether power de ontwikkeling en het gebruik van duurzame energiebronnen vergemakkelijken. Het <a href="https://tether.io/news/tether-advances-beyond-stablecoins-introduces-new-framework-embracing-core-divisions-to-foster-resilient-future-ready-financial-s/" rel="nofollow noopener noreferrer" target="_blank">opgehelderd</a>“Tether’s mining and energy division is zich aan het wagen aan duurzame <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> mijnbouwactiviteiten, in lijn met verantwoorde praktijken om de integriteit van het meest robuuste monetaire netwerk ter wereld te waarborgen.</p>
<p>Vervolgens zal Tether Edu zich richten op het bevorderen van adoptie van de blockchain en het bevorderen van digitale geletterdheid op wereldwijde schaal. De <a href="https://tether.io/news/tether-advances-beyond-stablecoins-introduces-new-framework-embracing-core-divisions-to-foster-resilient-future-ready-financial-s/" rel="nofollow noopener noreferrer" target="_blank">blockchainbedrijf uitgelegd</a>“Tether Edu is toegewijd aan het uitbreiden van wereldwijde toegang tot digitaal vaardigheidsonderwijs. Met een veelzijdige strategie cultiveert de divisie kennis, bewustzijn en vaardigheid in digitale en andere toonaangevende technologieën.”</p>
<p>Tot slot, met betrekking tot <a href="https://tether.io/news/tether-advances-beyond-stablecoins-introduces-new-framework-embracing-core-divisions-to-foster-resilient-future-ready-financial-s/" rel="nofollow noopener noreferrer" target="_blank">Tether Finance, zo staat in de blog vermeld</a>“Tether Finance staat op het punt om blockchain-technologie te benutten om onstuitbare financiële infrastructuur op te bouwen, waaronder het aanstaande platform voor tokenisatie van digitale activa, waardoor de mainstream-acceptatie van digitale activa wordt gestimuleerd.”</p>
<p>Met betrekking tot deze divisies, <a href="https://www.bitdegree.org/crypto/news/tether-expands-beyond-stablecoins-with-launch-of-new-business-divisions" rel="nofollow noopener noreferrer" target="_blank">Ardoino zei</a> Samen floreren zit in ons DNA. We hebben de traditionele financiële wereld verstoord met ‘s werelds eerste <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">en meest vertrouwde stablecoin</a>. Nu durven we inclusieve infrastructuuroplossingen op gang te brengen, waarbij traditionele en worden ontmanteld voor rechtvaardigheid.”</p>
<h2 id="h2-Impact20van20USDT20en20XAUT20op20TON20voor20gebruikers20en20het20financile20ecosysteem102949"><a name="Impact van USDT en XAUT op TON voor gebruikers en het financiële ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impact van USDT en XAUT op TON voor gebruikers en het financiële ecosysteem</h2><p>De integratie van USDT en XAUT zal veel voordelen bieden voor Telegram-gebruikers, omdat het soepele cryptobetalingen zal vergemakkelijken. Over het algemeen kunnen gebruikers goedkope en directe grensoverschrijdende betalingen doen. Belangrijker nog, er is geen behoefte aan digitale portefeuilleadressen of aparte apps om de digitale valuta’s te verzenden. Als gevolg hiervan zal het overdragen van digitale activa net zo eenvoudig zijn als het verzenden van Telegram-berichten.</p>
<p>Plaatsen op X, <a href="https://twitter.com/ton_blockchain/status/1781294475219812665" rel="nofollow noopener noreferrer" target="_blank">Ton zei</a>“Dit initiatief is bedoeld om wereldwijde peer-to-peer betalingen te transformeren, waardoor Telegram-gebruikers vrij en direct transfers kunnen sturen tussen alle Telegram-gebruikers; het enige wat je hoeft te doen is een DM sturen, geen behoefte aan een blockchain-adres, en geen noodzaak om een nieuwe app te downloaden.”<br><img src="https://gimg2.gateimg.com/image/article/17151628663.jpeg" alt=""><br>Bron: <a href="https://twitter.com/ton_blockchain/status/1781294479669944677" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>De <a href="https://twitter.com/ton_blockchain/status/1781294479669944677" rel="nofollow noopener noreferrer" target="_blank">dezelfde bron toegevoegd</a>, “USDT op TON zal bij de lancering vergezeld gaan van volledig geïntegreerde on-ramps van de meeste fiat-valuta’s wereldwijd. Binnenkort zullen geïntegreerde wereldwijde afritten gebruikers in staat stellen om ondersteunde fiat-valuta’s rechtstreeks op bankrekeningen of kaarten op te nemen. Het doel is dat USDT on TON een sneller, gemakkelijker en goedkoper grensoverschrijdend betalingssysteem wordt dan traditionele financiële diensten.”</p>
<p>De integratie van USDT zal leiden tot financiële inclusie, omdat het gemakkelijk en kosteneffectief zal zijn voor mensen om digitale valuta te verzenden en ontvangen. Bovendien zullen veel mensen cryptocurrencies adopteren voor wereldwijde betalingen, omdat het eenvoudig zal zijn om cryptocurrency om te zetten in fiatgeld, wat het hele gedecentraliseerde financiële systeem zal verrijken.</p>
<p>Bovendien zal de integratie de uitbreiding van de TON blockchain ondersteunen, omdat gebruikers stablecoins kunnen gebruiken in verschillende gedecentraliseerde applicaties. In een interview met CoinDesk legde Halil Mirakhmed, de chief operating officer van Wallet in Telegram, uit hoe USDT het Ton-netwerk zal ondersteunen. <a href="https://www.coindesk.com/business/2024/04/19/tether-is-expanding-its-usdt-xaut-stablecoins-to-ton-network-transparency-page-shows/" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, “Binnen het Ton Space-ecosysteem is alleen USDT op TON beschikbaar, waardoor de gebruikerservaring wordt gestroomlijnd voor degenen die geïnvesteerd zijn in het TON-ecosysteem.”</p>
<h2 id="h2-Unieke20kenmerken20van20USDT20op20TON593603"><a name="Unieke kenmerken van USDT op TON" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Unieke kenmerken van USDT op TON</h2><p>De Tether USDT heeft essentiële kenmerken die het tot een stabiele munt van keuze maken onder cryptogebruikers.</p>
<p><strong>Afdekking</strong> Het behoudt zijn waarde tegenover de Amerikaanse dollar, een van de belangrijkste fiatvaluta op de markt.</p>
<p><strong>Bevordert peer-to-peer transacties</strong> Vanwege zijn prijsstabiliteit zijn veel mensen bereid het te gebruiken bij dagelijkse transacties.</p>
<p><strong>Grensoverschrijdende betalingen</strong>: Mensen kunnen het gebruiken om betalingen te doen aan iedereen of elke instelling over de hele wereld.</p>
<h2 id="h2-Toekomst20van20USDT20op20Ton340884"><a name="Toekomst van USDT op Ton" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomst van USDT op Ton</h2><p>Veel mensen zullen waarschijnlijk transacties uitvoeren met USDT op Ton vanwege de efficiëntie, hoge schaalbaarheid en beveiliging van de blockchain. Ook zal het economisch nut van USDT toenemen door de virale mechanismen van Telegram en het grote aantal gebruikers. Aangezien Ton een van de meest kosteneffectieve blockchains is, zullen veel mensen waarschijnlijk USDT aannemen als betaalmiddel.</p>
<h2 id="h2-Conclusie518424"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Tether heeft aangekondigd dat het van plan is om USDT en XAUT te integreren met het Ton-netwerk om de toegankelijkheid en bruikbaarheid van zijn twee stablecoins te vergroten. Bovendien zullen de stablecoins profiteren van de schaalbaarheid en kosteneffectiviteit van het Ton-netwerk. Al met al zullen veel mensen waarschijnlijk USDT en XAUT gaan gebruiken, omdat ze nu toegankelijker zijn dan voorheen.</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 enkele beleggingsaanbevelingen.<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 stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>