SW4gZGUgY2hhb3MgdmFuIHZlcnNjaGlsbGVuZGUgUkMtMjAgcHJvdG9jb2xsZW4sIHdhYXIgaXMgZGUgdG9la29tc3QgdmFuIEJpdGNvaW4gKEJUQyk/

2023-12-22, 03:13

<p><img src="https://gimg2.gateimg.com/image/b16955a5-527d-4c86-ae1d-88dec47ecc25202506181721458302863811.png" alt="">
</p><h2 id="h2-202520Laatste20Update242737"><a name="2025 Laatste Update" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2025 Laatste Update</h2><p>Tegen 2025 is het RC-20-veld aanzienlijk ontwikkeld, met RoboCalls (RC20) als een belangrijke speler in het token-ecosysteem. Marktgegevens tonen aan dat, naast gevestigde cryptocurrencies, het RC-20-protocol ook veel aandacht heeft gekregen.</p>
<p>Populaire cryptocurrencies die momenteel aanzienlijke groei vertonen zijn:</p>
<table>
<thead>
<tr>
<th>cryptocurrency</th>
<th>groei percentage</th>
</tr>
</thead>
<tbody>
<tr>
<td>Axelar</td>
<td>58,15%</td>
</tr>
<tr>
<td><a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a></td>
<td>18,72%</td>
</tr>
<tr>
<td>Ethereum (ETH)</td>
<td>8,21%</td>
</tr>
<tr>
<td>Bitcoin (BTC)</td>
<td>1,89%</td>
</tr>
<tr>
<td><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a></td>
<td>1,77%</td>
</tr>
</tbody>
</table>
<p>RoboCalls heeft een groeiende gemeenschap en heeft toegewijde ondersteuningskanalen. De token wint aan populariteit onder handelaren die geleidelijk diversifiëren van traditionele BRC-20 investeringen.</p>
<p>Analyse van meerdere platforms toont aan dat RC20-tokens nu worden geïntegreerd in mainstream cryptocurrency-portefeuilles naast gevestigde activa zoals BTC, ETH en SOL, wat aangeeft dat de markt is volwassen geworden sinds de aanvankelijke RC-20-boom.</p>
<p>Gate (Gate) blijft deze ontwikkelingen volgen en besteedt speciale aandacht aan het integratiepotentieel van RoboCalls in gedecentraliseerde applicaties, aangezien het XRC-20-ecosysteem zijn nut uitbreidt buiten speculatie.</p>
<h2 id="h2-Een20verscheidenheid20aan20RC20protocollen20door20elkaar20waar20is20de20toekomst20van20Bitcoin240702"><a name="Een verscheidenheid aan RC-20-protocollen door elkaar, waar is de toekomst van Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een verscheidenheid aan RC-20-protocollen door elkaar, waar is de toekomst van Bitcoin?</h2><h2 id="h2-TLDR641909"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Het BRC-20-concept, dat voortdurend door de markt wordt gepromoot, heeft geleid tot een proliferatie van verschillende RC-20-tokenprotocollen die als paddenstoelen uit de grond schieten na de regen;</p>
<p>Momenteel zijn verschillende RC-20-concepten die op de markt zijn uitgegeven allemaal gebaseerd op het Ordinals-protocol.</p>
<p>De opkomst van verschillende tokens op basis van XRC-20 heeft een reeks gevolgen voor het Bitcoin-netwerk veroorzaakt;</p>
<p>XRC-20 kan een belangrijk onderdeel worden van de toekomstige gedecentraliseerde economie.</p>
<h2 id="h2-Inleiding688630"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Met de toenemende populariteit van BRC-20-tokens stijgt ook de waarde van tokens.</p>
<p>De eerste BRC-20 token ORDI had een initiële prijs van $0,1, bereikte een piek van $68,77 en kwam tot een maximale marktkapitalisatie van $1,35 miljard. Als gevolg hiervan heeft de oprichting van de BRC-20 standaard de interesse in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> opnieuw aangewakkerd.</p>
<p>De voortdurende hype rond het BRC-20-concept op de markt heeft geleid tot de opkomst van verschillende RC-20-tokenprotocollen die als paddenstoelen uit de grond schieten.</p>
<h2 id="h2-X2020RC20756628"><a name="X + RC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>X + RC-20</h2><p>Momenteel zijn verschillende RC-20-concepten die op de markt zijn uitgegeven gebaseerd op het Ordinals-protocol.</p>
<p>Er zijn ARC20,<br>IERC20 (Ethereum), CBRC20, SOL20, DRC20, ASC20, ORC20, LRC20, TRC20, SRC20 (ondersteunt alleen Bitcoin-adressen die beginnen met 1), Ethrunes (Ethereum runes) en veel andere nieuwe RC20-protocollen op basis van Ordinals van verschillende publieke ketens, en er zullen voortdurend meer worden toegevoegd, te veel om volledig te tellen.
</p><p>Met zoveel BRC20-protocollen gebaseerd op Ordinals, is het niet nodig om ze allemaal te begrijpen of elk afzonderlijk volledig te doorgronden. Het is voldoende om de onderliggende essentie van deze protocollen te begrijpen om een fundamenteel begrip van het geheel te hebben.</p>
<p>Uiteindelijk zijn ze fundamenteel hetzelfde als de BRC20, die ook tokens, NFT’s, domeinnamen, tickets, postzegels, enz. uitgeeft door 1 Satoshi over te dragen en identificatie-informatie in de overdrachtnotities te schrijven (de kleinste eenheid van Bitcoin is 1 Satoshi; andere RC20-protocollen geven ook tokens uit met behulp van de kleinste eenheid van L1-ketentokens), en de identifier-informatie in elke eenheid wordt erkend door een indexer.</p>
<p>Het verschil tussen hen en BRC20 is dat er enkele aanpassingen zijn gedaan op basis van de fundamenten, zoals het vereenvoudigen van informatie en het verminderen van byte-data, variërende lengtes van token-namen, het verbeteren van de efficiëntie van indexers en het vergroten van de beveiliging van het protocol, enzovoort. Net zoals sommige publieke ketens de TPS verbeteren, geven sommige prioriteit aan beveiliging en anderen proberen de flexibiliteit van contractcodering te vergroten, enzovoort.</p>
<h2 id="h2-Populaire20RC2020protocol531529"><a name="Populaire RC-20 protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Populaire RC-20 protocol</h2><h3 id="h3-ORC20353820"><a name="ORC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ORC-20</h3><p>ORC-20, net als BRC-20, is een tokenstandaard die draait op de Bitcoin-blockchain. Het is gecodeerd als een JSON (JavaScript Object Notation) bestand en geregistreerd met een serienummer op Satoshi.<br>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 en de huidige BRC-20 te verbeteren. ORC20 verwijdert de naamgevingsbeperkingen op tokens en voegt upgradebare functies toe, waardoor projectpartijen meer mogelijkheden kunnen inschakelen op basis van de tokens. Daarnaast introduceert het geavanceerde functies zoals het instellen van royalty’s en het creëren van whitelists.</p>
<p>ORC-20 is achterwaarts compatibel met BRC-20 en verbetert de aanpasbaarheid, schaalbaarheid en veiligheid, waardoor de mogelijkheid van dubbele uitgaven wordt geëlimineerd. Echter, vanwege de onderontwikkelde infrastructuur van ORC20 en het vermogenseffect dat nog steeds geconcentreerd is op BRC20, krijgt ORC20 momenteel zeer beperkte aandacht.</p>
<h3 id="h3-SRC20290140"><a name="SRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SRC-20</h3><p>In tegenstelling tot BRC-20 en ORC-20, die zijn gebaseerd op de Ordinals-theorie, neemt SRC-20 aan <a href="/zh/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a><br>Stempels worden gebruikt om tekst in te graveren. Bitcoin Stempels zijn vergelijkbaar met ERC-1155 semi-fungible tokens of digitale verzamelobjecten, en ze worden direct opgeslagen op de Bitcoin UTXO - het record van ongebruikte Bitcoins tijdens een transactie tussen twee adressen, in plaats van opgeslagen te worden in getuigengegevens zoals Ordinals.
</p><p>Echter, aangezien er momenteel geen markt is die SRC20 ondersteunt, is de enige handelsmethode via over-the-counter trading, en SRC-20 vereist nog steeds aanzienlijke ondersteuning. Daarom trekt dit project voornamelijk particuliere investeerders aan die de kans op de BRC-20 Ordi-tokens hebben gemist. Vanwege de beperkte instroom van speculatief kapitaal is het nog steeds nodig om voorzichtig te observeren.</p>
<p>Hoewel Binance een onderzoek heeft uitgevoerd naar SRC-20, heeft het geen substantiële financiële maatregelen genomen zoals OKX deed voor BRC-20, en de markt leunt momenteel nog steeds naar BRC-20.</p>
<h3 id="h3-ARC20567063"><a name="ARC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARC-20</h3><p>Het Atomicals-protocol is gebouwd op het Bitcoin-netwerk. Via het Atomicals-protocol op het Bitcoin-netwerk is het mogelijk om digitale items (NFT’s, zoals native digitale NFT’s, game NFT’s, digitale identiteiten, domeinnamen, sociale netwerken, enz.) te creëren (minten), over te dragen en te upgraden, evenals om verhandelbare tokens te creëren.</p>
<p>Dit betekent dat via het Atomicalas-protocol niet-fungibele NFT’s kunnen worden gegenereerd op het Bitcoin-netwerk, en dat ook fungibele tokens kunnen worden gemaakt. Deze fungibele token is de ARC20-token.</p>
<p>Het Atomicals-protocol benut volledig de kenmerken van Bitcoin UTXO, waarbij satoshi als rekeneenheid wordt gebruikt. Dit betekent dat elk digitaal item dat is gemaakt op basis van het Atomicals-protocol zijn transactiegeschiedenis kan traceren, waardoor het echt verifieerbaar is. Gebruikers, portemonnees, projectpartijen en elke individu of instelling kunnen de transactiegeschiedenis verifiëren via eenvoudige regels om te bepalen of deze authentiek en betrouwbaar is.</p>
<p>Het Atomicals-protocol is relatief compatibel met de kenmerken van BTC, en de implementatiemethode is relatief eenvoudig, wat de aandacht van mensen heeft getrokken en in de techgemeenschap in de smaak is gevallen. Kortom, het technische pad is relatief eenvoudig en sluit goed aan bij de kenmerken en de huidige situatie van Bitcoin.</p>
<h3 id="h3-IERC20305560"><a name="IERC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IERC-20</h3><p>IERC-20 is een tokenprotocol gebaseerd op Ethereum, verantwoordelijk voor het standaardiseren van inscriptietokens. Het biedt een kosteneffectief tokenecosysteem voor Ethereum-gebruikers zonder de bestaande infrastructuur te beïnvloeden, waardoor iedereen tokens kan implementeren, minten en verhandelen op IERC-20. EthinscXYZ introduceert een eerlijk miningmodel van PoW in het IERC-20-protocol en werkt actief samen met andere projecten om inscripties te lanceren.</p>
<p>De eerste token in het IERC20-ecosysteem is Ethi, dat ook bekendstaat als de leidende munt van IERC20. Het is echter al volledig gemint.</p>
<p>De uniekheid van iERC20 ligt niet alleen in de ontwikkeling van Swap, maar ook in de integratie van EVM cross-chain functionaliteit, waardoor een brug wordt gebouwd tussen Ethereum-inscripties en traditionele Layer2. Het introduceert meer mainstream munten en stablecoins, waardoor de TVL van het inscriptie-ecosysteem wordt uitgebreid en grotere mogelijkheden voor het hele systeem worden geboden.</p>
<p>Bovendien is het projectteam van plan om een eerlijk miningmodel van PoW in het IERC20-protocol te introduceren en actief samen te werken met andere projecten om inscripties te lanceren. Vergelijkbaar met de miningmethode van het Atom-protocol heeft dit in zekere mate geleid tot een nieuw model voor de Ethereum-ecosysteem Launchpad.</p>
<h2 id="h2-Wat20zal20de20toekomst20van20Bitcoin20zijn95072"><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>De opkomst van verschillende soorten XRC-20-tokens heeft een reeks gevolgen teweeggebracht voor het Bitcoin-netwerk.</p>
<p>Hoofdzakelijk gemanifesteerd in drie aspecten:</p>
<p>Ten eerste leidt het tot congestie in het Bitcoin-netwerk omdat de transactiegegevens van deze tokens op alle Bitcoin-blokken moeten worden opgeslagen, wat de transactielast verhoogt;</p>
<p>Ten tweede hebben XRC-20-tokens de reputatie van Bitcoin geschaad, waardoor Bitcoin gedwongen werd om om te gaan met negatieve nieuwsberichten die niet gerelateerd zijn aan XRC-20-projecten.</p>
<p>Uiteindelijk hebben XRC-20-tokens geen praktische toepassing, en in vergelijking met andere tokenstandaarden hebben ze geen compatibiliteit met smart contracts, wat hun praktische toepassingen beperkt.</p>
<p>Hoewel XRC-20-tokens in een korte periode een snelle groei hebben doorgemaakt, is het nog onduidelijk of ze slechts een voorbijgaande trend zijn of echte game changers.</p>
<p>Hoewel XRC-20 talrijke uitdagingen tegenkomt, kan de toename in verkeer en aandacht die het met zich meebrengt meer investeerders aantrekken die eerder niet in de cryptocurrency-ruimte zijn gestapt om zich bij de Bitcoin-gemeenschap aan te sluiten. Dit kan ook een positieve impact hebben op de toekomst van Bitcoin.</p>
<h2 id="h2-Conclusie261147"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De XRC-20 tokenstandaard beschikt over de nodige kenmerken om opkomende ecosystemen te bevorderen, en in de toekomst kan het deze experimentele tokens in staat stellen om te interopereren met andere blockchain-systemen en digitale activa, waardoor onderpand wordt geboden voor DeFi-platforms of geïntegreerd kan worden in dApps.</p>
<p>Vandaag verkent XRC-20 een mogelijkheid in het opkomende veld van Web3, en het kan in de toekomst een belangrijke component worden van de gedecentraliseerde economie. Gate zal de ontwikkeling van XRC-20-tokens in de komende maanden nauwlettend volgen.</p>
<div class="blog-details-info"><br>  <div>Auteur: Blog Team<br>  <div class="info-tips"><em>Deze inhoud vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br>  <div></div>Houd er rekening mee dat Gate alle of een deel van de diensten kan beperken of verbieden vanuit beperkte gebieden. Lees de gebruikersovereenkomst voor meer informatie, link:<a href="https://www.gate.io/zh/user-agreement。" data-index="4"></a><a href="https://www.gate.io/en/user-agreement" data-index="5">https://www.gate.io/nl/gebruikersovereenkomst</a>.<br><p></p><br></em></div></div></div>