SXMgZGUgaGVsZSBrZXRlbiB2YW4gaW5zY2hyaWp2aW5nZW4gYWFuIGhldCBleHBsb2RlcmVuPyBPdmVybG9vcCB2YW4gQlJDMjAgbmFhciBTb2xhbmEgZW4gUG9seWdvbg==

2023-11-24, 02:30

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-Introductie517150"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Omdat ORDI een legende van duizendvoud heeft ingesteld en halverwege deze maand een ongelooflijke piek heeft bereikt, is er een lichte daling geweest, maar dit kan de enthousiasme van de ‘Inie Spelers’ niet volledig dempen. Onder de particuliere beleggers is er ook een oproep voor iedereen om ‘blijven vasthouden en prijzen stabiliseren’, en het lijkt erop dat hun vertrouwen in hen hun enthousiasme voor korte termijnwinsten heeft overtroffen. Voor mijnwerkers is de situatie beter, en de enorme vraag naar iniegieten heeft hen veel voordelen opgeleverd.</p>
<p>Van $ORDI, $SATS tot $RATS en meer, deze ‘tokens zonder praktische toepassingsscenario’s’ hebben een aantal nieuwe projecten en husband chains overschaduwd, die zich verspreiden van BRC-20 naar andere openbare chains met lagere gasvergoedingen en gemakkelijker casting, en snel het repliceren van het proces van BRC-20 tokens.<br><img src="https://gimg2.gateimg.com/image/article/170079282415311700792410_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Start20Ordinals20en20Atomicals20Protocollen522275"><a name="Start: Ordinals en Atomicals Protocollen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Start: Ordinals en Atomicals Protocollen</h2><p>Hier zullen we kort herinneren aan het proces van BRC-20 dat zich naar alle aspecten verspreidt.</p>
<p>Laten we het eerst hebben over de belangrijkste upgrade van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kernprotocol gelanceerd in 2017- Isolation Witness, gericht op het aanpakken van de uitdagingen van Bitcoin-uitbreiding en specifieke kwetsbaarheden. Het bevordert voornamelijk de opname van meer transacties door de schaalbaarheidsproblemen van transacties te corrigeren en de beperkingen van de Bitcoin-blokgrootte te vergroten. Isolation Witness introduceert het concept van blokgewicht, ter vervanging van de traditionele blokgroottebeperking en vergroot het transactievolume dat kan worden ondergebracht.</p>
<p>Tegen het einde van 2021 begon het Bitcoin-ecosysteem met de Taprot-upgrade meer complexe s en gegevenstypen te ondersteunen, wat aanzienlijke vooruitgang bracht in de programmeerbaarheid en schaalbaarheid van BTC.</p>
<p>Later werden we bekend met Ordinals, dat oorspronkelijk voornamelijk werd gebruikt om NFT’s te maken. Op 8 maart 2023 lanceerde anonieme ontwikkelaar Domo BRC-20 op basis van het Ordinals-protocol, een <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Altcoin-uitgifteprotocol vergelijkbaar met ERC-20. Het definieert een specifiek formaat van JSON-gegevenspakketten die via Ordinals in de BTC-keten zijn gegraveerd.<br><img src="https://gimg2.gateimg.com/image/article/170079286515321700792427_.pic.jpg" alt=""><br>Bron: X@ gateio_ Zh</p>
<p>Maar tegelijkertijd zijn de nadelen van BRC20 ook zeer significant. BRC 20 vereist het gebruik van een externe sorter om de grootboek onder de BTC-keten vast te leggen, wat extra complexiteit met zich meebrengt en een zwak punt van het systeem wordt. De overdracht van BRC 20 wordt niet uitgevoerd op de BTC-hoofdketen en moet worden opgedeeld in twee stappen van BTC-transacties (eerst verzamelen en vervolgens overdragen), wat resulteert in een groot aantal nutteloze transacties.</p>
<p>Later was er een optimalisatiepunt bovenop dit - het atomicals protocol, dat het probleem van het eerlijk uitgeven van tokens overwoog. Het was gebaseerd op UTXO van Bitcoin voor het slaan en verzenden, terwijl het proof of work introduceerde om een ARC20-ecosysteem te genereren. ATOM was zijn eerste token en werd snel geslagen. Over het algemeen is ARC20 meer gedecentraliseerd, waardoor de mogelijkheden van het Bitcoin-ecosysteem verder worden uitgebreid.</p>
<h2 id="h2-RUNES2020Upgraded20versie20van20het20Ordinals20Team935526"><a name="RUNES - Upgraded versie van het Ordinals Team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RUNES - Upgraded versie van het Ordinals Team</h2><p>Hoewel ORDI misschien lijkt op een ‘token uitgegeven door het oprichtingsteam van ordinaal getallen,’ is dat eigenlijk niet het g. Casey Rodarmor, de oprichter van Ordinals, uitte zelfs ontevredenheid over de vele mensen die ten onrechte denken dat ORDI toebehoort aan het ordinaal team.</p>
<p>Hij gelooft dat 99% van de FT’s op de huidige Bitcoin openbare keten oplichterij zijn. Inderdaad, volgens de huidige situatie zijn veel BRC20-tokens meme-activa met alleen emotionele waarde uit de gemeenschap. Het Ordinals-team is al lang op de hoogte van de beperkingen van het toepassen van protocollen op het Bitcoin-ecosysteem, dus stelde Casey een ander RUNE-protocol voor - een fungibel token-protocolconcept op basis van UTXO.<br><img src="https://gimg2.gateimg.com/image/article/170079289715331700792441_.pic_hd.jpg" alt=""><br>Bron: unsplash</p>
<p>Het RUNE-protocol kan de problemen veroorzaakt door garbage UTXO in BRC20 verlichten, de netwerkbenutting en gebruikerservaring waarde verbeteren. Volgens Rodarmor vereist BRC20 dat u off-chain gegevens coördineert met de blockchain, wat resulteert in ongemakkelijke gebruikerservaringen. De adresgebaseerde methode kan niet goed worden gebruikt in combinatie met de UTXO-gebaseerde methode van Bitcoin, wat vergelijkbare moeilijkheden oplevert voor eindgebruikers. Rodarmor beweert dat Runes een eenvoudig, op UTXO gebaseerd, alternatief tokenprotocol is met een goede gebruikerservaring van Bitcoin en compatibel kan zijn met bliksemnetwerken.</p>
<p>Het is vermeldenswaard dat de huidige ontwikkelingsfocus van het team nog steeds ligt op het Ordinals-protocol, dus de concepten met betrekking tot RUNES bevinden zich nog in de beginfase. We kunnen echter vertrouwen op Casey’s vaardigheid en uitkijken naar het Ordinals-team, als de ‘oorsprong van het inie-ecosysteem’, dat meer bruikbaarheidsproblemen aanpakt en meer toepassingsscenario’s biedt voor het Bitcoin-ecosysteem.</p>
<p>De auteur is van mening dat zodra RUNE verdere ontwikkelingen heeft, het een nieuwe golf van enthousiasme zal veroorzaken in de inie-industrie.</p>
<h2 id="h2-POLS20SOLS20en20zelfs20ERC2020Van20Leeg20Verhaal20naar20de20Mogelijkheid20van20het20Introduceren20van20Slimme20Contracten77266"><a name="POLS, SOLS en zelfs ERC-20 Van Leeg Verhaal naar de Mogelijkheid van het Introduceren van Slimme Contracten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>POLS, SOLS en zelfs ERC-20 Van Leeg Verhaal naar de Mogelijkheid van het Introduceren van Slimme Contracten</h2><p>Na een verbluffende stijging van honderden of duizenden keren in de BRC20-tokens vertegenwoordigd door $ORDI en $SATS, zijn de bezettingsgraad en gasvergoedingen van de BTC openbare keten dienovereenkomstig toegenomen. In de meeste vergelijkbare nieuwe projecten is de populariteit van de BRC-20 ook afgenomen. Echter, deze ‘inie-rage’ heeft veel gebruikers een speculatieve trend van ‘iedereen kan deelnemen, iedereen kan winst maken’ getoond. Het heeft natuurlijk ook zich verspreid van de Bitcoin openbare keten naar andere lagere kosten en meer solide ecosysteem openbare ketens.</p>
<p>De eerste die de ‘BRC20-overdracht’ aantoont, is POLYGON, waar PRC-20, gemodelleerd naar BRC-20, is geboren. Het eerste inieproject, $pols, met in totaal 21 miljoen vellen, wordt de ‘isomeer’ van sats genoemd, omdat beide eenzelfde grote voorraad hebben. Zijn verschijning heeft plotseling de oude openbare keten gemaakt <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Veelhoek</a> extreem druk geweest voor een paar dagen, omdat de lage gasvergoedingen en relatief eenvoudige bediening veel gebruikers hebben aangetrokken en de gasvergoedingen vermenigvuldigd zijn.</p>
<p>Verschillende gemeenschappen zijn snel opgedoken met tutorials over ‘Hoe chatGPT-assistentie te gebruiken om POLS in batches te graveren,’ en het transactieaantal van <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> overschreed 6,1 miljoen, en bereikte zijn hoogtepunt binnen het jaar. Nu zijn alle 21 miljoen POLS verslagen, wat aangeeft dat de enthousiasme van veel spelers met inies verre van zijn hoogtepunt heeft bereikt.</p>
<p>Volgens de @POLS markt, zal POLS volledig open zijn voor handel op 24 november.<br><img src="https://gimg2.gateimg.com/image/article/170079293415341700792457_.pic.jpg" alt=""><br>Bron: twitter@polsmarket</p>
<p>Op 16 november, vlak na de opwinding van het slaan van POLS, verscheen ook SPL-20 op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, die kan worden geslagen via de officiële website van libreplex. De manier van slaan is complexer, voornamelijk verdeeld in de volgende stappen:</p>
<p>Bereid afbeeldingen en tekst voor - Kopieer code - Maak document aan - Maak NFT aan - Wijzig parameters - Open libreplex om de beschrijving initialisatie te maken - Wijzig de parameters van de inie - Pas de oorspronkelijk gekopieerde code toe op de parameters en breng uiteindelijk een release uit. Nadat de informatie van de inie is geverifieerd, selecteert u Onveranderlijk maken - hiermee wordt het proces van het maken van de inie voltooid. Zodra de informatie correct is, kan de inie door gebruikers op de SOL-keten worden geïndexeerd.</p>
<p>Vergeleken met SOLS is de muntslagmethode relatief omslachtig en kunnen fouten die niet kunnen worden gezocht, maar het kan de enthousiasme voor deelname nog steeds niet stoppen. Momenteel zijn alle 21000 vellen geslagen. Het lijkt erop dat steeds meer “20s” meedoen.</p>
<h2 id="h2-Eths2020Een20Ethereuminie20en20een20nieuwe20L2narratief210750"><a name="Eths - Een Ethereum-inie en een nieuwe L2-narratief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eths - Een Ethereum-inie en een nieuwe L2-narratief</h2><p>In het begin werd BRC-20 door velen erkend als een protocol dat gebaseerd was op de eigen eigenschappen van Bitcoin, omdat BTC geen slimme contracten ondersteunde. Het was gemodelleerd naar ERC-20, omdat het geen applicatie-ecosysteem kon opzetten zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> In zekere zin is dit ook waar - slimme contracten zijn het domein van Ethereum, terwijl de BRC-20 een innovatie is die niet als innovatief kan worden beschouwd wat betreft BTC-attributen. Daarom, wanneer <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ook een ‘iniespoor’ wil oprichten, lijkt het alsof het achteruit rijdt.</p>
<p>Ethers is een protocol dat smart contracts en L2 vervangt, waardoor gebruikers informatie kunnen delen en berekeningen kunnen uitvoeren tegen lage kosten op Ethereum L1. Het bereikt gedecentraliseerd computergebruik door regels toe te passen op Ethereum-oproepgegevens om smart contractopslag en -uitvoering te omzeilen. In augustus 2023 introduceerde Ethers de virtuele machine (ESC VM) om de functionaliteit te verbeteren en er een universele rekeneenheid van te maken.</p>
<p>Ethers maken het mogelijk om niet-financiële en willekeurige gegevens te schrijven naar de Ethereum blockchain, waardoor gebruikers elk type bestand kunnen verbranden, zolang de bestandsgrootte niet groter is dan 96 kilobytes.</p>
<p>Veel aanhangers beschrijven Ether als ‘een andere manier van layer2’, en leden van de Ether-gemeenschap geloven dat ‘ETHS goedkopere gas kan bereiken dan L2 zonder netwerkwisseling in vergelijking met andere L2-oplossingen (zoals ZK en ARB). Vandaag, na het upgraden van ESIP-5, is het gas per overdracht verminderd tot ongeveer 0,05u, en gasinteractie is zelfs goedkoper dan veel L2-oplossingen’.</p>
<p>Op dit moment heeft ETHS niet de overdreven schommelingen van andere inies, en veel mensen zien het over het hoofd. Echter, met de hulp en optimalisatie van slimme contracten, is de uitvoering van mechanismen zoals een eerlijke lancering niet moeilijk en heeft het meer gedecentraliseerde elementen. We kunnen ook zien dat op een dag de vrijheid van Ethereum inies en Ether-s enkele onverwachte innovaties kan brengen.<br><img src="https://gimg2.gateimg.com/image/article/170079297515351700792475_.pic.jpg" alt=""><br>Bron: unsplash</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>