Qml0Y29pbiBzdGVsdCBuaWV1d2UgYWxsLXRpbWUgaGlnaCBpbiB2b29yIGRhZ2VsaWprc2UgdHJhbnNhY3RpZXMsIGdlc3RpbXVsZWVyZCBkb29yIG9yZGluYWFscw==

2023-05-18, 09:28

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR381346"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het dagelijkse aantal transacties van ‘s is gestegen tot een hoog niveau als gevolg van de stijging van BTC NFT’s.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Ordinals zullen de beveiliging van het netwerk verbeteren nadat het delven van BTC is voltooid.</p>
<p>De prijs van BTC schommelt rond de $27,000 .</p>
<h2 id="h2-Introductie499669"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is een van de meest bekende cryptocurrencies vanwege zijn first mover-voordeel. Het staat ook op de meeste, zo niet alle, cryptocurrency-beurzen genoteerd. De dominantie ervan staat echter al enkele jaren onder druk door andere layer-1 blockchains die applicaties hosten en protocollen hebben voor het slaan van NFT’s. Het kan meteen zijn dominantie behouden als gevolg van <a href="https://www.gate.io/price/ordinals-ordi" target="_blank">BTC-ordinaals</a>. Vandaag onderzoeken we hoe <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT leidde tot zijn recente all-time-high dagelijkse transacties.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684402001BTC ATH 1.png" alt=""></p>
<h2 id="h2-Toename20van20dagelijkse20transacties20op20het20Bitcoinnetwerk771599"><a name="Toename van dagelijkse transacties op het Bitcoin-netwerk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toename van dagelijkse transacties op het Bitcoin-netwerk</h2><p>Het handelsvolume <a href="https://www.gate.io/learn/articles/what-are-bitcoin-ordinals/508" target="_blank">van Bitcoin Ordinals</a> bereikte op 30 april 2023 een nieuw record, aangezien het aantal van deze NFT’s 300.000 bereikte. Op dezelfde dag bereikte het aantal <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> transacties bereikten een nieuw recordhoogte voor 2023, wat de impact laat zien die de BTC Ordinals hebben op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-you-need-to-know-about-ordinals-and-brc20/507" target="_blank">Wat u moet weten over ordinals en BRC20?</a></p>
<p>In een gerelateerde stap, zei Glassnode, een on-chain analytics provider, op 1 mei dat de dagelijkse transacties op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> was op weg naar een nieuwe all-time-high. Dit komt doordat de dagelijkse transacties al 348.700 hadden bereikt, maar er waren duidelijke tekenen dat het nog steeds in een stijgende trend zat.</p>
<p>Het laatste gemiddelde dagelijkse piekniveau was in 2017 toen het 379.000 bereikte. Intotheblock, een bedrijf dat marktinformatie en geavanceerde DeFi-tools biedt, stemde in met deze statistieken toen het tweette: ‘Het 7-daags gemiddelde van dagelijks’ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> transacties waren deze week op hun hoogste niveau sinds december 2017. Het toenemende aantal dagelijkse transacties wijst op een groeiend actief gebruik van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain.</p>
<p>In werkelijkheid echter, is de hoogste dagelijkse transactie op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Op 30 april bereikte de blockchain 426.814. Dit cijfer, inclusief transacties van Ordinals, vertegenwoordigt een stijging van 70% sinds het begin van het jaar.</p>
<p>De Glassnode-gegevens tonen aan dat 30% tot 40% van deze transacties het gevolg zijn van Ordinale inschrijvingen. De andere dagelijkse transacties komen van monetaire transacties op beurzen. Over het algemeen zijn normale BTC-transacties goed voor ongeveer 30%.</p>
<h2 id="h2-BTC20Ordinalen301959"><a name="BTC Ordinalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC Ordinalen</h2><p>Als herinnering, BTC Ordinals zijn niet-vervangbare tokens die worden gecreëerd op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain die voornamelijk bestaat uit tekstinies. Met andere woorden, gebruikers kunnen gegevens inbedden op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain, waardoor digitale kunstwerken en meme tokens worden gemaakt, onder andere.</p>
<p>Hoewel Satoshi, de kleinste eenheden van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, zijn uitwisselbaar, maar worden niet-uitwisselbaar als mensen er numerieke waarden aan toekennen of er teksten op inschrijven. Op 8 april waren er meer dan één miljoen inies op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> blockchain.</p>
<p>Lees ook: <a href="https://www.gate.io/es/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>
<h2 id="h2-Positieve20effecten20van20Bitcoin20Orakels20op20de20blockchain418023"><a name="Positieve effecten van Bitcoin Orakels op de blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Positieve effecten van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Orakels op de blockchain</h2><p>Tot nu toe is er een sterke discussie onder crypto-enthousiastelingen en volgers of Ordinal Inions al dan niet meer waarde hebben gebracht aan de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk. De waarheid is dat er zowel negatieve als positieve kanten aan zitten. Laten we eerst de positieve effecten van Ordinals bespreken op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain.</p>
<p><a href="https://grayscale.com/can-ordinals-unlock-new-potential-for-bitcoin/" rel="nofollow noopener noreferrer" target="_blank">Grayscale, een beheerder van diverse activa, zegt</a> dat de creatie van een technologie die mensen in staat stelt om Ordinale Inschriften te ontwikkelen op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain biedt een grote kans voor een grotere adoptie van het netwerk dan voorheen. Dit heeft ook geholpen om het idee te verdrijven dat de blockchain rigide is.</p>
<p>De introductie van Ordinals verhoogt de beveiliging van de blockchain. In het verleden geloofden analisten dat de beveiliging van het netwerk zou afnemen wanneer alle munten gemined zijn. Dit komt doordat er zeer weinig prikkels zouden zijn voor de miners om door te gaan met deelname aan de blockchain.</p>
<p>Als gevolg hiervan betekent de ontwikkeling van Ordinals dat het netwerk blijft inkomsten genereren via kosten om de activiteiten van de mijnwerkers te ondersteunen. Dit zorgt voor beveiliging van de blockchain gedurende zijn hele levensduur.</p>
<p>Al kunnen we al zien dat Ordinals veel inkomsten genereren voor de blockchain. Gegevens van Dune Analytics laten zien dat op 5 mei alleen BTC Ordinals 257 BTC aan kosten heeft gegenereerd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684402038BTC ATH 2.png" alt=""></p>
<p>Zoals waargenomen, de totale vergoedingen gegenereerd uit <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De Ordinals per 5 april bedroeg 899,39 BTC. Dit toont aan dat de Ordinals het potentieel hebben om aanzienlijke inkomsten te genereren voor de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Blockchain.</p>
<p>Sommige analisten zijn ook van mening dat ordinale inies het potentieel hebben om meer gebruikers naar het netwerk te trekken en om meer ontwikkeling op de blockchain te stimuleren. Met het oog hierop <a href="https://grayscale.com/can-ordinals-unlock-new-potential-for-bitcoin/" rel="nofollow noopener noreferrer" target="_blank">Grayscale reageerde</a>, “Hoewel er legitieme zorgen bestaan, geloven wij dat ordinaals het potentieel hebben om een positieve impact te hebben op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk op de langere termijn, waardoor een nieuwe golf van enthousiaste gebruikers en ontwikkelaars wordt aangetrokken om het te omarmen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gemeenschap.</p>
<p>Op dezelfde manier zei een Twitter-gebruiker met de gebruikersnaam @LeonidasNFT: ‘Zolang de waarde van het minten van BRC-20 tokens hoger is dan de waarde die verloren gaat aan de iniekosten, zullen we kosten zien op’ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blijven stijgen.” Trouwens, Ordinaals zijn <a href="https://www.gate.io/uk/article/30674" target="_blank">in de vorm van BRC-20 tokens.</a></p>
<p>Leonidas voegde eraan toe: “Het duidt op een sterke vraag naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> de blockspace van ‘s, wat essentieel is voor het langetermijnsucces van het protocol. De dagen dat alleen gebruik wordt gemaakt van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> om BTC naar je hardware wallet over te dragen, is voorbij gekomen.</p>
<p>De opvattingen van dergelijke gebruikers en analisten tonen aan dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT heeft de perceptie veranderd die mensen hebben op het netwerk. Daarnaast hebben de Ordinals een nieuwe use case gecreëerd voor de blockchain.</p>
<h2 id="h2-Negatieve20effecten20van20Bitcoin20Ordnals20op20de20blockchain634469"><a name="Negatieve effecten van Bitcoin Ordnals op de blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Negatieve effecten van Bitcoin Ordnals op de blockchain</h2><p>Op dit moment, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en de cryptogemeenschap hebben niet veel zorgen geregistreerd, behalve dat de Ordinale Inschrijvingen veel ruimte op de blockchain innemen. De critici zeggen ook dat congestie op de blockchain ook de netwerkvergoedingen kan verhogen.</p>
<h2 id="h2-Bitcoin20Prijsverwachting2029000453317"><a name="Bitcoin Prijsverwachting $29,000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Prijsverwachting $29,000</h2><p>Tegen het einde van april <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bleef een waarde van meer dan $29.000 behouden, ondanks korte periodes waarin het schommelde onder de $28.000. Zo daalde het bijvoorbeeld naar ongeveer $27.000 toen de markt het nieuws kreeg dat de Amerikaanse regering van plan was om haar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bezittingen.</p>
<p>Op het moment van schrijven schommelt de waarde van BTC lichtjes onder de $27.000 zoals aangegeven in <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> hieronder.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684402073BTC ATH 3.png" alt=""></p>
<p>Zoals u opmerkt, schommelt de prijs van BTC rond de $27.000. De waarde daalde op 6 mei onder de $29.000 en het blijft daar nog steeds onder zweven.</p>
<h2 id="h2-Conclusie128554"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De handelsvolume van BTC NFT’s is sinds het begin van het jaar geleidelijk gestegen. Dit heeft de omzet verhoogd die de blockchain genereert, evenals de adoptie ervan. In de toekomst zullen de Ordinale Inschrijvingen een instrument worden om de beveiliging van het netwerk te handhaven.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het toestaan van herpublicatie van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>