S2FuIGRlIEJSQy00MjAgQmx1ZSBCb3ggZGUgJ1BhbmRvcmEncyBCb3gnIHppam4gZGllIGhldCBCaXRjb2luLWVjb3N5c3RlZW0gb3BlbnQ/

2024-01-25, 07:22

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR352153"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>BRC-420协议 —— De eerste inieproject gebaseerd op het Bitcoin-metaversum;</p>
<p>De blauwe doos is vergelijkbaar met de moederdoos van het $Raca ecosysteem;</p>
<p>Blue Box is actively promoting the development of a full-chain game eco for Bitcoin;</p>
<p>Met het succes van het BRC-420-protocol en het Blue Box-project markeert dit het begin van een nieuwe hoogtepunt voor het BTC-ecosysteem.</p>
<h2 id="h2-Inleiding782113"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Onlangs heeft de ontwikkeling van de inierace geleid tot een FOMO-trend op de markt, waarbij iedereen zich een voorstelling maakt van het bitcoin-ecosysteem in het metaversum.</p>
<p>Het BRC-420-protocol is het eerste inieproject in de metaverse van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en de vloerprijs van de NFT Blue Box die het lanceert steeg in korte tijd van $ 0,15 naar $ 17.000, met een piek van $ 25.000, een stijging van meer dan 160.000 keer, wat heeft geleid tot brede aandacht voor de Bitcoin-metaverse.</p>
<h2 id="h2-Wat20is20het20BRC420protocol398230"><a name="Wat is het BRC-420-protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het BRC-420-protocol</h2><p>Kort gezegd is BRC-420 een activabeheerprotocol gebaseerd op ordinaal en bitmaps op BTC.</p>
<p>Bitmap is een metaverse-project in het Bitcoin-ecosysteem, gebaseerd op de Oridnals-ordetheorie en de bitmap-theorie, die correspondeert met het bloknummer en wordt gedefinieerd als het land van BTC.</p>
<p>RCSV is de projectpartij van BRC-420 en is momenteel een team dat op basis van bitmaps werkt aan de ontwikkeling van het BTC-metaversum. Blue Box is het eerste BRC-420 activum uitgegeven door RCSV, de projectpartij van BRC-420.<br><a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON crypto</a></p>
<p>BRC420 Blue Box is similar to the mother box of $Raca ecology. As an asset management protocol on BTC, it is promoted by RCSV. It is said that the holder of the blue box will receive ecological income dividends and enjoy airdrops of ecological cooperation projects and whitelist qualifications for Bitcoin ecological cooperation projects from time to time.</p>
<p>Hoewel de blauwe doos op het eerste gezicht een NFT is, wordt er gezegd dat deze binnenkort getokeniseerd zal worden, waarbij elke blauwe doos kan worden ingewisseld voor 2100 tokens om de liquiditeit te waarborgen en het gemakkelijker te maken voor grote fondsen om posities in te nemen en voor market makers om transacties uit te voeren.</p>
<h2 id="h2-Voortdurend20doorbraak20van20de20vloerprijs850419"><a name="Voortdurend doorbraak van de vloerprijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voortdurend doorbraak van de vloerprijs</h2><p>Door het verhaal van de Blue Box dat het verhaal van de metaverse van de grote taart volgt, samen met het feit dat bitmap zelf al erg goed gestegen is, is het dus alleen maar blijven stijgen. En bitmap is momenteel het meest waardevolle project in de markt van ordinals inie-NFT’s.</p>
<p>De huidige prijs van de Blue Box is 0.4269 BTC (gegevens bijgewerkt tot 19 januari 2024), met een totale hoeveelheid van 10.000 en een marktkapitalisatie van ongeveer 200 miljoen. Op basis van CoinmarketCap-gegevens en rekening houdend met de potentiële omvang van de Bitcoin-ecosysteem en de ervaring van de vorige bullmarkt, wordt verwacht dat de toekomstige marktkapitalisatie tussen de 200.000 en 500.000 dollar zal liggen.</p>
<p>Deelnemers aan Blue Box zullen profiteren van het Bitcoin-ecosysteem, of ze nu houders zijn of makers in het ecosysteem, ze zullen aanzienlijke opbrengsten behalen tijdens deze door Bitcoin gedomineerde bullmarkt. Daarom kan BRC420 worden beschouwd als een geldboom en is het de beste manier om deel te nemen aan het Bitcoin-ecosysteem en betrokken te raken bij NFT en GameFi.<br><img src="https://gimg2.gateimg.com/image/article/1706167240img_v3_027e_c925775e-f5a6-466e-8f56-cc2b3a4143ix.jpg" alt=""></p>
<p>Het BRC-420-protocol kan meerdere inies combineren tot een complexe activa, waardoor verschillende schalen van activa kunnen worden gecreëerd, van kleine personages en huisdieren tot complete game-s en virtuele machines. Vanwege de open-source aard op de keten kan elke client deze uitvoeren of verifiëren, wat ten volle de geest van ‘Client Agnostic’ van het volledige ketenspel weerspiegelt, waardoor de verbeeldingsruimte en prijsverwachtingen in één keer worden geopend.</p>
<p>Hoewel de Bitmap-browser van RCSV de markt domineert, hebben andere teams ook de mogelijkheid om een client te ontwikkelen om de activa van BRC-420 uit te voeren. Tegenwoordig heeft het aantal houders van Bitmap-adressen Sandbox overtroffen en is het de meest voorkomende houder van metaverse-activa op de hele keten geworden. Dit succes is te danken aan het eerlijke lanceringsmechanisme en de gezamenlijke inspanningen van meer dan 200 ontwikkelingsteams rond Bitmap.</p>
<p>Met de lancering van de Bitmap-browser en het protocol zelf groeit ook de marktwaarde van BRC-420 gestaag.</p>
<p>RCSV, as the project party of BRC-420, is actively promoting the full-chain gaming plan of Bitcoin ecology. The plan emphasizes assets, gameplay, logic, and data on the full chain, aiming to create a truly decentralized Bitcoin on-chain gaming eco. For example, developers can use the ‘Fighting Module’ on BRC-420 to quickly develop and release new games, while only needing to pay royalties through the protocol.</p>
<p>Mingwen-Blue Box, as a product under the BRC-420 protocol, its rapid increase in floor price not only reflects the market’s high expectations for the project, but also demonstrates investors’ recognition of the future development potential of the metaverse track. The concept of floor price refers to the lowest acceptable buying price in the market, and the soaring floor price of Mingwen-Blue Box undoubtedly indicates its scarcity and unique value.<br><img src="https://gimg2.gateimg.com/image/article/1706167269img_v3_027e_75303757-6391-42ed-8856-8b192ca2f0ix.jpg" alt=""></p>
<h2 id="h2-Waarom20is20het20populair20op20de20markt960299"><a name="Waarom is het populair op de markt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is het populair op de markt?</h2><p>De reden waarom de Inschrijving - Blue Box zoveel aandacht heeft gekregen op de markt, is voornamelijk te danken aan de volgende punten:</p>
<ol>
<li>Ecological Tools: Op dit moment is de handel in BRC20 voornamelijk geconcentreerd op OKX en Unisat. Met de opkomst van andere protocollen zijn er ook verschillende handelsmarkten ontstaan. Uiteindelijk zal de opkomst van een toonaangevend protocol een unieke handelsmarkt creëren, en de concurrentie op de handelsmarkt is nog lang niet voorbij.</li></ol>
<p>Met de voortdurende toestroom van kapitaal naar de markt voor inies, beginnen gebruikers hun aandacht te richten op toepassingen op basis van inies. BRC420 is een typisch voorbeeld. Unisat brengt innovatie naar BRC20 en met BRC20-Swap kunnen gebruikers gemakkelijk BRC20-tokens uitwisselen, net als bij AMM DEX. Dit heeft het potentieel om het DeFi-ecosysteem van Bitcoin vrij te maken en er kunnen meer functies zoals leningen en derivaten verschijnen.</p>
<ol>
<li>Met het concept van het metaversum: Met de trend van Bitcoin Layer2 wordt het bouwen van een metaversum-ecosysteem op Bitcoin geleidelijk een nieuwe hotspot op de markt, en Mingwen-Blue Box is geboren op basis van dit concept.</li></ol>
<p>In maart 2023 voorspelt Galaxy Research and Mining dat de marktkapitalisatie van de Ordinals-markt tegen 2025 $5 miljard zal bedragen. Op dat moment waren er slechts 260.000 inies, maar nu zijn er al 33 miljoen, een groei van 126 keer. Tegelijkertijd is de marktkapitalisatie van Dragon One ORDIs gestegen tot $400 miljoen en is de marktkapitalisatie van Dragon Two SATS ook gestegen tot $300 miljoen. Het is duidelijk dat de voorspellingen voor de Bitcoin-ecosysteemmarkt sterk zijn onderschat.</p>
<ol>
<li>Investeringsvooruitzichten: Veel investeerders zijn optimistisch over de langetermijnvooruitzichten van het metaverse en geloven dat vroege investeringen enorme rendementen kunnen opleveren. Er zijn nu verschillende protocollen opgedoken op het spoor van inies, waarvan de mijnwerkers het meest profiteren, wat een positieve cyclus is. Volgens gegevens van Tokenview over de keten bedroegen de dagelijkse transactiekosten van het Bitcoin-netwerk 11,6 miljoen dollar, voor het eerst sinds 2020 meer dan die van Ethereum.</li></ol>
<p>Met de aanstaande halvering van Bitcoin hebben mijnwerkers dringend behoefte aan extra inkomsten. De bloei van de Inion Track brengt niet alleen voordelen voor mijnwerkers, maar draagt ook indirect bij aan de beveiliging van het Bitcoin-netwerk. De vermindering van de blokbeloning zal mijnwerkers afhankelijker maken van transactiekosten om operationele kosten te dekken. In de toekomst zal er concurrentie zijn tussen verschillende schaalbaarheidsoplossingen voor Bitcoin, en de explosie van de Inion Track en de hoge transactiekosten zullen een katalysator zijn voor toekomstige ontwikkeling.</p>
<ol>
<li>Technische innovatie: Brc420 is een echte innovatie in de monetaire inhoud, na Brc20. Voorheen waren er alleen NFT’s en tokens, maar nu is er een geconsolideerde portefeuille die door middel van recursie wordt voltooid. Bovendien is er innovatieve liquiditeitsvrijgave, wat het moment is dat echt de aandacht van de hele markt trekt.</li></ol>
<h2 id="h2-Conclusie811703"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het BRC-420-protocol en het bijbehorende Bitmap-project stimuleren innovatie en dynamiek in het Bitcoin-ecosysteem. Door het creëren van complexe, modulaire digitale activa biedt BRC-420 nieuwe economische kansen en interactieve ervaringen voor makers, ontwikkelaars en gebruikers. Met de voortdurende inspanningen van het RCSV-team wordt het concept van full-chain games en metaverse in het Bitcoin-ecosysteem langzaam werkelijkheid, waarbij de brede vooruitzichten van Bitcoin-technologie en -toepassingen worden getoond.</p>
<p>Met de vooruitgang van de technologie en een dieper begrip van de markt, hebben we alle reden om te geloven dat dit gebied nog meer innovaties en kansen zal blijven voortbrengen. Voor investeerders is het cruciaal om de ontwikkelingen in het metaverse te blijven volgen en rationeel te analyseren, aangezien dit essentieel is om toekomstige kansen te benutten.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Byron B.</strong>, Onderzoeker bij Gate.io<br>  <div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br>  </em><div><em></em> Deze inhoud is origineel en het auteursrecht behoort toe aan Gate.io, als u het wilt herdrukken, gelieve de auteur en de bron te vermelden, anders zullen er juridische consequenties zijn.<br></div><p></p><br></div></div></div>