VGV0aGVyIGVzcGFuZGUgbGEgc3VhIHBvcnRhdGE6IFVTRFQgZSBYQVVUIFN0YWJsZWNvaW5zIGxhbmNpYW5vIHN1bGxhIGJsb2NrY2hhaW4gVE9OIGRpIFRlbGVncmFt

2024-05-08, 10:09

<p><img src="https://gimg2.gateimg.com/image/article/1715162527sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR135280"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>L’integrazione di USDT e XAUT con Ton Telegram probabilmente porterà a una maggiore adozione delle valute digitali rispetto a prima.</p>
<p>Le basse commissioni di transazione della rete Ton probabilmente favoriranno l’uso di USDT e XAUT.</p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha introdotto nuove divisioni aziendali che includono <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> Data, Tether Finance, Tether Power e Tether Edu.</p>
<h2 id="h2-Introduzione657619"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Tether è una delle principali blockchain che promuove la tecnologia crittografica in quanto facilita il trasferimento di denaro internazionale utilizzando valute digitali. Non c’è dubbio che Tether USDT, classificato al terzo posto, sia uno degli asset crittografici migliori grazie alla sua stabilità. L’altra stablecoin di Tether, <a href="https://www.gate.io/learn/articles/what-is-tether-gold/1180" target="_blank">XAUT supportato dall’oro</a>, probabilmente segnerà una grande svolta nell’economia digitale.</p>
<p>Questa analisi esamina la partnership tra Tether e Telegram finalizzata a promuovere l’uso di criptovalute come TON, XAUT e USDT. Ci concentreremo anche sul beneficio derivante dal lancio di USDT e XAUT sulla Ton Blockchain. Infine, esploreremo le nuove linee di business di Tether che includono Tether Data, Tether Finance, Tether Power e Tether Edu.</p>
<h2 id="h2-USDT20e20XAUT20verranno20lanciati20sulla20blockchain20TON262274"><a name="USDT e XAUT verranno lanciati sulla blockchain TON" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDT e XAUT verranno lanciati sulla blockchain TON</h2><p>I principali progetti blockchain ora sfruttano le partnership per offrire servizi di qualità ai propri utenti. Con questo obiettivo, Tether, uno dei principali fornitori di servizi blockchain, ha annunciato il suo piano di integrare le sue due stablecoin USDT e XAUT con la blockchain Telegram Open Network (TON). Paolo Ardoino, CEO di Tether, ha dato la buona notizia all’evento Token2049 a Dubai.</p>
<p>Il lancio di USDT, una stablecoin supportata dal dollaro statunitense, e XAUT, una stablecoin supportata dall’oro, sulla blockchain TON probabilmente sbloccherà molti benefici per gli utenti di Telegram, poiché aumenteranno la liquidità e consentiranno uno scambio senza soluzione di continuità del valore nell’ecosistema. <a href="https://www.theblock.co/post/289798/tether-ton-blockchain-usdt-and-gold-xaut" rel="nofollow noopener noreferrer" target="_blank">In una dichiarazione, citata da TheBlock, Ardoino ha detto</a>“Il lancio di USDT e XAUT su TON consentirà un trasferimento di valore senza soluzione di continuità, aumentando l’attività e la liquidità e offrendo agli utenti un’esperienza finanziaria che può competere con quelle presenti nel sistema finanziario tradizionale.”</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/tether-gold-xaut" target="_blank">Previsione e previsione del prezzo dell’oro Tether per il 2024, 2025, 2030</a></p>
<p>Ha aggiunto: ‘Telegram ha un ecosistema impressionante con 900 milioni di utenti attivi mensili. Tether ha più di 300 milioni di utenti in tutto il mondo. Tether e Telegram possono potenziare reciprocamente gli ecosistemi.’</p>
<p>L’integrazione di TON con USDT e XAUT avviene in un momento in cui la capitalizzazione di mercato di USDT ha superato i 109 miliardi di dollari, mentre quella di XAUT è superiore ai 114 miliardi di dollari. Come si può notare, XAUT è la più piccola delle due stablecoin di Tether. D’altra parte, Ton Coin, <a href="https://www.theblock.co/price/248363/toncoin-ton-usd" rel="nofollow noopener noreferrer" target="_blank">la blockchain nativa di Ton Telegram</a> La capitalizzazione di mercato delle criptovalute ha superato i 24 miliardi di dollari. Il grafico seguente mostra le attuali capitalizzazioni di mercato delle criptovalute.<br><img src="https://gimg2.gateimg.com/image/article/17151626621.jpeg" alt=""><br>Capitalizzazione di mercato delle stablecoin - <a href="https://www.theblock.co/data/stablecoins/usd-pegged/total-stablecoin-supply" rel="nofollow noopener noreferrer" target="_blank">TheBlock</a></p>
<p>Come osservato, Tether USDT domina il mercato delle stablecoin, seguito da USDC. È strategico da parte di Tether portare USDT e XAUT su Telegram <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> poiché la stablecoin beneficerà dei più di 900 milioni di utenti in tutto il mondo di questa piattaforma di social media. Grazie alla funzione di trasferimento da fiat a cripto su Ton Telegram, il lancio della stablecoin di Tether creerà un’esperienza finanziaria paragonabile solo a quella del sistema finanziario tradizionale.</p>
<p>Leggi anche: <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">Come acquistare Tether Gold (XAUT)</a>”</p>
<p>Nel frattempo, il valore della moneta Ton è aumentato significativamente quando Telegram ha annunciato il suo piano di utilizzare la moneta Ton per ricompensare i proprietari dei canali e condividere i ricavi generati dagli annunci sulla piattaforma. Attualmente, <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> classificato al nono posto in base alla capitalizzazione di mercato, sta negoziando a $5,25 dopo aver guadagnato il 5,7% nei ultimi 30 giorni. Il grafico successivo mostra le prestazioni attuali del prezzo di TON.<br><img src="https://gimg2.gateimg.com/image/article/17151627092.jpeg" alt=""><br>Grafico dei prezzi di <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> - <a href="https://www.coingecko.com/en/coins/toncoin" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Come si nota nel diagramma, Toncoin è in picchiata da quando il 11 aprile ha raggiunto il suo massimo storico di $7.63. Attualmente il suo prezzo è inferiore del 31,2% rispetto al massimo storico ma superiore del 910% rispetto al minimo storico raggiunto il 21 settembre 2021.</p>
<h2 id="h2-I20discorsi20di20Paolo20Ardoino20e20Pavel20Durov988697"><a name="I discorsi di Paolo Ardoino e Pavel Durov" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I discorsi di Paolo Ardoino e Pavel Durov</h2><p>Come abbiamo notato, il 19 aprile Tether ha annunciato la sua intenzione di lanciare Tether USDT e XAUT su Ton Network al fine di beneficiare della sua infrastruttura crittografica e dell’espansione della blockchain. Ardoino, CEO di Tether e Pavel Durov, fondatore di Telegram, hanno annunciato l’integrazione a Token2049, un evento criptato tenutosi a Dubai. Durante l’evento, i due leader hanno menzionato i benefici della partnership tra Telegram e Tether.</p>
<p>Ad esempio, hanno parlato delle funzionalità di accesso e uscita che avrà la blockchain Ton. Ciò significa che diventerà facile per gli utenti di Telegram e della blockchain Ton convertire le loro criptovalute in denaro fiat e viceversa. In particolare, Jack Booth, responsabile marketing della TON Foundation, ha detto <a href="https://cointelegraph.com/news/tether-usdt-stablecoin-ton-blockchain" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph su un tale sviluppo</a>.</p>
<p><a href="https://cointelegraph.com/news/tether-usdt-stablecoin-ton-blockchain" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “Ci sono on-ramp incorporati per il denaro fiat al lancio e presto arriveranno off-ramp globali per carte di credito e conti bancari. Questa sarà la prima volta che un’ampia audience potrà utilizzare l’infrastruttura criptovalutaria per i pagamenti globali.”</p>
<p>Tether ha anche annunciato l’introduzione di altre linee di business, vale a dire Tether Data, Tether Finance, Tether Power e Tether Edu. Ciascuna di queste divisioni si specializzerà in un’area particolare legata alla tecnologia blockchain. Ad esempio, Tether Data si concentrerà sullo sviluppo di tecnologie emergenti come l’intelligenza artificiale e i sistemi di pagamento peer-to-peer che rafforzeranno ulteriormente la sua posizione all’interno del settore della finanza decentralizzata.</p>
<p>Leggi anche: <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">Superando Tether come il più grande stablecoin?</a></p>
<p>Tether ha utilizzato il suo blog per spiegare cosa otterrà ogni nuova linea di business. Per quanto riguarda Tether Finance, ad esempio, afferma che sfrutterà la tecnologia blockchain per costruire un’infrastruttura finanziaria inarrestabile, compresa la prossima piattaforma di tokenizzazione degli asset digitali, catalizzando l’adozione diffusa degli asset digitali.</p>
<p>D’altra parte, la potenza di Tether faciliterà lo sviluppo e l’utilizzo di fonti di energia sostenibili. <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">chiarito</a> La divisione mineraria ed energetica di Tether si sta avventurando in soluzioni sostenibili <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> operazioni di mining, allineandosi alle pratiche responsabili per garantire l’integrità della rete monetaria più robusta al mondo.</p>
<p>Successivamente, Tether Edu si concentrerà sull’incremento dell’adozione della blockchain e sulla promozione della cultura digitale a livello globale. Il <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">azienda blockchain spiegata</a>“Tether Edu si impegna a espandere l’accesso globale all’istruzione sulle competenze digitali. Con una strategia multifacetica, la divisione coltiva conoscenza, consapevolezza e competenza nelle tecnologie digitali e altre tecnologie all’avanguardia.”</p>
<p>Infine, riguardo <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, il blog ha dichiarato</a>“Tether Finance è pronta a guidare l’utilizzo della tecnologia blockchain per costruire un’infrastruttura finanziaria inarrestabile, inclusa la prossima piattaforma di tokenizzazione degli asset digitali, catalizzando l’adozione diffusa degli asset digitali.”</p>
<p>Riguardo a queste divisioni, <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 ha detto</a>, “Prosperare insieme è nel nostro DNA. Abbiamo sconvolto il tradizionale panorama finanziario con il primo al mondo <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">e stablecoin più affidabile e affidabile</a>. Ora, ci stiamo osando a far partire soluzioni di infrastrutture inclusive, smantellando sistemi tradizionali per garantire equità.</p>
<h2 id="h2-Impatto20di20USDT20e20XAUT20su20TON20per20gli20utenti20e20lecosistema20finanziario844238"><a name="Impatto di USDT e XAUT su TON per gli utenti e l’ecosistema finanziario" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impatto di USDT e XAUT su TON per gli utenti e l’ecosistema finanziario</h2><p>L’integrazione di USDT e XAUT porterà molti vantaggi agli utenti di Telegram in quanto faciliterà pagamenti criptati fluidi. In generale, gli utenti saranno in grado di effettuare pagamenti transfrontalieri economici e istantanei. In modo ancora più significativo, non sarà necessario avere indirizzi di portafoglio digitale o app separate per inviare le valute digitali. Di conseguenza, il trasferimento degli asset digitali sarà così facile come inviare messaggi su Telegram.</p>
<p>Pubblicazione su X, <a href="https://twitter.com/ton_blockchain/status/1781294475219812665" rel="nofollow noopener noreferrer" target="_blank">Ton ha detto</a>, “Questa iniziativa è destinata a trasformare i pagamenti peer-to-peer globali, consentendo agli utenti di Telegram di inviare trasferimenti liberamente e istantaneamente tra tutti gli utenti di Telegram; tutto ciò che devi fare è inviare un messaggio diretto, non c’è bisogno di un indirizzo blockchain e non c’è bisogno di scaricare una nuova app.”<br><img src="https://gimg2.gateimg.com/image/article/17151628663.jpeg" alt=""><br>Origine: <a href="https://twitter.com/ton_blockchain/status/1781294479669944677" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Il <a href="https://twitter.com/ton_blockchain/status/1781294479669944677" rel="nofollow noopener noreferrer" target="_blank">stessa fonte aggiunta</a>, “USDT su TON sarà accompagnato da rampe di accesso completamente integrate dalla maggior parte delle valute fiat a livello globale al lancio. Presto, le rampe di accesso globali integrate consentiranno agli utenti di prelevare le valute fiat supportate direttamente sui conti bancari o sulle carte. L’obiettivo è che USDT su TON diventi un sistema di pagamento transfrontaliero più veloce, più semplice e più economico rispetto ai tradizionali servizi finanziari.”</p>
<p>L’integrazione di USDT porterà all’inclusione finanziaria in quanto sarà facile ed economico per le persone inviare e ricevere valute digitali. Inoltre, poiché sarà semplice convertire la criptovaluta in denaro fiat, molte persone adotteranno le criptovalute per i pagamenti globali, il che arricchirà l’intero sistema finanziario decentralizzato.</p>
<p>Inoltre, l’integrazione supporterà l’espansione della blockchain TON poiché i suoi utenti saranno in grado di utilizzare stablecoin in varie applicazioni decentralizzate. In un’intervista con CoinDesk, Halil Mirakhmed, il direttore operativo di Wallet in Telegram, ha spiegato come USDT supporterà la rete Ton. <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">Ha detto</a>, “All’interno dell’ecosistema Ton Space è disponibile solo USDT su TON, semplificando l’esperienza dell’utente per coloro che investono nell’ecosistema TON.”</p>
<h2 id="h2-Caratteristiche20uniche20di20USDT20su20TON476659"><a name="Caratteristiche uniche di USDT su TON" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Caratteristiche uniche di USDT su TON</h2><p>Il Tether USDT ha caratteristiche essenziali che lo rendono una stablecoin di scelta tra gli utenti di criptovalute.</p>
<p><strong>Hedging</strong>: Mantiene il suo valore contro il dollaro degli Stati Uniti, una delle principali valute fiat sul mercato.</p>
<p><strong>Promuove le transazioni peer-to-peer</strong> A causa della sua stabilità di prezzo, molte persone sono disposte a utilizzarlo per condurre transazioni quotidiane.</p>
<p><strong>Pagamenti transfrontalieri</strong>: Le persone possono usarlo per effettuare pagamenti a chiunque o a qualsiasi istituzione in tutto il mondo.</p>
<h2 id="h2-Il20futuro20di20USDT20su20Ton745451"><a name="Il futuro di USDT su Ton" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il futuro di USDT su Ton</h2><p>Molte persone probabilmente effettueranno transazioni con USDT su Ton a causa dell’efficienza, dell’alta scalabilità e della sicurezza della blockchain. Inoltre, l’utilità economica di USDT aumenterà grazie alla meccanica virale di Telegram e al gran numero di utenti. Poiché Ton è una delle blockchain più convenienti dal punto di vista dei costi, molte persone probabilmente adotteranno USDT come mezzo di pagamento.</p>
<h2 id="h2-Conclusion897270"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Tether ha annunciato i suoi piani per integrare USDT e XAUT con la rete Ton per aumentare l’accessibilità e l’utilità delle sue due stablecoin. Inoltre, le stablecoin beneficeranno della scalabilità e della convenienza della rete Ton. Nel complesso, molte persone sono probabilmente inclini ad adottare USDT e XAUT poiché diventano più accessibili rispetto al passato.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>