QVNDLTIwIGtvbXQgb3AgaGV0IHRvbmVlbDoga2FuIGhldCBBdmFsYW5jaGUtZWNvc3lzdGVlbSBvcG5pZXV3IG9wc3RhYW4/

2023-12-28, 02:38

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR828177"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Nadat het BRC20-tokenmodel de markt veroverde, zijn grote openbare ketens het gaan navolgen;</p>
<p><a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Het inieprotocol ASC-20 is geïnspireerd op het Ordinals-project van Bitcoin;</p>
<p>Op <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> zijn er interessante tokenprojecten zoals AVAV, AVAS, ATXS om in de gaten te houden;</p>
<p>De lancering van de ASC-20 standaard is een belangrijke stap in het toekomstige ontwikkelingsplan van Avalanche.</p>
<h2 id="h2-Inleiding643085"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Onlangs heeft er een golf van inietokens plaatsgevonden in de cryptocurrency-wereld.</p>
<p>Sinds de BRC20-tokenmodus van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> de markt heeft veroverd, hebben grote openbare ketens deze nagebootst en hun eigen inietokens uitgebracht. Bijvoorbeeld <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>、 <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>、 <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>、Oude openbare ketens zoals Avalanche, evenals zkSync, Arbirtrum, <a href="/price/klaytn-klay" rel="nofollow noopener noreferrer" target="_blank">Klaytn</a> Nieuwe opkomende openbare ketens sluiten zich allemaal aan bij deze rage.</p>
<p>Dit fenomeen heeft de eens zo inactieve gemeenschapsatmosfeer sterk aangewakkerd. Maar naarmate gebruikers massaal naar verschillende openbare ketens stromen om inies te slaan, wordt het probleem van congestie op het netwerk steeds duidelijker.</p>
<p>In de afgelopen tijd hebben zes openbare blockchain-netwerken, waaronder Arbirtrum en Celestia, vanwege overmatige gebruikersdruk storingen gehad. De vraag van gebruikers naar het inschrijven van openbare blockchains is een soort stresstest geworden. Openbare blockchains die geen inschrijvingstokens aanbieden, zullen ook in twijfel worden getrokken door de gemeenschap en de markt.</p>
<p>Deze trend toont niet alleen de vitaliteit van de cryptomarkt, maar stelt ook hogere eisen aan de technische stabiliteit en schaalbaarheid van openbare blockchains. In het licht van deze uitdaging heeft Avalanche zich weten te onderscheiden.<br><img src="https://gimg2.gateimg.com/image/article/1703730977img_v3_026i_f1716f48-6d14-447e-bb2b-9ff0fe4099ix.jpg" alt=""></p>
<h2 id="h2-Wat20is20ASC20669913"><a name="Wat is ASC-20?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is ASC-20?</h2><p>Het inieprotocol ASC-20 van Avalanche is geïnspireerd op het Ordinals-project van Bitcoin en stelt gebruikers in staat gegevens op de Avalanche-keten te graveren, waardoor een effect ontstaat vergelijkbaar met digitale verzamelobjecten.</p>
<p>De lancering van ASC-20 trok snel de aandacht van de markt, waardoor het dagelijkse handelsvolume van het Avalanche-netwerk op 19 november steeg tot 2,3 miljoen transacties, terwijl het gemiddelde dagelijkse handelsvolume daarvoor slechts 450.000 transacties bedroeg.</p>
<p>De ASC-20-token maakt het mogelijk om informatie in de transactiegegevens in te bedden, waardoor informatie tegen lage kosten op de keten kan worden opgeslagen.</p>
<p>Deze functie zorgt voor een aanzienlijke verbetering van de transactiesnelheid van het Avalanche-netwerk, met een gemiddelde van meer dan 40 transacties per seconde en zelfs bij piekbelasting bijna 100 transacties per seconde. Ondanks de toename van het aantal transacties blijft de blokbevestigingstijd ongeveer een seconde, wat de efficiënte verwerkingscapaciteit van het Avalanche-netwerk aantoont.</p>
<p>Volgens Jacob Everly, technisch productmanager van Ava Labs, zijn de kosten voor het uitvoeren van ASC-20 transacties relatief laag, met een gemiddelde kostprijs van ongeveer 0,05 dollar per ASC-20 transactie.<br><img src="https://gimg2.gateimg.com/image/article/1703731015img_v3_026i_493725a0-3146-4a96-98e0-8d1283c0edix.jpg" alt=""></p>
<h2 id="h2-Welke20tokens20zijn20er20beschikbaar325309"><a name="Welke tokens zijn er beschikbaar?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke tokens zijn er beschikbaar?</h2><p>Volgens de analyse van Blockworks Research-analist Dan Smith zijn er momenteel meer dan 7 miljoen transacties gerelateerd aan de ASC-20 token.</p>
<p>Als de eerste gegraveerde token op de Avalanche blockchain, toont de recente marktontwikkeling een handelsvolume van meer dan 25.000 AVAX in 24 uur, wat het op de derde plaats van het avaions.com handelsplatform plaatst.</p>
<p>De tekstmarkt van Avalanche werd oorspronkelijk geleid door het AVAL-token, maar met de marktvolatiliteit en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Na opmerkingen van Core-ontwikkelaars heeft de prijs en marktkapitalisatie van AVAL een daling doorgemaakt. Na een terugval vanaf het hoogste punt heeft AVAL nog slechts een marktkapitalisatie van $5.783 over en is de bodemprijs bijna nul.</p>
<p>Ondertussen is de waarde van de ASCT-token snel gestegen sinds de implementatie op 7 december, met een marktkapitalisatie van $21.000.817. Het is het grootste project in termen van handelsvolume op het Avaions handelsplatform en heeft ook de meeste houders.</p>
<p>Naast ASCT zijn er nog enkele andere interessante inieprojecten actief op Avalanche:</p>
<p>AVAV: Dit project is behoorlijk populair in de gemeenschap, met een totale hoeveelheid van 21 miljoen munten, waarbij elke munt 69.696.969 eenheden bevat.</p>
<p>AVAS: Als een van de eerste tokens die zijn uitgerold op het ASC-20-protocol, is AVAS op 12 december op de markt gekomen en is de handel begonnen. Het staat op de tweede plaats qua handelsvolume op Avaions.</p>
<p>ATXS: Rangschikt als derde op het Avaions-handelsplatform, hoewel het muntaanbod al 100% is bereikt, zijn er momenteel weinig bestellingen.<br><img src="https://gimg2.gateimg.com/image/article/1703731052img_v3_026i_68f1c212-c784-4b33-94de-ac24d89938ix.jpg" alt=""></p>
<p>Op 11 december lanceerde Avalanche officieel Avaions, de officiële marktplaats voor iniehandel. Op dit platform kunnen gebruikers verschillende inieprojecten bekijken, inclusief prijzen, handelsvolumes en houderinformatie, en handelen.</p>
<p>Op 18 december toont de Avascan-gegevens aan dat de gemiddelde gasvergoeding op het Avalanche-netwerk momenteel 5.110,30 nAVAX bedraagt (ongeveer $ 4,41). Eerder kondigde de oprichter van Trader Joe, @cryptofishx, de lancering aan van de asc-20 standaardinie (Avaion) BEEG op sociale media en zei dat de inie geen routekaart of praktisch gebruik heeft, maar slechts een sociaal experiment is.</p>
<p>Naar verluidt is 37% van de BEEG binnen 2 uur en 15 minuten na lancering geslagen, met ongeveer 4300 houders. @cryptofishx heeft excuses aangeboden voor het veroorzaken van congestie op het Avalanche-netwerk en bespreekt oplossingen.</p>
<p>In december bereikte de Avalanche-website opnieuw een recordgroei, waarbij zowel het aantal validators als het aantal actieve gebruikers per maand een historisch hoogtepunt bereikte, met 1708 validators en ongeveer 1,31 miljoen actieve gebruikers per maand.</p>
<h2 id="h2-Vooruitzichten20voor20het20Avalancheecosysteem363013"><a name="Vooruitzichten voor het Avalanche-ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vooruitzichten voor het Avalanche-ecosysteem</h2><p>ASC-20 is een standaardprotocol ontworpen door Avalanche voor NFT’s, met als doel het vereenvoudigen en standaardiseren van het creëren, verhandelen en beheren van NFT’s in het Avalanche-ecosysteem. Deze standaard verbetert niet alleen de gebruikerservaring, verlaagt de toetredingsdrempel, maar verhoogt ook de interoperabiliteit van NFT’s op Avalanche.</p>
<p>Met deze standaard kunnen ontwikkelaars gemakkelijker complexe NFT-projecten creëren en implementeren, terwijl gebruikers kunnen genieten van een soepelere en veiligere handelservaring.</p>
<p>De lancering van de ASC-20 standaard heeft een positieve invloed gehad op het Avalanche-ecosysteem.</p>
<p>Ten eerste bevordert het de ontwikkeling van diverse toepassingen binnen het ecosysteem, waardoor het meer ontwikkelaars en projecten aantrekt. Ten tweede verhoogt deze standaard de concurrentiepositie van Avalanche op het gebied van NFT’s, waardoor het beter kan concurreren met andere toonaangevende platforms zoals Ethereum.</p>
<p>Bovendien heeft ASC-20 de gebruikersbinding van het Avalanche-ecosysteem versterkt door een rijker en handiger NFT-ervaring te bieden, wat veel nieuwe gebruikers heeft aangetrokken.</p>
<p>De lancering van de ASC-20-standaard is een cruciale stap in de toekomstige ontwikkelingsplannen van Avalanche. Met de positieve effecten van de ASC-20 die geleidelijk aan zichtbaar worden, heeft Avalanche het potentieel om een belangrijk platform te worden voor NFT’s en een breder scala aan digitale activa-handel.</p>
<p>In de toekomst heeft Avalanche potentieel om een belangrijke rol te spelen in verschillende gebieden van de blockchain-industrie, zoals decentrale financiën (DeFi), gaming, metaverse, etc. met de voortdurende vooruitgang van technologie en de volwassenheid van het ecosysteem, waardoor het een onmisbare kracht wordt.</p>
<h2 id="h2-Slotwoord706878"><a name="Slotwoord" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Slotwoord</h2><p>De ASC-20 standaard is niet alleen een weerspiegeling van technologische innovatie, maar ook een van de strategieën van Avalanche om aan de behoeften van de markt te voldoen en de bloei van het ecosysteem te bevorderen. Met de komst van meer projecten en kapitaal wordt verwacht dat het Avalanche-ecosysteem een nieuwe fase van groei en toegenomen activiteit zal doormaken.</p>
<p>Voor investeerders en gebruikers biedt ASC-20 en de bijbehorende veranderingen ongetwijfeld nieuwe kansen en uitdagingen. In de snel evoluerende wereld van blockchain-technologie en de voortdurende uitbreiding van mogelijkheden, blijft de toekomst van Avalanche veelbelovend.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Byron B.</strong>Gate.io onderzoeker<div class="info-tips"><em> Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen beleggingsadvies.<br>  </em><div><em></em>De inhoud van dit artikel is origineel en het auteursrecht behoort toe aan Gate.io. Vermeld alstublieft de auteur en de bron bij het overnemen, anders zullen er juridische consequenties volgen.<br></div><p></p><br></div></div></div>