SG9ldmVlbCB2YW4gZGUgdG9wIDEwIHRva2VucyBpbiBoZXQgQml0Y29pbi1lY29zeXN0ZWVtIGhlYiBqZSBnZcOvbnZlc3RlZXJkPw==

2023-12-22, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<p>De cryptomarkt van dit jaar is erg spannend, met <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> heropleving, Layer 2 en modulaire blockchain. Maar als het gaat om de helderste ster van dit jaar, kan het niemand anders zijn dan de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem.</p>
<p>Net zoals hoe <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Werd gebruikt om de hele blockchaint wereld te verbazen met slimme contracten, de 23-jarige trend van inies is ook een nieuw verhaal dat mensen in staat stelt om “meer mogelijkheden te bouwen op de Bitcoin-blockchain” te zien.</p>
<p>Hier zullen we kort de huidige top 10 tokens introduceren op basis van marktwaarde. De ranglijst op basis van marktwaardegegevens is afkomstig van X-gebruiker @0xSea.eth.</p>
<h2 id="h2-TOP1STX709376"><a name="TOP1-$STX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP1-$STX</h2><p>STX is de native token van de <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> het netwerk, dat Layer2 op de BTC-keten is en tot doel heeft slimme contracten op <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> te implementeren.<br><img src="https://gimg2.gateimg.com/image/article/1703216113img_v3_026c_79823990-e0fe-4df0-bca8-5608514317ix.jpg" alt=""></p>
<p>Met de opkomst van Bitcoin-gebaseerde NFT-projecten zoals Ordinals, is de positie van <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> het afgelopen jaar sterk gestegen. Volgens DefiLlama is het aantal vergrendelde fondsen in Stacks sinds het begin van dit jaar gestegen van $7 miljoen naar $50 miljoen. Ondertussen is $STX sinds investeerder Tim Draper positieve feedback heeft gegeven over Stacks, snel gestegen met 30%.</p>
<p>Stacks kan gezien worden als de leider in economische toepassingen op Bitcoin, met als doel de hoeksteen te bouwen van Defi, Dapp en meer toepassingen. Stacks introduceert het concept van ‘sBTC’, dat aan BTC gekoppeld zal zijn, waardoor de Stacks-laag $500 miljard aan BTC-kapitaal kan vrijgeven, waardoor de maximale en meest duurzame gedecentraliseerde activa voor meer mensen en meer gebruikstoepassingen beschikbaar komen.</p>
<p>Nu kunnen Stacks ook BTC verdienen door deel te nemen aan consensus, STX vast te houden en tijdelijk te vergrendelen, en netwerkbeveiliging en consensus te ondersteunen. De consensusbeloning is verdeeld over meer dan 2000 Bitcoins, en het is niet verrassend dat de TVL en marktwaarde zo geweldig zijn.</p>
<h2 id="h2-TOP2sats865869"><a name="TOP2-$sats" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP2-$sats</h2><p>$Sats is de eerste batch tokens die zijn uitgegeven met behulp van het BRC-20-protocol, vernoemd naar de kleinste eenheid van Bitcoin, satoshi, met een overeenkomstig maximale voorraad van 21 miljoen.</p>
<p>In het begin was Sats meer als een memecoin, maar na te zijn gebruikt als transactiekosten op UniSats, kreeg het ongetwijfeld een meer stabiel en veelzijdig toepassingsscenario. Na de lancering van CEX werd zijn status verder erkend; De individuele waarde van Sats is relatief laag en de holdings zijn ook verspreid, maar het heeft geen sterke daling ervaren na een golf van winsten; Nu heeft zijn totale marktwaarde ORDI overtroffen.<br><img src="https://gimg2.gateimg.com/image/article/1703216156img_v3_026c_66e9edaa-705b-4a75-9712-13c63b874fix.jpg" alt=""></p>
<h2 id="h2-TOP3ordi982775"><a name="TOP3-$ordi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP3-$ordi</h2><p>Misschien wel de meest bekende BRC-20 token voor iedereen, en ook de eerste BRC-20 token gemaakt door communitygebruiker @ Domo; Destijds trok ORDI de meeste aandacht omdat het rechtstreeks was gebouwd op de BTC-blockchain, en zijn naam was ook afgeleid van het Ordinals-protocol.</p>
<p>Spelers kunnen hun eigen Ordi-tokens creëren en bestellingen plaatsen voor transacties door te munten, te implementeren en in te schrijven op de keten. De essentie van het Ordinals-protocol is een logica van tekstindexering en herordenen, die verschilt van de functie van slimme contracten. Het hoeft niet te worden voltooid via bepaalde specifieke platforms of applicaties en vereist alleen lage Gas-kosten om zijn eigen inie-assets te creëren.</p>
<p>Sinds het begin van 2023 hebben veel spelers het potentieel van Ordi gezien als een toonaangevend project in het nieuwe traject van het BTC-ecosysteem en hebben eraan deelgenomen. De prijs is gestegen van slechts afhankelijk zijn van gasvergoedingen tot inies, minder dan een paar cent, tot bijna 70U op de secundaire markt.</p>
<p>De BRC-20-token heeft echter ook veel controverses teweeggebracht, zoals het verhogen van de belasting op Bitcoin-blokken. Sommige mensen geloven dat dit de zuiverheid van Bitcoin als gedecentraliseerd grootboek ondermijnt. Het moet echter worden gezegd dat degenen die aanvankelijk deelnamen aan de inies van Ordi op de primaire markt de meest verbazingwekkende rijkdomscode van het jaar onder de knie hebben gekregen, en sommigen verwijzen zelfs naar inies als ‘geld drukken’. Vanuit het oogpunt van groei is dit op zijn minst niet onredelijk. De huidige langetermijnwaarde van de inieactiva moet echter nog steeds rustig worden waargenomen.</p>
<h2 id="h2-TOP4Mubi571577"><a name="TOP4-$Mubi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP4-$Mubi</h2><p>Mubi is de inheemse token van MultiBit, de eerste tweezijdige brug in de geschiedenis die is ontworpen om cross-network transacties tussen BRC20- en ERC20-tokens te vergemakkelijken. Over het algemeen verplaatsen gebruikers BRC20-tokens naar speciale BRC20-adressen. Na bevestiging kunnen deze tokens worden gemunt op het EVM-netwerk. De uniciteit van MultiBit ligt echter in zijn tweezijdige brugfunctie, waarmee naadloos kan worden overgeschakeld van het EVM-netwerk naar Bitcoin.</p>
<p>Door de liquiditeit van deze tokens te bevorderen, verbetert MultiBit de interoperabiliteit tussen verschillende blockchains. Het doel is om de liquiditeit en toegankelijkheid van BRC- en ERC-tokens op een veilige en gebruiksvriendelijke manier te verbeteren.</p>
<p>Op 20 december bedraagt de marktwaarde van MUBI ongeveer $340 miljoen, met een totale voorraad van 1 miljard.</p>
<h2 id="h2-TOP205Rats217277"><a name="TOP 5-$Rats" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP 5-$Rats</h2><p>RATS is een BRC-20 token gemaakt via het Ordinals protocol, met een huidige marktwaarde van ongeveer $330 miljoen. Het is een typische memecoin.</p>
<p>Het hoogtepunt van RATS ligt in zijn actieve communityondersteuning en het ontwerp van de afbeelding is zeer succesvol. De impliciete betekenis van ‘kleine en talloze ongenode gasten in de blockchain’ heeft ook de psyche van veel spelers geraakt. RATS voltooide de volledige circulatie in november.<br><img src="https://gimg2.gateimg.com/image/article/1703216201img_v3_026c_6b653f8e-2f12-4e3b-a5ac-7427773be5ix.jpg" alt=""></p>
<h2 id="h2-TOP6Atom713639"><a name="TOP6-$Atom" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP6-$Atom</h2><p>ATOM is een token gebaseerd op de ARC-20 standaard van de Bitcoin blockchain en behoort tot het Atomicals protocol.</p>
<p>Het Atomicals Protocol is een eenvoudig en flexibel protocol dat wordt gebruikt om NFT’s te maken, over te dragen en bij te werken voor UTXO-blockchains zoals Bitcoin. Atomic (of ‘atomisch’) is een manier om de creatie, overdracht en bijwerking van digitale objecten te organiseren - het is in wezen een digitale eigendomsketen die is gedefinieerd op basis van enkele eenvoudige regels.</p>
<p>Vanuit het perspectief van ontwikkelaars is Atomic de eenvoudigste manier om digitale activa op blockchains zoals Bitcoin te organiseren. Atomicals heeft een breed scala aan toepassingen, zoals spelmechanica, kunstcollecties, virtueel land, enz., maar mist momenteel enige stabiliteit.<br><img src="https://gimg2.gateimg.com/image/article/1703216224img_v3_026c_c2873a0c-45af-4bd8-b7a9-cad8b97849ix.jpg" alt=""></p>
<h2 id="h2-TOP7ALEX483537"><a name="TOP7-$ALEX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP7-$ALEX</h2><p>ALEX is het eerste platform dat via Stacks one-stop DeFi-diensten op Bitcoin aanbiedt. Op basis van Bitcoin-leningen kunnen slimme contracten die deze leningen beheren, worden gebruikt om obligaties te creëren. Door gebruik te maken van deze gedecentraliseerde obligaties kunnen derivatenproducten, hefboomwerking en alle andere geavanceerde financiële functies opnieuw worden gecreëerd en vervangen worden door algoritmes van geautomatiseerde liquiditeitsbeurzen of ALEX.</p>
<p>De huidige circulatievoorraad van $ALEX is 600 miljoen stuks, met een maximale voorraad van 1 miljard.</p>
<h2 id="h2-TOP8Trac572490"><a name="TOP8-$Trac" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP8-$Trac</h2><p>$TRAC is een token gebaseerd op de BRC-20 standaard, vergelijkbaar met ORDI, met een totale circulatie van 21 miljoen tokens.</p>
<p>De huidige omloopwaarde van TRAC is $140 miljoen.</p>
<h2 id="h2-TOP9RIF393284"><a name="TOP9-$RIF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP9-$RIF</h2><p>$RIF is het native token van Rootstock Infrastructure Framework, dat een open en gedecentraliseerd infrastructuurprotocol toepast om gedistribueerde applicaties (dApps) sneller, gemakkelijker en schaalbaarder te ontwikkelen in een uniforme omgeving. Door open-source en gedecentraliseerde tools en technologieën aan te bieden, is het eenvoudig om toegankelijke DeFi-producten te bouwen.</p>
<p>RIF Rollup wordt ondersteund door zkRollup-technologie, en spelers die geïnteresseerd zijn in <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> weten misschien dat zkRollUp een Layer2-oplossing is die wordt gebruikt om doorvoerproblemen op te lossen, een trustless protocol voor snelle, schaalbare en goedkope betalingen op Rootstock. De huidige functies en reikwijdte omvatten de goedkope overdracht van RBTC en ERC20-tokens op het Rootstock-netwerk.</p>
<p>Over het algemeen heeft RIF een brug gebouwd tussen complexe blockchain technologie en naadloze gebruikerservaring, waarbij open en gedecentraliseerde tools en technologieën worden aangeboden, met een huidige marktwaarde van ongeveer $130 miljoen.</p>
<p>In het Bitcoin-ecosysteem verschillen tokens met onderliggende architecturen zoals $RIF, STX, ALEX, STX, etc. van die met inies. Je kunt de dynamiek van het project in de gaten houden en het economische model begrijpen, en je kunt ook handelen op het Gate-platform.</p>
<h2 id="h2-TOP10PIPE713075"><a name="TOP10-$PIPE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP10-$PIPE</h2><p>PIPE is een Bitcoin lokaal token protocol geïnspireerd door Casey Rodarmor’s RUNES en Ordinal’s BRC-20 ideeën.</p>
<p>Vanwege het feit dat RUNES geen eerlijke muntcreatie toestaat (een belangrijk aspect van BRC-20) en mogelijk alle tokens waardevolle effecten maakt, probeert PIPE de voordelen van deze twee concepten te combineren.</p>
<p>PIPE bestaat uit drie functies: implementatie, muntproductie en overdracht, wat vergelijkbaar is met BRC-20. De implementatiefunctie geeft aan dat een nieuwe token is geïmplementeerd, terwijl de muntproductiefunctie munten toestaat om te worden geslagen van die token op basis van implementatieregels (aanbod, beperking). Tenslotte wordt de overdrachtsfunctie gebruikt om tokens naar de geselecteerde ontvanger te sturen.</p>
<p>Op dit moment bedraagt de circulerende marktwaarde van pipeline ongeveer 130 miljoen, en pipeline heeft geen index of portemonnee. Met meer gespecialiseerde markten om pipeline-munt en -handel te ondersteunen, wordt verwacht dat het ook een positief keteneffect kan veroorzaken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry</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 op 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>