WnVsbGVuIFRhcHJvb3QgQXNzZXRzIGRlIHZvbGdlbmRlIEJUQyBMMiB6aWpuPw==

2023-10-26, 03:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR795843"><a name="[TL; DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]:</h2><p>Het Taproot Assets-protocol is een inheemse activalaag gebouwd op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, biedt kernfunctionaliteit voor ontwikkelaars om activa uit te geven, te verzenden, te ontvangen en te ontdekken op de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blockchain zonder uitbreiding van het Bitcoin-netwerk.</p>
<p>Taproot Assets gebruiken Bitcoin niet als een volledige gegevensbeschikbaarheidslaag en gebruikers moeten gegevensopslag buiten de keten indexeren of configureren.</p>
<p>Op dit moment zijn Taproot Assets meer geschikt voor high-frequency trading scenario’s, zoals fungible tokens (stablecoins, etc).</p>
<h2 id="h2-Inleiding69610"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Bitcoin Layer2-infrastructuurbedrijf Lightning Labs heeft onlangs de alfaversie van het Taproot Assets-mainnet uitgebracht, waarin officieel is verklaard dat het protocol een volledig functionele ontwikkelervaring zal bieden voor de uitgifte, het beheer en de verkenning van stablecoins of andere activa op de Bitcoin-blockchain.</p>
<p>In feite zijn er al veel projecten gericht op het uitbreiden van de prestaties van Bitcoin-netwerken, zoals de BRC20 die we hebben genoemd op onze blog en de recente BitVM. Echter, het lightning-netwerk ontwikkeld door Lighting Labs behoudt nog steeds het belangrijkste voordeel op het gebied van systeemvolledigheid en toepassingsdienstbereik. Wat zijn de hoogtepunten van hun huidige Taproot Assets, of ze een toonaangevend project kunnen worden in BTC L2, en hoe ze de marktsituatie zullen beïnvloeden, het artikel zal samen komen.</p>
<h2 id="h2-Technische20conceptie20van20Taprot20Assets667702"><a name="Technische conceptie van Taprot Assets" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technische conceptie van Taprot Assets</h2><p>Volgens het Taproot Assets-protocol BIP is het Taproot Assets-protocol een Taproot-native assetlaag gebouwd op Bitcoin.</p>
<p>Dit protocol biedt kernfunctionaliteit voor ontwikkelaars om activa uit te geven, te verzenden, te ontvangen en te ontdekken op de Bitcoin-blockchain door te proberen een hogere privacy en schaalbaarheid te bereiken, zonder het Bitcoin-netwerk te laten groeien.<br><img src="https://gimg2.gateimg.com/image/article/169829046012011698290368_.pic.jpg" alt=""><br>Figuur 1: Voorbeeld van ontvangst en betaling voor Taproot Assets</p>
<p>We weten dat Bitcoin beperkte programmering kan bereiken door ‘eenvoudige code’ te schrijven in een  op het Taproot-adres en het vervolgens uit te voeren als een UTXO-bestedingsvoorwaarde-instructie.</p>
<p>In het activa-uitgifte scenario van Taproot Assets kan het systeem deze eenvoudige bewerkingscode specificeren als de basisregels voor het totale uitgiftebedrag, de uitgiftetijd, het uitgifteobject, etc. van de token. Door verbinding te maken met een set van meerdere ondertekende adressen kan de bewerkingscode gezamenlijk worden geactiveerd, waardoor een point-to-point batchhandelsfunctie wordt bereikt.</p>
<p>Een interessant aspect van het technische implementatieproces van het protocol is dat de relay nodes van het bliksemnetwerk dienen als boekhoudkundige managementfuncties voor vermogensbeheer en distributie, waardoor er interacties met lage kosten, hoge frequentie en efficiënte distributie mogelijk zijn.</p>
<p>In dit proces ondersteunt de oorspronkelijke nieuwe boomstructuur van Taproot ontwikkelaars bij het insluiten van willekeurige activa-metadata, terwijl de deelnemers aan de overdracht van Taproot-activa de kosten van verificatie en opslag dragen. Als gevolg hiervan begint er een gedecentraliseerd boekhoudsysteem voor de uitgifte, het beheer en de distributie van meerdere activa vorm te krijgen.</p>
<p>Samengevat hebben Taproot Assets de volgende technische kenmerken:</p>
<p>Lage UTXO-bezetting (vergelijkbaar met Runes/IPE), omdat gebruikers meerdere tokens kunnen creëren of overdragen in een enkele transactie;</p>
<p>Gebruikers kunnen de meeste van hun transactiegegevens buiten de keten zelf opslaan of in het universum, wat betekent dat de on-chain bezetting van grote transacties zeer klein is;</p>
<p>Het is volledig gebaseerd op UTXO, dus het kan goed geïntegreerd worden met Bitcoin’s Lightning, DLC’s, RGB, enz.</p>
<p>Het is direct geïntegreerd met Lightning, dus na het overzetten naar Lightning (alle tokens + BTC in één transactie), kunnen gebruikers snelle en goedkope transacties uitvoeren.</p>
<h2 id="h2-De20Toepassingsvooruitzichten20van20Taprootactiva170486"><a name="De Toepassingsvooruitzichten van Taproot-activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Toepassingsvooruitzichten van Taproot-activa</h2><p>In vergelijking met de lage drempel, eenvoudige en ietwat ruwe BRC20 van deze zomer, is het multi-asset protocolontwerp van Taproot Assets meeromvattend en rigoureus en kan het native technologieoplossingen integreren zoals RGB, DLC en Lightning Network. Momenteel is het meer geschikt voor handelsscenario’s met een hoge frequentie, zoals fungibele tokens (stablecoins, enz.).<img src="https://gimg2.gateimg.com/image/article/169829050912021698290384_.pic.jpg" alt=""><br>Figuur 2: Lightning Labs uitleg van Taproot Assets</p>
<p>Omdat Taproot Assets geen gebruik maken van Bitcoin als de volledige gegevensbeschikbaarheidslaag, moeten gebruikers gegevensopslag buiten de keten indexeren of configureren, waardoor de toepassingsscenario’s van het protocol beperkt worden. Hier zijn enkele mogelijke aanpassingsscenario’s:</p>
<p>-Introductie van stablecoins op Taproot-activa (de belangrijkste focus van het lighting lab)</p>
<p>-Uitgifte en overdracht van andere tokens op Taproot-activa</p>
<p>-Asynchrone ontvangstfunctie en één-naar-veel-tokenoverdracht en -overdracht in één transactie</p>
<p>-Implementatie van Taproot Assets+Lightning Network voor enkele Bitcoin DeFi Use Cases</p>
<p>-Combinatie met BRC20, Atomicals proof-of-work mining en andere vormen van mining, etc</p>
<p>-Creatie en overdracht van ERC-721 en ERC-1155 activa</p>
<p>Volgens officiële bronnen heeft het agreement sinds de lancering van het Taproot Assets mainnet op 18 oktober meer dan 15.000 verschillende assets gecast.</p>
<p>Over het algemeen hebben Taproot Assets hun eigen afwegingen qua richting in vergelijking met bestaande Bitcoin-interchangeable-token-protocollen. Het is niet de ultieme oplossing voor Bitcoin L2, maar het stelt een praktische en haalbare ontwikkelingsrichting voor meerdere activa voor die een goede rol kunnen spelen in gevestigde scenario’s.</p>
<h2 id="h2-De20impact20van20Taprootactiva20op20de20marktomstandigheden161771"><a name="De impact van Taproot-activa op de marktomstandigheden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De impact van Taproot-activa op de marktomstandigheden</h2><p>Het Taproot Asset-protocol, gelanceerd door Lightning Labs, streeft naar een alles-in-één functionaliteit zoals uitgifte en beheer van meerdere activa op het Bitcoin-netwerk. Hoewel er nog steeds veel technische belemmeringen en bugs zijn, is de welvaart van het Bitcoin-ecosysteem tot een einde gekomen.</p>
<p>In de toekomst zullen, wanneer het protocol lightning networks ondersteunt en betalingskanaalfuncties voltooit, ondersteunende projecten zoals gedecentraliseerde portefeuilles en offline consumptie-betalingskanalen opkomen. Tegelijkertijd zullen gebruikers op efficiënte en kosteneffectieve wijze aangepaste tokens kunnen ontvangen, verzenden en beheren via lightning networks, wat zal helpen bij het verder verbeteren van de daadwerkelijke adoptiegraad van Bitcoin.</p>
<p>Het valt te voorzien dat met de lancering en ontwikkeling van Bitcoin-metaprotocollen zoals Taproot Asset, BRC20, Runes en BitVM, het ecosysteem van Bitcoin ook steeds welvarender zal worden, wat tot op zekere hoogte de tekortkomingen van <a href="/how-to-buy/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">waar glmr te kopen</a> dominant ecosysteem en zelfs een nieuwe verhaallijn worden voor de volgende bullmarkt van Bitcoin.<img src="https://gimg2.gateimg.com/image/article/169829063112031698290408_.pic.jpg" alt=""><br>Figuur 3: ORDI/USDT handelsparen op Gate.io</p>
<p>Ten slotte moet worden opgemerkt dat Gate.io als toonaangevend handelsplatform voor crypto-activa in de branche altijd beoefenaars heeft gevolgd die bijdragen aan technologische vooruitgang en productinnovatie in de crypto-industrie. In de Ordinals Summer van dit jaar waren we bijvoorbeeld de eersten die het vlaggenschip-token $ORDI lanceerden, wat leidde tot de “populaire” rage voor Bitcoin-inies. In de toekomst zullen we aandacht blijven besteden aan meer innovatieve ontwikkelingen in het Bitcoin-ecosysteem, waardoor beleggers meer waardewaarnemingen en beleggingsproducten krijgen.</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 mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan mits Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>