RGUga29tc3QgdmFuIGVlbiBuaWV1dyB0aWpkcGVyayB2YW4gQml0Y29pbiBlbiBkZSBzcHJvbmcgaW4gaGV0IGVjb3N5c3RlZW0gbmEgZGUgZ2VrdGUgdmFuIGluc2NocmlqdmluZ2Vu

2024-03-07, 06:57

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR667731"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>2024 kan worden beschouwd als een jaar van uitgebreide bouw en welvaart voor de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem, met tal van nieuwe elementen geïntegreerd in het Bitcoin-netwerk, zoals innovaties zoals BRC-137, ter bevordering van de welvaart van het ecosysteem.</p>
<p>Verschillende asset-uitgifteprotocollen zoals Atomicals, Runes, BTC-stempels, enz. hebben geleid tot nieuwe tokenstandaarden zoals ARC-20, SRC-20 en ORC-20, evenals standaarden zoals BRC-137 en BRC-420, die de diversiteit en innovatie van het Bitcoin-ecosysteem laten zien.</p>
<p>Het Bitcoin-ecosysteem kampt met een relatief lage schaalbaarheid en sterk stijgende transactiekosten. Echter, door innovatieve technologieën en de ontwikkeling van producten of applicaties die aansluiten bij inheemse scenario’s, heeft het Bitcoin-ecosysteem nog steeds enorme potentie en ontwikkelingsruimte.</p>
<h2 id="h2-Introductie146924"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Als 2023 het beginjaar is voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> om zijn ecosysteem nieuw leven in te blazen vanwege de populariteit van inies, dan zal met de lancering van spot ETF’s en de komst van de vierde halvering, 2024 ongetwijfeld een welvarend jaar worden voor de algehele ontwikkeling van het Bitcoin-ecosysteem.</p>
<p>Het Bitcoin-netwerk, dat in de vorige bullmarkt als stilstand werd beschouwd, is nu nieuw leven ingeblazen met vele spannende nieuwe elementen.</p>
<p>Maar welke andere explosieve voorwerpen kunnen er dit jaar naast de inies verschijnen? Wat zijn de innovatieve proposities waar zij voor staan? Hoe kunnen we vanuit een breder perspectief vooruitkijken naar potentiële projectmogelijkheden? Laten we samen deze mysteries ontrafelen en de toekomstige ontwikkeling van het Bitcoin-veld verkennen.</p>
<h2 id="h2-Bitcoin20Eco20Game20Digitaal20Goud20of20Slimme20Contracten165574"><a name="Bitcoin Eco Game: Digitaal Goud of Slimme Contracten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Eco Game: Digitaal Goud of Slimme Contracten?</h2><p>Zoals algemeen bekend is, is sinds de geboorte van Bitcoin de positionering ervan geweest als een peer-to-peer elektronisch geldsysteem, altijd in het verhaal van ‘digitaal goud’. Maar in de loop van de tijd hopen veel gebruikers en ontwikkelaars de toepassingsscenario’s en ecosysteemconstructie van Bitcoin verder uit te breiden.</p>
<p>In 2013, Vitalik Buterin stelde het concept van voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> als een blockchain en mede-oprichter van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> met Gavin Wood en Joseph Lubin, onder anderen.</p>
<p>De kern van Ethereum ligt in zijn programmeerbaarheid, waardoor ontwikkelaars een platform hebben om verschillende applicaties te bouwen, wat heeft geleid tot talloze typen activa zoals Layer2-applicaties, ERC20 en ERC721, evenals verschillende vervolgprojecten. Het Ethereum-ecosysteem is zonder uitzondering tot bloei gekomen.</p>
<p>Hoewel Bitcoin inferieur is aan Ethereum in TPS, bloktijd, Turing-volledigheid en andere aspecten, heeft zijn oorspronkelijke bedoeling als cryptohandel ontwikkelaars er niet van weerhouden slimme contracten en applicatieontwikkeling erop te introduceren, waardoor een langdurig spel ontstaat tussen fundamentalisten in de Bitcoin-gemeenschap en ontwikkelaars die proberen te innoveren.</p>
<p>Vergeleken met de verlatenheid van de stierenmarkt van 2020 tot 2021 heeft Bitcoin innovaties ingeluid die worden vertegenwoordigd door het Ordinals-protocol en BRC-20-inies in deze ronde van de stierenmarkt. De kracht om conservatieve en radicale facties te doorbreken, is de actieve gemeenschap. Uiteindelijk is de belangrijkste drijvende kracht de zoektocht van mensen naar consensus over waarde. Zonder de onderliggende code en beveiligingslogica van Bitcoin te veranderen, kan iedereen zijn beveiligingsconsensus benutten om een zekere mate van activainnovatie te bereiken, wat verder de consensus van Bitcoin als waardevol digitaal bezit en ruilmiddel zal versterken.<img src="https://gimg2.gateimg.com/image/article/17097944311.jpg" alt=""><br>Bron: Ryze Labs</p>
<p>Veel ecosysteemprojecten die vertrouwen op het Bitcoin-netwerk, hebben nieuwe vitaliteit geïnjecteerd in eerder inactieve Bitcoin-activa. Deze protocollen bieden niet alleen Bitcoin meer activastandaarden en nieuwe scenario’s voor protocoluitgiften, maar transformeren het ook van een louter statisch activum naar een belangrijke bijdrager aan de netwerkbeveiliging.</p>
<p>Deze transformatie zal meer gebruikers aantrekken om zich aan te sluiten bij het nieuwe narratieve ecosysteem, waardoor de beveiliging van het Bitcoin-netwerk verder wordt verbeterd en meer applicaties en diensten worden aangetrokken om zich in te vestigen, waardoor een opwaartse spiraal ontstaat.</p>
<h2 id="h2-Die20Opmerkelijke20Ecosysteem20Nieuwe20Paradigmas479304"><a name="Die Opmerkelijke Ecosysteem Nieuwe Paradigma’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Die Opmerkelijke Ecosysteem Nieuwe Paradigma’s</h2><p>Met de golf van inschrijvingen die wordt veroorzaakt door het Ordinals-protocol en de BRC-20-tokenstandaard, hebben ook activa-uitgifteprotocollen voor verschillende soorten Bitcoin snel de aandacht van de markt getrokken.</p>
<p>Diversified asset issuance protocols such as Atomicals, Runes, BTC Stamps, Taproot Assets, etc., have emerged, giving rise to many new token standards such as ARC-20, SRC-20, ORC-20, etc.</p>
<p>Naast de hierboven genoemde mainstream activa-uitgifteprotocollen zijn er ook veel activaprotocollen met rijke toepassingsscenario’s in overweging.</p>
<p>Bijvoorbeeld, BRC-137 is gebaseerd op het Ordinals-protocol, waardoor iedereen op een volledig toestemmingsloze en gedecentraliseerde manier composable DIDs kan creëren op de Bitcoin blockchain, met ondersteuning voor gebruikersauthenticatie en herkenning van verschillende toepassingen op de keten.<br><img src="https://gimg2.gateimg.com/image/article/17097944702.jpg" alt=""><br>Bron: brc137.io</p>
<p>De BRC-420 standaard is vergelijkbaar met ERC-1155, die meerdere inies kan combineren tot complexe activa en een breed scala aan toepassingsscenario’s biedt voor gaming en metaverse-velden (zoals het ERC-1155-protocol voor NFT- en FT-gecombineerde gaming-scenario’s).</p>
<p>Sommige memecoin gemeenschappen zijn ook begonnen met het lanceren van nieuwe activaprotocollen op BTC, zoals de DRC-20 gelanceerd door de <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> gemeenschap die een diverse innovatietrend laat zien.</p>
<p>Naast de verschillende L2-ecoen die we eerder in onze blogpost hebben genoemd, evenals het eerder genoemde verhaal van de activainnovatie, is de ontwikkeling van projecten die Bitcoin gebruiken als onderliggende zekerheid een nieuw hoogtepunt van dit jaar geworden.</p>
<h2 id="h2-LSTmodus20Bitcoin20inzetten20voor20beveiligingsbescherming849355"><a name="LST-modus: Bitcoin inzetten voor beveiligingsbescherming" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LST-modus: Bitcoin inzetten voor beveiligingsbescherming</h2><p>Het verhaal van Bitcoin-inzetrente is niet nieuw, maar het Babylon-project heeft BTC-inzetten uitgebreid naar een nieuwe dimensie. Het project heeft als doel om Bitcoin te gebruiken als een niet-gekwalificeerd ingezetene activum om de beveiliging van de Cosmos openbare keten te waarborgen door het toepassen van het Slashingsmechanisme.</p>
<p>Deze innovatieve strategie transformeert niet alleen Bitcoin in een onderliggend rentegevend vermogen, maar biedt ook een solide beveiligingsbarrière voor de publieke keten via het Bitcoin-netwerk.</p>
<h2 id="h2-DeFiminingmodus20Bitcoin20staken20om20tokens20te20verkrijgen107539"><a name="DeFi-miningmodus: Bitcoin staken om tokens te verkrijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi-miningmodus: Bitcoin staken om tokens te verkrijgen</h2><p>Veel opkomende BTC Layer2-projecten, zoals Merlin Chain en BSquare, onderzoeken start-up strategieën voor het inzetten van Bitcoin voor mining.</p>
<p>Als voorbeeld nemen we Merlin Chain, dit project is een Bitcoin L2-netwerk dat belangrijke modules integreert zoals het ZK-Rollup-netwerk, gedecentraliseerd orakelnetwerk en Bitcoin on-chain fraudebewijs. Het doel is om de inheemse activa, protocollen en toepassingsecosysteem op BTC Layer 1 te versterken via Layer 2. Momenteel is de TVL meer dan $2 miljard.</p>
<h2 id="h2-Het20postbitcoin20tijdperk20is20aangebroken20en20gemeenschappen20drijven20waardeontdekking20aan854681"><a name="Het post-bitcoin tijdperk is aangebroken, en gemeenschappen drijven waardeontdekking aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het post-bitcoin tijdperk is aangebroken, en gemeenschappen drijven waardeontdekking aan</h2><p>Het is niet moeilijk om te zien uit de vorige tekst dat de ontwikkeling van het Bitcoin ecosysteem nieuwe kansen heeft gebracht voor het hele crypto-veld.</p>
<p>Ondertussen zien we dat Bitcoin en gerelateerde ecosysteemtokens (zoals STX, RGB, enz.) ook een snelle waardegroei doormaken. Momenteel staat de ecosysteemontwikkeling van Bitcoin echter nog voor veel uitdagingen.<img src="https://gimg2.gateimg.com/image/article/17097945383.jpg" alt=""><br>Bron: Coinmarketcap</p>
<p>De schaalbaarheid van het Bitcoin-netwerk is relatief laag. Als we Ethereum emuleren om terreinen zoals DeFi, NFT, GameFi, DAO, enz. te verkennen, zal het Bitcoin-ecosysteem natuurlijk achterblijven. Omdat het Bitcoin-netwerk geen complexe smart contractinteracties ondersteunt, is een veilige en betrouwbare schaaloplossing die acceptabel is voor de gemeenschap nodig om grootschaligere toepassingen te dragen.</p>
<p>Het meest typische voorbeeld is dat BRC-20 transacties hebben geleid tot een sterke groei in de Bitcoin blokruimte, wat kan leiden tot congestie in de geheugenpool, resulterend in een stijging van transactiekosten en een verlenging van de transactiebevestigingstijd.</p>
<p>De aanstaande halvering van Bitcoin wordt verwacht plaats te vinden eind april 2024, wanneer de beloningen voor blokken van miners zullen worden gehalveerd, wat het debat over Ordinal technologie en de bijbehorende elementen verder zal intensiveren.</p>
<p>Naast de behoefte aan innovatieve technologie om verandering te stimuleren, moeten we ook meer populaire producten of toepassingen verwachten in het Bitcoin-ecosysteem die aansluiten bij de oorspronkelijke scenario’s. Bijvoorbeeld, hoe men gedecentraliseerde indexering en andere infrastructuur in L2-constructie kan behouden blijft een leegte om meer gebruikers en ontwikkelaars aan te trekken en een positieve ontwikkelingscyclus te vormen, wat ook het focuspunt van dit artikel is.</p>
<p>Vanuit het perspectief van paradigma-innovatie heeft het Bitcoin-netwerk zijn eigen sterke beveiligingsconsensus en tekortkomingen in de interactie van slimme contracten. Daarom zou het bouwen van een Bitcoin-ecosysteem anders moeten zijn dan het volgen van de voetstappen van Ethereum. Ontwikkelaars moeten unieke toepassingsscenario’s verkennen en ontwikkelen op basis van hun unieke eigenschappen van activa.</p>
<p>Vanuit het perspectief van de ontwikkelingsfase wordt het Bitcoin-ecosysteem momenteel belemmerd en heeft het nog een lange weg te gaan, en er is nog steeds een enorme potentie ruimte om te worden verkend. In de huidige context van relatief overvloedige fondsen en sterke gebruikersvraag, zijn er nog veel schaalbare gebieden en innovatieve oplossingen voor het ontwikkelen van het Bitcoin-ecosysteem.</p>
<p>Kortom, met behulp van toonaangevende Bitcoin-tokenstandaarden zoals digitale verzamelobjecten, metaprotocollen en BRC-20, evenals de geest van open source, eerlijkheid en gedeelde cryptocurrency, groeit een levendig Bitcoin-ecosysteem voortdurend, en we zullen ons blijven richten op zijn grote visie en kleine innovaties.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>