SW5zY3JpcHRpZSBvZiBMMjogQmVzbGlzc2luZyBvdmVyIGRlIG9udHdpa2tlbGluZyB2YW4gaGV0IEJpdGNvaW4tZWNvc3lzdGVlbQ==

2023-12-21, 06:58

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR147235"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Inie is een nieuwe methode om willekeurige gegevens op de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blockchain te schrijven. Inies zoals ORDI en SATS hebben een golf van gerelateerde infrastructuur teweeggebracht en hebben gevolgen gehad voor andere openbare keteninies.</p>
<p>De twee sporen van Inion en L2 concurreren niet alleen op technologisch en filosofisch gebied, maar steunen ook op elkaar om de waardeontdekking van Bitcoin te bevorderen. In de toekomst zullen ze meer use cases dragen en verder de charme en waarde van het Bitcoin-netwerk ontketenen.</p>
<h2 id="h2-Introductie649591"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Met de lancering van de Bitcoin Inion-functie beginnen steeds meer gebruikers Bitcoin te gebruiken voor NFT-transacties, metadata-opslag en andere toepassingen. Diverse L2-projecten gebaseerd op Bitcoin beginnen ook weer op de markt te verschijnen.</p>
<p>Echter worden problemen zoals hoge netwerktransactiekosten en de trage afwikkelingssnelheid van Bitcoin steeds prominenter. Dit heeft opnieuw discussies in de markt aangewakkerd over het ontwikkelingsplan van het Bitcoin-ecosysteem.</p>
<p>In het verleden zijn er verschillende plannen voor het uitgeven en uitbreiden van activa ontstaan rondom de prestatieproblemen van Bitcoin, waaronder het vergroten van de blokruimte, sidechains, bliksemsnetwerken, enzovoort. Deze oplossingen werden echter niet breed geaccepteerd vanwege de fundamentalistische benadering van de Bitcoin-gemeenschap.</p>
<p>Tegenwoordig, met de toenemende vraag naar inieshandel, zijn debatten over de richting van de ontwikkeling van het ecosysteem van Bitcoin begonnen naar boven te komen: ofwel om de ontwikkeling van gerelateerde activaovereenkomsten rond inies voort te zetten of om een uitgebreider Layer2-ecosysteem op te bouwen.</p>
<p>Het artikel zal een gedetailleerde bespreking geven van deze twee richtingen ten behoeve van de lezers.</p>
<h2 id="h2-Bitcoin20Inschrijving20Geniet20tegenwoordig20van20een20trend920225"><a name="Bitcoin Inschrijving: Geniet tegenwoordig van een trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Inschrijving: Geniet tegenwoordig van een trend</h2><p>Bitcoin-inie is een nieuwe methode om willekeurige gegevens op de Bitcoin-blockchain te schrijven. Het maakt gebruik van het P2TR (Pay-to-Taproot) type dat is geïntroduceerd in de Bitcoin Taproot-upgrade. Het P2TR- maakt het mogelijk om willekeurige gegevens op te slaan met behulp van de output van Bitcoin-transacties.</p>
<p>Bitcoin-inies kunnen voor verschillende doeleinden worden gebruikt, waaronder:</p>
<ul>
<li>Het creëren van niet-vervangbare tokens (NFT’s): NFT’s zijn unieke en schaarse digitale activa. Bitcoin-inies kunnen worden gebruikt om NFT’s te creëren die kunstwerken, verzamelobjecten, in-game items en meer vertegenwoordigen.</li></ul>
<p>-Opslagmetadata: Bitcoin-inies kunnen worden gebruikt om metadata op te slaan, zoals titels van afbeeldingen, auteurs, auteursrechteninformatie, enz. Dit kan het traceren en beheren van afbeeldingen gemakkelijker maken.</p>
<ul>
<li>Het implementeren van complexe logica: Bitcoin-inies kunnen worden gebruikt om complexe logica te implementeren, zoals slimme contracten. Dit kan nieuwe toepassingsmogelijkheden bieden voor de Bitcoin-blockchain.</li></ul>
<p>Het is precies op basis van de volgende voordelen dat Bitcoin Inion dit jaar een marktgekte heeft veroorzaakt.</p>
<p>-Decentralisatie: Bitcoin-inies worden opgeslagen op de Bitcoin-blockchain, waardoor ze de eigenschap van decentralisatie bezitten.</p>
<p>-Beveiliging: De Bitcoin-blockchain heeft een uiterst hoge beveiliging, dus ook de Bitcoin-inies hebben een hoge beveiliging.</p>
<p>-Schalbaarheid: Bitcoin inies zijn niet beperkt door blokgrootte, daarom hebben ze een goede schaalbaarheid.<br><img src="https://gimg2.gateimg.com/image/article/1703141737img_v3_026b_074250c9-ccf1-4c19-9431-a3fe34da5eix.jpg" alt=""><br>Bron: Gate.io</p>
<p>We hebben eerder verschillende artikelen geschreven om de marktsituatie van inies vertegenwoordigd door ORDI, SATS en RATS te introduceren. We zullen hier geen gedetailleerde uitleg geven over specifieke inies.</p>
<p>Naarmate de populariteit van de iniemarkt zich verspreidt, hebben veel ontwikkelaars ook veel inieprotocollen voorgesteld op basis van het Bitcoin-netwerk, waarbij verschillende technologische middelen worden gebruikt om te voldoen aan de eisen van efficiëntie en kosteneffectieve inies.</p>
<h2 id="h2-Nostr20Assets917921"><a name="Nostr Assets" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nostr Assets</h2><p>NostrAssets is een open-source gedecentraliseerd protocol dat tot doel heeft om Taprot-assets en Bitcoin naadloos te integreren in het Nostr-ecosysteem.</p>
<p>Het stelt gebruikers in staat om de openbare en privésleutels van Nosr te gebruiken voor verschillende financiële activiteiten, het verzenden, ontvangen en verhandelen van digitale activa; Het is een toestemmingsloos en betrouwbaar relaisnetwerk dat de functionaliteit van Bitcoin-inies (Taproot) combineert met het beheer van digitale activa.</p>
<p>Op dit moment is de loterij-activiteit voor de tweede fase van NOSTR’s eerlijke casting begonnen. Als testtokens geïnvesteerd in de activamarkt, hebben Treat en Trick al meer dan 20 keer rendement gegenereerd, en Gate.io zal de voortgang van het project blijven volgen.</p>
<h2 id="h2-Atomicals134154"><a name="Atomicals" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Atomicals</h2><p>Het Atomicals-protocol is een eenvoudig en flexibel protocol dat wordt gebruikt om digitale objecten te maken, verhandelen en bijwerken op de blockchain van UTXO-modellen zoals Bitcoin.</p>
<p>Het Atomicals-protocol is qua functionaliteit uitgebreider dan het bekende Ordinals-protocol. Het ondersteunt verschillende soorten digitale objecten zoals tokens, NFT’s, domeinen, containers, enz., wat ontwikkelaars en gebruikers meer flexibele keuzes biedt. Sinds de lancering heeft het Atomicals-protocol talloze ontwikkelaars en gebruikers aangetrokken en heeft het een snelle ontwikkeling doorgemaakt, met gietvolumes van tienduizenden.</p>
<h2 id="h2-Trac40106"><a name="Trac" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trac</h2><p>Trac is een belangrijk gedecentraliseerd metaprotocol in het Bitcoin-ecosysteem, dat noodzakelijke tools biedt voor ontwikkelaars die Ordinals gebruiken. De opkomst van Trac lost het probleem van hoge centralisatie in bestaande metaprotocol trackers op, wat in overeenstemming is met de gedecentraliseerde aard van cryptocurrencies zoals Bitcoin. Trac biedt een gedecentraliseerd netwerk dat iedereen in staat stelt om het te verbinden, te gebruiken en er winst uit te halen.</p>
<p>Trac heeft samenwerkingsverbanden opgezet met meerdere projecten, waaronder Bitmap en InscribedHandles. Daarnaast werkt Trac actief samen met individuele ontwikkelaars die geïnteresseerd zijn in de implementatie van haar technologie. Deze samenwerkingsverbanden zullen bijdragen aan een bredere toepassing van Trac in het Bitcoin-ecosysteem.</p>
<p>Op dit moment heeft Gate.io deze token gelanceerd.</p>
<p>Naast de infrastructuur die verband houdt met de bovenstaande inschrijvingen, zijn er vele andere inschrijvingen en overeenkomsten die deze markt verkennen, waar we eerder over hebben gesproken. Het is niet nodig om hier verder op in te gaan.</p>
<h2 id="h2-Bitcoin20L220Krijg20een20nieuw20leven907112"><a name="Bitcoin L2: Krijg een nieuw leven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin L2: Krijg een nieuw leven</h2><p>Het Bitcoin L2-schema is een tweedelaags netwerk dat buiten de Bitcoin-hoofdketen is gebouwd en dat de schaalbaarheid van Bitcoin kan verbeteren via verschillende methoden, waaronder Lightning Network, sidechain-technologie, BitVM, enz.</p>
<p>Aangedreven door de trend van inschrijvingen, is het L2-schema onlangs in trek bij marktfondsen. Zo zagen veteraan Bitcoin L2-projecten zoals STX en RIF respectievelijk hun hoogste stijgingen van 90% en 60% in december.</p>
<p>Over het algemeen zijn er twee hoofdideeën voor de schaalbaarheidsoplossing van Bitcoin: on-chain schaalbaarheid en off-chain schaalbaarheid.</p>
<p>On-chain schaalbaarheid verwijst naar directe uitbreiding op de Bitcoin hoofdketen, zoals het wijzigen van de blokgrootte of gegevensstructuur. Maar deze methode is technisch moeilijk en kan leiden tot consensusfragmentatie, dus het is vandaag de dag niet langer mainstream.</p>
<p>Off-chain schaalbaarheid verwijst naar de oprichting van een tweede laag handelsnetwerk buiten de Bitcoin hoofdchain, zoals bliksemnetwerken, zijketens, enz. Deze methode kan sommige transacties buiten de chain overbrengen, waardoor de verwerkingscapaciteit van de hoofdchain verbetert.</p>
<p>Op dit moment zijn er verschillende soorten off-chain uitbreidingsoplossingen:</p>
<p>State channels, zoals bliksemsnetwerken, kunnen hoogfrequente transacties buiten de keten overzetten, waardoor de transactieverwerking verbetert.</p>
<p>Side chains, zoals Liquid, <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>, en Rootstock, kunnen Bitcoin-activa naar de zijketen overbrengen, waardoor schaalbaarheid en flexibiliteit worden verbeterd.</p>
<p>Andere gebieden, zoals Rollup-technologie en BitVM voor fraudebestendigheid, hebben iets langzamere vooruitgang laten zien op dit gebied.</p>
<p>We hebben ook verschillende artikelen geschreven in onze blog om Lightning Network, BitVM, etc. te introduceren. Hier zullen we kort de voortgang van andere projecten introduceren.</p>
<h2 id="h2-Stacks684556"><a name="Stacks" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stacks</h2><p>Stacks is een oud L2-protocol dat in 2018 is gelanceerd, met als kern technologie het PoW-to-Proof-of-Transfer (PoW-to-PoX) consensusmechanisme. Het PoW-to-PoX-mechanisme combineert het PoW-consensusmechanisme van Bitcoin met het PoX-consensusmechanisme om de beveiliging en decentralisatie van Bitcoin te bereiken, terwijl de schaalbaarheid van slimme contracten wordt verbeterd.<br><img src="https://gimg2.gateimg.com/image/article/1703141840img_v3_026b_f63536b5-97ba-4619-b1b7-1b0b373200ix.jpg" alt=""><br>Bron: <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> officiële website</p>
<p>Sinds de lancering is Stacks bekritiseerd door de Bitcoin-gemeenschap omdat het afwijkt van de waarde van Bitcoin, maar met de komst van Nakamoto-upgrades zal deze situatie effectief worden verlicht.</p>
<p>De upgrade van Nakamoto maakt het snel mogelijk om Stacks volledig gedecentraliseerd naar Bitcoin te schrijven, waardoor ontwikkelaars volledig gedecentraliseerde slimme contracten op Bitcoin kunnen bouwen. Bovendien zal het de uitvoeringstijd aanzienlijk verkorten, waardoor Stacks een meer competitief smart contract platform wordt.</p>
<p>Het protocol-token STX wordt ondersteund door zowel spot- als perpetual contractproducten op Gate.io.</p>
<h2 id="h2-Rootstock275625"><a name="Rootstock" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rootstock</h2><p>Rootstock is de eerste EVM-compatibele sidechain op het Bitcoin-netwerk, ontwikkeld en gelanceerd door IOV Labs in januari 2018. De kerntechnologie ervan is Rootstock VM (RVM).<br><img src="https://gimg2.gateimg.com/image/article/1703141865img_v3_026b_98a55b04-8dfe-488a-a34c-d10665fabbix.jpg" alt=""><br>Bron: officiële website van Rootstock</p>
<p>RVM is een op Bitcoin gebaseerde virtuele machine die slimme contracten kan uitvoeren die zijn geschreven in de Solidity-taal. Het ontwerpdoel van RVM is om compatibel te zijn met de beveiliging en decentralisatie van Bitcoin, en tegelijkertijd de schaalbaarheid van slimme contracten te verbeteren.</p>
<p>Volgens de gegevens die worden weergegeven op de officiële website van Rootstock, bereikt de TVL van zijn ecosysteem momenteel $300M, met meer dan 100 implementatieprojecten die meerdere gebieden bestrijken, zoals Swap, cross-chain bruggen, lenen, orakelmachines, betalingskanalen, portefeuilles, enz. Het is een van de hoogwaardige protocollen met een relatief compleet Bitcoin L2-ecosysteem.</p>
<h2 id="h2-Om20samen20te20vatten570799"><a name="Om samen te vatten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Om samen te vatten</h2><p>De uitbreiding van het Bitcoin Inion-ecosysteem is niet te stoppen en ook het L2-netwerk van Bitcoin zal in de toekomst een krachtige ontwikkeling doormaken. Het afgelopen jaar geeft aan dat in de Bitcoin bullmarkt, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en EVM-ketens kunnen hun dominante positie verliezen, terwijl het Bitcoin-ecosysteem naar verwachting het middelpunt zal worden van de nieuwe generatie van cryptofinanciën.</p>
<p>Met de verbetering van verschillende technologische faciliteiten en de deelname van meer gebruikers, zal het Bitcoin Inion en L2-project ook in grote aantallen worden gelanceerd in 2024, waardoor het Bitcoin-ecosysteem verder wordt verrijkt.</p>
<p>Analoog aan het ecosysteem evolutiepad van de vorige bullmarkt, ontstond de DeFi-zomer van 2020 vanuit <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en creëerde veel welvaartseffecten door nieuwe modellen zoals liquiditeitsmining.</p>
<p>Vervolgens opende de infrastructuurboom nieuwe mogelijkheden zoals NFT en GameFi. De inie is ontstaan uit Bitcoin en heeft het vroege ketenpionierswerk, de Unisat-lancering en de CEX-toegang doorlopen, waarbij vroeg marktprediking en kapitaalaccumulatie werden voltooid.</p>
<p>De verdere populariteit van Bitcoin-inies is te wijten aan de wereldwijde verspreiding van de Chinese wereld, die de ontwikkeling van infrastructuur en zelfs L2-inies op Bitcoin heeft gestimuleerd.</p>
<p>Bovendien concurreren de twee sporen van Inion en L2 niet alleen op technologisch en filosofisch gebied, maar steunen ze ook op elkaar om de waardeontdekking van Bitcoin te bevorderen. In de toekomst zal er een trend van dubbele dominantie zijn.</p>
<p>Hoewel er nog steeds veel controverses zijn, neemt het Bitcoin-ecosysteem onstuitbaar toe. Of het nu gaat om inies/runen of L2 schaalbaarheidsoplossingen, deze projecten zullen te maken krijgen met felle concurrentie, en de productie van een groot aantal projecten zal ongetwijfeld meer gebruiksmogelijkheden met zich meebrengen en de charme en waarde van het Bitcoin-netwerk verder ontketenen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>