VGUgbWlkZGVuIHZhbiBkZSBjaGFvcyB2YW4gdmVyc2NoaWxsZW5kZSBSQy0yMCBwcm90b2NvbGxlbiwgd2FhciBsaWd0IGRlIHRvZWtvbXN0IHZhbiBCaXRjb2luPw==

2023-12-22, 03:13

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR730508"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Het constant gehypete BRC-20 concept op de markt heeft geleid tot het ontstaan van verschillende RC-20-tokenprotocollen als paddenstoelen na regenval;</p>
<p>Op dit moment zijn verschillende RC-20-concepten die op de markt zijn uitgegeven, gebaseerd op het Ordinals-protocol;</p>
<p>De opkomst van verschillende XRC-20 tokens heeft een reeks gevolgen veroorzaakt voor de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk;</p>
<p>De XRC-20 kan een belangrijk onderdeel worden van de toekomstige gedecentraliseerde economie.</p>
<h2 id="h2-Introductie497816"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Met de toenemende populariteit van BRC-20 tokens is ook hun waarde enorm gestegen.</p>
<p>De eerste BRC-20 token ORDI, met een initiële prijs van $0.1, steeg tot een maximum van $68.77 en een marktwaarde van $1.35 miljard. Daarom heeft de formulering van de BRC-20 standaard opnieuw de aandacht getrokken van mensen die tokens vergelijken.</p>
<p>Het voortdurend gehypte BRC-20 concept op de markt heeft geleid tot de opkomst van verschillende RC-20-tokenprotocollen als paddenstoelen na regen.<br><img src="https://gimg2.gateimg.com/image/article/1703214422img_v3_026c_e2d5fa79-7425-40de-ab26-8a17637151ix.jpg" alt=""></p>
<h2 id="h2-X2020RC20134073"><a name="X + RC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>X + RC-20</h2><p>Op dit moment zijn verschillende RC-20 concepten die op de markt zijn uitgebracht gebaseerd op het Ordinals-protocol.</p>
<p>Er zijn ARC20, IERC20 ( <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>), CBRC20, SOL20, DRC20, ASC20, ORC20, LRC20, TRC20, SRC20 (ondersteunt alleen Bitcoin-adressen die beginnen met 1), <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (Ethereum-runes), evenals vele nieuwe RC20-protocollen gebaseerd op Ordinals in de openbare keten, en ze zullen in de toekomst geleidelijk worden toegevoegd, te veel om volledig te tellen.</p>
<p>Er zijn zoveel BRC20-protocollen gebaseerd op ordinaals dat je ze niet allemaal hoeft te begrijpen, noch kun je ze volledig begrijpen. Je hoeft alleen de onderliggende essentie van deze protocollen te begrijpen om een zeker basaal begrip van het gehele systeem te hebben.</p>
<p>Uiteindelijk zijn ze in wezen hetzelfde als de onderliggende BRC20, waarbij tokens, NFT’s, domeinnamen, tickets, postzegels, enz. worden uitgegeven door 1 Cong over te dragen en identificatiegegevens in het overdrachtsopmerkingenvak te schrijven (de kleinste eenheid van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is 1 Satoshi, terwijl andere RC20-protocollen ook tokens uitgeven via de kleinste eenheid van L1-keten tokens), en het identificeren van de identificatiegegevens in elke eenheid via een indexer.</p>
<p>Het verschil tussen hen en BRC20 is dat ze enkele wijzigingen hebben aangebracht op basis van het fundament, zoals het vereenvoudigen van informatie en het verminderen van bytegegevens, de lengte van de token-naamgeving, het verbeteren van de efficiëntie van de indexer en het verhogen van de protocolbeveiliging. Net zoals sommige openbare ketens zijn ontworpen om TPS te verbeteren, zijn sommige ontworpen voor grotere veiligheid en sommige zijn ontworpen om de flexibiliteit van contractcodering te vergroten.</p>
<h2 id="h2-Populaire20RC20protocollen97610"><a name="Populaire RC-20-protocollen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Populaire RC-20-protocollen</h2><h3 id="h3-ORC20454715"><a name="ORC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ORC-20</h3><p><img src="https://gimg2.gateimg.com/image/article/1703214461img_v3_026c_072b5e02-e141-4b71-aaa7-cc3497d960ix.jpg" alt=""><br>ORC-20, net als BRC-20, is een tokennorm die draait op de Bitcoin blockchain. Het is gecodeerd als een JSON (Java Object Representation) bestand en opgenomen op Satoshi als een serienummer. ORC-20 is een geüpgradede versie van de BRC-20 standaard die enkele van zijn tekortkomingen aanpakt.</p>
<p>ORC-20 is gelanceerd door OrcDAO met als doel de functionaliteit van Ordinals-tokens op het Bitcoin-netwerk te verbeteren ten opzichte van de huidige BRC-20. ORC20 heeft de token-naambeperkingen opgeheven en geüpgradede functies toegevoegd voor tokens, waardoor projectpartijen meer empowerment kunnen uitvoeren op basis van tokens. Ondertussen zijn geavanceerde functies zoals het instellen van royalties en het instellen van whitelists toegevoegd.</p>
<p>ORC-20 kan achterwaarts compatibel zijn met BRC-20 en de aanpasbaarheid, schaalbaarheid en veiligheid verbeteren, waarbij de mogelijkheid van dubbele consumptie wordt geëlimineerd. Vanwege de onvolledige ontwikkeling van de infrastructuur van ORC20 en het nog steeds geconcentreerde welvaartseffect op BRC20, ontvangt ORC20 op dit moment echter beperkte aandacht.</p>
<h3 id="h3-SRC20592903"><a name="SRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SRC-20</h3><p><img src="https://gimg2.gateimg.com/image/article/1703214503img_v3_026c_238afcf1-637f-4511-bf2f-a3b999eeb2ix.jpg" alt=""><br>In tegenstelling tot BRC-20 en ORC-20 gebaseerd op Ordinals-theorie, gebruikt SRC-20 Bitcoin-stempels om tekst in te schrijven. Bitcoin-stempels zijn vergelijkbaar met ERC-1155 semi-homogene tokens of digitale verzamelobjecten, die rechtstreeks worden opgeslagen op de UTXO van Bitcoin - een record van Bitcoin dat niet wordt gebruikt bij handel tussen twee adressen, in plaats van te worden opgeslagen in getuigenisgegevens zoals Ordinals.</p>
<p>Er is momenteel echter geen markt die SRC20 ondersteunt, dus de enige handelsmethode is via over-the-counter-handel, en SRC20 heeft nog steeds aanzienlijke ondersteuning nodig. Daarom trok het project voornamelijk particuliere beleggers aan die de kans op de BRC-20 Ordi-token hebben gemist. Vanwege de beperkte instroom van heet geld is nog steeds voorzichtigheid geboden bij het observeren.</p>
<p>Hoewel Binance een onderzoek heeft uitgevoerd naar SRC-20, heeft het geen substantiële financiële maatregelen genomen zoals OKX deed met BRC-20, en de markt neigt nog steeds naar BRC-20.</p>
<h3 id="h3-ARC20851436"><a name="ARC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARC-20</h3><p><img src="https://gimg2.gateimg.com/image/article/1703214627img_v3_026c_6fdc3c38-3544-4b83-9c28-e270effc2fix.jpg" alt=""><br>Het Atomicals-protocol is een protocol dat is gebouwd op het Bitcoin-netwerk. Op het Bitcoin-netwerk kunnen digitale items (NFT’s, zoals inheemse digitale NFT’s, spel-NFT’s, digitale identiteiten, domeinnamen, sociale netwerken, etc.) worden gecreëerd, overgedragen en geüpgraded, evenals inwisselbare tokens, via het Atomicals-protocol.</p>
<p>Dat wil zeggen, via het Atomicalas-protocol kunnen niet-uitwisselbare NFT’s en uitwisselbare tokens worden gegenereerd in het Bitcoin-netwerk. Dit uitwisselbare token is de ARC20-token.</p>
<p>Het Atomicals-protocol maakt volledig gebruik van de kenmerken van Bitcoin UTXO, waarbij Satoshi als de rekeneenheid wordt gebruikt, wat betekent dat elk digitaal item dat is gemaakt op basis van het Atomicals-protocol zijn transactiegeschiedenis kan traceren en authenticiteit en controleerbaarheid kan bereiken. Gebruikers, portefeuilles, projectpartijen en elke andere individuele of institutionele partij kunnen transactiegeschiedenis verifiëren en authenticiteit detecteren via eenvoudige regels.</p>
<p>IERC-20 is een op Ethereum gebaseerd Inion Token Protocol dat verantwoordelijk is voor het standaardiseren van Inion Tokens. Het kan een goedkoop token-ecosysteem bieden voor Ethereum-gebruikers zonder de bestaande infrastructuur aan te tasten, waardoor iedereen tokens kan implementeren, minten en verhandelen op de IERC-20. EthinscXYZ heeft de eerlijke Mining-modus van PoW geïntroduceerd in het IERC-20-protocol en werkt actief samen met andere projecten om inies te lanceren.</p>
<h3 id="h3-IERC20433155"><a name="IERC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IERC-20</h3><p><img src="https://gimg2.gateimg.com/image/article/1703214665img_v3_026c_5b16ac5d-e0e2-476a-a511-48db08f777ix.jpg" alt=""><br>IERC-20 is een op Ethereum gebaseerd Inion Token Protocol dat verantwoordelijk is voor het standaardiseren van Inion Tokens. Het kan een kosteneffectief token-ecosysteem bieden voor Ethereum-gebruikers zonder de bestaande infrastructuur te beïnvloeden, waardoor iedereen tokens kan implementeren, maken en verhandelen op de IERC-20. EthinscXYZ heeft de eerlijke Mining-modus van PoW geïntroduceerd in het IERC-20-protocol en werkt actief samen met andere projecten om inies te lanceren.</p>
<p>De eerste token in het IERC20-ecosysteem is Ethi, ook bekend als de vlaggenschipmunt van IERC20. Maar het is al geslagen.</p>
<p>De uniciteit van IERC20 ligt niet alleen in de ontwikkeling van Swap, maar ook in de integratie van EVM cross-chain functionaliteit, het bouwen van een kanaal tussen Ethereum inies en traditionele Layer2, het introduceren van meer gangbare en stabiele munten, het vergroten van de TVL van het inies ecosysteem en het bieden van meer mogelijkheden voor het gehele systeem.</p>
<p>Bovendien is het projectteam van plan om het eerlijke mijnmodel van PoW in het IERC20-protocol te introduceren en actief samen te werken met andere projecten om inies te lanceren, vergelijkbaar met de mijnmethode van het Atom-protocol, wat in zekere mate leidt tot het nieuwe model van het Ethereum-ecosysteem Launchpad.</p>
<h2 id="h2-Wat20zal20de20toekomst20van20Bitcoin20zijn869919"><a name="Wat zal de toekomst van Bitcoin zijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zal de toekomst van Bitcoin zijn</h2><p><img src="https://gimg2.gateimg.com/image/article/1703214710img_v3_026c_a8a1c913-fb8b-4925-a1d9-dabd685a74ix.jpg" alt=""><br>De opkomst van verschillende XRC-20 tokens heeft een reeks impacten veroorzaakt op het Bitcoin-netwerk. Voornamelijk tot uiting komend in drie aspecten:</p>
<p>Ten eerste leidt dit tot congestie in het Bitcoin-netwerk, omdat de transactiegegevens van deze tokens op alle Bitcoin-blokken moeten worden opgeslagen, wat de transactiebelasting verhoogt.</p>
<p>Ten tweede heeft de XRC-20 token de reputatie van Bitcoin geschaad, waardoor het heeft moeten reageren op negatief nieuws dat niets te maken heeft met het XRC-20 project.</p>
<p>Tenslotte ontbreekt het XRC-20-token aan praktisch gebruik en compatibiliteit met slimme contracten in vergelijking met andere tokenstandaarden, waardoor hun praktische toepassing beperkt is.</p>
<p>Hoewel XRC-20 tokens in korte tijd een snelle groei hebben doorgemaakt, is het momenteel onduidelijk of ze slechts een trend zijn of een echte game changer.</p>
<p>En hoewel de XRC-20 voor veel uitdagingen staat, kan zijn groeiend verkeer en de aandacht die het trekt meer investeerders aantrekken die zich nog niet eerder in het cryptoveld hebben gewaagd om zich bij de Bitcoin-gemeenschap aan te sluiten. Dit zal ook een positieve invloed hebben op de toekomst van Bitcoin.</p>
<h2 id="h2-Conclusie247415"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De XRC-20-tokenstandaard heeft de noodzakelijke kenmerken om opkomende ecoen te bevorderen, en in de toekomst kan het deze experimentele tokens in staat stellen om te interageren met andere blockchainen en digitale activa, waardoor ze onderpand kunnen bieden voor DeFi-platforms of ze integreren in dApps.</p>
<p>Tegenwoordig verkent XRC-20 de mogelijkheid in het opkomende gebied van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en kan ook een belangrijk onderdeel worden van de toekomstige gedecentraliseerde economie. Gate.io zal de ontwikkeling van de XRC-20 token de komende maanden nauwlettend blijven volgen.</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 mening van de onderzoeker en vormt geen investeringssuggesties.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>