Qml0Y29pbidzIE1lbWUgQ29pbiBSZW5haXNzYW5jZTogSG9lIGluc3RpdHV0aW9uZWxlIGJlbGVnZ2VycyB1aXQgQXppw6sgbW9nZWxpamsgZGUgZ3JvZWkgdmFuIFJ1bmVzIGt1bm5lbiBzdGltdWxlcmVu

2024-06-13, 01:41

<p><img src="https://gimg2.gateimg.com/image/article/1718242605sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR286378"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Veel instellingen gevestigd in Azië zijn bereid om te investeren in het Runes-protocol.</p>
<p>Newman Group, Magic Eden en OKX zijn voorbeelden van organisaties die al hebben geïnvesteerd in het Runes-protocol.</p>
<p>De Dog Go to the Moon-token is een van de toonaangevende meme-munten op het Runes-protocol.</p>
<h2 id="h2-Introductie533850"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De lancering van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Runen op 20 april, de dag waarop de BTC-halvering plaatsvond, gaven veel hoop aan de cryptosector. Veel mensen geloven dat de Runen- en Ordinals-inies levendigheid hebben gebracht in de blockchain, omdat de twee protocollen kunnen helpen bij het in stand houden van het netwerk via transactiekosten. Die veronderstelling leek te zijn… <a href="https://www.gate.io/learn/articles/introducing-runes-the-next-step-in-bitcoins-fungible-token-protocols/1327" target="_blank">gideerd door de stijging van de transactiekosten van Runes</a> gedurende de komende weken. Echter, keerde het tij toen het niveau van Runes gegenereerde transactiekosten in de afgelopen weken daalde. In dit artikel bespreken we hoe institutionele beleggers uit Azië de groei van Runes kunnen stimuleren.</p>
<h2 id="h2-Stenencasten20van20Bitcoins20rotsige20start998283"><a name="Stenencasten van Bitcoin’s rotsige start" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stenencasten van Bitcoin’s rotsige start</h2><p>Het verhaal van het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> Runes-protocol, een slim contract voor het maken van mememunten, heeft gemengde signalen gestuurd naar de cryptogemeenschap. Na de lancering van het protocol op 20 april was er een golf van activiteit die leidde tot een astronomische stijging van de bitcoin-transactiekosten. Een paar dagen na de lancering werden meer dan honderd tickers toegevoegd aan het bitcoin-netwerk. <a href="https://www.gate.io/learn/articles/what-is-the-bitcoin-rune-protocol/2621" target="_blank">met behulp van het Runes-protocol</a>. Opmerkelijk genoeg waren er binnen drie dagen na de lancering van de Runen meer dan 1 miljoen transacties.</p>
<p>Helaas daalde in de daaropvolgende week het transactievolume op het protocol met meer dan 90%, waardoor sommige analisten de duurzaamheid van het Runes-protocol in twijfel trokken. Echter, eind mei was er hernieuwde activiteit op het protocol. Net als voorheen, zwakte de koorts op het Runes-protocol opnieuw af. Sindsdien is het activiteitsniveau op het protocol zeer laag gebleven. De volgende grafiek toont de groei van het Runes-volume sinds de lancering van het protocol.<br><img src="https://gimg2.gateimg.com/image/article/171824270511.jpeg" alt=""><br>Runes Transactie Volumes - <a href="https://www.aliteq.com/wp-content/uploads/2024/06/2Runes.png" rel="nofollow noopener noreferrer" target="_blank">GenniData</a></p>
<p>Als <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> geeft aan dat de handelsvolumes hoog waren tijdens april en de eerste week van mei. Daarna daalde het scherp. De heropleving van de bitcoin Runes kan echter leiden tot een stijging van meme coins. Bovendien kan de uitbreiding van het bitcoin gaming-ecosysteem een stijging van de vraag naar het protocol en de resulterende handelsvolumes veroorzaken.</p>
<h2 id="h2-Institutionele20optimisme20drijft20Runes20Protocol144715"><a name="Institutionele optimisme drijft Runes Protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Institutionele optimisme drijft Runes Protocol</h2><p>Hoewel de <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Hoewel de belangstelling voor het Runes-protocol leek te zijn afgenomen binnen de westerse digitale activamarkt, brengen Aziatische institutionele beleggers het project nieuw leven in doordat ze bereid zijn om meer financiële middelen dan voorheen te storten. Een reden voor hun interesse in het protocol is de sterke eigenschappen zoals geoptimaliseerde transactiemodellen, beveiligingsfuncties en robuuste schaalbaarheid.</p>
<p>Sommige Aziatische institutionele beleggers zoals de Newman Group, Magic Eden en OKX zijn bereid om het Runes-protocol te omarmen om hun verschillende functionaliteiten te stimuleren en te voldoen aan hun unieke behoeften. Zo werkt de Newman Group, via haar portfoliobedrijven Liquidium en Xverse, aan de lancering van haar producten op het Runes-protocol.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/understanding-bitcoin-s-layer-1-runes-protocol/1963" target="_blank">Het begrijpen van het Layer 1 Runes Protocol van Bitcoin</a></p>
<p>Aan de andere kant heeft Magic Eden, een cross-chain NFT-marktplaats, haar platform geïntegreerd met het Runes-protocol. Op vergelijkbare wijze heeft OKX, een toonaangevende gecentraliseerde beurs in Azië, ook geïntegreerd met het protocol, waardoor het nul-tarief transacties kan aanbieden. Een andere reden voor institutioneel enthousiasme voor Runes is het vermogen van het protocol om naadloos te interageren met andere crypto-projecten. Overigens is dat een reden waarom OKX ervoor heeft gekozen om het bitcoin meme-muntprotocol te integreren.</p>
<p>Volgens een verklaring geciteerd door Aliteq, <a href="https://www.aliteq.com/can-institutional-investors-in-asia-help-bitcoin-runes-revive/" rel="nofollow noopener noreferrer" target="_blank">Adrian Lai, oprichter van Newman Group, zei</a>, “We geloven dat Runes uiteindelijk zouden kunnen worden <a href="https://www.gate.io/learn/articles/what-are-bitcoin-runes-and-how-do-they-differ-from-brc-20-tokens/2782" target="_blank">groter dan BRC-20</a>, met name wanneer men de voordelen voor institutionele beleggers in overweging neemt. De technische voordelen van Runes en het efficiënte potentieel voor cross-chain transacties zouden het de voorkeurskeuze kunnen maken voor instellingen die toegang willen krijgen tot DeFi op Bitcoin.</p>
<p>Paige Xu, een investeerder bij OKX, gelooft ook in het langetermijnpotentieel van het Runes-protocol. <a href="https://www.aliteq.com/can-institutional-investors-in-asia-help-bitcoin-runes-revive/" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>“Runes heeft de juiste dingen, waaronder efficiëntie en een dunne blockchain-voetafdruk (energiezuinig, draagt bij aan de vermindering van broeikasgassen), technologie waar organisaties vaak naar op zoek zijn, om snel aan de grote vraag te voldoen”.</p>
<p>Xu denkt echter dat de groei van het Rune-protocol mogelijk veel meer tijd kan vergen. Hij voegde eraan toe: “De adoptie van op Bitcoin gebaseerde technologie zoals deze is nog steeds vrij nieuw en hangt sterk af van het opleidingsniveau en de integratie van deze activa in de bredere financiële wereld.”</p>
<h2 id="h2-Runes20Protocol20bereikt20een20marktkapitalisatie20van20220miljard622701"><a name="Runes Protocol bereikt een marktkapitalisatie van $2 miljard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Runes Protocol bereikt een marktkapitalisatie van $2 miljard</h2><p>Zoals eerder aangegeven was er enige activiteit op het Runes-protocol enkele dagen geleden. <a href="https://www.gate.io/learn/articles/navigating-runes-protocol-launch-beyond-the-initial-hype/2850" target="_blank">na de lancering in april</a>. Tegen het einde van mei had de marktkapitalisatie van Runes $1 miljard bereikt. Echter, vanwege de aanhoudende interesse in bitcoin-gebaseerde memecoins is de totale waardering ervan de $2 miljard overschreden. Naarmate de adoptie van het Runes-protocol blijft stijgen dankzij institutionele steun, kan de marktkapitalisatie van Runes blijven groeien.</p>
<p>In feite is het ontwikkelingsteam van het Runes-protocol gericht op het verbeteren van technische voordelen van bitcoin, zoals efficiëntie en kosteneffectiviteit. De schaalbaarheid van het Runes-protocol is bijvoorbeeld één van de belangrijkste attracties van het gehele systeem. Casey Rodarmor, die ook de oprichter is van de <a href="https://www.gate.io/learn/articles/what-are-bitcoin-ordinals/508" target="_blank">Ordinalen protocol</a>, is van mening dat het Runes-protocol een veilige, schaalbare en efficiënte bitcoin fungibele token standaard smart contract is.</p>
<h2 id="h2-Analyse20van20de20functies20van20Runes142510"><a name="Analyse van de functies van Runes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyse van de functies van Runes</h2><p>Zoals gezegd geven veel investeerders de voorkeur aan het Runes-protocol boven het Ordinals-protocol vanwege verschillende redenen, waaronder het gebruiksgemak. Ook hebben verschillende analisten gereageerd op de technische voordelen van bitcoin Runes, zoals schaalbaarheid en efficiëntie. Bijvoorbeeld, <a href="https://decrypt.co/233430/bitcoin-runes-resurgence-asia-institutional-investors" rel="nofollow noopener noreferrer" target="_blank">Ciara Sun, oprichter</a> en managing partner van C Squared Ventures, een op Azië gericht crypto-investeringsbedrijf, vertelde Decrypt: ‘Runes is gestructureerd om mogelijk te voldoen aan de strenge eisen van institutionele beleggers, waarbij schaalbaarheid, efficiëntie en veiligheid benadrukt worden’.</p>
<p>Volgens dezelfde bron zei Xu: “Runes heeft de juiste eigenschappen - efficiëntie en een slanke blockchain-voetafdruk - waar instellingen doorgaans naar zoeken in technologie die veilig zware vraag aankan.”</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/runes-protocol-and-the-open-etching-issuance-mechanism/2610" target="_blank">Runes-protocol en het uitgiftemechanisme van ‘open etsen’</a></p>
<h2 id="h2-Prijsstijging20van20DOG20en20andere20Runestokens344078"><a name="Prijsstijging van DOG en andere Runes-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijsstijging van DOG en andere Runes-tokens</h2><p>De Dog Go to the Moon-token (DOG), gelanceerd op 20 april op het Runes-protocol, staat nu op de derde plaats op het bitcoin-netwerk en op de zevende plaats in de gehele memecoin-markt. Met een marktkapitalisatie van $759.987.083 en een handelswaarde van $0,00774 heeft DOG in de afgelopen 2 weken met 86% gewonnen en in de afgelopen 30 dagen met 189%. De volgende afbeelding toont enkele van de toonaangevende tokens op het Runes-protocol die het ook goed doen.<br><img src="https://gimg2.gateimg.com/image/article/171824284412.jpeg" alt=""><br>memecoins op Runes Protocol - <a href="https://s3.magazine.cointelegraph.com/magazine/wp-content/uploads/2024/04/0xNefu.png" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph</a></p>
<p>Zoals u opmerkt, is RSIC met een marktkapitalisatie van meer dan $300 miljoen een andere toonaangevende mememunt op het Runes-protocol.</p>
<h2 id="h2-Potentie20van20runen20voorbij20de20hype793079"><a name="Potentie van runen: voorbij de hype" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potentie van runen: voorbij de hype</h2><p>Het vooruitzicht van het Runes-protocol is geweldig, gezien het feit dat veel investeerders er veel interesse in hebben. Om echter de adoptie ervan te vergroten, is het nodig om leden van de cryptogemeenschap, waaronder ontwikkelaars en projectleiders, erover te informeren. De mogelijkheid van het Runes-protocol om activa te integreren in de bredere financiële wereld is cruciaal voor de toekomstige groei en adoptie ervan.</p>
<h2 id="h2-Conclusie983998"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Er is hoop dat de markt een opleving van bitcoin meme munten kan zien na een aanzienlijke investering van Aziatische institutionele beleggers in het Runes-protocol. Bijvoorbeeld, Newman Group, Magic Eden en OKX hebben al in het project geïnvesteerd. Dergelijke institutionele beleggers zijn bereid te investeren in het protocol vanwege de uitstekende functies zoals hoge schaalbaarheid, kosteneffectiviteit en efficiëntie.</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 genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>