VmFuIFF1ZXJ5IHRvdCBCZWdyaXA6IE9wZW4gaGV0IFJpamtkb20gV2FjaHR3b29yZCB2YW4gSW5zY2hyaWp2aW5nZW4=

2023-12-21, 06:40

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR326830"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Nummer de satoshi en gebruik het als basis voor gegevensopslag en handel, waardoor elke satoshi unieke waarde en betekenis krijgt;</p>
<p>Het kernprobleem van inies is nog steeds de schaalbaarheid van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>, en de essentie is nog steeds de strijd tussen grote en kleine blokken;</p>
<p>De Taproot-upgrade van BTC heeft een subtiele verandering teweeggebracht, die opnieuw de aandacht heeft gevestigd op het BTC-ecosysteem;</p>
<p>De projecten met betrekking tot inies omvatten onderwerpen zoals portefeuilles, cross chains, handelsmarkten, muntslaggereedschappen en gegevensanalyse.</p>
<h2 id="h2-Kennismaking90840"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Met de voortdurende ontwikkeling en innovatie van het Bitcoin-ecosysteem trekt een nieuw concept veel aandacht van de markt - Ordinale getallen.</p>
<p>De introductie van het Ordinals-protocol heeft nieuwe toepassingsvooruitzichten voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> gebracht. De kern ervan is om aan elke SATS een unieke waarde en betekenis toe te kennen door het te nummeren en het als basis te gebruiken voor gegevensopslag en handel.</p>
<p>Het werkingsprincipe van het Ordinals-protocol kan worden samengevat als ‘nummering+inie’. Het zorgt er eerst voor dat het uniek en onvervangbaar is door aan elke satoshi een uniek volgnummer toe te wijzen. Dit volgnummer is net als elke slimme ID-kaart, het is het bewijs van zijn bestaan in het Bitcoin-ecosysteem. Vervolgens gebruikt het Ordinals-protocol dit volgnummer om elk type gegevens (zoals tekst, afbeeldingen, video’s, enz.) aan een specifiek apparaat te koppelen, een proces dat bekend staat als ‘inie’.</p>
<p>Het proces van graveren is vergelijkbaar met het creëren van een smart contract op de blockchain, waar metadata en het serienummer van satoshi gecodeerd en opgeslagen zijn op de blockchain. Zodra de transactie bevestigd is, zullen de metadata en het serienummer van satoshi permanent opgeslagen worden op de blockchain, en daarmee een onveranderlijk onderdeel worden.</p>
<p>Op deze manier heeft elke satoshi niet alleen een uniek serienummer, maar ook unieke informatie en verhaal, waardoor het een nieuw type niet-fungibel token (NFT) is.<br><img src="https://gimg2.gateimg.com/image/article/1703140545img_v3_026b_18393747-6965-4047-9510-1a0798df20ix.jpg" alt=""></p>
<h2 id="h2-Is20de20Inion20Garbage996103"><a name="Is de Inion Garbage?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is de Inion Garbage?</h2><p>Al vroeg in de maand (6 december) veroorzaakte de post van Bitcoin-coreontwikkelaar Luke Dashjr een enorme schok op de iniemarkt. Luke verklaarde dat Inion een kwetsbaarheid in de Bitcoin Core-client exploiteert om spamberichten naar de blockchain te sturen. Sinds 2013 stelt Bitcoin Core gebruikers in staat om extra gegevenslimieten in te stellen bij het doorsturen of delven van transacties. Door zijn gegevens in programmacode te vervagen, omzeilt de inie deze beperking.</p>
<p>De auteur maakt een ongepaste analogie, die gelijk staat aan het feit dat WeChat rode enveloppen oorspronkelijk werden overgeboekt, maar nu elke keer als ik 1 cent naar je overmaak, wij erop staan om te chatten via de notities op de rode envelop. Hoewel het moeilijk is om te zeggen dat dit een misbruik is, is het zeer waarschijnlijk misbruik of zelfs betekenisloos.</p>
<p>Bovendien ondersteunt normale Bitcoin geen NFT’s maken, maar dit wordt bereikt door deze vorm van ‘overdracht+notitie’. Ondertussen, door het gebruik van Taproot-technologie, is de oorspronkelijke bovengrens van notities omzeild en verhoogd van enkele bytes naar maximaal 512 bytes.<br><img src="https://gimg2.gateimg.com/image/article/1703140585img_v3_026b_818037fa-069e-4f4e-a93f-f9ccbba7b6ix.jpg" alt=""></p>
<p>Dit zal een grote hoeveelheid overbodige rommelinformatie in het Bitcoin-blok schrijven, waardoor de opslaglast van de hele node toeneemt. Het kernprobleem van inies is nog steeds de schaalbaarheid van Bitcoin, en de essentie is nog steeds de concurrentie tussen grote en kleine blokken. De inie wordt zeker gedreven door marktvraag, maar Bitcoin is nog steeds een klein kopje. De inie speelt een tornado in een kopje en het knijpen ervan zal onvermijdelijk resulteren in het knijpen van normale handel.</p>
<p>Maar in feite wordt blockchain zelf bereikt door middel van een groot aantal knooppunten, waarbij consensusalgoritmen gezamenlijk de boekhouding voltooien. Sommige mensen zeggen ook dat blockchain overbodig is. De decentralisatie die door deze redundantie wordt teweeggebracht, is waar sommige mensen op hopen. Op dezelfde manier brengt deze redundantie ook enkele interessantere dingen naar het Bitcoin-ecosysteem, waarbij wordt geloofd dat het opnemen van verzamelobjecten in Bitcoin niet alleen interessant maar ook nuttig is.</p>
<p>Hoewel Luke Dashjr ooit geloofde dat BRC-20 en het Inion-protocol de gegevensgroottebeperking van Bitcoin-blokken omzeilden en een grote hoeveelheid rommelgegevens in de blokken forceerden, zou deze aanpak een onnodige last veroorzaken voor nodes, omdat het hun netwerksnelheid, bandbreedte en opslagcapaciteitskosten zou verhogen. Als deze situatie lang aanhoudt, zal dit de mate van decentralisatie in Bitcoin-netwerken voortdurend verminderen.</p>
<p>Maar hij bevestigde ook het standpunt dat Bitcoin Layer 2 de nieuwe bestemming is voor BRC-20 en stelde onomwonden dat het niet nodig is om alle inies te elimineren om voordelen te bieden aan het Bitcoin-netwerk.</p>
<h2 id="h2-Inzicht20in20de20waarde20van20inies747761"><a name="Inzicht in de waarde van inies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inzicht in de waarde van inies</h2><p>Vorig jaar bracht de Taproot-upgrade van BTC een subtiele verandering teweeg, die opnieuw de aandacht vestigde op het BTC-ecosysteem.</p>
<p>Deze upgrade heeft een belangrijke basis gelegd voor de ontwikkeling van BTC van financiële kenmerken tot adoptiekenmerken. Met de opkomst van nieuwe protocollen zoals Ordinals, Drivechain, BitVM en Taproot Asset, zijn de adoptie-eigenschappen van Bitcoin verder ontwikkeld.<br><img src="https://gimg2.gateimg.com/image/article/1703140624img_v3_026b_0b196d54-8d94-4237-b9d4-6990746212ix.jpg" alt=""></p>
<p>De iniewaarde van BTC vertoont overeenkomsten met de sieradenwaarde van goud, die allebei tentoongesteld en samengevat kunnen worden in een gedeeltelijk gescheiden esthetisch consensus. De gelijkenis van deze waardevorm betekent dat als je deze logica begrijpt, je zult begrijpen waarom de inie onlangs haar vitaliteit heeft herwonnen na haar ogenschijnlijk korte verschijning in maart van dit jaar.</p>
<p>De uniciteit van inies ligt niet alleen in de verschillende afbeeldingen of tekens die ze momenteel dragen, maar ook in de mogelijkheid om in de toekomst meer informatie te dragen. Deze stukken informatie kunnen nieuwe waardeankers worden, net zoals de kom die door keizer Qin Shi Huang werd gebruikt, die niet alleen een gewone kom is, maar ook historische en culturele waarden draagt. Daarom kan de waarde van inies veel groter zijn dan die van BTC zelf, omdat ze nieuwe waardeankers kunnen worden.</p>
<h2 id="h2-Geselecteerde20Inschrijvingsprojecten855979"><a name="Geselecteerde Inschrijvingsprojecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Geselecteerde Inschrijvingsprojecten</h2><p>De projecten met betrekking tot inschrijvingen bestrijken verschillende sporen, zoals portefeuilles, cross chain, handelsmarkten, castingtools, data &amp; queries, enz. We hebben 5 projecten geselecteerd die misschien wel de volgende sterrenbaan kunnen worden en delen deze met iedereen. Suggesties voor niet-investeringen zijn alleen ter referentie en we zijn op zoek naar infrastructuur met betrekking tot inschrijvingen.<br><img src="https://gimg2.gateimg.com/image/article/1703140655img_v3_026b_933bb54d-f921-4634-8f06-ee784b4e22ix.jpg" alt=""></p>
<p><strong>Unisat</strong><br>Unisat is een non-custodial open-source Bitcoin Inion plugin wallet die Ordinals en BRC20 ondersteunt, waardoor gebruikers BRC20 tokens kunnen opslaan, minten en verzenden, inclusief het kopen en verkopen van BTC, NFT, domeinnamen en meer. Bovendien is Unisat Marketplace een Insights-markt op de Bitcoin-keten onder Unisat die is gebaseerd op PSBT en BRC-20-assets ondersteunt. In november stond het op de vierde plaats in de NFT-markt met een handelsvolume van $41 miljoen.<br><img src="https://gimg2.gateimg.com/image/article/1703140686img_v3_026b_4213d0b3-2f36-464a-bf6f-2d26c53c1cix.jpg" alt=""></p>
<p><strong>BIIS</strong><br>BIIS streeft ernaar de ultieme geïntegreerde en handige technologiestapel te creëren voor BRC20-tokens, gepositioneerd als de ‘BRC Eco Toolbox’ voor ontwikkelaars en gebruikers. Het heeft tot doel een uitgebreide set integratietools te bieden voor projectontwikkelaars en gebruikers, waaronder batchdistributie en -inzameling van BRC20-tokens, batchdistributie en -inzameling van NFT-assets zoals BRC-721, en andere integratietools. In de toekomst wordt ook een volledig geautomatiseerd activavrijgaveplatform gelanceerd, ondersteuning voor meerdere modale activavrijgavemodi zoals Free Mint/AirDrop/IDO, en het bieden van het projectteam een gegraveerd Dao-stemmingssysteem om geautomatiseerde projectvrijgave en gedecentraliseerd gemeenschapsbestuur te bereiken.<br><img src="https://gimg2.gateimg.com/image/article/1703140710img_v3_026b_d37c17b0-2297-4b45-843e-2a03fa9f2fix.jpg" alt=""></p>
<p><strong>MultiBit</strong><br>MultiBit is een cross-chain protocol tussen BRC20 en ERC20, gebaseerd op het bidirectionele cross-chain bridge ontwerp van BRC20, met als doel het bereiken van cross-chain transmissie tussen BRC20 en ERC20 tokens.<br><img src="https://gimg2.gateimg.com/image/article/1703140734img_v3_026b_6b11479d-74d7-4dac-a125-4101e4c723ix.jpg" alt=""></p>
<p><strong>GeniiData</strong><br>GeniiData is een Ordinals ecosysteem gegevensanalyseplatform dat de populariteitsindex en rangschikkingsgegevens van BRC20-tokens biedt, waardoor gebruikers real-time casting van hot inions en NFT’s kunnen vastleggen.</p>
<p>Ondertussen heeft het de ORC-20 indexeringsservice gelanceerd, die voornamelijk informatie weergeeft over de implementatie van ORC-20-tokens, waaronder maximale aanbod, huidige status van muntenmaken en of het kan worden geüpgraded, informatie over houders van ORC-20-tokens, transactierecords en de mogelijkheid om de transactiestatus te verifiëren.<br><img src="https://gimg2.gateimg.com/image/article/1703140765img_v3_026b_fff3d0f9-247e-42ab-ad0c-e358b8268eix.jpg" alt=""></p>
<p><strong>Magic Eden Bitcoin</strong><br>Magic Eden Bitcoin is een Bitcoin ecosysteem NFT-markt gelanceerd in maart van dit jaar, waarmee gebruikers Ordinals kunnen vermelden, kopen en verkopen. Daarnaast heeft Magic Eden ook de Bitcoin Launchpad gelanceerd, met als doel makers te helpen bij het direct starten van het Ordinals-protocol en het creëren van Bitcoin NFT’s op Magic Eden Launchpad.</p>
<h2 id="h2-Conclusie694449"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In de wereld van blockchain worden voortdurend nieuwe concepten voorgesteld, en de huidige iniewedstrijd gaat als volgt, alsof alle publieke ketens beginnen met ‘iniecultuur’.</p>
<p>We bevinden ons in een veld waarin vermogenscodes snel veranderen, en het is moeilijk om zelfs maar een seconde afgeleid te worden, omdat de volgende seconde iemand winst kan maken op een project waarvan je op de hoogte bent maar niet zeker bent. Dit soort winst- of verlieseffect trekt kapitaal aan om continu te… <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flow</a> in het inie-ecosysteem komen, waardoor het Mattheuseffect ontstaat, waardoor meer mensen er naartoe stromen.</p>
<p>Samengevat, hoewel het verschijnen van inies de ontwikkeling van de Bitcoin blockchain heeft versneld naar een bijna volledige staat, kan dit leiden tot toenemende congestie in het Bitcoin-netwerk en het gebruik van Bitcoin duurder maken. Maar we moeten ons er meer van bewust zijn dat het verschijnen van Bitcoin Ordinals het traditionele concept van NFT’s heeft doorbroken, door elk individu unieke waarde en betekenis te geven, wat nieuwe toepassingsvooruitzichten brengt voor het Bitcoin-ecosysteem.</p>
<p>Er zijn nog steeds enkele uitdagingen op dit moment, en we moeten geloven dat met de voortdurende vooruitgang van de technologie en de uitbreiding van toepassingsscenario’s, we reden hebben om te geloven dat inies in de toekomst een grotere rol zullen spelen en innovatie en ontwikkeling van het gehele Bitcoin-ecosysteem zullen stimuleren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</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 opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>