SGV0IG1vbWVudCB3YWFyb3AgaW5zY3JpcHRpZXN0ZXJyZW4gZm9ua2VsZW4=

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR395387"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Onlangs is er opnieuw een reeks dierinies op BRC20 begonnen, wat heeft geleid tot een golf van opwinding. Katten zijn de belangrijkste inies in de sector geworden door de actieve verspreiding van de community en de promotie door meerdere KOLs.</p>
<p>Het overloopeffect van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het gebruik van inies heeft geleid tot de toenemende populariteit van inies op verschillende openbare ketens, zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> s sols, Rune Alpha’s cook, and Avalanche’s avav, asct, and BEEG.</p>
<p>Ondanks enkele controverses is de eerlijke en transparante nieuwe methode voor het uitgeven van munten op de iniemarkt zelf meer in lijn met het streven naar decentralisatie van consensus, wat liquiditeit, aandacht en welvaart voor het ecosysteem met zich meebrengt.</p>
<h2 id="h2-Inleiding385509"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Gedreven door de recente populariteit van BRC20-inies op Bitcoin, verspreidt de rage om inies op belangrijke leiders van publieke ketens te slaan en te verhandelen zich ook. Dit artikel zal de huidige populaire inies van openbare ketens introduceren om lezers te vermaken.</p>
<h2 id="h2-Zoo20Inion20Tokens20Leiden20de20Weg20in20Prijs20BRC2020Inschrijvingen20Blijven20het20Scherm20Domineren417122"><a name="Zoo Inion Tokens Leiden de Weg in Prijs, BRC20 Inschrijvingen Blijven het Scherm Domineren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zoo Inion Tokens Leiden de Weg in Prijs, BRC20 Inschrijvingen Blijven het Scherm Domineren</h2><p>Onlangs heeft een reeks van dierlijke inies op BRC20 opnieuw een golf van opwinding veroorzaakt, met zoo-inietokens vertegenwoordigd door rates, katten, muizen, beren, schildpadden, mmss, enz. die de leiding nemen in prijs. De dagelijkse toename van wel 100% zorgt voor opwinding op de markt.</p>
<p>In feite heeft UniSat Wallet al eind oktober het BRC20-swap mainnet gelanceerd, en meerdere BRC-20 tokens vernoemd naar verschillende dieren die in maart zijn ingezet, waren gek genoeg uitverkocht.</p>
<p>Als voorbeeld wordt de leidende rente genomen, de rente is in maart van dit jaar vastgesteld, met een enkele muntlimiet van 1 miljoen stuks. In de beginperiode werd de Rats geen leider door door het scherm te scrollen, maar door de actieve verspreiding van de gemeenschap en de promotie van meerdere KOLs, hebben Rats al snel Beren ingehaald en snel aan populariteit gewonnen.</p>
<p>Bijvoorbeeld, op het officiële Twitter-account van de BRC20 Chinese gemeenschap heeft Rats een leidende positie verworven. Daarnaast heeft het KOL-incubatie crypto-project SoulLand ook gepost op het officiële Twitter-platform van de gemeenschap, waarbij de oprichting van een virtueel landmark-gebouw van Rats werd aangekondigd.<br><img src="https://gimg2.gateimg.com/image/article/1702973583img_v3_0269_5bf14bee-fa51-47b8-8573-aafb638985ix.jpg" alt=""><br>Bron: twitter@soulland_en</p>
<p>Sinds half november heeft Gate.io achtereenvolgens ratten, muizen en andere producten gelanceerd, waardoor opnieuw marktsentiment voor de dierentuinmarkt is vrijgegeven. Talloze dierentuintokens zijn geroteerd en hebben prijzen aangevuld, en hebben zelfs een groot aantal <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> L2-projecten geactiveerd, zoals de Bitcoin sidechain Liquid voor institutionele diensten en de cross-chain BEVM gebaseerd op Taproot. Zelfs het Lightning Network heeft NostrAssets gelanceerd, dat applicaties en diensten biedt voor Taproot-assets en Lightning-betalingen. We zullen deze ontwikkelingen in het ecosysteem in detail bespreken in het volgende artikel.</p>
<p>Het moet worden opgemerkt dat niet alle dieren tokens in de gunst zijn glen. Volgens mediaberichten zijn diereninies zoals vossen en leeuwen, die begin november werden genoteerd, tot nu toe vrijwel genegeerd.</p>
<h2 id="h2-RUNE20Alpha20heeft20zijn20eerste20Rune2020Cook20gelanceerd513294"><a name="RUNE Alpha heeft zijn eerste Rune - Cook gelanceerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RUNE Alpha heeft zijn eerste Rune - Cook gelanceerd</h2><p>Rune Alpha is een pas gelanceerd Bitcoin-netwerk rune-project gebaseerd op Ord 0.11.1, met zijn versie gelegen in de Ordinal repository. Het moet worden opgemerkt dat dit project niet direct gerelateerd is aan het Runes-protocol dat is voorgesteld door Casey, de oprichter van het Ordinals-protocol.</p>
<p>Volgens officiële verklaringen zijn Bitcoin runen gebaseerd op het UTXO-model van Bitcoin, een gloednieuwe, unieke en vervangbare token die is ontworpen om vervangbare activa met unieke functies en metadata te vertegenwoordigen. Volgens Casey Rodarmor is het Runes-protocol dat hij wil creëren een eenvoudig, op UTXO gebaseerd FT-protocol dat Bitcoin-gebruikers een goede gebruikerservaring kan bieden. Het kan ongeldige ‘junk’ UTXO verminderen en zal het Bitcoin-netwerk niet blokkeren.</p>
<p>Hoewel zowel Rune Alpha als Casey verklaarden dat ze geen verband hielden met elkaar, had de eerste COOK-release nog steeds verkeersinmenging en steeg de prijs buiten de beurs kortstondig met ongeveer tien keer.<img src="https://gimg2.gateimg.com/image/article/1702973622img_v3_0269_2602d0b7-b7e1-4963-af46-9ccbcfe58fix.jpg" alt=""><br>Bron: Rune Alpha</p>
<p>Met de officiële lancering van de Sign-functie door Rune Alpha onlangs, zal de volgende stap zijn om het testnetwerk te openen om use cases voor s toe te voegen. De leidende rol van s als het eerste rune-concept heeft natuurlijk veel aandacht van de markt getrokken.</p>
<p>Intussen hebben ook de eerste tokenpipe gebaseerd op het Bitcoin UTXO-tokenprotocol Pipe en de ers gebaseerd op het ERC-1155-tokenprotocol Etherunes markthype veroorzaakt.</p>
<h2 id="h2-Eerste20Trending20Ecosysteem20Inschrijving20van20Solana2020Sols141593"><a name="Eerste Trending Ecosysteem Inschrijving van Solana - Sols" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eerste Trending Ecosysteem Inschrijving van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> - Sols</h2><p>Sols is de eerste Solana-ecosysteeminie gebaseerd op SPL-20, vergelijkbaar met het Ordinals-protocol BRC20, met in totaal 21.000 stuks.</p>
<p>Door de opeenvolgende sterke stijgingen van Solana in de afgelopen twee maanden en de terugkeer van zijn ecosysteem naar welvaart, heeft de markt hogere verwachtingen gegenereerd voor het inieproject van Solana. Als gevolg daarvan begon Solana zich op de avond van 16 november te richten op een breed scala van marktactiviteit.</p>
<p>Vanwege het overdreven complexe muntsysteem zijn veel mensen begonnen te twijfelen of Sols echt een inieproject is.</p>
<p>Maar deze twijfel verdween snel in de hete mint trend, en tegen 17 november begon Sols de markthandelvolume te laten zien met een transactieprijs van ongeveer $250 per vel, een stijging van maar liefst 40 keer in vergelijking met de initiële gemiddelde muntkosten.</p>
<p>In tegenstelling tot conventionele brugtokens of EVM-gebaseerde cross-chain oplossingen, onderscheidt Sols zich op Solana als het eerste inheemse uitwisselingsprotocol met inies in het ecosysteem. Dit stelt Sols in staat een kernrol te spelen in het ecosysteem van Solana, zonder afhankelijk te zijn van Layer 2-oplossingen of externe en.<br><img src="https://gimg2.gateimg.com/image/article/1702973662img_v3_0269_b6ef8842-cad1-4dbe-9e6c-200a2c9cddix.jpg" alt=""><br>Bron: Gate.io</p>
<p>Vooral na de volledige online lancering op 14 december, gesteund door Gate.io, is de prijs van Sols gestegen tot een hoogtepunt van $8,33, maar is sindsdien licht gedaald. De snelle fluctuatie van de muntkoers weerspiegelt volledig de hoge erkenning van de markt voor zijn speculatieve potentieel.</p>
<h2 id="h2-De20LawineInie20Gaat20van20Asct20naar20Avav20en20Dan20naar20BEEG831218"><a name="De Lawine-Inie Gaat van Asct naar Avav, en Dan naar BEEG" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Lawine-Inie Gaat van Asct naar Avav, en Dan naar BEEG</h2><p>Al in juni van dit jaar was de eerste inie AVAS op <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> al ingezet door Ethan, de oprichter van het domeinnaamproject. <a href="/price/tezos-xtz" rel="nofollow noopener noreferrer" target="_blank">Tezos</a> Domeinen. Echter, de marktconsensus van de eerste leidende figuur werd uitgedaagd op de <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> protocol, en op 19 november werd AVAL de eerste inie die in populariteit steeg.</p>
<p>Maar de goede tijden duurden niet lang. Asct werd een best-hit inie. Volgens de gegevens van Dune begon Asct op 7 december te worden ingezet en is het nu gestopt met slaan. Op het moment van publicatie bereikte de marktwaarde $13M.<img src="https://gimg2.gateimg.com/image/article/1702973689img_v3_0269_18e283ea-de08-4f49-bdb2-1e48cd4fc1ix.jpg" alt=""><br>Bron: Dune</p>
<p>Op 16 december kreeg de inie het officiële blauwe label en het handelsvolume klom snel boven de 27.000 AVAX, wat een sterke trend van terugkeer naar de leidende positie laat zien.</p>
<p>Echter, op de 18e maakte de nieuwe inie BEEG een sterke comeback, waardoor de populariteit van de Avalanche Protocol inie verder steeg naar de top van de belangrijkste openbare keten inie ranglijsten.</p>
<p>Cryptofishx, medeoprichter van TraderJoe, de grootste gedecentraliseerde beurs op Avalanche, kondigde maandag de lancering van de inie BEEG aan en verklaarde dat BEEG geen routekaart, geen machtiging heeft en slechts een sociaal experiment is.</p>
<p>Cryptofishx, medeoprichter van TraderJoe, de grootste gedecentraliseerde exchange op Avalanche, heeft vandaag ook (18e) de release van de inie BEEG aangekondigd. Hij verklaarde dat BEEG geen roadmap, geen machtiging heeft en slechts een sociaal experiment is.</p>
<p>Deze memetische beweging verspreidde zich snel in de gemeenschap, wat leidde tot een stijging van de gasvergoedingen op Avalanche, met een gemiddelde gasvergoeding van 5110,30 nAVAX (ongeveer $4,41). Volgens de gegevens van avascan.info is de on-chain gas op het moment van schrijven terugglen naar $0,49.</p>
<p>Na enkele omzwervingen is de huidige dominante scherm speler Avav, die aanvankelijk niet in de smaak viel.</p>
<p>De initiële muntkosten van avav lagen tussen $1,2 en $1,7, wat aanvankelijk niet erg populair was, maar na meer dan de helft van de tijd, toen alle belangrijke inies al waren geslagen, verschoof de snel groeiende gemeenschap haar aandacht naar avav.</p>
<p>Avav heeft meerdere wonderen gecreëerd, met een gasprijs van maximaal $16M en een cumulatief aantal inies van 21M. Meer dan 50000 mensen wereldwijd namen tegelijkertijd deel, maar na de lancering daalde het snel en werd het snel omhooggetrokken tot $50M door kopers.<br><img src="https://gimg2.gateimg.com/image/article/1702973731img_v3_0269_cb91981f-d824-4a16-bf68-f2fc6eac85ix.jpg" alt=""><br>Bron: Avaions</p>
<p>Het Avalanche-protocol heeft wereldwijd een brede gebruikersbasis en zijn enorme consensusenthousiasme en precies de juiste technologische voordelen hebben geleid tot het ontstaan van meerdere populaire inies op Avalanche, wat een hoogte is die andere openbare ketens nog niet hebben bereikt, tenminste voor nu.</p>
<h2 id="h2-Samenvattend177699"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>De opkomst van Bitcoin-inies en hun neveneffecten hebben ongetwijfeld deze ronde van de crypto-stierenmarkt naar een nieuw hoogtepunt geduwd. Hoewel het enige twijfels en discussies heeft veroorzaakt, is de eerlijke en transparante nieuwe muntuitgiftemethode van de iniemarkt zelf meer in overeenstemming met het consensus streven naar decentralisatie. De verhoogde liquiditeit, aandacht en ecosysteemprosperiteit die het met zich meebrengt, kunnen niet worden genegeerd.</p>
<p>Natuurlijk bestaat de markt voor inies nog steeds met risico’s en voordelen. Naarmate de tijd verstrijkt, zal de populariteit van inies geleidelijk afnemen. Deelnemers moeten voldoende onderzoek en begrip verrichten, de voor- en nadelen van het project identificeren, en irrationele misverstanden vermijden die ontstaan door mee te doen aan FOMO.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>