T1JESSBiZXJlaWt0IGVlbiBuaWV1dyBob29ndGVwdW50LCBhbmFseXNlZXIgZGUgdHJlbmRzIGVuIG9udHdpa2tlbGluZ2VuIHZhbiBCaXRjb2luLWluc2NyaXB0aWVz

2023-12-06, 07:59

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR428885"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Volgens de gegevens van Gate.io bedraagt de huidige marktwaarde van ORDI meer dan $1,3 miljard, met een handelsvolume van bijna $30 miljoen in 24 uur, en staat het op de derde plaats op de lijst van populaire zoekopdrachten.</p>
<p>Naast ORDI zijn er ook populaire ingeschreven tokens zoals SATS, RATS, OXBT, MEME, enzovoort.</p>
<p>Het ecosysteem gecreëerd door Ordinals is voldoende om te dienen als een nieuwe verhaallijn voor het uitgeven van activa op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Deze opkomende fenomeen fluctueert in consensusgroei en publieke kritiek, om uiteindelijk de ontdekking van waarde te realiseren.</p>
<h2 id="h2-Introductie271531"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De Bitcoin-markt is altijd vol met hete onderwerpen, en de inie hete markt is ongetwijfeld de meest opvallende van dit jaar. De inies vertegenwoordigd door ORDI hebben niet alleen een aanzienlijke invloed op de waarde van Bitcoin, maar bieden ons ook een nieuw perspectief op het begrijpen van de cryptocurrency-markt.</p>
<p>Dus, hoe zijn deze inies populair geworden en welke andere populaire inies zijn het waard om te leren kennen? Laten we deze kwesties samen verkennen.</p>
<h2 id="h2-ORDI20Racete20helemaal20naar20de20MAAN10929"><a name="ORDI Racete helemaal naar de MAAN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ORDI Racete helemaal naar de MAAN</h2><p>Op de schrijfdatum is ORDI ondanks kleine aanpassingen nog steeds met 27,87% gestegen in de afgelopen 24 uur en heeft een rendement van 250% behaald in de afgelopen 7 dagen.</p>
<p>Volgens de gegevens van Gate.io bedraagt de huidige marktkapitalisatie van ORDI $1.3 miljard, met een handelsvolume van 24 uur dat bijna $30 miljoen nadert, waarmee het op de derde plaats staat op de hot search-lijst.<img src="https://gimg2.gateimg.com/image/article/170184940815971701849201_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>In feite werd het Ordinals-protocol al begin dit jaar gelanceerd, omdat het gebruikers op creatieve wijze in staat stelt media zoals afbeeldingen en tekst in de Bitcoin-blockchain te ‘schrijven’. Deze innovatieve stap is populair geworden zonder de oorspronkelijke vereisten van de Bitcoin-gemeenschap aan te tasten.</p>
<p>In maart van dit jaar konden gebruikers alternatieve tokens maken via de BRC-20 standaard. Als eerste token in zijn soort, uitgebracht door de anonieme maker Domo, voldoet ORDI natuurlijk aan de wet van het eerste-release-effect in de branche en wordt het de eerste benchmark in de inierace.</p>
<p>Na de stilte van Bitcoin-inies gedurende een half jaar, is de publieke investeringsdrang teruggekeerd naar deze sector. Als leider is ORDI ook wijdverbreid aangenomen, met de steun van beurzen zoals Gate en de lancering van nieuwe functies van Ordinals, wat heeft geleid tot een aanzienlijke stijging van de muntkoersen. Afgelopen week heeft ORDI zijn grootste stijging tot nu toe meegemaakt.</p>
<p>Volgens CoinMarketCap gegevens is ORDI altijd al de grootste token geweest in de BRC20 markt, gerangschikt op de 66e plaats op basis van marktwaarde, op de voet gevolgd door SATS, TRAC en RATS.<img src="https://gimg2.gateimg.com/image/article/170184944115981701849212_.pic.jpg" alt=""><br>Bron: CoinMarketcap</p>
<h2 id="h2-Die20onderscheidende20inies20die20zijn20voortgekomen20uit20de20cryptowereld696675"><a name="Die onderscheidende inies die zijn voortgekomen uit de cryptowereld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Die onderscheidende inies die zijn voortgekomen uit de cryptowereld</h2><p>We hebben verschillende artikelen geschreven waarin we de oorsprong van ORDI introduceren, dus we zullen hier niet te veel in detail treden. Lezers kunnen klikken op <a href="https://www.gate.io/blog_detail/3438/new-narrative-of-the-bull-market-bitcoin-eco-development-landscape" target="_blank">Nieuwe vertelling van de stierenmarkt - Bitcoin ecosysteem ontwikkelingslandschap</a> om te bladeren en te bekijken. Dit artikel richt zich op het introduceren van andere zeer populaire BRC20-tokens.</p>
<p><strong>SATS</strong><br>SATS is de negende ingeschreven token op basis van het Brc-20 protocol en de volledige naam is satoshis. Satoshi is de kleinste eenheid in Bitcoin, vaak aangeduid als satoshi of Bit satoshi.</p>
<p>In het Bitcoin-systeem is één BTC (Bitcoin) gelijk aan 100 miljoen satoshi. De totale omloop bedraagt 2100 biljoen yuan, wat gelijk is aan 21 miljoen BTC’s.</p>
<p>SATS’s marktaandacht, totale marktwaarde, en zelfs ORDI in november overtroffen, en werd daarmee de meest cultureel belangrijke populaire token. Met de steun van Unisat voor Sats als gasvergoeding op L2 en andere positieve factoren is Sats nu de token met de hoogste marktwaarde op een na, na ORDI.</p>
<p><strong>RATS</strong><br>Rats is een soort BRC20-serie inieactiva, opgericht in maart van dit jaar, met een maximale enkele muntslaglimiet van 1 miljoen stuks.</p>
<p>Als een inbreedingstoken van Sats wordt het succes van RATS ook toegeschreven aan de samenhang van gemeenschapsleden op het consensusniveau. Het leent de creativiteit van dierlijke Meme-munten en neemt culturele bindingfactoren uit zowel het Oosten als het Westen op. De Rats-gemeenschap heeft ooit het Twitter-promotieplatform veroverd.</p>
<p>De overeenkomstige relatie tussen “rat” en “mint” wordt op slimme wijze gebruikt in community marketing, en tekstspelletjes zoals deze zitten vol humor en beeldspraak, waardoor mensen onmiddellijk de kenmerken van RATS-tokens kunnen herinneren.</p>
<p><strong>OXBT</strong><br>OXBT is een BRC20-token uitgegeven door het Redacted NFT-project, met in totaal 2 miljard tokens. Deze zomer bereikte de on-chain handelsvolume van OXBT 10 keer dat van Ordi.</p>
<p><strong>MEME</strong><br>MEME is de tweede BRC20-token met een aanbod van slechts 99.999 tokens, en elke inbreng kan slechts een maximum van 1 MEME slaan.</p>
<p>Na zorgvuldige overweging van het token toewijzingsmechanisme waren er al meer dan 2000 houders van $meme nadat de munt was geslagen, en dit aantal is nu gestegen tot 5071.</p>
<p><strong>MAAN</strong><br>De MOON-token, afgeleid van de uitdrukking TO DA MOON in de cryptogemeenschap, heeft ook een grote aanhang, met een beperkte voorraad van slechts 100 miljoen munten en 6685 houders, wat op de 10e plaats staat qua marktwaarde in deze sector.</p>
<h2 id="h2-De20Potentile20Ruimte20van20BRC2020Inschrijving219247"><a name="De Potentiële Ruimte van BRC20 Inschrijving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Potentiële Ruimte van BRC20 Inschrijving</h2><p>In feite is BRC-20 een benchmark voor de klassieke <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> protocol ERC-20, en zijn werkingsgebied en afgeleide ecosysteem zullen ook gebaseerd zijn op ERC-20. Maar in vergelijking met het ERC-20-protocol, is dit protocol geënt op de Bitcoin-gemeenschap met de hoogste consensus en heeft het een ruimere bedrijfsruimte en verspreidingsplatform.</p>
<p>Als gevolg hiervan wordt de waarde van deze track geleidelijk vrijgegeven, met meer rechtvaardige gemeenschappelijke muntmethoden en de voortdurende upgrading van het BRC-20-protocol, en steeds meer instellingen en beurzen (zoals Gate.io) beginnen zich aan te sluiten, uit te breiden en de waarde ervan toe te passen.</p>
<p>Over het algemeen heeft deze experimentele standaard voor het munten van munten on-chain, die het Ordinals-protocol gebruikt om inies op elke satoshi te slaan (satoshi is de kleinste eenheid van Bitcoin, 1 satoshi is 0,0000001btc), de kenmerken van eerlijke uitgifte en hoge beveiliging, waardoor een groep inies van nature zelfpropagerende MEME-eigenschappen heeft.</p>
<p>Uiteindelijk wordt de recente stijging van BRC20-tokens gedreven door zowel speculatief sentiment als investeringswaarde, met verschillende specifieke redenen:</p>
<p>De uitgifte van BRC20-tokens is relatief eerlijk en alle gebruikers die munten worden op gelijke wijze behandeld. Het projectteam kan geen extra BRC20-tokens reserveren of uitgeven. Zelfs als de uitgever de uitgegeven BRC20-tokens wil verkrijgen, moeten ze deelnemen aan het munten. Dit maakt de BRC20-token van nature schaars, waardoor het de aandacht van investeerders trekt.</p>
<p>De BRC20-token heeft een hoge beveiliging en maakt gebruik van het beveiligingsmechanisme van de Bitcoin-keten, dat bestand is tegen aanvallen. Dit maakt de BRC20-token betrouwbaarder voor investeerders.</p>
<p>Het BRC20-tokenecosysteem ontwikkelt zich voortdurend en er zijn een aantal hoogwaardige BRC20-tokenprojecten ontstaan. Deze projecten bestrijken meerdere gebieden zoals betalingen, DeFi, NFT en GameFi, en hebben veel potentieel.</p>
<p>Echter, als het hierop aankomt, moeten we nog steeds letten op het feit dat deze consensus nog steeds fragiel is in vergelijking met Bitcoin, en de snelle veranderingen in sentiment op korte termijn zullen synchroon worden weerspiegeld in de munt prijs, en kunnen zelfs de strategieën van veel institutionele beleggers beïnvloeden om af te wijken.</p>
<p>Gate.io heeft op 5 december 2023 een 100% reserve snapshot uitgebracht van de top projecten van het BRC20 ecosysteem op het platform, als reactie op recente marktschommelingen.<img src="https://gimg2.gateimg.com/image/article/170184951815991701849230_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>In feite was de aanzienlijke toename van het handelsvolume op de avond van 4 december 2023 voornamelijk te wijten aan aanzienlijke marktfluctuaties die avond, wat leidde tot problemen met de handelsstrategieën van sommige kwantitatieve institutionele gebruikers. Het is niet ongebruikelijk dat institutionele gebruikersstrategieën afwijken tijdens marktfluctuaties, maar gebruikers moeten nog steeds rendementen en risico’s in evenwicht houden en beheersen.</p>
<p>Kortom, het ecosysteem dat is gecreëerd door Ordinals is voldoende als een nieuwe verhaallijn voor het uitgeven van activa op de Bitcoin-keten. Dit opkomende fenomeen fluctueert in consensusgroei en publieke kritiek en realiseert uiteindelijk de ontdekking van waarde. We zijn bereid deze innovatie te omarmen en nieuwe waarden te verkennen.</p>
<p>Tenslotte moet worden vermeld dat de waarde van nieuwe dingen dynamisch evolueert, en Rome is niet in één dag gebouwd. Daarom moeten investeerders nog steeds voorzichtig blijven wanneer ze te maken hebben met de eerder genoemde hete projecten.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>