UnVuZXMgSXMgdmlyYWFsIGdlZ2Fhbiwga2FuIGhldCBlZW4gbmlldXdlIGh5cGUtbmFycmF0aWVmIHdvcmRlbiBuYSBkZSBoYWx2ZXJpbmc/

2024-04-23, 08:25

<p><img src="https://gimg2.gateimg.com/image/article/1713860094rdzz.jpeg" alt=""><br>[TL;DR]:<br>As <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> behaalt met succes zijn vierde halvering, de populariteit van Runes-runen in het Bitcoin-ecosysteem blijft toenemen.</p>
<p>Of de opkomst van inies en runen met kortetermijneffecten op de rijkdom of de lancering van op <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> gebaseerde protocollen zoals L2 en DeFi duiden op hernieuwd enthousiasme onder investeerders en ontwikkelaars om Bitcoin uit te breiden als een ecosysteemnetwerk.</p>
<p>Bitcoin heeft zich in de loop van vier jaar ontwikkeld, waarbij elke halvering een belangrijke mijlpaal is in zijn ontwikkeling. Hoewel de prijs van Bitcoin na halvering kan fluctueren, lijkt de trend van stabiele langetermijngroei niet onveranderd te blijven.</p>
<h2 id="h2-Inleiding315886"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Nu Bitcoin zijn vierde productiehalvering heeft voltooid, is het hete onderwerp op de markt of het halveringseffect volledig tot uiting is gekomen in de prijzen. Tegelijkertijd kijken mensen reikhalzend uit naar nieuwe welvaartsdrivers op de markt, waarbij ordinaalgetallen en runen belangrijke trends zijn geworden die we niet kunnen negeren.</p>
<h2 id="h2-Runes20Runes20Online20Actieve20Markt20Trading794847"><a name="Runes Runes Online, Actieve Markt Trading" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Runes Runes Online, Actieve Markt Trading</h2><p>Nu Bitcoin zijn vierde halvering heeft bereikt, blijft de populariteit van ordinale nummers en runen in het Bitcoin-ecosysteem toenemen.</p>
<p>Het innovatieve concept van rangtelwoorden, voor het eerst geïntroduceerd door @rodarmor in januari 2023, bevordert in hoge mate de ontwikkeling van inietechnologie door de hoeveelheid opgeslagen gegevens op de blockchain te vergroten. De opkomst van deze technologie heeft geleid tot talloze innovatieve toepassingen, zoals BRC-20 en runen.</p>
<p>Tegenwoordig, met de lancering van het Runes protocol tijdens de vierde Bitcoin-halvering, heeft het handelsvolume van runen een verbazingwekkende groeitrend laten zien, vaag herinnerend aan de populariteit van inies van vorig jaar.</p>
<p>Hoewel BRC20 ooit de handel in het Bitcoin-ecosysteem domineerde na de release van Ordinals, heeft @rodarmor er altijd reserves over gehad.</p>
<p>In september 2023 stelde @rodarmor officieel het concept van Runes voor via een blogartikel en analyseerde de verschillende problemen die bestaan in bestaande protocollen zoals BRC20, RGB en Taproot Assets. Vooral de BRC20-tokenstandaard ontving vorig jaar zware kritiek van Bitcoin-coreontwikkelaars vanwege de generatie van ‘rommel’ gegevens die leidt tot congestie in het Bitcoin-netwerk. We schreven ook een artikel getiteld “ <a href="https://www.gate.io/blog_detail/3691" target="_blank">Heroverweging achter de gekte: 8 Misvattingen over In_ion Debatten</a> om dit probleem te verkennen.<img src="https://gimg2.gateimg.com/image/article/17138605501.jpeg" alt=""><br>Bron: @rodarmor</p>
<p>Tegenwoordig stijgt de runehype en heeft @rodarmor’s Runes veel voordelen ten opzichte van BRC20:</p>
<p>Gemak van bediening: Runes vereenvoudigt en implementeert efficiënt, slaat op en overdraagt, vermindert transactietijden en ondersteunt meervoudige ontvangers en meervoudige tokenoverdrachten.</p>
<p>Gebruiksvriendelijkheid voor ontwikkelaars: Runes heeft een meer gebruiksvriendelijke gegevensopslag- en indexatiemethode, waarbij het UTXO-model wordt gebruikt voor eenvoudige balansbevestiging. Bovendien biedt Runes referentie-implementaties, waaronder functies zoals indexering, browser en portemonnee, waardoor de ontwikkelingscomplexiteit wordt verminderd.</p>
<p>Compatibiliteit en schaalbaarheid: Runes is compatibel met het UTXO Layer 2-protocol, maakt gebruik van smart contract functionaliteit en ondersteunt lichte portemonnee en soft fork upgrades, waardoor het schaalbaarder wordt.</p>
<p>Tokenuitgifte flexibiliteit: Runes bieden meer flexibiliteit en keuzemogelijkheden met betrekking tot de lengte van de tokennaam, naamduidelijkheid, uitgiftemethoden, enz., terwijl ze het Commit-Reveal-mechanisme aannemen om het probleem van naamwedstrijd op te lossen.</p>
<p>Veiligheid: Runen kunnen effectief weerstand bieden tegen vergiftiging en handelsaanvallen, waardoor de algehele beveiliging verbetert.<img src="https://gimg2.gateimg.com/image/article/17138605942.jpeg" alt=""><br>Bron: Openbare informatie</p>
<p>In feite, een paar uur na de lancering van het Runes-protocol op 20 april, gaven mensen meer dan 3.200 BTC (ongeveer $205 miljoen) uit aan runes, en de Bitcoin blokhandelskosten bereikten op een gegeven moment 20 BTC, waardoor mijnwerkers twee keer zoveel verdienden als voor de halvering. UniSat had in januari een wekelijks actief gebruikersaantal van 500.000, en binnen een week na de lancering van Runes klom deze indicator snel naar 1 miljoen.</p>
<p>Tot dusver heeft Gate.io ook enkele Runes-tokens gelanceerd, zoals $WANKO•MANKO•RUNES, $SATOSHI•NAKAMOTO, $MEME•ECONOMICS, enzovoort.</p>
<h2 id="h2-Bitcoinecosysteemontwikkeling20en20halvering742215"><a name="Bitcoin-ecosysteemontwikkeling en halvering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin-ecosysteemontwikkeling en halvering</h2><p>Hoewel Runes veel voordelen hebben, zijn er ook enkele belangrijke tekortkomingen.</p>
<p>Ten eerste verhogen de complexe uitgiftebeheersregels en specifieke benamingseisen niet alleen de moeilijkheidsgraad van de gebruikershandelingen, maar kunnen ze ook het risico verhogen dat gebruikers slachtoffer worden van phishing.</p>
<p>Ten tweede koos Casey ervoor om live te gaan tijdens de halveringsperiode van BTC en ontbrak het aan testnet, wat resulteerde in beperkte toegang voor vroege toegangsinstituten en de noodzaak van ecosysteemrijpheid.</p>
<p>Bovendien heeft Rune nog steeds compatibiliteitsproblemen, voornamelijk beperkt tot het distributieniveau en niet volledig geïntegreerd in een breder ecosysteem.</p>
<p>De markt is ook sceptisch of Runes een meer gebruikersvriendelijke handelservaring kan bieden, waarbij sommigen van mening zijn dat het niet significant is verbeterd ten opzichte van BRC20 en nog steeds soortgelijke problemen ondervindt.<br><img src="https://gimg2.gateimg.com/image/article/17138606343.jpeg" alt=""><br>Bron: mempool.space/</p>
<p>Ongeacht de situatie toont de explosieve lancering van Runes wel het positieve sentiment van de markt bij het deelnemen aan het Bitcoin-ecosysteem. Echter, in de huidige macro-economische en mijnbouwomgeving die niet bevorderlijk is voor de scherpe stijging van Bitcoin, heeft de markt dringend behoefte aan een nieuw verhaal na de speculatie over halvering en het tijdelijk stoppen.</p>
<p>Alleen vertrouwen op rune-hype in het Runes-protocol is niet genoeg om mijnwerkers langdurig te ondersteunen tijdens de crisis van halvering.</p>
<p>Laten we eerst de historische ervaring van het halveren van vee in de vorige rondes bekijken. Tijdens de eerste twee glen van Bitcoin-halvering, die plaatsvonden in 2012 van 50BTC naar 25BTC en in 2016 van 25BTC naar 12.5BTC, richtten technologie-enthousiastelingen in de gemeenschap zich voornamelijk op het potentieel van Bitcoin als elektronisch geld.</p>
<p>Echter, in 2020, toen de derde halvering plaatsvond, van 12,5 BTC naar 6,25 BTC, verschoof de aandacht van mensen geleidelijk naar de rol van Bitcoin als betaalmiddel, wat veel discussies veroorzaakte.</p>
<p>Nu bevinden we ons in de vierde halveringscyclus, dalend van 6,25 BTC naar 3,125 BTC. Bitcoin en de hele industrie hebben enkele ongekende nieuwe veranderingen laten zien. Met de succesvolle toepassing van Bitcoin’s spot ETF, wordt Bitcoin geleidelijk beschouwd als een alternatieve investeringsactiva, en de inrichting van traditionele instellingen en kapitaal is een nieuw aandachtspunt geworden.</p>
<p>Ondertussen wijzen zowel het opduiken van inies en runen met kortetermijnrijkdomseffecten als de lancering van protocollen zoals L2 en DeFi op basis van Bitcoin erop dat investeerders en ontwikkelaars hun enthousiasme voor het uitbreiden van Bitcoin als ecosysteemnetwerk hebben hernieuwd, wat onbeperkt ontwikkelingspotentieel en nieuwe kansen met zich meebrengt voor Bitcoin zelf.</p>
<h2 id="h2-Toekomstperspectief20van20Bitcoin802168"><a name="Toekomstperspectief van Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectief van Bitcoin</h2><p>Terugkijkend op de vorige halvering, na het evenement, was de prijs van BTC aanzienlijk gestegen en herhaaldelijk historische hoogtepunten bereikt. Dit patroon geeft de huidige cryptomarkt ook hoop dat BTC een andere briljante toekomst kan creëren.</p>
<p>Echter moet worden opgemerkt dat BTC-prijzen na elke halvering een variërende mate van retracement zullen ervaren, tot een maximum van 40%. Daarom moeten investeerders voorzichtig zijn, hoewel de markt over het algemeen optimistisch is over de halvering.<img src="https://gimg2.gateimg.com/image/article/17138606734.jpeg" alt=""><br>Bron: @ChartsBtc</p>
<p>Wat betreft deze halvering is er nog steeds geen consensus over een bullish marktoverzicht. Over het algemeen ziet de meerderheid echter nog steeds een stabiele langetermijngroei in Bitcoin. De halvering van de blockbeloningen is teruggebracht van 6,25 bitcoins naar 3,125 bitcoins, waarbij de meest directe impact een afname van de winst van mijnwerkers is. Dit zet ook mijnwerkers aan om de onderliggende technologie en netwerkdynamiek van cryptocurrencies opnieuw te beoordelen, waardoor de robuustheid van het Bitcoin-netwerk wordt verbeterd en het vertrouwen van gebruikers en bedrijven wordt vergroot.</p>
<p>Ondertussen heeft het bestaan van Bitcoin spot ETF’s gezorgd voor aanhoudende momentum voor de opkomst van Bitcoin. ETF-uitgevers in de Verenigde Staten werken hard om erkenning te krijgen van instellingen en meer retailbeleggers dan Bitcoin. Wanneer meer beleggers beseffen dat het verhogen van de vermogensallocatie met 5% voor cryptocurrencies gunstig is voor het verhogen van risicorendementen, zal dit een grotere investeringsgolf teweegbrengen.</p>
<p>In de Hong Kong-markt, Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s worden binnenkort genoteerd en staan toe dat ETF-aandelen kunnen worden ingeschreven via fysieke aflossing, wat betere mogelijkheden voor prijsvinding biedt voor traditionele instellingen en de algehele liquiditeit van Bitcoin verbetert.</p>
<p>Bovendien gedijen en ontwikkelen veel ecoen die zijn gebouwd op Bitcoin constant. Als de inies van vorig jaar de deur openden naar de constructie van het Bitcoin-ecosysteem, dan biedt Runes, in vergelijking met Runen, die duidelijke voordelen heeft laten zien op het gebied van werking, ontwikkeling, compatibiliteit, uitgifte en beveiliging, een meer uitgebreide en efficiënte oplossing voor de ontwikkeling van het ecosysteem. De lancering van andere L2- en DeFi-protocollen zal ook aanzienlijk de activawaarde van Bitcoin vrijgeven.</p>
<p>Over het algemeen heeft Bitcoin zich in de loop van vier jaar ontwikkeld, waarbij elke halvering een belangrijke mijlpaal is in zijn ontwikkeling. Hoewel de prijs van Bitcoin na halvering kan schommelen, blijft de langetermijnstabiele groeitrend onveranderd. Tegelijkertijd moeten investeerders de macro-liquiditeit en de dynamiek van de ontwikkeling van het Bitcoin-ecosysteem na halvering nauwlettend in de gaten houden en meer marktkansen grijpen.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em> Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>