QXB0b3MgbmVlbXQgU3VpIG92ZXIgZW4gYmxhYXN0IGRlIHJhZ2UgdmFuIGhldCBNb3ZlLWVjb3N5c3RlZW0gbmlldXcgbGV2ZW4gaW4=

2024-10-31, 08:00

<p><img src="https://gimg2.gateimg.com/image/article/17303614241690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR65308"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p><a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> (APT), dat altijd saai is geweest, is de laatste tijd gestaag gestegen, met een circulerende marktkapitalisatie van bijna $5 miljard, wat een sterke opwaartse trend laat zien na SUI.</p>
<p>Aptos, als een opkomende high-performance en schaalbare blockchain, trekt marktaandacht met zijn hoge doorvoer en lage latentie kenmerken. DeFi en AI zijn de twee labels voor de welvaart van zijn ecosysteem.</p>
<p>Aptos Labs is in gesprek om HashPalette over te nemen en de Japanse blockchainmarkt te betreden, met het potentieel om diverse methoden te gebruiken om marketing van Zuid-Korea naar Japan te ‘hersenspoelen’.</p>
<h2 id="h2-Introductie294845"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>We hebben de technologische innovatie en munt prijs prestaties van Sui Network (SUI) meerdere malen gedeeld in onze blog artikelen, en de recente sterke schommelingen in SUI prijzen hebben ook onze eerder optimistische visies bevestigd. Dit artikel zal dieper ingaan op een andere high-performance publieke keten <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> in de Move serie, waarbij een reeks innovatieve trends en munt prijs prestaties van de keten worden gedeeld.</p>
<h2 id="h2-APT20Relay20SUI20Rose20TVL20Surged308806"><a name="APT Relay SUI Rose, TVL Surged" class="reference-link"></a><span class="header-link octicon octicon-link"></span>APT Relay SUI Rose, TVL Surged</h2><p>Onlangs is de prestatie van de Move-serie publieke blockchain in de markt bijzonder opvallend geweest. Van de sterke aantrekkingskracht van het Sui-ecosysteem en de boom van het on-chain ecosysteem en Meme, tot de verwachte lancering van het langverwachte Movement-ecosysteem mainnet, deze reeks gebeurtenissen blijft de Move-serie publieke blockchain naar voren duwen in de markt.</p>
<p>In deze context heeft Aptos, dat altijd saai is geweest, ook zijn glansmoment beleefd, met token APT die gestaag stijgt en een sterke opwaartse trend in SUI.<img src="https://gimg2.gateimg.com/image/article/17303614571.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Ondanks de algehele marktdaling en de wijdverbreide ineenstorting van Altcoins vorige week, bleef de prijs van APT sterk en brak met succes door de $11 grens, waarmee het een nieuw hoogtepunt voor de tweede helft van het jaar vestigde. Op dit moment staat APT in de top 25 tokens met een circulerende marktwaarde van bijna $5 miljard.</p>
<p>Ondertussen heeft de totale waarde vergrendeld (TVL) van het Aptos-ecosysteem ook een opmerkelijke groeitrend laten zien. Volgens DefiLlama-gegevens is de TVL van het Aptos-ecosysteem gegroeid tot $1,6 miljard, een toename van bijna 14 keer dit jaar. Op 28 september bedroeg dit cijfer slechts $558 miljoen, een toename van meer dan drie keer, wat de sterke ontwikkeling van zijn ecosysteem aantoont.<img src="https://gimg2.gateimg.com/image/article/17303614722.jpeg" alt=""><br>Bron: DefiLlama</p>
<p>Specifiek vertegenwoordigen de top protocollen in het Aptos ecosysteem, zoals Aries Markets en Amnis Finance, respectievelijk $660 miljoen en $240 miljoen aan TVL, met een stijging van meer dan 26% in de afgelopen 30 dagen. Echelon Market leidt andere protocollen in de keten met een TVL-stijging van 209%.</p>
<p>Volgens CoinMarketcap-gegevens zijn er in totaal 25 Aptos-ecosysteemtokens met een totale marktwaarde van meer dan $ 5,6 miljard. Het is niet moeilijk te zien dat hoewel het ecosysteem van deze keten steeds welvarender wordt, de inspanningen van verschillende toepassingen nog steeds onvoldoende zijn en er nog steeds veel potentieel is voor verbetering.</p>
<h2 id="h2-Het20DeFiecosysteem20is20actief20en20richt20zich20recentelijk20op20AI862177"><a name="Het DeFi-ecosysteem is actief en richt zich recentelijk op AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het DeFi-ecosysteem is actief en richt zich recentelijk op AI</h2><p>Aptos, als een opkomende high-performance en schaalbare blockchain, heeft sinds de lancering door Avery Ching en Mo Shaikh op 12 oktober 2022 veel aandacht getrokken vanwege zijn hoge doorvoer en lage latentie.</p>
<p>Volgens officiële websitedata kan Aptos ongeveer 160.000 transacties per seconde verwerken en de verificatie in minder dan 1 seconde voltooien. Met een maandelijks actieve gebruikersbasis van 6,3 miljoen biedt het sterke ondersteuning voor de uitbreiding van het bedrijf in DeFi, Game en andere gebieden.</p>
<p>Op de schrijfdatum is Aptos geïntegreerd met meer dan 180 gedecentraliseerde applicaties (DApps), waarvan DeFi een van de meest actieve en belangrijke toepassingsgebieden is in het Aptos-ecosysteem. Sinds het begin van dit jaar bouwt Mastercard een crypto-identificatietool op het Aptos-netwerk, dat een belangrijke maatregel is geworden voor Aptos om naar grootschalige adoptie in de praktijk te gaan.<img src="https://gimg2.gateimg.com/image/article/17303614953.jpeg" alt=""><br>Bron: aptosfoundation.org</p>
<p>Wat betreft DeFi-projecten in het Aptos-ecosysteem zijn uitstekende projecten zoals Aries Markets, Amnis Finance en Echo Protocol achtereenvolgens opgekomen, wat speciale aandacht verdient.</p>
<p>Aries Markets: Als het grootste DeFi- uitleenproject in het Aptos-ecosysteem biedt Aries Markets een verscheidenheid aan functies, waaronder lenen, hefboomhandel en rentedragende activa. De recent gelanceerde “Efficiency Mode” optimaliseert het activagebruik van gebruikers en het Aptos-ecosysteem door de kapitaalefficiëntie te verbeteren en zo de marktcompetitiviteit verder te versterken.</p>
<p>Amnis Finance: Als het eerste liquiditeitsstakingprotocol in het Aptos-ecosysteem heeft Amnis Finance een TVL van meer dan $240 miljoen en meer dan 300.000 stakers. Het innovatieve concept van tokenisatie van inkomsten stelt gebruikers in staat om onmiddellijk een equivalent bedrag aan stAPT te ontvangen terwijl ze APT staken en het te gebruiken in andere DeFi-protocollen in het ecosysteem.</p>
<p>Echo Protocol: In minder dan een maand sinds de lancering heeft Echo Protocol $147 miljoen aan TVL naar het Aptos-ecosysteem gebracht. Echo Protocol richt zich op het BTCFi multifunctionele protocol voor het Move-ecosysteem, waarbij BTC-liquiditeit in het Move-ecosysteem wordt geïntroduceerd door middel van cross-chain, liquiditeitsstaking en opnieuw staking-diensten, en innovatieve opnieuw staking-oplossingen voor BTC-activa worden geïntroduceerd. Dit innovatieve model van cross-chain en liquiditeitsstaking verrijkt niet alleen de toepassingsscenario’s van het Aptos-ecosysteem, maar bevordert ook de interconnectiviteit tussen BTC en het Aptos-ecosysteem.</p>
<p>Bovendien heeft Aptos AI sinds het begin van dit jaar diep geïntegreerd, niet alleen in samenwerking met Microsoft om de AI-beveiligingsassistent Aptos Assistant te creëren, maar ook om een door AI aangedreven vraag- en antwoordapplicatie genaamd FIND OUT van Aptos Labs te lanceren, die een interactieve en gemeenschapsgerichte ervaring biedt voor de gemeenschap.<br><img src="https://gimg2.gateimg.com/image/article/17303615234.jpeg" alt=""><br>Bron: assistant.aptosfoundation.org/</p>
<p>In oktober kondigde de Aptos Foundation een partnerschap aan met NVIDIA, Tribe en DISG ondersteunde Ignition AI-accelerators om de ontwikkeling van AI-startups in de regio Azië-Pacific en daarbuiten te stimuleren. Het werkte ook samen met gedecentraliseerd AI-platform FLock.io om kunstmatige intelligentie-tools te lanceren waarmee programmeren met behulp van de blockchain-aangepaste programmeertaal Move gemakkelijker wordt.</p>
<p>Kortom, terwijl traditionele gebieden zoals GameFi, Meme, RWA andere publieke ketens niet kunnen overtreffen, smeedt Aptos zijn eigen unieke pad van ecosysteemconstructie door AI-technologie te integreren.</p>
<h2 id="h2-Dubbelwielaandrijving20van20technologische20innovatie20en20marketing777315"><a name="Dubbelwielaandrijving van technologische innovatie en marketing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dubbelwielaandrijving van technologische innovatie en marketing</h2><p>In deze stierenmarkt-cyclus kan Aptos, als een van de tweelingsterren van op Move gebaseerde blockchaintechnologie, hoewel aanvankelijk een laag profiel houdt, niet worden genegeerd vanwege zijn innovatieve vermogen en marktprestaties. Met de leidende opkomst van Sui heeft het vroege prijsmodel met succes algemene marktaandacht aangetrokken en de activiteit van het hele ecosysteem gestimuleerd. Verwacht wordt dat Aptos dit pad van roem zal repliceren.</p>
<p>In feite heeft de Aptos blockchain sinds de lancering in 2022 in korte tijd ongelooflijke ontwikkelingen doorgemaakt, waarbij honderden projecten, waaronder DeFi-operators, zijn aangetrokken. <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>, NFT-orakelmachines zoals SupraOracles en opstartborden zoals BuilderDAO. De snelle groei van dit ecosysteem toont niet alleen de technologische kracht van Aptos aan, maar legt ook een solide basis voor zijn toekomstige marktcompetitie.</p>
<p>Naast consistente technologische innovatie heeft Aptos ook innovatieve marketingstrategieën gedemonstreerd die verschillen van die van Sui. Het meest opvallende is ongetwijfeld het nummer “APT.” dat is geschreven in samenwerking met Rosé, een lid van de wereldwijd populaire meidengroep Blackpink, en de bekende zanger Bruno Mars. Dit nummer werd snel wereldwijd populair, niet alleen het vernieuwen van verschillende muzieklijsten, maar ook het veroorzaken van veel discussies op sociale media. Hoewel het nummer en het project zelf alleen naar elkaar zijn vernoemd en geen directe verbinding hebben, heeft Aptos met dit wereldwijde onderwerp met succes de merkbekendheid en marktinfluentie vergroot.<img src="https://gimg2.gateimg.com/image/article/17303615505.jpeg" alt=""><br>Bron: openbare informatie</p>
<p>Vooral in de Koreaanse gemeenschap is de aanstekelijke hersenspoelende tekst “APT APT APT APT APT…” niet alleen het enthousiasme van de leden van de gemeenschap aangewakkerd, maar ook de positie van Aptos op de Koreaanse markt verder geconsolideerd.</p>
<p>Volgens het laatste marktnieuws is Aptos Labs in gesprek om HashPalette over te nemen en de Japanse blockchainmarkt te betreden. Het is niet moeilijk om af te leiden of Aptos ook betrokken zal zijn bij hersenspoelende marketing van Zuid-Korea naar Japan via verschillende middelen.</p>
<p>Vooruitkijkend blijft het potentieel van op Move gebaseerde blockchaintechnologie enorm. Hoewel de algehele omvang en activiteit van het Move-ecosysteem op dit moment niet zo hoog zijn als andere volwassen ecoen, wordt verwacht dat het Move-blockchain met de voortdurende volwassenheid van technologie en de uitbreiding van toepassingsscenario’s in de toekomst een grotere rol zal spelen. Vooral nu sommige projecten beginnen Move te introduceren in het ETH Layer2-ecosysteem, wordt verwacht dat Aptos in de toekomst nog meer briljante prestaties zal behalen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle 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 beleggingssuggestie.<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 schending van het auteursrecht.<br></div><p></p></div></div></div></div>