Z2F0ZUxpdmUgQU1BIFJlY2FwLVN0YXR0ZXIgTmV0d29yaw==

<p><img src="https://gimg2.gateimg.com/image/article/171195603720240401-151948.jpeg" alt=""></p>
<h2 id="h2-Q120We20weten20dat20er20veel20beoordelingen20zijn20van20de20Statter20Network20vanuit20de20industrie20en20de20gemeenschap20Als20belangrijkste20netwerktoken20heeft20STT20ook20verschillende20labels20gekregen20zoals20metaverse20DePIN20gemoduleerde20openbare20blockchain20mijnmunt20en20mijnbouwproject20Als20vertegenwoordiger20van20de20Chinese20gemeenschap20en20als20iemand20die20diepgaande20kennis20heeft20van20het20project20hoe20ziet20u20het20Statter20Network20en20de20STTmunt20vanuit20uw20perspectief20of20het20perspectief20van20het20projectteam20Waar20moeten20we20ons20op20richten20als20we20het20hebben20over20STT108953"><a name="Q1: We weten dat er veel beoordelingen zijn van de Statter Network vanuit de industrie en de gemeenschap. Als belangrijkste netwerk-token heeft STT ook verschillende labels gekregen, zoals metaverse, DePIN, gemoduleerde openbare blockchain, mijnmunt en mijnbouwproject. Als vertegenwoordiger van de Chinese gemeenschap en als iemand die diepgaande kennis heeft van het project, hoe ziet u het Statter Network en de STT-munt vanuit uw perspectief of het perspectief van het projectteam? Waar moeten we ons op richten als we het hebben over STT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: We weten dat er veel beoordelingen zijn van de Statter Network vanuit de industrie en de gemeenschap. Als belangrijkste netwerk-token heeft STT ook verschillende labels gekregen, zoals metaverse, DePIN, gemoduleerde openbare blockchain, mijnmunt en mijnbouwproject. Als vertegenwoordiger van de Chinese gemeenschap en als iemand die diepgaande kennis heeft van het project, hoe ziet u het Statter Network en de STT-munt vanuit uw perspectief of het perspectief van het projectteam? Waar moeten we ons op richten als we het hebben over STT?</h2><p>Bedankt voor uw vraag. Voordat ik deze vraag beantwoord, wil ik graag benadrukken dat ik als vertegenwoordiger van de Chinese gemeenschap van het Statter Network, ook een grote houder van STT, een pleitbezorger van STT en een gewone deelnemer in de cryptosector, alleen mijn persoonlijke standpunt weergeef. Mijn standpunt kan niet de stem van het publiek vervangen en gebruikers kunnen openbare informatie raadplegen via de officiële website of sociale media van STT en andere nieuwe mediakanalen. Verschillende gebruikers hebben verschillende interpretaties en standpunten.</p>
<p>Als gebruiker die verschillende cryptoperiodes heeft meegemaakt, weten we allemaal dat de Web3-industrie en de cryptografie-industrie een zeer veranderlijke en snel evoluerende industrie zijn. We hoeven niet ver terug te gaan, maar in de afgelopen drie of vier jaar heeft de industrie DeFi-zomer, Gamefi, Meme-seizoenen doorgemaakt en ook nieuwe verhalen gecreëerd zoals NFT’s, gedecentraliseerde opslag, cross-chain, Layer2, Bitcoin-inies, Solana-ecosysteem, enzovoort.</p>
<p>Wanneer we deze hotspots observeren, merken we dat deze applicatie-ecoen niet exclusief zijn voor een bepaalde openbare keten of een bepaald platform. Natuurlijk kan de oorsprong van sommige toepassingen of de kenmerken van een bepaald platform duidelijk zijn. Bijvoorbeeld, mensen zijn gewend om NFT’s op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> te spelen of inies op de Bitcoin-keten te spelen. Maar uiteindelijk behoren deze technologieën en toepassingen tot de hele cryptogeldindustrie. Alleen in verschillende fasen zijn er verschillende populaire spelmethodes en verschillende concepten die mensen creëren.</p>
<p>Terugkomend op de vraag die de presentator vandaag heeft gesteld, is hoe het Statter Network-project gedefinieerd moet worden, en wat voor soort token is de STT governance token. In wezen denk ik dat Statter een high-performance public chain wil creëren, een chain die een alomvattende service kan bieden voor het metaverse-ecosysteem, game-ontwikkeling of andere toepassingen zoals inies, meme-tokens, Swap-implementatie, en zelfs de ontwikkeling van second-layer chains.</p>
<p>Natuurlijk, je zou kunnen zeggen dat de publieke blockchain nu erg vol is, met veel tweedelaagse ketens binnen het ETH-ecosysteem, en dat is inderdaad het g. Daarom heeft Statter op het gebied van publieke blockchain-technologie gedurfde innovaties doorgevoerd, waaronder modulaire ontwerpen, het genereren van publieke blockchain-technologie via drag-and-drop, het bouwen van Dapps als een puzzel met bouwstenen, EVM-compatibiliteit en vele andere conventionele en speciale innovaties. Dit alles is bedoeld om technologische barrières en een ecologische beschermingslinie op te bouwen, wat ook de uitdaging is waar Statter als publieke blockchain voor staat en waar het anticiperend op reageert.</p>
<p>Bovendien, je noemde net dat STT DePIN en mijnmunten zijn. Deze twee labels worden gebruikt op het STT-mainnet, en ik denk dat dat heel nauwkeurig is. Omdat de werking van het Statter-mainnet voornamelijk afhankelijk is van duizenden hardwaremijnwerkers en verschillende mijnzwembaden over de hele wereld, kan STT-token alleen worden gegenereerd door fysieke mijnbouwmachines. Dus wat betreft de werking van het mainnet en de productie van STT-token, behoort het tot het DePIN-traject. Het consensusmechanisme van STT, SPOW, is vergelijkbaar met het POW-mechanisme van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en is een vorm van mijnmunt.<br>Daarnaast moeten we bij het bespreken van het Statter-mainnet de focus leggen op een principe: het is een waardegedreven openbare keten. De waarde ervan ligt in het feit dat er in de toekomst veel ecoen zullen ontstaan op het tweedelaagsnetwerk, die rijker zullen zijn dan ETH in termen van toepassingen. Tegelijkertijd kan het downwards compatible zijn en samensmelten met het Layer0-netwerk, vooral in termen van het ecosysteem van de meta-universumstad. Dit zal de fusie van virtueel en reëel, en de eenheid van on-chain en off-chain realiseren. Dit is de grootste waarde van het Statter-mainnet.</p>
<h2 id="h2-V220Goed20zeer20gedetailleerde20introductie20We20begrijpen20nu20duidelijk20dat20Statter20Network20een20openbare20keten20is20die20diverse20diensten20biedt20aan20ontwikkelaars20STT20kan20worden20geclassificeerd20als20een20DePINmunt20U20hebt20net20gezegd20dat20de20openbare20keten20zeer20competitief20is20dus20wat20zijn20de20kerncompetenties20van20Statter20als20sterke20speler20in20de20openbare20keten20of20wat20zijn20de20kern20technische20kenmerken20Statter20is20een20NoordAmerikaans20project20Vooral20in20de20Verenigde20Staten20en20wereldwijd20is20er20nog20steeds20een20grote20innovatiebarrire20en20beperkingen20in20de20ontwikkeling20van20internet20Daarom20zijn20er20nieuwe20technologien20zoals20AI20AR20AI20en20het20metaversum20verschenen20In20200220en20200320begon20Facebook20ook20met20grootschalige20ontwikkeling20van20metaversetechnologie20zelfs20de20naam20werd20gewijzigd20en20ook20Google20Apple20en20Nvidia20zijn20actief20bezig20met20AI20Dus20vanaf20het20begin20van20het20project20heeft20het20ontwikkelingsteam20van20Statter20zich20gericht20op20het20maken20van20vooruitgang20in20de20richting20van20het20metaversum20wat20de20visie20van20het20technische20team20weerspiegelt20Op20de20officile20website20statterio20staat20dat20Statter20Network20een20openbare20ketenplatform20is20dat20een20allesomvattende20dienstverlening20biedt20voor20het20metaverseecosysteem676645"><a name="V2: Goed, zeer gedetailleerde introductie. We begrijpen nu duidelijk dat Statter Network een openbare keten is die diverse diensten biedt aan ontwikkelaars. STT kan worden geclassificeerd als een DePIN-munt. U hebt net gezegd dat de openbare keten zeer competitief is, dus wat zijn de kerncompetenties van Statter als sterke speler in de openbare keten, of wat zijn de kern technische kenmerken? Statter is een Noord-Amerikaans project. Vooral in de Verenigde Staten en wereldwijd is er nog steeds een grote innovatiebarrière en beperkingen in de ontwikkeling van internet. Daarom zijn er nieuwe technologieën zoals AI, AR, AI en het metaversum verschenen. In 2002 en 2003 begon Facebook ook met grootschalige ontwikkeling van metaverse-technologie, zelfs de naam werd gewijzigd, en ook Google, Apple en Nvidia zijn actief bezig met AI. Dus vanaf het begin van het project heeft het ontwikkelingsteam van Statter zich gericht op het maken van vooruitgang in de richting van het metaversum, wat de visie van het technische team weerspiegelt. Op de officiële website statter.io staat dat Statter Network een openbare ketenplatform is dat een allesomvattende dienstverlening biedt voor het metaverse-ecosysteem." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Goed, zeer gedetailleerde introductie. We begrijpen nu duidelijk dat Statter Network een openbare keten is die diverse diensten biedt aan ontwikkelaars. STT kan worden geclassificeerd als een DePIN-munt. U hebt net gezegd dat de openbare keten zeer competitief is, dus wat zijn de kerncompetenties van Statter als sterke speler in de openbare keten, of wat zijn de kern technische kenmerken? Statter is een Noord-Amerikaans project. Vooral in de Verenigde Staten en wereldwijd is er nog steeds een grote innovatiebarrière en beperkingen in de ontwikkeling van internet. Daarom zijn er nieuwe technologieën zoals AI, AR, AI en het metaversum verschenen. In 2002 en 2003 begon Facebook ook met grootschalige ontwikkeling van metaverse-technologie, zelfs de naam werd gewijzigd, en ook Google, Apple en Nvidia zijn actief bezig met AI. Dus vanaf het begin van het project heeft het ontwikkelingsteam van Statter zich gericht op het maken van vooruitgang in de richting van het metaversum, wat de visie van het technische team weerspiegelt. Op de officiële website statter.io staat dat Statter Network een openbare ketenplatform is dat een allesomvattende dienstverlening biedt voor het metaverse-ecosysteem.</h2><p>Dus vanuit het perspectief van de ecosysteemtoepassing is Statter een project dat zich richt op het bedienen van ontwikkelaars, gebruikers en makers van het metaversum. Metaverse-toepassingen kunnen worden gezegd allesomvattend te zijn, waarbij zowel de Web3- als de traditionele internetindustrie worden beslaan, en ze dienen als een medium voor de meest praktische toepassingsscenario’s in het tijdperk van waardeverbinding.</p>
<p>Tegelijkertijd is statter ook een openbare blockchain. Vanuit het perspectief van de openbare blockchainindustrie heeft het ook technologische kenmerken, zoals modulaire technologie. Door de openbare blockchain in verschillende lagen te verdelen en de functies binnen verschillende lagen te verfijnen en te coördineren om de efficiëntie van de openbare blockchain te verbeteren, doen nu veel modulaire openbare blockchains dit. Sharding-technologie en DAG high-speed asynchrone technologie zorgen ervoor dat Statter efficiënt en krachtig is.</p>
<p>Als ik een kenmerkend label moet vinden om Statter te beschrijven, denk ik dat de drag-and-drop technologie het meest geschikt is.<br>Het visieplan van het Statter ontwikkelingsteam is om een ​​blockchain-platform te bouwen met honderden satellietketens, en om een ​​groot ecosysteem rond het Statter Network hoofdketen te vormen. Op basis van dit concept hebben ontwikkelaars een zeer geavanceerde technologie ontwikkeld, namelijk de drag-and-drop technologie voor het creëren van een openbare blockchain, die momenteel wereldwijd de eerste is.</p>
<p>De componenten zijn voornamelijk verdeeld in drie grote delen. De eerste is het opzetten van een open bibliotheek met openbare ketencomponenten, die een verscheidenheid aan basismodules met hoge compatibiliteit bevat die nodig zijn voor de openbare keten, en ontwikkelaars kunnen verschillende functionele modules kiezen en combineren op basis van hun behoeften. De tweede is dat ontwikkelaars een reeks standaarden hebben geformuleerd voor de ontwikkeling van openbare ketens met slepen en neerzetten, en ontwikkelaars hoeven alleen maar volgens de normen uit te voeren om snel modules te combineren en openbare ketens te maken; Het derde onderdeel is technische assistentie, de componentenbibliotheek biedt basismodules, maar de geboorte van verschillende openbare ketens moet worden gediversifieerd en de technische aspecten moeten nog steeds worden gericht op het verbeteren van de parameters.<br>De drag-and-drop-generatie van publieke ketentechnologie is grofweg onderverdeeld in de bovenstaande onderdelen. Wat de vooruitgang van deze technologie betreft, heb ik eerder uit de officiële informatie vernomen dat er tot nu toe belangrijke vooruitgang is geboekt en dat deze naar verwachting binnenkort officieel zal worden gelanceerd.</p>
<h2 id="h2-Q320Het20slepen20en20neerzetten20van20generieke20ketentechnologie20is20inderdaad20vernieuwend20en20momenteel20is20het20ongekend20in20de20branche20We20kijken20erg20uit20naar20de20snelle20lancering20van20deze20technologie20Nu20we20het20over20de20ontwikkeling20van20DePIN20hebben20gehad20is20het20waar20dat20DePIN20niet20helemaal20nieuw20is20zoals20inies20maar20het20lijkt20dit20jaar20nieuw20leven20te20zijn20ingeblazen20vooral20met20het20actieve20DePINproject20gebaseerd20op20het20Solanaecosysteem20De20STTmunt20als20conceptmunt20voor20DePIN20wat20zijn20de20verschillen20of20voordelen20ten20opzichte20van20andere20concurrenten968201"><a name="Q3: Het slepen en neerzetten van generieke ketentechnologie is inderdaad vernieuwend, en momenteel is het ongekend in de branche. We kijken erg uit naar de snelle lancering van deze technologie. Nu we het over de ontwikkeling van DePIN hebben gehad, is het waar dat DePIN niet helemaal nieuw is zoals inies, maar het lijkt dit jaar nieuw leven te zijn ingeblazen, vooral met het actieve DePIN-project gebaseerd op het Solana-ecosysteem. De STT-munt als conceptmunt voor DePIN, wat zijn de verschillen of voordelen ten opzichte van andere concurrenten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Het slepen en neerzetten van generieke ketentechnologie is inderdaad vernieuwend, en momenteel is het ongekend in de branche. We kijken erg uit naar de snelle lancering van deze technologie. Nu we het over de ontwikkeling van DePIN hebben gehad, is het waar dat DePIN niet helemaal nieuw is zoals inies, maar het lijkt dit jaar nieuw leven te zijn ingeblazen, vooral met het actieve DePIN-project gebaseerd op het Solana-ecosysteem. De STT-munt als conceptmunt voor DePIN, wat zijn de verschillen of voordelen ten opzichte van andere concurrenten?</h2><p>Of het nu gaat om de fil, bzz van een paar jaar geleden of de populaire van dit jaar <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De essentie van DePIN op Gate.io is naar mijn mening nog steeds kapitaalgericht en heeft een beetje een gevoel van oude wijn in nieuwe zakken. Natuurlijk heeft STT ook kapitaalinvesteringen, vorig jaar investeerde <a href="/price/holo-hot" target="_blank" class="blog_inner_link">HOLO</a> tientallen miljoenen dollars, maar in wezen kan kapitaal geen STT-munten krijgen.</p>
<p>Ik denk dat er drie aspecten zijn die STT anders maken in de DePIN-ruimte:</p>
<p>Het eerste verschil is het consensusmechanisme. STT maakt gebruik van het SPoW-mechanisme, dat geen eenvoudige POW-rekenkrachtcompetitie of peer-to-peer delen van CPU- of GPU-bronnen is. Het werkt door middel van een gefaseerde verdeling van mijnbouwhashes in mijnbouwpools. Mijnwerkers halen mijnbouwopdrachten op bij de mijnbouwpools, berekenen ze door middel van exhaustieve berekeningen en dienen vervolgens de juiste resultaten in om beloningen te krijgen. In de toekomst zal er ook gedeelde bronnen zoals harde schijven en rekenkracht verhuurd worden om mijnbouwinkomsten te genereren.</p>
<p>Ten tweede is de STT-productiemethode anders. STT heeft slechts één productiepad, namelijk mijnbouw via fysieke hardware. Er is geen openbare aanbieding, geen particuliere plaatsing, geen ICO en geen airdrop. Het genereren van het eerste blok op het mainnet betekent de productie van de eerste STT-token, wat een eerbetoon is aan Bitcoin en het Satoshi-team in termen van ontwerp. Na de productie vindt er een tweede verdeling plaats, waarbij meer dan 90% van de STT-tokens wordt verdeeld onder de bijdragers aan het mainnet, waaronder mijnwerkers, miningpools en andere bijdragers. De resterende 8% wordt gereserveerd voor de stichting en ontwikkelaarsondersteuning. De productie- en distributiemethoden zijn zeer eerlijk en volledig gedecentraliseerd.</p>
<p>Het derde punt is de duurzaamheid van het deflatiemodel. De totale uitgifte van STT is 1,861 miljard, wat op het eerste gezicht misschien veel lijkt, maar in werkelijkheid is het helemaal niet veel. Dit komt omdat 90% ervan is vernietigd door het dubbele GAS-tarief via methoden zoals het creëren van satellietketens en circulatie op de keten. Naarmate de toepassingsgemeenschap groeit en de vraag toeneemt, zal de totale hoeveelheid afnemen en zal de waarde door prijsstijgingen door de markt worden ontdekt. Tegelijkertijd wordt elke STT-token geproduceerd door middel van mining, met beperkte jaarlijkse productie en lineaire jaarlijkse afname van 25%. Naarmate de productie in de latere stadia trager wordt, zal de prijs verder door de markt worden gestimuleerd door toenemende vraag.</p>
<p>Tegelijkertijd is het verbrandingsmechanisme het grootste hoogtepunt. Het verbrandingsmechanisme wordt gelijktijdig met de lancering van het mainnet geactiveerd. Uiteindelijk zal 90% van de STT worden verbrand. Er zullen slechts ongeveer 1,861 miljard STT in omloop zijn, gecombineerd met het feit dat iedereen het kan gebruiken, wat betekent dat STT-tokens in de toekomst schaars zullen zijn. Dus ondanks dat de totale uitgifte schijnbaar groot lijkt, zal de werkelijke hoeveelheid die in omloop is niet zo groot zijn. Bovendien is het voor het delven van mijnen ook nodig om STT te staken voor het beheer van het DAO-governancestadium op de keten. Een normale STT-machine heeft een staking van STT ter waarde van 1500U nodig. Op dit moment is er al meer dan 80 miljoen STT gestort op de keten, wat overeenkomt met 30% van de STT die is gestort. Dit betekent dat de TVL-indicator erg gezond is, de populariteit is laag en de investeringswaarde groot is.</p>
<h2 id="h2-Q420De20werking20en20veiligheid20van20het20Statter20Network20worden20voornamelijk20onderhouden20door20mijnbouwmachines20en20mijnwerkers20en20mijnbouwzwembaden20de20onderhouders20van20het20netwerk20kunnen20STT20als20beloning20ontvangen20Wat20voor20soort20mijnbouwmachine20is20het20en20wat20maakt20het20uniek767856"><a name="Q4: De werking en veiligheid van het Statter Network worden voornamelijk onderhouden door mijnbouwmachines, en mijnwerkers en mijnbouwzwembaden, de onderhouders van het netwerk, kunnen STT als beloning ontvangen. Wat voor soort mijnbouwmachine is het en wat maakt het uniek?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: De werking en veiligheid van het Statter Network worden voornamelijk onderhouden door mijnbouwmachines, en mijnwerkers en mijnbouwzwembaden, de onderhouders van het netwerk, kunnen STT als beloning ontvangen. Wat voor soort mijnbouwmachine is het en wat maakt het uniek?</h2><p>Vanuit het oogpunt van SPoW vereist STT dat mijnbouwapparatuur milieuvriendelijk, energiezuinig en koolstofarm is, omdat POW-mijnbouwmechanismen zoals Bitcoin buitensporig veel energie verbruiken. Dit is de reden waarom veel regeringen en NGO’s hiertegen zijn. Daarom heeft STT de werkwijze verbeterd om de concurrentie tussen mijnwerkers te vermijden. Dit maakt de mijnbouwapparatuur draagbaarder, milieuvriendelijker en minder vervuilend, terwijl aan de behoeften van het hoofdnetwerk wordt voldaan.</p>
<p>Op dit moment zijn er twee grote merkfabrikanten die STT-mijnbouwapparatuur produceren, een is HashMax uit de Verenigde Staten en de andere is een fabrikant uit Maleisië. Naar mijn weten is de productie van STT-mijnbouwapparatuur vergunningvrij, maar er is nog steeds een aanvraag- en autorisatieproces vereist, waarbij bepaalde kwalificaties en productievoorwaarden moeten worden geverifieerd. Over het algemeen is dit proces echter redelijk open.</p>
<p>STT-mijnen waren oorspronkelijk bedoeld om wereldwijd gedecentraliseerd te zijn, bij voorkeur op huishoudelijk niveau, om voldoende decentralisatie en veiligheid te waarborgen. Op dit moment zijn er echter ook grote mijnwerkers in sommige regio’s die mijnpools hebben opgezet en de mijnen centraal beheren. Het officiële standpunt is niet om dit te ondersteunen of tegen te zijn, maar in wezen wordt decentralisatie aangemoedigd. Dit is in wezen de situatie met mijnbouwmachines.</p>
<h2 id="h2-Q520We20weten20dat20het20STTmainnet20medio20vorig20jaar20officieel20live20ging20dus20het20is20bijna20een20jaar20geleden20ontwikkeld20Hoe20is20de20ontwikkeling20van20het20Statterecosysteem20en20de20investeringsstatus686406"><a name="Q5: We weten dat het STT-mainnet medio vorig jaar officieel live ging, dus het is bijna een jaar geleden ontwikkeld. Hoe is de ontwikkeling van het Statter-ecosysteem en de investeringsstatus?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: We weten dat het STT-mainnet medio vorig jaar officieel live ging, dus het is bijna een jaar geleden ontwikkeld. Hoe is de ontwikkeling van het Statter-ecosysteem en de investeringsstatus?</h2><p>Mijn investeringssituatie werd aanvankelijk ook genoemd, waarbij ik tientallen miljoenen dollars aan investeringen ontving. Het ging als volgt: ongeveer rond deze tijd vorig jaar organiseerden het Statter-project en de investeerders een gezamenlijke persconferentie in New York. Veel Wall Street-instellingen en functionarissen uit de staat New York woonden toen bij. De investeerder HOLO kondigde de investering in STT aan. HOLO was de hoofdinvesteerder en raadde Statter ook sterk aan bij branchegenoten.</p>
<p>Op dit moment is bekend dat er al een investeringsronde is geweest. Het is nog niet duidelijk of er in de toekomst nieuwe kapitaalinvesteringen zullen zijn, het is ook mogelijk dat er kapitaalinvesteringen zijn verkregen maar nog niet door het projectteam zijn aangekondigd, wat ook mogelijk is.</p>
<p>Wat betreft de ecologische ontwikkeling, vanuit het perspectief van de Statter-portemonnee, zijn er momenteel meer dan een dozijn ecologische Dapps gelanceerd, waaronder games, NFT’s enzovoort. Ondanks dat het mainnet al bijna een jaar online is, is de ecologie nog steeds niet officieel uitgebarsten. Het kan ook zijn dat het ontwikkelingsteam te veel gericht is op de ontwikkeling van de ‘drag-and-drop’ openbare ketentechnologie, die relatief complex is en meer tijd vergt om herhaaldelijk te valideren.</p>
<p>Sinds het begin van dit jaar zijn er echter tekenen van een versnelde ontwikkeling van het ecosysteem, waaronder de onlangs aangekondigde strategische samenwerking tussen ecosysteemoverschrijdende samenwerking en het Fil-ecosysteem, de opening van EVM-ondersteuning en compatibiliteit met applicaties op de Ethereum-keten, de investering van de Foundation in een nieuw staking-platform om on-chain TVL te verbeteren, en de aanstaande lancering van nieuwe en meer geavanceerde slimme contracttechnologieën.</p>
<p>Samen met de aankomende vermindering van STT, die ongeveer gelijktijdig is met de vermindering van Bitcoin, maar iets later, tonen deze gebeurtenissen en tijdstippen het potentieel voor explosieve groei van STT. Dit jaar zal ongetwijfeld een opmerkelijk jaar zijn voor de ontwikkeling van het STT-public blockchain.</p>
<p>Auteur: GateLive Team</p>
<ul>
<li>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.</li><li>De inhoud van dit artikel is origineel en het auteursrecht berust bij Gate.io. Bij herdruk dient de auteur en bron vermeld te worden, anders kunnen er juridische gevolgen zijn.</li></ul>