RGVGaSB2ZXJrZW5uZW4gYWxzIGthdGFseXNhdG9yIHZvb3IgZGUgZ3JvZWkgdmFuIEJpdGNvaW46IGhldCBvbnRncmVuZGVsZW4gdmFuIGVlbiBuaWV1d2UgZmFzZSB2YW4gQml0Y29pbi1leHBhbnNpZT8=

<p><img src="https://gimg2.gateimg.com/image/article/1717041257sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR397119"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Bitcoin-ontwikkelaars werken aan verschillende projecten om de programmeerbaarheid van de blockchain te verbeteren.</p>
<p>Binnen de laatste drie jaar waren de Lightning-laag-2-blockchain, het ordinals-protocol en het Runes-protocol belangrijke ontwikkelingen op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk.</p>
<p>Als <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> een bepaald niveau van programmeerbaarheid bereikt, zal het waarschijnlijk het grootste DeFi-ecosysteem worden.</p>
<h2 id="h2-Inleiding954817"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Er vinden veel innovaties plaats op de bitcoin blockchain die het mogelijk kunnen transformeren tot een volwaardig DeFi-ecosysteem dat concurreert met de . <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk. De lancering van het lightning-netwerk en het ordinals-protocol hebben veel ontwikkelaars laten zien dat ze de blockchain op verschillende manieren kunnen verbeteren om de bruikbaarheid en duurzaamheid ervan te vergroten. Vandaag richten we ons op verschillende initiatieven die kunnen leiden tot een bloeiend Bitcoin DeFi-ecosysteem.</p>
<h2 id="h2-Het20potentieel20van20DeFi20om20Bitcoin20te20transformeren20in20een20dynamisch20programmeerbaar20platform509215"><a name="Het potentieel van DeFi om Bitcoin te transformeren in een dynamisch, programmeerbaar platform" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het potentieel van DeFi om Bitcoin te transformeren in een dynamisch, programmeerbaar platform</h2><p>Ondanks dat bitcoin de nummer één cryptocurrency is op basis van marktkapitalisatie, is <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> progressiever op het gebied van DeFi, omdat het veel gedecentraliseerde applicaties en slimme contracten ondersteunt. Nu werken veel bitcoin-ontwikkelaars hard aan oplossingen die bitcoin in staat stellen gedecentraliseerde applicaties te hosten.</p>
<p>Een robuust bitcoin DeFi-ecosysteem zal de cryptocurrency transformeren van slechts digitaal goud naar een programmeerbaar en dynamisch platform dat veel functionaliteiten ondersteunt. Toby Lewis, medeoprichter van OrdinalsBot - een project gebaseerd op het Ordinals-protocol - denkt dat Bitcoin het vermogen heeft om het toonaangevende DeFi-protocol te worden en Ethereum te overtreffen.</p>
<p>Historisch gezien hebben mensen bitcoin beschouwd als een waardeopslag en een digitale valuta, met beperkte functionaliteit. Dit is heel anders geweest dan Ethereum (ETH) dat een groot ecosysteem van DeFi-toepassingen en andere slimme contracten ondersteunt. Echter, <a href="https://www.gate.io/learn/articles/summary-of-new-technological-developments-that-led-to-bitcoins-resurgence/2711" target="_blank">recente ontwikkelingen op het netwerk</a> geeft aan dat bitcoin mogelijk een sterke DeFi-groeikatalysator kan worden.</p>
<p>Verschillende ontwikkelingen die hebben plaatsgevonden op de bitcoin blockchain, waaronder het ordinals protocol, het Runes protocol en andere bitcoin layer-2 netwerken zoals lightning, hebben hoop gecreëerd onder ontwikkelaars dat ze de programmeerbaarheid van de blockchain kunnen vergroten. De belangrijkste rol van de bitcoin layer-2 netwerken is echter het verbeteren van de schaalbaarheid van de blockchain en het nut van gedecentraliseerde applicaties.</p>
<p>Nu zoeken de ontwikkelaars naar manieren om nieuwe functies te integreren op het oorspronkelijke netwerk. Dit komt doordat zij geloven dat het toevoegen van programmeerbaarheid aan de blockchain nieuwe investeringen zal aantrekken, wat een nieuwe stimulans zal zijn voor een BTC prijsrally. In het verleden lag de nadruk van ontwikkelaars vooral op het verhelpen van ontwerpfouten van de blockchain, zoals schaalbaarheidsuitdagingen. Helaas bleken sommige innovaties gebrekkig te zijn. Zo zijn de bruggen bijvoorbeeld vatbaar voor hacks.</p>
<p>Op dit moment zijn er verschillende innovaties gaande. Bijvoorbeeld, sommige ontwikkelaars werken aan OP_CAT, een software die het mogelijk zal maken om programmeerbaarheid te implementeren. Dit initiatief heeft veel steun gekregen van de gemeenschap van bitcoin ontwikkelaars.</p>
<p>Een andere innovatie op de kaarten is ARC, een software die bovenop de bitcoin blockchain draait en de integratie van applicaties van de mogelijk maakt. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> netwerk. Yahoo News citeerde <a href="https://ca.news.yahoo.com/keep-eye-creeps-hidden-camera-145649497.html" rel="nofollow noopener noreferrer" target="_blank">Kyle Samani, medeoprichter van Multicoin</a>, zo wordt gezegd: “Het is een enorme ontgrendeling voor Bitcoin. Het is echt goed voor gebruikers.” Al Multicoin Capital heeft ARC al geholpen om $7 miljoen voor het project op te halen.</p>
<p>In een gerelateerde beweging ontwikkelt Layer 1 Foundation een programmeerbare module die geschikt is voor het BRC-20 metaprotocol, waarmee berichten in code kunnen worden opgeslagen op de Bitcoin blockchain. Met behulp hiervan kan een indexer de berichten vinden en berekeningen uitvoeren op slimme contracten die op het netwerk bestaan. Aangezien de blockchain een langere bevestigingstijd heeft dan Ethereum, zal het waarschijnlijk die functie op een betere manier uitvoeren dan laatstgenoemde.</p>
<p>Het is ook belangrijk om te beseffen dat meer dan 20 teams van bitcoin-ontwikkelaars werken aan verschillende initiatieven om de programmeerbaarheid van bitcoin te verbeteren.</p>
<h2 id="h2-Toby20Lewis20over20het20DeFipotentieel20van20Bitcoin20Hoe20het20DeFiecosysteem20van20Bitcoin20het20grootste20zou20kunnen20worden20in20de20Cryptowereld420"><a name="Toby Lewis over het DeFi-potentieel van Bitcoin: Hoe het DeFi-ecosysteem van Bitcoin het grootste zou kunnen worden in de Crypto-wereld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toby Lewis over het DeFi-potentieel van Bitcoin: Hoe het DeFi-ecosysteem van Bitcoin het grootste zou kunnen worden in de Crypto-wereld</h2><p>Bitcoin-programmeerbaarheid zal leiden tot veel voordelen, waaronder een toestroom van gedecentraliseerde financiële (DeFi) toepassingen. Dit kan op zijn beurt leiden tot hogere kapitaalinstromen in het ecosysteem, evenals grotere adoptie en bruikbaarheid. In een recente… <a href="https://www.bloomberg.com/news/newsletters/2024-02-20/bitcoin-s-latest-buzz-and-risks-sound-a-lot-like-ethereum-s" rel="nofollow noopener noreferrer" target="_blank">In een publicatie meldde Bloomberg dat de Bitcoin TVL de 1,1 miljard dollar heeft overschreden.</a> Met een dergelijke ontwikkeling gelooft Toby Lewis dat het Bitcoin DeFi-ecosysteem binnen de komende jaren het grootste zal worden.</p>
<p>Plaatsen op zijn X-profiel <a href="https://twitter.com/ordinalsbot/status/1792277675366609036" rel="nofollow noopener noreferrer" target="_blank">Lewis zei</a>, ‘Het DeFi-ecosysteem van Bitcoin zou kunnen uitgroeien tot het grootste in de hele crypto. Het is mogelijk dat het Bitcoin DeFi-ecosysteem in de komende jaren kan groeien tot biljoenen dollars aan marktkapitalisatie, en het lijkt een van de belangrijkste drijfveren te zijn van de groei in crypto in deze cyclus.’</p>
<p>Sommige ontwikkelaars beweren dat de programmeerbaarheid van bitcoin zal leiden tot de volgende bitcoin revolutie en bull run. De volgende onderschrift bevestigt het sentiment onder ontwikkelaars en andere bitcoiners.<br><img src="https://gimg2.gateimg.com/image/article/1717041477a.jpeg" alt=""><br>Bron: <a href="https://twitter.com/ordinalsbot/status/1792277675366609036/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<h2 id="h2-De20opkomst20van20Bitcoin20TVL20Onderzoek20naar20de20huidige20staat20van20de20totale20waarde20van20Bitcoin20opgesloten20in20DeFi990303"><a name="De opkomst van Bitcoin TVL: Onderzoek naar de huidige staat van de totale waarde van Bitcoin opgesloten in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van Bitcoin TVL: Onderzoek naar de huidige staat van de totale waarde van Bitcoin opgesloten in DeFi</h2><p>Zoals gezegd is de totale waarde van bitcoin (TVL) in de loop der jaren gestaag gegroeid. Op dit moment bedraagt de bitcoin TVL $1.137 miljard, zoals aangegeven door DeFiLlama.<br><img src="https://gimg2.gateimg.com/image/article/1717041498b.jpeg" alt=""><br>Bitcoin TVL: <a href="https://defillama.com/chain/Bitcoin" rel="nofollow noopener noreferrer" target="_blank">DeFiLlama</a></p>
<p>Lewis merkte hierover op: “Het is mogelijk dat het Bitcoin DeFi-ecosysteem in de komende jaren zou kunnen groeien tot biljoenen dollars aan marktkapitalisatie, en het lijkt een van de belangrijkste drijfveren te zijn van groei in crypto deze cyclus.” Programmeerbaarheid zal waarschijnlijk leiden tot een toename van BTC TVL.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/panoramic-analysis-of-the-btc-eco-reshaping-history-or-starting-the-next-bull-market/1804" target="_blank">Panoramische analyse van het BTC-ecosysteem</a></p>
<h2 id="h2-Het20Runes20Protocol20Analyse20van20de20initile20stijging20en20daaropvolgende20daling20van20de20netwerkactiviteit855865"><a name="Het Runes Protocol: Analyse van de initiële stijging en daaropvolgende daling van de netwerkactiviteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Runes Protocol: Analyse van de initiële stijging en daaropvolgende daling van de netwerkactiviteit</h2><p>Het bitcoin Runes-protocol, gelanceerd op 20 april, heeft de levendigheid van bitcoin vergroot. De markt is echter nog niet zeker van de richting die de Runes zullen nemen. De reden hiervoor is dat na hun lancering het aantal transacties steeg naar 56.372 tegen 19 mei. Na die piek daalde hun activiteit echter met meer dan 50%, wat leidde tot lage bitcoin-kosten. Bijvoorbeeld slechts ongeveer 5.000 Runes zijn gecreëerd sinds 1 mei, wat resulteerde in slechts ongeveer $100.000 aan kosten. De volgende grafiek toont de veranderingen die optraden in bitcoin-transacties na de lancering van het Runes-protocol.<br><img src="https://gimg2.gateimg.com/image/article/1717041539c.jpeg" alt=""><br>Bitcoin Runes Transactie: <a href="https://dune.com/cryptokoryo/runes" rel="nofollow noopener noreferrer" target="_blank">Dune</a></p>
<p>Zoals <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> Duidt erop dat bitcointransacties aanzienlijk toenamen na de lancering van het Runes-protocol. Tegen 19 mei was de activiteit van Runes echter gedaald tot een zeer laag niveau.</p>
<p>In feite maakt het Runes-protocol bitcoin de creatie en het beheer van fungibele tokens op de blockchain mogelijk. Het is essentieel om te beseffen dat de Runes verschillen van traditionele standaarden zoals BRC-20, omdat ze het model op basis van Unspent Transaction Output (UTXO) hebben aangenomen, wat de schaalbaarheid, efficiëntie en beveiliging verhoogt.</p>
<h2 id="h2-Bitcoin20Ordinals20en20BRC2020tokens20in20Bitcoinecosysteem981185"><a name="Bitcoin Ordinals en BRC-20 tokens in Bitcoin-ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Ordinals en BRC-20 tokens in Bitcoin-ecosysteem</h2><p>Naast de Runen zijn de andere bitcoin-standaarden BRC-20 en Ordinals Inions, die de bruikbaarheid van het netwerk hebben vergroot. Het ordinals-protocol maakte het mogelijk voor makers om niet-vervangbare tokens op de bitcoin-blockchain te slaan. Later bedacht Domo, een niet-geïdentificeerde ontwikkelaar, een systeem om BRC-20 tokens te maken. <a href="https://www.gate.io/blog_detail/3136/ordinals-transformed-bitcoin" target="_blank">met behulp van het bitcoin Ordinals-protocol</a>. Daarom hebben deze twee ontwikkelingen de programmeerbaarheid van bitcoin verbeterd.</p>
<h2 id="h2-Hoe20Bitcoin20het20functionaliteitsverschil20met20Ethereum20overbrugt406033"><a name="Hoe Bitcoin het functionaliteitsverschil met Ethereum overbrugt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe Bitcoin het functionaliteitsverschil met Ethereum overbrugt</h2><p>De verschillende ontwikkelingen die zich hebben voorgedaan op de bitcoin blockchain in de afgelopen twee jaar, <a href="https://www.gate.io/learn/articles/comprehensive-overview-of-btc-layer-2-leader-bevm-eco-with-20-projects/1709" target="_blank">inclusief de lancering van laag-2 netwerken</a>, de Runen evenals de BRC-20 tokens hebben het netwerk gepositioneerd als een sterke concurrent van Ethereum. De lopende inspanningen en ontwikkelingsinitiatieven zullen van bitcoin een competitieve DeFi-crypto maken, met veel nut en investeringspotentieel. Om dit te illustreren, in de afgelopen twee maanden <a href="https://www.gate.io/learn/articles/understanding-the-top-10-bitcoin-nfts-in-one-article/1895" target="_blank">Bitcoin-gebaseerde NFT’s presteerden beter dan die van Ethereum</a>.</p>
<h2 id="h2-Conclusie511609"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De ontwikkelingen die zich de afgelopen twee jaar op de bitcoin blockchain hebben voorgedaan, hebben de bruikbaarheid ervan vergroot en de leidende positie versterkt. Zo zijn er bijvoorbeeld BRC-20 tokens, <a href="https://www.gate.io/learn/articles/introduction-to-runes/2786" target="_blank">Ordinale inies en runen</a> hebben de programmeerbaarheid van bitcoin verbeterd en verdere investeringen aangetrokken naar de toonaangevende crypto-activa. Ondertussen werken ontwikkelaars aan andere initiatieven zoals ARC en OP-CAT bitcoin om de blockchain competitiever te maken dan ooit tevoren.</p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoin72879"><a name="Veelgestelde vragen over Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin</h2><h3 id="h3-Wie20zijn20de20grootste20houders20van20bitcoin685128"><a name="Wie zijn de grootste houders van bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie zijn de grootste houders van bitcoin?</h3><p>De grootste houders van bitcoin zijn onder andere Satoshi Nakamoto, Cameron en Tyler Winklevoss, Changpeng Zhao (CZ), Tim Draper, Michael J. Saylor. Bitcoin mining bedrijven zoals Marathon Digital Holdings en Hut 8 Mining Corp bezitten ook grote hoeveelheden bitcoin. Onlangs, <a href="https://www.gate.io/learn/articles/bitcoin-efts-have-been-trading-around-the-world-for-years/2801" target="_blank">uitgevers van spot bitcoin ETF’s</a> zoals Grayscale Bitcoin Trust ook <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">veel bitcoin verworven</a>.</p>
<h3 id="h3-Wie20domineert20Bitcoinmining371767"><a name="Wie domineert Bitcoin-mining?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie domineert Bitcoin-mining?</h3><p>AntPool, Foundry USA, Marathon, Riot, Hut 8 Mining Corp, CleanSpark en Canaan Inc. domineren de bitcoin-miningsector. De reden waarom enkele mijnbedrijven de sector domineren, is de hoge kosten van de operaties.</p>
<h3 id="h3-Hoe20lang20duurt20het20om20120bitcoin20te20delven154210"><a name="Hoe lang duurt het om 1 bitcoin te delven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe lang duurt het om 1 bitcoin te delven?</h3><p>De kortste tijd die nodig is om 1 bitcoin te delven is 10 minuten. Dit komt doordat 10 minuten de kortste tijd is waarin een blok aan de bitcoin blockchain wordt toegevoegd. Momenteel krijgt een miner die een blok aan de bitcoin blockchain toevoegt een beloning van 3,125 BTC.</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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>