SGV0IHBvdGVudGllZWwgdmFuIEJpdGNvaW4ncyBCUkMtMjAtdG9rZW5zIG9udHJhZmVsZW4=

2023-05-12, 01:14

<p><img src="https://gimg2.gateimg.com/blog/1679447253722320711jiami.jpeg" alt=""><br>De komst van blockchain-technologie heeft een tijdperk van innovatie ingeluid, waarin een volledig ecosysteem van digitale activa is ontstaan, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> aan het roer. Als de eerste en meest bekende cryptocurrency, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft de toon gezet voor deze technologische revolutie. Nu, in een nieuwe en spannende ontwikkeling, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> heeft een nieuwe functie: de BRC-20 tokens. De BRC-20 token is een technische standaard die wordt gebruikt voor smart contracts op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Als een vergelijkbaar concept met <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ERC-20 tokens, BRC-20 tokens vertegenwoordigen een belangrijke stap voorwaarts in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> evolueert, diversifieert zijn gebruiksmogelijkheden en vergroot zijn functionaliteit.</p>
<h2 id="h2-BRC2020Token20Standaard2020De20Oorsprong382064"><a name="BRC-20 Token Standaard - De Oorsprong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BRC-20 Token Standaard - De Oorsprong</h2><p>Een pseudonieme programmeur genaamd Domo creëerde de BRC-20 tokenstandaarden in maart 2023. Deze creatie werd grotendeels gestimuleerd door de lancering van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het Ordinals-protocol wordt gelanceerd in januari 2023, waardoor het voor het eerst mogelijk wordt om niet-fungibele tokens (NFT’s) te maken op het platform. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Het doel van Domo was om deze mogelijkheid uit te breiden van niet-vervangbare naar vervangbare tokens. Daarom werd de BRC-20-tokenstandaard bedacht, waardoor het mogelijk werd om rechtstreeks op de blockchain vervangbare tokens te maken en te slaan. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk.</p>
<p>De <a href="https://www.gate.io/trade/ORDI_USDT" target="_blank">De eerste BRC-20 token die werd ingezet was ‘ORDI’.</a> het opzetten van het podium voor andere tokens om te volgen. In de volgende maanden werden veel BRC-20 tokens gelanceerd, waaronder verschillende meme tokens, die elk bijdroegen aan de exponentiële groei van dit opkomende ecosysteem. Op het moment van schrijven hebben sommige BRC-20 tokens een aanzienlijke stijging van hun prijs meegemaakt, waarbij ze aanzienlijke marktkapitalisaties hebben verkregen.</p>
<h2 id="h2-Hoe20werken20BRC20tokens850373"><a name="Hoe werken BRC-20-tokens?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werken BRC-20-tokens?</h2><p>BRC-20 tokens werken met behulp van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het Ordinals-protocol, een uniek systeem dat het nummeren van individuele satoshi’s mogelijk maakt en extra gegevens aan hen kan koppelen via een proces genaamd ‘inie’.</p>
<p>Om BRC-20 tokens te maken, te slaan en over te dragen, schrijven ontwikkelaars JSON (Java Object Notation) data op het <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. De BRC-20-tokenstandaard omvat specifieke functies voor deze operaties: de ‘implementeren’ functie om een nieuwe BRC-20-token te maken, de ‘munt’ functie om een gespecificeerde hoeveelheid van de nieuw gecreëerde token te genereren, en de ‘overdracht’ functie om deze tokens tussen adressen te verplaatsen.</p>
<p>Hoewel deze technologie een enorm potentieel heeft, is het belangrijk op te merken dat deze nog in de kinderschoenen staat. Het proces van het inzetten, minten en overdragen van BRC-20 tokens is nog niet gebruiksvriendelijk en de ondersteunende infrastructuur is beperkt. Naarmate het BRC-20-ecosysteem zich blijft ontwikkelen, wordt echter verwacht dat deze processen meer gestroomlijnd en toegankelijk zullen worden.</p>
<h2 id="h2-Voordelen20van20BRC20tokens545262"><a name="Voordelen van BRC-20-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voordelen van BRC-20-tokens</h2><p><strong>Veiligheid</strong> Een van de belangrijkste voordelen van BRC-20 tokens is hun inherente veiligheid. Omdat deze tokens bestaan op het <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain, ze profiteren van de robuuste beveiliging die het biedt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> protocol biedt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het Proof of Work (PoW) consensusmechanisme van ‘s en het uitgebreide netwerk van miners maken het een van de meest veilige blockchains.</p>
<p><strong>Compatibiliteit</strong>: BRC-20 tokens zijn van nature compatibel met de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain, die naadloze integratie mogelijk maakt in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem. Deze compatibiliteit maakt het mogelijk voor bestaande <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ontwikkelaars om BRC-20 tokens gemakkelijk in hun projecten te bouwen en op te nemen.</p>
<p><strong>Fungibiliteit</strong>: BRC-20 tokens zijn fungibel, wat betekent dat elke token uitwisselbaar is met elke andere identieke token. Deze eigenschap maakt ze gemakkelijk verhandelbaar op verschillende platforms en biedt een eenvoudig en toegankelijk alternatief voor nieuwkomers in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> handel.</p>
<h2 id="h2-Nadelen20van20BRC2020Tokens143246"><a name="Nadelen van BRC-20 Tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nadelen van BRC-20 Tokens</h2><p>Hoewel BRC-20 tokens veel voordelen met zich meebrengen, is het ook essentieel om enkele mogelijke uitdagingen te overwegen.</p>
<p><strong>Beperkt ecosysteem</strong>: De BRC-20-tokenstandaard is relatief nieuw, wat betekent dat zijn ecosysteem kleiner is dan de goed gevestigde ERC-20-standaard op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Dit leidt tot minder middelen, ontwikkelaars en tools die beschikbaar zijn voor het bouwen en beheren van BRC-20 tokens.</p>
<p><strong>Potentiële hoge transactiekosten</strong>: De snelle groei van BRC-20 token activiteit heeft geleid tot een verhoging van transactiekosten op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Naarmate meer gebruikers betrokken raken bij BRC-20 tokens, kan dit mogelijk leiden tot hogere transactiekosten, wat de toegankelijkheid en betaalbaarheid van het gebruik van deze tokens kan beïnvloeden.</p>
<h2 id="h2-De20implicaties20van20BRC20tokens856885"><a name="De implicaties van BRC-20-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De implicaties van BRC-20-tokens</h2><p>De introductie van BRC-20 tokens heeft brede implicaties voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en de bredere cryptogeldindustrie. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft lang de positie van de toonaangevende cryptocurrency ingenomen, maar het ontbreken van een slimme contractlaag is een beperkende factor geweest in de concurrentie met <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en andere slimme contractplatforms. De introductie van BRC-20-tokens zou kunnen helpen om het speelveld gelijk te trekken, waardoor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> om rechtstreeks te concurreren op gebieden die overwegend zijn geweest <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> domein.</p>
<p>Bijvoorbeeld, gedecentraliseerde financiën, of DeFi, is een van de opvallende trends geweest in de blockchain ruimte in de afgelopen jaren. Echter, tot nu toe heeft de meeste DeFi-activiteit plaatsgevonden op het <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain vanwege de mogelijkheden voor slimme contracten. Met de introductie van BRC-20 tokens kunnen nu ook DeFi projecten gebouwd worden op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Deze ontwikkeling heeft het potentieel om de DeFi-landschap aanzienlijk te beïnvloeden. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De robuuste beveiliging en bredere acceptatie zouden meer gebruikers en ontwikkelaars kunnen aantrekken tot zijn DeFi-projecten. Bovendien zou het kunnen helpen om enige congestie en hoge gasvergoedingen te verlichten die worden ervaren op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk.<br><img src="https://gimg2.gateimg.com/image/article/16838539441.jpeg" alt=""><br>De introductie van BRC-20 tokens speelt ook een rol in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> schaalvergroting inspanningen. Zoals de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het netwerk worstelt met schaalbaarheidsproblemen, alternatieve oplossingen zoals het Lightning Network zijn ontstaan. De introductie van BRC-20 tokens voegt een andere dimensie toe aan deze inspanningen, waardoor meer mogelijkheden ontstaan voor transacties buiten het hoofdnetwerk om. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain, het verlichten van netwerkcongestie. Daarom kan het een aanzienlijke impact hebben. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De marktpositie van Gate.io kan mogelijk worden verbeterd, wat de waarde en het aantal gebruikers kan vergroten.</p>
<h2 id="h2-Marktreactie20op20BRC20tokens957247"><a name="Marktreactie op BRC-20-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktreactie op BRC-20-tokens</h2><p>Onlangs heeft de totale marktkapitalisatie van BRC-20 tokens de grens van $1 miljard overschreden en in de afgelopen 24 uur hebben deze tokens een totaal handelsvolume van $206,2 miljoen gehad. Enkele van de meest opmerkelijke BRC-20 tokens zijn onder andere ORDI, VMPX, MEME, BANKBRC, PEPEBRC en NALS, die momenteel actief zijn op populaire cryptocurrency-beurzen zoals <a href="https://www.gate.io/" target="_blank">Gate.io</a>. Sterker nog, Gate.io is het eerste BRC-20-handelsplatform op het web dat zes BRC-20-tokens noteert. En er is een prijsvariatie van tussen +197% en -56% in de afgelopen 24 uur.<br><img src="https://gimg2.gateimg.com/image/article/16838539692.png" alt=""><br>Bovendien bereiden walletproviders zich ook voor op integratie, zodat gebruikers naadloos BRC-20 tokens kunnen opslaan en ermee kunnen handelen. BitKeep heeft bijvoorbeeld gezegd dat het zowel de Ordinals als de BRC-20 protocollen zal ondersteunen op zijn mobiele en plugin-extensieplatforms. Dit omvat het introduceren van een nieuwe. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT-sectie in de BitKeep NFT-marktplaats, die het tonen, minten, overdragen en verhandelen van BTC NFT’s op basis van het Ordinals-protocol mogelijk zal maken.</p>
<p>Terwijl <a href="/price/trust-wallet-twt" rel="nofollow noopener noreferrer" target="_blank">Trust Wallet</a> heeft nog geen ondersteuning geïntegreerd voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Ordinalen, andere belangrijke portemonneeproviders hebben stappen ondernomen in deze richting. MetaMask, een populaire <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> portemonnee, voegde in februari een functie toe om Ordinals op te slaan, en Ledger, een bekende hardware portemonnee provider, ondersteunt ook het Ordinals protocol.</p>
<h2 id="h2-Conclusie47655"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De introductie van BRC-20 tokens is een kantelpunt voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en de bredere cryptocurrency markt. Door smart contract functionaliteit naar de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Op het netwerk hebben BRC-20 tokens het potentieel om de cryptowereld te revolutioneren, waardoor er een nieuwe wereld van mogelijkheden wordt geopend voor zowel ontwikkelaars als gebruikers. Hoewel het nog vroeg is voor BRC-20 tokens, is de eerste reactie van de markt overweldigend positief geweest en ziet de toekomst er veelbelovend uit.</p>
<p>Naarmate het ecosysteem zich blijft ontwikkelen, kunnen we verwachten dat er een groot aantal innovatieve toepassingen en projecten zullen ontstaan die gebruikmaken van deze spannende nieuwe technologie. Verandering is de enige constante in de wereld van cryptocurrencies, en de opkomst van BRC-20 tokens is daarvan een bewijs. Terwijl we blijven verkennen wat de potentie van blockchaintechnologie is, vertegenwoordigt de introductie van BRC-20 tokens een significante stap voorwaarts, waardoor we dichter bij een toekomst komen waar digitale activa een nog integralere rol spelen in ons leven.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Andrei Dr.</strong>, Onderzoeker bij Gate.io<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 voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen er juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>