QW5hbGlzaSBkZWxsYSBjYXRlbmEgVE9OIGluIHRlbmRlbnphOiBlc3Bsb3JhIGwnaW5jb250cm8gZGkgdW4gbWlsaWFyZG8gZGkgdXRlbnRpIGNvbiB1biBjb2ludm9sZ2VudGUgZ2lvY28gc29jaWFsZSBHYW1lRmk=

2024-04-03, 10:08

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR211545"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Lo sviluppo della catena pubblica TON ha vissuto alti e bassi, ma recentemente è stato stimolato da notizie come l’annuncio della piattaforma pubblicitaria di Telegram sull’utilizzo della blockchain TON per pagamenti e prelievi, il che ha portato ad un significativo aumento del prezzo dei token TON. Nel frattempo, ciò ha anche portato popolarità ad altri progetti dell’ecosistema nella catena TON e aumentato alcuni token.</p>
<p>Con la massiccia base di utenti di Telegram, molti progetti TON legati al sociale, ai giochi e ad altri settori stanno prosperando.</p>
<p>Con ulteriore approfondimento dell’integrazione dell’ecosistema, TON sfrutterà la massiccia base di utenti di Telegram e DAPP più divertenti, che potrebbero portare a un’esplosione dell’ecosistema.</p>
<h2 id="h2-Introduzione223055"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con il continuo riscaldamento del mercato, è iniziata una nuova fase del mercato rialzista. In questa magnifica competizione delle catene di blocco pubbliche, come sfondare l’accerchiamento e dimostrare i propri vantaggi unici è diventato un problema urgente da risolvere per ogni progetto.</p>
<p>In questo contesto, in qualità di partner tecnologico ufficiale di Telegram, TON ha dimostrato un forte potenziale competitivo con il suo enorme vantaggio di traffico e la vitalità dell’ecosistema. Questo articolo fornirà un’introduzione dettagliata a TON.</p>
<h2 id="h2-La20Open20Network20ha20vissuto20colpi20di20scena20facendo20una20forte20svolta656067"><a name="La Open Network ha vissuto colpi di scena, facendo una forte svolta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Open Network ha vissuto colpi di scena, facendo una forte svolta</h2><p>TON, come abbreviazione di The Open Network, e il suo token nativo TON hanno recentemente guadagnato un’attenzione di mercato sorprendente con una forte crescita.<br>Secondo i dati di Gate.io, il token TON ha toccato un minimo di circa $0.99 all’inizio di giugno 2023, seguito da un forte rimbalzo, ed è salito da allora alla linea dei $5-$6, guidando il mercato con un aumento fino al 500%.<br><img src="https://gimg2.gateimg.com/image/article/17121386441.jpg" alt=""><br>Origine: Gate.io</p>
<p>Alla data di scrittura, il TVL on-chain di TON è salito solo a $96,78M, ma il suo valore di mercato ha superato i $17B, posizionandosi all’ottavo posto nella classifica del valore di mercato delle criptovalute (escludendo le stablecoin).<br><img src="https://gimg2.gateimg.com/image/article/17121387242.jpg" alt=""><br>Fonte: DeFiLlama</p>
<p>In realtà, il punto di partenza dello sviluppo di TON può essere fatto risalire al 2018. La Open Network è stata attentamente progettata e creata dal tanto atteso team di Telegram, con l’obiettivo di essere una blockchain Layer 1 completamente decentralizzata che combina scalabilità, prestazioni di sharding, velocità di transazione veloce, costi di transazione bassi e applicazioni user-friendly.</p>
<p>Tuttavia, lo sviluppo del TON non è stato un percorso senza intoppi. Nel 2020, il team di Telegram ha dovuto trovare un accordo con la SEC a causa di controversie legali che l’accusavano di aver emesso titoli non registrati, con conseguente sospensione temporanea del progetto.</p>
<p>Fortunatamente, gli sviluppatori della comunità hanno visto il potenziale di TON e hanno preso il controllo del progetto, dandogli un nuovo nome—The Open Network—e continuando a spingerlo avanti.</p>
<p>La logica tecnica di TON è incentrata sulle applicazioni ad alta velocità, e le sue transazioni sono direttamente collegate in base ai messaggi, supportando la comunicazione punto a punto. L’architettura dinamica multi-shard fornisce un forte supporto per la scalabilità delle sue applicazioni.</p>
<p>TON adotta un meccanismo di Proof of Stake (POS), e i token TON svolgono un ruolo importante nell’ecosistema per pagare le commissioni di transazione, elaborare i pagamenti di regolamento e verificare le transazioni. Secondo i parametri di base di TON, il tasso di inflazione annuale è controllato a circa lo 0,6%, dimostrando un modello economico robusto.</p>
<p>Ma alla fine di dicembre dello scorso anno, lo sviluppo di TON ha subito un altro contrattempo. Il suo account Twitter ufficiale @ton_blockchain è stato bloccato per motivi sconosciuti, causando qualche inconveniente alla comunità.</p>
<p>Tuttavia, il momento di sviluppo dell’ecosistema TON non è stato significativamente influenzato. Il 20 marzo di quest’anno, <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> La Fondazione ha annunciato un importante piano di distribuzione, segnando lo sviluppo sostanziale dell’ecosistema TON.</p>
<p>Dopo l’annuncio di questa notizia, l’interesse degli investitori per TON è aumentato nuovamente e il prezzo della moneta TON è rapidamente aumentato del 10% nello stesso giorno.<br>Recentemente, la piattaforma pubblicitaria di Telegram ha annunciato che utilizzerà la blockchain TON per i pagamenti e i prelievi, il che ha non solo aumentato il prezzo dei token TON ma anche portato alla popolarità di altri progetti dell’ecosistema nella catena TON e aumentato alcuni token.</p>
<h2 id="h2-Esplora20i20progetti20in20tendenza20nellecosistema20TON329487"><a name="Esplora i progetti in tendenza nell’ecosistema TON" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esplora i progetti in tendenza nell’ecosistema TON</h2><p>Nell’ecosistema dinamico di TON, molte applicazioni di tracciamento, in particolare progetti sociali e di gioco con vantaggi di traffico naturale, stanno prosperando, promuovendo congiuntamente la prosperità e il progresso dell’ecosistema.</p>
<h3 id="h3-PESCE891903"><a name="PESCE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PESCE</h3><p>FISH è il primo progetto di meme coin sulla blockchain TON, progettato con il coinvolgimento della comunità e l’intrattenimento come suo nucleo.<br><img src="https://gimg2.gateimg.com/image/article/17121387803.jpg" alt=""><br>Fonte: tonfish.io</p>
<p>Gli utenti possono ottenere token FISH in vari modi e tenerli per interagire con l’ecosistema attraverso il trading, la raccolta di NFT o la partecipazione alle attività della comunità.</p>
<p>L’unicità di FISH risiede nella sua introduzione di due serie di NFT, tra cui TON ROCK COLLectiON e TON FISH BOX COLLectiON, che aggiungono valore tangibile all’ecosistema. Come simbolo di sperimentazione e creatività sulla blockchain TON, FISH ha rapidamente attirato l’attenzione della comunità cripto.</p>
<h3 id="h3-Notcoin465435"><a name="Notcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notcoin</h3><p>Notcoin è un progetto rappresentativo dell’ecosistema TON. Sebbene classificato come gioco nel centro Tapp, la sua funzionalità tende ad essere più simile a uno strumento pubblicitario o di svago con gameplay.<br><img src="https://gimg2.gateimg.com/image/article/17121388064.jpg" alt=""><br>Origine: @thenotcoin</p>
<p>NOTCOIN sfrutta appieno i vantaggi del traffico di Telegram e le caratteristiche sociali, consentendo agli utenti di guadagnare premi punti attraverso semplici operazioni come cliccare sui pulsanti e completare compiti. Allo stesso tempo, gli utenti possono anche guadagnare più punti invitando altri utenti o indirizzandoli a diverse applicazioni, oltre a unirsi a team e indirizzarli a diversi canali.</p>
<p>Vale la pena notare che oltre il 95% degli utenti in NOTCOIN arriva tramite raccomandazioni, il che dimostra appieno il potente potere dell’interazione sociale nell’attrarre utenti.</p>
<h3 id="h3-Egg20Fight20Club4977"><a name="Egg Fight Club" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Egg Fight Club</h3><p>Egg Fight Club è un gioco innovativo che combina combattimento, strategia e collezionabili.<br><img src="https://gimg2.gateimg.com/image/article/17121388325.jpg" alt=""><br>Fonte: @EggFightClub</p>
<p>I giocatori possono raccogliere e coltivare personaggi unici in forma di “uova”, creare una potente formazione di battaglia, partecipare a battaglie in tempo reale e sperimentare un piacere di combattimento avvincente e intenso. Il gioco enfatizza il divertimento della raccolta e fornisce una varietà di personaggi da esplorare.</p>
<p>Inoltre, le caratteristiche sociali basate su Telegram rendono questo gioco naturalmente dotato di ricche funzioni sociali, consentendo ai giocatori di comunicare e collaborare con altri giocatori per esplorare insieme i misteri del gioco. Ciò non solo aumenta l’interattività del gioco, ma consente anche ai giocatori di fare più amicizie nel gioco.</p>
<h3 id="h3-STONEfi863728"><a name="STONE.fi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STONE.fi</h3><p>STON.fi è una DEX relativamente matura sulla catena TON, che utilizza meccanismi AMM (Automated Market Maker) avanzati per il trading, offrendo un’esperienza di funzionamento a costo quasi zero. Allo stesso tempo, lo slippage è estremamente basso e il design dell’interfaccia è semplice e intuitivo, rendendo facile per gli utenti iniziare.<img src="https://gimg2.gateimg.com/image/article/17121388546.jpg" alt=""><br>Origine: SONT.fi</p>
<p>Attualmente, STON.fi supporta la negoziazione di 20 tipi di asset, tra cui TON, jUSDT, WTON, ecc., coprendo una varietà di valute mainstream e potenziali. Allo stesso tempo, supporta anche gli impegni di liquidità per circa 30 coppie di trading di asset, offrendo agli utenti ulteriori canali di valore aggiunto.</p>
<p>Vale la pena menzionare che il TVL su STON.fi si è avvicinato a $400M, il che dimostra pienamente il suo forte appeal nel mercato e l’alta fiducia degli utenti.</p>
<h2 id="h2-TON20Chain20adotta20un20approccio20unico20e20si20concentra20su20tracce20sociali20e20di20gioco379899"><a name="TON Chain adotta un approccio unico e si concentra su tracce sociali e di gioco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TON Chain adotta un approccio unico e si concentra su tracce sociali e di gioco</h2><p>La crescita di TON non si basa sui tradizionali percorsi DeFi ma è emersa attraverso strategie che continuano a approfondire l’esperienza dell’utente, l’interazione sociale, gli strumenti di applicazione e il gioco.</p>
<p>Il team del progetto ha utilizzato astutamente la vasta base di utenti Web2 di Telegram e, attraverso metodi innovativi come portafogli nativi integrati e mini-giochi, TON ha attirato con successo molti utenti a partecipare e ha ottenuto risultati significativi integrando elementi sociali, NFT e altri.<img src="https://gimg2.gateimg.com/image/article/17121388877.jpg" alt=""><br>Origine: ton.org</p>
<p>Di recente, con la notizia che Telegram ha annunciato l’uso di TON per gestire i ricavi pubblicitari e sta cercando un’offerta pubblica iniziale, il prezzo della moneta TON è rapidamente aumentato e la sua attività on-chain è significativamente aumentata. La sua resilienza e vitalità sono state continuamente verificate.</p>
<p>Tuttavia, mentre l’ecosistema TON si sta sviluppando rapidamente, affronta anche alcune sfide. Alcuni progetti Altcoin cercano di replicare il modello di successo su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, ma a causa di una mancanza di approfondita indagine sulle specifiche esigenze di mercato di TON, la comunità di token e il volume delle transazioni di questi progetti non hanno raggiunto il livello previsto. Inoltre, l’ecosistema TON attualmente non è in grado di essere amichevole e compatibile con EVM, né è stato in grado di lanciare stablecoin native, il che ha portato molti utenti di criptovalute a rimanere in attesa e la velocità degli afflussi di capitali non ha ancora formato una scala.</p>
<p>Tuttavia, siamo ancora pieni di aspettative per il futuro di TON. Con lo sviluppo continuo dell’ecosistema dell’app Web di Telegram, più progetti entreranno nell’ecosistema di TON, portando una gamma più ampia di scenari di applicazione. Non vediamo l’ora di vedere TON lanciare applicazioni innovative basate sullo sfruttamento dei vantaggi delle applicazioni di Telegram, come il pagamento istantaneo offline, il supporto nativo per USDT e l’integrazione della scena sociale.</p>
<p>Nel complesso, l’ecosistema TON ha dimostrato una forte vitalità e ampie prospettive di sviluppo. Anche se il team iniziale di Telegram non era più direttamente coinvolto nello sviluppo, i principali sviluppatori di TON e la comunità hanno comunque mantenuto una stretta cooperazione con Telegram per promuovere congiuntamente la costruzione dell’ecosistema di The Open Network.</p>
<p>Si può prevedere che con l’approfondimento dell’integrazione dell’ecosistema, TON sfrutterà gli utenti massicci di Telegram e DAPPs più interessanti e divertenti per aprire un futuro più brillante, diventando una rete veramente aperta che collega diverse regioni, ecosistemi e applicazioni.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttrice: Joy Z.<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 venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>