SGV0IGFuYWx5c2VyZW4gdmFuIGRlIFRyZW5kaW5nIFRPTiBDaGFpbjogVmVya2VuIGRlIGJpamVlbmtvbXN0IHZhbiBlZW4gbWlsamFyZCBnZWJydWlrZXJzIG1ldCBlZW4gb3B2YWxsZW5kIFNvY2lhbCBHYW1lRmk=

2024-04-03, 10:08

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR899136"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De ontwikkeling van het TON openbare keten heeft ups en downs meegemaakt, maar recentelijk is het gestimuleerd door nieuws zoals het Telegram advertentieplatform dat aankondigt dat het gebruik maakt van de TON blockchain voor betaling en opname, wat heeft geleid tot een aanzienlijke stijging in de prijs van TON tokens. Ondertussen heeft het ook populariteit gebracht aan andere ecosysteemprojecten in de TON keten en sommige tokens verhoogd.</p>
<p>Met de enorme gebruikersbasis van Telegram, bloeien veel sociale, gaming- en andere TON-ketenprojecten.</p>
<p>Met de verdere verdieping van de integratie van het ecosysteem, zal TON profiteren van de enorme gebruikersbasis van Telegram en meer leuke DAPPs, wat mogelijk kan leiden tot een ecosysteemexplosie.</p>
<h2 id="h2-Kennismaking644665"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Met de voortdurende opwarming van de markt is een nieuwe ronde van de bullmarkt begonnen. In deze prachtige strijd tussen publieke blockchains is het een urgente vraag voor elk projectteam om de omsingeling te doorbreken en zijn unieke voordelen te demonstreren.</p>
<p>In deze context heeft TON als officiële technologiepartner van Telegram sterke concurrentiepotentieel aangetoond met zijn enorme verkeersvoordeel en ecosysteemvitaliteit. Dit artikel geeft een gedetailleerde introductie van TON.</p>
<h2 id="h2-Het20Open20Network20heeft20wendingen20en20bochten20meegemaakt20waardoor20het20een20sterke20doorbraak20heeft20gemaakt52867"><a name="Het Open Network heeft wendingen en bochten meegemaakt, waardoor het een sterke doorbraak heeft gemaakt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Open Network heeft wendingen en bochten meegemaakt, waardoor het een sterke doorbraak heeft gemaakt</h2><p>TON, als afkorting van The Open Network, en zijn native token TON hebben onlangs verbazingwekkend veel aandacht op de markt gekregen met sterke groei.<br>Volgens de gegevens van Gate.io bereikte de TON-token begin juni 2023 een dieptepunt van ongeveer $0,99, gevolgd door een sterke opleving, en is sindsdien gestegen naar de $5-$6 lijn, waarbij het de markt leidt met een stijging van maar liefst 500%.<br><img src="https://gimg2.gateimg.com/image/article/17121386441.jpg" alt=""><br>Bron: Gate.io</p>
<p>Op de schrijfdatum is de on-chain TVL van TON slechts gestegen tot $96,78M, maar de marktwaarde heeft $17B overschreden en staat op de 8e plaats in de ranglijst van marktwaarde van cryptocurrencies (exclusief stablecoins).<br><img src="https://gimg2.gateimg.com/image/article/17121387242.jpg" alt=""><br>Bron: DeFiLlama</p>
<p>In feite kan het ontwikkelingsstartpunt van TON worden herleid tot 2018. Het Open Network is zorgvuldig ontworpen en gemaakt door het zeer verwachte Telegram-team, met als doel een volledig gedecentraliseerde Layer 1 blockchain te zijn die schaalbaarheid, schaalprestaties, snelle transactiesnelheid, lage transactiekosten en gebruikersvriendelijke applicaties combineert.</p>
<p>De ontwikkeling van TON is echter niet zonder hobbels verlopen. In 2020 moest het Telegram-team een schikking treffen met de SEC vanwege juridische geschillen waarin het werd beschuldigd van het uitgeven van niet-geregistreerde effecten, wat leidde tot een tijdelijke opschorting van het project.</p>
<p>Gelukkig zagen community-ontwikkelaars het potentieel van TON en namen ze het project over, gaven het een nieuwe naam - The Open Network - en bleven het vooruit duwen.</p>
<p>De technische logica van TON is gericht op high-speed toepassingen, en de transacties zijn rechtstreeks gekoppeld op basis van berichten, waarbij punt-tot-punt-communicatie wordt ondersteund. De dynamische multi-shard architectuur biedt sterke ondersteuning voor de schaalbaarheid van de toepassingen.</p>
<p>TON maakt gebruik van een Proof of Stake (POS) mechanisme en TON-tokens spelen een belangrijke rol in het ecosysteem voor het betalen van transactiekosten, het verwerken van afwikkelingsbetalingen en het verifiëren van transacties. Volgens de basisparameters van TON wordt de jaarlijkse inflatie beheerd op ongeveer 0,6%, wat een robuust economisch model aantoont.</p>
<p>Maar aan het einde van december vorig jaar stuitte de ontwikkeling van TON op een nieuwe tegenslag. Zijn officiële Twitter-account @ton_blockchain is om onbekende redenen verbannen, wat enige overlast veroorzaakt voor de gemeenschap.</p>
<p>Ondanks dit is de ontwikkelingsdynamiek van het TON ecosysteem niet significant beïnvloed. Op 20 maart van dit jaar, de <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> De Foundation heeft een belangrijk distributieplan aangekondigd, wat de aanzienlijke ontwikkeling van het TON-ecosysteem markeert.</p>
<p>Na de aankondiging van dit nieuws nam de interesse van investeerders in TON opnieuw toe en steeg de prijs van de TON-munt op dezelfde dag snel met 10%.<br>Onlangs kondigde het advertentieplatform van Telegram aan dat het de TON-blockchain zou gebruiken voor betaling en opname, wat niet alleen de prijs van TON-tokens omhoog dreef, maar ook zorgde voor de populariteit van andere ecosysteemprojecten in de TON-keten en sommige tokens verhoogde.</p>
<h2 id="h2-Verken20Trending20Projecten20in20het20TONecosysteem45306"><a name="Verken Trending Projecten in het TON-ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verken Trending Projecten in het TON-ecosysteem</h2><p>In het dynamische ecosysteem van TON, bloeien veel toepassingen, met name sociale en gaming projecten met natuurlijke verkeersvoordelen, gezamenlijk bevorderen zij de welvaart en vooruitgang van het ecosysteem.</p>
<h3 id="h3-VIS525235"><a name="VIS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VIS</h3><p>FISH is het eerste mememuntproject op de TON-blockchain, ontworpen met gemeenschapsbetrokkenheid en entertainment als kern.<br><img src="https://gimg2.gateimg.com/image/article/17121387803.jpg" alt=""><br>Bron: tonfish.io</p>
<p>Gebruikers kunnen op verschillende manieren FISH-tokens verkrijgen en ze vasthouden voor interactie met het ecosysteem via handel, het verzamelen van NFT’s of deelnemen aan gemeenschapsactiviteiten.</p>
<p>De uniciteit van FISH ligt in de introductie van twee sets NFT’s, waaronder TON ROCK COLLectiON en TON FISH BOX COLLectiON, die tastbare waarde toevoegen aan het ecosysteem. Als symbool van experiment en creativiteit op de TON blockchain trok FISH snel de aandacht van de cryptogemeenschap.</p>
<h3 id="h3-Notcoin977205"><a name="Notcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notcoin</h3><p>Notcoin is een representatief project in het TON-ecosysteem. Hoewel het wordt geclassificeerd als een spel in het Tapp-center, neigt de functionaliteit meer naar een advertentietool of een afleidingstool met gameplay.<img src="https://gimg2.gateimg.com/image/article/17121388064.jpg" alt=""><br>Bron: @thenotcoin</p>
<p>NOTCOIN maakt volledig gebruik van de verkeersvoordelen en sociale kenmerken van Telegram, waardoor gebruikers puntenbeloningen kunnen verdienen door eenvoudige handelingen zoals het klikken op knoppen en het voltooien van taken. Tegelijkertijd kunnen gebruikers ook meer punten verdienen door andere gebruikers uit te nodigen of door te verwijzen naar verschillende toepassingen, evenals door zich bij teams aan te sluiten en door te verwijzen naar verschillende kanalen.</p>
<p>Het is vermeldenswaard dat meer dan 95% van de gebruikers in NOTCOIN via aanbevelingen komt, wat volledig het krachtige effect van sociale interactie bij het aantrekken van gebruikers aantoont.</p>
<h3 id="h3-Egg20Fight20Club246447"><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 is een innovatief spel dat gevechten, strategie en verzamelobjecten combineert.<img src="https://gimg2.gateimg.com/image/article/17121388325.jpg" alt=""><br>Bron: @EggFightClub</p>
<p>Spelers kunnen unieke “ei”-personages verzamelen en cultiveren, een krachtige gevechtsopstelling vormen, deelnemen aan real-time gevechten en spannend en intens gevechtsplezier ervaren. De game benadrukt het plezier van verzamelen en biedt een verscheidenheid aan personages die spelers kunnen verkennen.</p>
<p>Daarnaast zijn de sociale kenmerken gebaseerd op Telegram maken dit spel van nature uitgerust met rijke sociale functies, waardoor spelers kunnen communiceren en samenwerken met andere spelers om samen de mysteries van het spel te verkennen. Dit verhoogt niet alleen de interactiviteit van het spel, maar stelt spelers ook in staat om meer vrienden te maken in het spel.</p>
<h3 id="h3-STONEfi622751"><a name="STONE.fi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STONE.fi</h3><p>STON.fi is een relatief volwassen DEX op het TON-netwerk, dat geavanceerde AMM (Automated Market Maker) mechanismen gebruikt voor handel, waardoor bijna geen kosten worden gemaakt. Tegelijkertijd is de slippage extreem laag en het interface-ontwerp eenvoudig en intuïtief, waardoor het gemakkelijk is voor gebruikers om aan de slag te gaan.<img src="https://gimg2.gateimg.com/image/article/17121388546.jpg" alt=""><br>Bron: SONT.fi</p>
<p>Op dit moment ondersteunt STON.fi de handel in 20 soorten activa, waaronder TON, jUSDT, WTON, enz., waaronder een verscheidenheid aan mainstream en potentiële valuta. Tegelijkertijd ondersteunt het ook liquiditeitsbeloften voor ongeveer 30 handelsparen van activa, waardoor gebruikers meer waardekanalen krijgen.</p>
<p>Het is vermeldenswaard dat de TVL op STON.fi bijna $400M heeft bereikt, wat volledig de sterke aantrekkingskracht op de markt en het hoge vertrouwen van gebruikers aantoont.</p>
<h2 id="h2-TON20Chain20neemt20een20unieke20aanpak20en20richt20zich20op20sociale20en20gaming20tracks899492"><a name="TON Chain neemt een unieke aanpak en richt zich op sociale en gaming tracks" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TON Chain neemt een unieke aanpak en richt zich op sociale en gaming tracks</h2><p>De opkomst van TON is niet afhankelijk van traditionele DeFi-paden, maar is ontstaan door strategieën die blijven bijdragen aan een diepere gebruikerservaring, sociale interactie, toepassingstools en gaming.</p>
<p>Het projectteam heeft op slimme wijze gebruik gemaakt van de uitgebreide Web2-gebruikersbasis van Telegram, en door innovatieve methoden zoals ingebedde native wallets en mini-games, is TON erin geslaagd om met succes veel gebruikers aan te trekken om deel te nemen, en heeft significante resultaten behaald door het integreren van sociale, NFT en andere elementen.<br><img src="https://gimg2.gateimg.com/image/article/17121388877.jpg" alt=""><br>Bron: ton.org</p>
<p>Onlangs is met het nieuws van Telegram dat het gebruik van TON aankondigt om advertentie-inkomsten te verwerken en een IPO te zoeken, de prijs van TON-munten snel gestegen en is de on-chain activiteit aanzienlijk toegenomen. De veerkracht en vitaliteit ervan zijn voortdurend geverifieerd.</p>
<p>Echter, terwijl het TON-ecosysteem zich snel ontwikkelt, staat het ook voor enkele uitdagingen. Sommige Altcoin-projecten proberen het succesvolle model na te bootsen op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, maar door een gebrek aan diepgaand onderzoek naar de speciale marktvraag van TON, hebben de token community en het transactievolume van deze projecten niet het verwachte niveau bereikt. Bovendien is het TON-ecosysteem momenteel niet vriendelijk en compatibel met EVM, noch in staat om native stablecoins te lanceren, waardoor veel cryptocurrency-gebruikers afwachtend blijven en de snelheid van kapitaalinstroom nog geen schaal heeft gevormd.</p>
<p>Desalniettemin zitten we nog steeds vol verwachtingen voor de toekomst van TON. Met de voortdurende ontwikkeling van het Telegram Web App-ecosysteem zullen er meer projecten het TON-ecosysteem betreden, waardoor er een rijker scala aan toepassingsscenario’s ontstaat. We kijken ernaar uit om TON meer innovatieve toepassingen te zien lanceren op basis van het benutten van de voordelen van Telegram-toepassingen, zoals offline directe betaling, native USDT-ondersteuning en integratie met sociale scènes.</p>
<p>Over het algemeen heeft het TON-ecosysteem een sterke vitaliteit en brede ontwikkelingsvooruitzichten aangetoond. Hoewel het vroege team van Telegram niet langer rechtstreeks betrokken was bij de ontwikkeling, onderhielden de kernontwikkelaars van TON en de gemeenschap nog steeds nauwe samenwerking met Telegram om gezamenlijk de ecosysteemconstructie van The Open Network te bevorderen.</p>
<p>Het kan worden voorzien dat met de verdere verdieping van de integratie van het ecosysteem, TON zal profiteren van de enorme gebruikers van Telegram en meer interessante en leuke DAPPs om een ​​briljantere toekomst in te luiden, en zal een echt open netwerk worden dat verschillende regio’s, ecoen en toepassingen met elkaar verbindt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen in g van inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>