SG9lIG9yZGluYWFscyBCaXRjb2luIGhlZWZ0IGdldHJhbnNmb3JtZWVyZCB2b29yYmlqIGRlIHdpbmtlbHdhYXJkZQ==

2023-08-29, 09:31

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""><br>Ordinals hebben veel nut gecreëerd op de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blockchain.</p>
<p>Bitcoin gebruikers kunnen nu activa met waarde op de blockchain vastleggen.</p>
<p>Het ontbreken van interoperabiliteit op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain vertraagt de adoptie van BTC ordinals.</p>
<p>Trefwoorden: Bitcoin NFT’s, BTC-ordes, Bitcoin-ordes, op Bitcoin gebaseerde NFT’s, Ordinals Bitcoin</p>
<h2 id="h2-Introductie602923"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Sinds de oprichting in 2009 wordt Bitcoin beschouwd als een van de beste waardeopslagplaatsen die op de blockchain bestaan. Het feit dat de bitcoin blockchain robuust en onhackbaar is, maakt het tot een favoriet beleggingsactief voor cryptoinvesteerders. Echter, gedurende een lange periode zijn sommige blockchains zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> had andere toepassingen zoals het registreren van waardevolle activa in de vorm van niet-vervangbare tokens die het Bitcoin-netwerk niet kon.</p>
<p>Dingen veranderden in december 2022 toen Bitcoin-ontwikkelaar Casey Rodarmor de ORD-software uitbracht die het paradigma van Bitcoin veranderde. Mensen kunnen nu Ordinals maken op de Bitcoin blockchain. Deze analyse bekijkt hoe BTC-ordinals andere gebruiksmogelijkheden hebben gecreëerd voor de bitcoin blockchain, naast het gebruik van de munten als waardeopslag.</p>
<h2 id="h2-Ordinals20hebben20het20nut20van20de20Bitcoin20Blockchain20getransformeerd99351"><a name="Ordinals hebben het nut van de Bitcoin Blockchain getransformeerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ordinals hebben het nut van de Bitcoin Blockchain getransformeerd</h2><p>Sinds 2009, toen de eerste bitcointransactie werd uitgevoerd, werd BTC altijd beschouwd als een opslag van waarde, een hedge tegen inflatie en een peer-to-peer betalingssysteem. Er waren geen andere verhalen over bitcointechnologie dan deze.</p>
<p>Zoals eerder uiteengezet, hebben BTC-ordinals de essentie van de Bitcoin-blockchain veranderd, omdat mensen unieke Satoshis kunnen creëren. Meer specifiek is Bitcoin niet langer een technologie die alleen peer-to-peer-transacties ondersteunt, omdat mensen BTC nu kunnen gebruiken voor andere doeleinden, zoals het registreren van de waarde van activa. Door deze transformatie heeft Bitcoin een grote community die de technologie en functionaliteiten ondersteunt.</p>
<p>De op bitcoin gebaseerde NFT’s hebben ook de activiteit op de blockchain verhoogd. Als gevolg van Ordinals heeft de netwerkactiviteit een twee jaar hoogtepunt bereikt, aangezien er al meer dan 23,4 miljoen Bitcoin NFT’s op de blockchain zijn gemunt. Momenteel worden de ordinals voornamelijk gebruikt als non-fungible tokens en memecoins die voldoen aan de BRC-20 tokenstandaard.</p>
<h2 id="h2-Wat20zijn20Bitcoinordinals264065"><a name="Wat zijn Bitcoin-ordinals?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Bitcoin-ordinals?</h2><p>Laten we ons even richten op <a href="https://www.gate.io/learn/articles/what-you-need-to-know-about-ordinals-and-brc20/507" target="_blank">welke BTC getallen zijn</a>. Bitcoin-ordinalen zijn programmeerbare slimme contracten die worden gemaakt door informatie aan individuele Satoshi’s te koppelen. Trouwens, een Satoshi is de kleinste eenheid van bitcoin die gelijk is aan 0,00000001 BTC.</p>
<p>De ordinals bestaan volledig on-chain en hebben vergelijkbare beveiliging als bitcoins. Ordinal makers uploaden inhoud zoals audio, video’s of afbeeldingen op Satoshis. Wanneer een individuele maker inhoud koppelt aan een Satoshi, geeft het Bitcoin Ordinals-protocol het een serienummer en volgt het wanneer de maker of eigenaar het overdraagt. Het proces van het toevoegen van extra gegevens aan Satoshis wordt inie genoemd.</p>
<p>Interessant genoeg heeft elke BTC Ordinal op elk moment slechts één eigenaar vanwege zijn niet-vervangbare aard. Het is deze expliciete eigendom die hen veel waarde en aantrekkingskracht geeft in de digitale wereld.</p>
<p>Ordinals vertrouwen niet op oplossingen van laag 2, maar maken gebruik van baanbrekende Bitcoin-netwerkontwikkelingen, waaronder Taproot en SegWit.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/2607/unpacking-the-potential-of-bitcoin-s-brc-20-tokens" target="_blank">Het potentieel ontsluiten van Bitcoin’s BRC-20 Tokens</a></p>
<h2 id="h2-De20potentile20ordinaals20Bitcoin20brengen20naar20de20blockchain773354"><a name="De potentiële ordinaals Bitcoin brengen naar de blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De potentiële ordinaals Bitcoin brengen naar de blockchain</h2><p>Zoals eerder vermeld, hebben Ordinals bitcoin meer waarde aan de blockchain toegevoegd dan eerder werd verwacht. Dit komt door hun niet-vervangbare karakter, dat in contrast staat tot bitcoin, dat vervangbaar is.</p>
<p>Bitcoin munten zijn uitwisselbaar omdat ze één op één met elkaar kunnen worden uitgewisseld, aangezien ze dezelfde waarde hebben. Met andere woorden, bitcoin munten zijn onderling uitwisselbaar omdat ze identiek zijn. Aan de andere kant zijn bitcoin ordinaalgetallen niet uitwisselbaar, omdat elk van hen verschilt van de rest. Meer specifiek, er zijn geen twee identieke BTC ordinaalgetallen.</p>
<p>Ondanks kritiek van sommige sectoren van de cryptobranche hebben Bitcoin-ordinals veel waarde toegevoegd aan het netwerk. Ten eerste hebben Bitcoin-ordinals de generatie van meer waardevolle blokken verbeterd. Dit komt omdat sommige gebruikers die de bitcoin NFT’s slaan veel blokruimte kopen, waardoor blokken consequent worden gevuld, wat de BTC per blokvloer verhoogt.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2602/exploring-ordinals-and-brc-20-a-revolution-in-bitcoin-and-the-crypto-market" target="_blank">Het verkennen van Ordinals en BRC-20: Een Revolutie in Bitcoin en de Crypto Markt</a></p>
<p>Wanneer dit gebeurt, verdienen bitcoin miners meer transactiekosten dan anders, waardoor er een gezond beveiligingsbudget ontstaat. Met andere woorden, op Bitcoin gebaseerde NFT’s verhogen de inkomsten voor miners, wat aanzienlijk bijdraagt aan de blockchain beveiliging. De volgende grafiek toont de toename van de totale kosten die toegeschreven kunnen worden aan BTC ordinals.<br><img src="https://gimg2.gateimg.com/image/article/16933013871.png" alt=""><br>Toename van transactiekosten tussen december 2022 en april 2023 - Grayscale</p>
<p>De grafiek toont een gestage toename van transactiekosten sinds december 2022, toen bitcoin-ordinals werden geïntroduceerd.</p>
<h2 id="h2-Kritiek20op20BTCordinaatgetallen517450"><a name="Kritiek op BTC-ordinaatgetallen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kritiek op BTC-ordinaatgetallen</h2><p>Zoals hierboven aangegeven, zijn er verschillende kritieken op bitcoin-ordinaals. Sommige critici beweren bijvoorbeeld dat de ordinaals afwijken van het doel van het peer-to-peer elektronische geldsysteem dat Satoshi Nakamoto, de uitvinder van bitcoin, voor ogen had.</p>
<p>Het andere argument is dat de ordinals afbreuk doen aan de eigenschap van fungibiliteit van Bitcoin. Voor de uitvinding van ordinals waren Satoshis onderling uitwisselbaar omdat mensen ze gemakkelijk konden vervangen. Nu, door gegevens op Satoshis te graveren, blijven ze niet langer onderling uitwisselbaar, wat hun oorspronkelijke doel van elektronische valuta vermindert.</p>
<p>In verband hiermee <a href="https://grayscale.com/can-ordinals-unlock-new-potential-for-bitcoin/" rel="nofollow noopener noreferrer" target="_blank">Grayscale zei</a>, “Als een aanzienlijk aantal satoshi’s wordt gegraveerd, zal de fungibiliteit van Bitcoin afnemen, wat mogelijk van invloed is op het primaire gebruik als elektronische valuta.”</p>
<p>Hoewel het inschrijven van satoshis de fungibiliteit vermindert, wordt geschat dat het ongeveer 238 jaar zal duren om ordinaals te slaan die ‘ongeveer 0,24% van de totale BTC-voorraad van de terminal’ gebruiken.</p>
<p>Bovendien zal het inschrijven van gegevens op satoshis de grootte van de bitcoin blockchain vergroten, waardoor het moeilijker wordt om te downloaden. Anderen zeggen dat de inies zorgen voor het vervuilen van de blockchain met onnodige informatie.</p>
<p>Nog een uitdaging waar bitcoin-kardinalen mee te maken hebben, is het ontbreken van interoperabiliteit op de bitcoin-blockchain. Er is interoperabiliteit als een blockchain communiceert met een andere blockchain. Op dit moment kan de bitcoin-blockchain niet communiceren met andere netwerken. Dit beperkt de <a href="https://www.gate.io/learn/articles/what-are-bitcoin-ordinals/508" target="_blank">potentieel van BTC ordinaals</a>.</p>
<p>Sommige blockchains communiceren met andere door gebruik te maken van verschillende opties zoals laag-2 oplossingen, atomic swaps en cross-chain bruggen. Op dit moment stellen geen van deze oplossingen het bitcoinnetwerk in staat om te communiceren met andere blockchains.</p>
<p>Interoperabiliteit kan veel voordelen bieden voor de bitcoin blockchain. Bijvoorbeeld, het kan cross-chain ordinaals lenen mogelijk maken. Het kan ook de schaalbaarheid verbeteren via laag 2 protocollen die de verkeerscongestie op het netwerk kunnen verminderen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2669/bitcoin-blockchain-size-revised-explosion-ordinals" target="_blank">Bitcoin Blockchain Grootte wordt naar boven bijgesteld als gevolg van de explosie in ordinals</a></p>
<h2 id="h2-Voordelen20van20ordinals20een20bullish20perspectief199239"><a name="Voordelen van ordinals: een bullish perspectief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voordelen van ordinals: een bullish perspectief</h2><p>Ran Neuners perspectief op Bitcoin en ordinaalgetallen helpt ons om hun waarde te waarderen. Neuner, een voormalige altcoin-maximalist, werd een bitcoin-enthousiast na de lancering van bitcoin ordinaalgetallen. De reden hiervoor is dat hij gelooft dat de BTC-ordinaalgetallen de bitcoin-blockchain hebben voorzien van functionaliteiten die vergelijkbaar zijn met Ethereum.</p>
<p><a href="https://beincrypto.com/bitcoin-ordinals-transformed-the-network/" rel="nofollow noopener noreferrer" target="_blank">Neuner zei</a>, “Bitcoin is geëvolueerd van alleen een waardeopslag naar een concurrent van Ethereum.” Hij is ook van mening dat het het beste is om te investeren in bitcoin en zijn technologie in plaats van je te concentreren op minder bekende altcoins.</p>
<p>Met betrekking hierop voegde Neuner toe: “We zijn nu echt, echt, echt een nieuw tijdperk ingegaan met Bitcoin… Zou ik liever investeren in kleine altcoins ergens anders? Of zou ik liever investeren in geweldige infrastructuur die wordt gebouwd in het Bitcoin-ecosysteem?”</p>
<p>Er zijn veel andere cryptoliefhebbers zoals Michael Saylor, de voormalige CEO van MicroStrategy, die geloven dat Bitcoin-ordinaals veel nut hebben gecreëerd voor de blockchain. Als voorbeeld, <a href="https://beincrypto.com/bitcoin-ordinals-transformed-the-network/" rel="nofollow noopener noreferrer" target="_blank">Saylor zei</a>“Wat er gebeurde met Ordinals en NFT’s is dat we deze kloof overstaken van wat een bearish scenario was naar een bullish scenario. Als ik een miner was, zou ik extatisch zijn.”</p>
<p>Hoewel NFT’s die bestaan op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain en andere netwerken unieke doeleinden hebben, zijn BTC-ordinales anders omdat ze zeldzamer zijn en bestaan op een hack-proof en bewezen blockchain.</p>
<p>Het is een feit dat <a href="https://nftandgamefi.com/2023/04/17/bitcoin-ordinals-explained/" rel="nofollow noopener noreferrer" target="_blank">BTC Ordinals hebben de bitcoin blockchain getransformeerd</a> van een netwerk dat alleen een peer-to-peer elektronisch systeem ondersteunt naar een netwerk vol open mogelijkheden. Deze nieuwe functionaliteit zal naar verwachting de prijs van Bitcoin verder opstuwen dan zijn hoogste punt in 2021.</p>
<h2 id="h2-Conclusie28883"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het Ordinals-protocol heeft mensen in staat gesteld Bitcoin NFT’s te creëren, die veel nut hebben gegenereerd voor de blockchain, aangezien individuen activa met waarde op het netwerk kunnen registeren. Deze niet-fungibele tokens hebben geholpen de activiteit op de blockchain te verhogen. Ze verbeteren ook het beveiligingssysteem door mijnwerkers in staat te stellen meer winst te genereren, waardoor ze worden gestimuleerd om het netwerk te beveiligen.</p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoin20Ordes722644"><a name="Veelgestelde vragen over Bitcoin Ordes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin Ordes</h2><h3 id="h3-Wat20zijn20Bitcoinordinalen334615"><a name="Wat zijn Bitcoin-ordinalen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Bitcoin-ordinalen?</h3><p>Bitcoin ordinals zijn satoshis waarop gegevens zoals video’s, afbeeldingen en audio zijn ingeschreven. Content creators kunnen gegevens inschrijven op satoshis met behulp van het Ordinals-protocol, dat ook hun transfers bijhoudt.</p>
<h3 id="h3-Wat20is20het20ordinale20nummer20van20een20bitcoin346933"><a name="Wat is het ordinale nummer van een bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het ordinale nummer van een bitcoin?</h3><p>De ordinaalnummers zijn als serienummers die worden gebruikt om individuele satoshi’s te volgen waar gegevens zijn ingeschreven. In feite wordt het ordinaalnummer toegewezen aan een satoshi wanneer deze wordt gedolven en overgedragen in transacties.</p>
<h3 id="h3-Zijn20ordinals20goed20voor20Bitcoin929153"><a name="Zijn ordinals goed voor Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn ordinals goed voor Bitcoin?</h3><p>Ordinals zijn goed voor bitcoin omdat ze de transactiekosten verhogen die dienen als beloning voor miners voor het beveiligen van het netwerk. Als gevolg van de BTC ordinals heeft bitcoin een grote gemeenschap die het ondersteunt.</p>
<h3 id="h3-Waar20bitcoin20ordes20kopen244843"><a name="Waar bitcoin ordes kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar bitcoin ordes kopen?</h3><p>U kunt bitcoin-ordinalen kopen op verschillende cryptocurrency-uitwisselingen, waaronder Gate.io, Binance en Coinbase. U heeft een bitcoin-portemonnee nodig om uw BTC-ordinalen op te slaan.</p>
<p><a href="/how-to-buy/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">hoe IoTeX te kopen</a> <a href="/how-to-buy/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">hoe IOTEX te kopen</a> Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><a href="/how-to-buy/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">hoe IoTeX kopen</a><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br><a href="/how-to-buy/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">hoe IoTeX te kopen</a></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><a href="/how-to-buy/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">hoe IoTeX te kopen</a></p>
<div class="blog-details-info"><p></p><br></div>