U3RvcCBhbGxlZW4gbWFhciBiZWdyaXAgdmFuIGRlIEJpdGNvaW4tZWNvbG9naWUsIGRlemUgaW5zY3JpcHRpZXMgemlqbiBlcmcgcG9wdWxhaXIu

2024-01-02, 08:00

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Sinds de explosie van het Mingwen-ecosysteem tot nu toe, verschijnen er elke dag talloze nieuwe projecten/nieuwe protocollen, vanaf de oorspronkelijke BRC-20, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Vanaf Stamp tot SPL-20, ASC-20, ARC-20, PRC-20, DRC-20, INS-20 … zijn allerlei xx-20 als paddenstoelen uit de grond geschoten en hebben ze elke hoek van de cryptomarkt overgenomen.</p>
<p>Uit de onderstaande grafiek blijkt de afgelopen drie jaar de verandering van de blokkostenratio en de markt voor het inieprotocol. De blokkostenratio steeg sterk in mei-juni en november van dit jaar en er zijn veel soorten xx-20 in november en december. Het heeft een momentum vergelijkbaar met de ‘DeFi-zomer’ van dat jaar.<br><img src="https://gimg2.gateimg.com/image/article/1704182273img_v3_026n_8fbd6e25-0799-4bc1-9dfc-d9001c1b14ix.jpg" alt=""><br>Bron: Mempool.space</p>
<p>In deze golf van verhalen is overnight trading al lang geen nieuws meer, alleen het spelen van één soort inie-ecosysteem is nieuws. Hieronder vindt u een introductie van enkele populaire inieprotocollen naast het bitcoin-ecosysteem.</p>
<h2 id="h2-Een20terugkerende20voorouder20inie2020SPL20579870"><a name="Een ‘terugkerende voorouder’ inie - SPL-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een ‘terugkerende voorouder’ inie - SPL-20</h2><p>SPL-20 is de enige on-chain bibliotheek op Solona die, net als andere inieprotocollen, gebruikers in staat stelt om hun eigen aangepaste SPL-20-tokens te maken. De reden waarom SPL-20 “atavistisch” is, is omdat het gebruikers een unieke manier biedt om afbeeldingen hun eigen on-chain-adressen te laten hebben, wat in strijd is met de vorige populaire manier om alle NFT-afbeeldingen op een gedistribueerde manier off-chain op te slaan, en lijkt een beetje een “terug in de tijd” -trend te zijn.</p>
<p>De productiekosten van de eerste inie van SPL-20, SOLS, bedroegen ongeveer $5,-. De hoogste waarde van de token in de geschiedenis was $8,24,- en de laagste waarde was $0,26,-. Op de Gate.io spotmarkt was de handelsvolume van SOLS in de afgelopen 24 uur ongeveer 1,6338 miljoen, wat overeenkomt met ongeveer $5,72 miljoen.<br><img src="https://gimg2.gateimg.com/image/article/1704182312img_v3_026n_df352bb0-105c-48d2-a489-d93c140e62ix.jpg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Tweede20Kraslotinie2020ASC20833576"><a name="Tweede, “Kraslot”-inie - ASC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tweede, “Kraslot”-inie - ASC-20</h2><p>ASC-20 is <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Het Inion Protocol op <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> stelt gebruikers in staat om gegevens in steen te graveren, waardoor een soort digitale verzamelobjecten ontstaan. ASC-20 heeft snel de aandacht van de markt getrokken, met het dagelijkse transactievolume op het Avalanche-netwerk dat is gestegen van ongeveer 450.000 naar meer dan 2,3 miljoen. Het wordt het ‘kraslot’-inie genoemd vanwege de lage kosten, toegangsdrempel en gasvergoedingen van ASC-20, en gebruikers kunnen het zien als het geld dat ze uitgeven om een lot te kopen en wat ‘verrassingen’ krassen in het ASC-20-ecosysteem.</p>
<p>Eerder populaire zoals AVAL, AVAV, enz. hebben allemaal een iniepercentage van 100%, met een bezettingsgraad van ongeveer 20.000 mensen. Nu DINO opkomt, heeft het ook een iniepercentage van 100% en een bezettingsgraad van bijna 40.000 mensen.<br><img src="https://gimg2.gateimg.com/image/article/1704182346img_v3_026n_c5f0eafe-d091-4474-8efe-84b9024d24ix.jpg" alt=""><br>Bron: <a href="https://avaions.com/" rel="nofollow noopener noreferrer" target="_blank">https://avaions.com/</a></p>
<h2 id="h2-Drie20nieuwe20PoW20mijnenmodus2020ARC20801496"><a name="Drie, nieuwe PoW mijnenmodus - ARC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Drie, nieuwe PoW mijnenmodus - ARC-20</h2><p>ARC-20 maakt gebruik van een getinte muntmodel, waarbij elke ARC-20 token een satoshi ondersteunt, in tegenstelling tot BRC-20, die wordt onderscheiden door sorteren. Omdat ARC-20 tokens volledig gebaseerd zijn op satoshi, kan het worden opgesplitst en samengevoegd, net als Bitcoin, en direct worden overgedragen via het Bitcoin-netwerk. In tegenstelling tot andere inieprotocollen, vereist het slaan van tokens in ARC-20 niet alleen Gas-kosten, maar ook een bijdrage van uw CPU/GPU. Hoewel het slaan proces ingewikkelder lijkt, biedt het meer schaalbaarheid en interoperabiliteit op de Bitcoin-chain in vergelijking met ordinale voor NFT’s, games, sociale interacties en identiteitsverificatie.</p>
<p>De eerste gecreëerde ARC-20 token is ATOM, die de afgelopen 30 dagen met 22,7% is gestegen onder invloed van ‘Inion Fever’. Bovendien is de ARC-20 token QUARK, met de Engelse betekenis ‘quark’, ook erg populair geworden. Veel leden van de gemeenschap geloven dat vanwege zijn eigen memetische eigenschappen, QUARK potentieel heeft om een uitstekende mememunt te worden binnen het Atomicals-ecosysteem.<br><img src="https://gimg2.gateimg.com/image/article/1704182382img_v3_026n_67252515-98f4-48d8-ad1c-f5c877fe39ix.jpg" alt=""><br>Bron: <a href="https://atomicalmarket.com/" rel="nofollow noopener noreferrer" target="_blank">https://atomicalmarket.com/</a></p>
<h2 id="h2-Vier20beginnervriendelijk20gieten2020PRC20101797"><a name="Vier, beginner-vriendelijk gieten - PRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vier, beginner-vriendelijk gieten - PRC-20</h2><p>PRC-20 is uitgegeven in <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> Het ecosysteem van het Permanent Carving Inion Protocol, volgens de officiële introductie, is de belangrijkste kenmerken van PRC-20 eerlijke verdeling, lage tarieven, hoge TPS-interactie en geen beperkingen op blokgrootte, dit is ook waarom PRC-20 wordt beschouwd als een ‘beginnersvriendelijke’ inie. De ‘exit’ van PRC-20 is voornamelijk te wijten aan het feit dat de gemeenschap op 16 november ontdekte dat de PRC-20 standaard token POLS al in mei van dit jaar werd uitgegeven en dat er sindsdien veel munten zijn bijgekomen, wat heeft geleid tot een sterke stijging van de Gas-kosten, maar tegelijkertijd heeft het ook de leidende positie van POLS in de PRC-20 bevestigd.</p>
<p>Op dit moment is de POLS-muntproductiegraad 100% en het aantal mensen dat betrokken is bij het slaan van deze token is maar liefst 18.552. De kosten van het slaan van POLS bedragen meer dan 800.000 MATIC aan Gas.<br><img src="https://gimg2.gateimg.com/image/article/1704182404img_v3_026n_38028eae-6f8e-4015-b245-105d94abccix.jpg" alt=""><br>Bron: <a href="https://dune.com/satsx/pols-exclude-internal-tx" rel="nofollow noopener noreferrer" target="_blank">https://dune.com/satsx/pols-exclude-internal-tx</a></p>
<h2 id="h2-Vijfde20OpenSea20trendlijst20nummer20n2020INS202342"><a name="Vijfde, OpenSea trendlijst nummer één - INS-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vijfde, OpenSea trendlijst nummer één - INS-20</h2><p>INS-20 is een protocol voor het gratis graveren van inies op de EVM, waarbij gegevens worden vervoerd via gebeurtenissen in de EVM, waardoor inies niet langer gescheiden zijn van slimme contracten en waardoor ze kunnen deelnemen aan bestaande DeFi-protocollen. De eerste gecreëerde INS-20 token is INSC, gemaakt op 21 december 2023. Slechts drie dagen later werd INSC (ins-20) de nummer één in de OpenSea-trendlijst, met een vloerprijs van 0.06 ETH en 2563 houders. Het lijkt erop dat de huidige inschrijvingssnelheid van INSC nog niet 100% heeft bereikt, geïnteresseerde gebruikers kunnen dit zelf onderzoeken voordat ze gaan graveren.<br><img src="https://gimg2.gateimg.com/image/article/1704182426img_v3_026n_36d0c4d5-3d5d-4515-b00a-7fa92b67faix.jpg" alt=""><br>Bron: <a href="https://dune.com/0xinion/ins-20" rel="nofollow noopener noreferrer" target="_blank">https://dune.com/0xinion/ins-20</a></p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Jiji M.</strong>, Gate.io Researcher<div class="info-tips"><em> Deze tekst vertegenwoordigt alleen de standpunten van de auteur en vormt geen handelsadvies.<br>  </em><div><em></em>Deze inhoud is origineel en is eigendom van Gate.io. Als u het wilt herdrukken, vermeld dan de auteur en de bron, anders zullen er wettelijke consequenties volgen.<br></div><p></p><br></div></div></div>