Z2F0ZUxpdmUgQU1BIFJlY2FwLUFsZXhMYWI=

2023-05-15, 06:15

<p><img src="https://gimg2.gateimg.com/image/article/1684130940BlogA.jpg" alt=""></p>
<h2 id="h2-BRC2020de20standaard20token20op20de20Bitcoin20BTC20blockchain20heeft20binnen20enkele20maanden20na20de20lancering20een20marktkapitalisatie20van20meer20dan20620miljard20bereikt20Wat20is20BRC2020precies20Wat20zijn20de20meest20populaire20tokens451111"><a name="BRC-20, de standaard token op de Bitcoin (BTC) blockchain, heeft binnen enkele maanden na de lancering een marktkapitalisatie van meer dan $6 miljard bereikt. Wat is BRC-20 precies? Wat zijn de meest populaire tokens?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BRC-20, de standaard token op de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) blockchain, heeft binnen enkele maanden na de lancering een marktkapitalisatie van meer dan $6 miljard bereikt. Wat is BRC-20 precies? Wat zijn de meest populaire tokens?</h2><p><strong>Dr. Chiente Hsu (CEO en medeoprichter van Alex):</strong><br>De belangrijkste conclusie is dat met BRC20, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft nu een fungibel token standaard die het iedereen mogelijk maakt om een unieke ticker uit te rollen die een gratis munt zal starten.</p>
<p>1) gregory maxwell, andrew poelstra en pieter wuille stelden in 2018 een upgrade voor van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> protocol genaamd ‘taproot’ dat in feite twee dingen heeft verbeterd. Een daarvan is MultiSig en de andere is het versoepelen van de - en inputlimieten op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> transacties, d.w.z. optimaliseer het gebruik van blokruimte. En het is geactiveerd in november 2021.</p>
<p>2) Casey Rodarmor maakt gebruik van de versoepelde limieten en versoepelde beperkingen op invoergroottes om een eenvoudig protocol te bouwen dat brokken willekeurige gegevens inbedt in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.Toen Casey Rodarmor in januari 2023 het Ordinals-protocol lanceerde, vond hij een manier om elke Satoshi te indexeren en het gedurende het hele proces te volgen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> netwerk. Een Satoshi of sat, is de kleinste eenheid van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Het Ordinals Protocol stelt u in staat om elk type bestand on-chain in te schrijven op gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Die inie wijst naar een sat die de eigendom bijhoudt, dus wat je uiteindelijk hebt is een volledig on-chain. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT.</p>
<p>3)domodata vindt de brc-20 standaard uit, een json-indeling voor het slaan van tokens via ordinaire inies<br>Op 8 maart 2023 tweette Domodata een reeks tweets waarin een manier werd geopperd om een fungibele tokenstandaard te creëren bovenop het Ordinals-protocol, genaamd BRC-20.</p>
<p>Het staat dat iedereen Java Object Notation of JSON-bestanden kan inschrijven op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> via het Ordinals Protocol om een BRC-20 te ‘implementeren’, om $ORDI-token als voorbeeld te gebruiken, werd het geïmplementeerd met de naam ‘Ordi’, een maximum van 21 miljoen en een limiet van 1000.</p>
<p>Dan kan iedereen het gratis slaan. Alle BRC-20 tokens zijn gratis mints zonder pre-mine. Zodra $ORDI is ingezet, kan iedereen een mint JSON inschrijven die werkt totdat 21.000.000 tokens zijn geslagen.</p>
<p>Zodra de token wordt aangemaakt, kunt u beginnen met het overdragen van uw tokens door een overdracht JSON in te schrijven van hoeveel tokens u wilt verzenden.</p>
<p>Er zijn meer dan 14.000 BRC-20-tokens uitgegeven, waarbij ORDI, PIZA, MEME en MOON het populairst zijn.</p>
<p>Het laatste wat te begrijpen over zowel ordinals als BRC-20 is dat de indexers elk inie of BRC-20 token een uniek nummer toewijzen op basis van de volgorde van zijn creatie. Dus de eerste BRC-20 token is 1, de tweede is 2, enzovoort. De markt lijkt deze volgorde veel te waarderen.</p>
<p>Met NFT’s en al deze BRC20 memecoins lijkt het er zeker op dat <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> is aangekomen op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>. Als dit inderdaad het g is, hebben we veel in te halen.</p>
<h2 id="h2-Recente20activiteiten20hebben20bijgedragen20aan20de20recente20stijging20van20transactiekosten20voor20miners20samen20met20de20marktkapitalisatie20Welke20impact20zal20dit20hebben20op20miners249323"><a name="Recente activiteiten hebben bijgedragen aan de recente stijging van transactiekosten voor miners, samen met de marktkapitalisatie. Welke impact zal dit hebben op miners?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recente activiteiten hebben bijgedragen aan de recente stijging van transactiekosten voor miners, samen met de marktkapitalisatie. Welke impact zal dit hebben op miners?</h2><p><strong>Dr. Chiente Hsu (CEO en medeoprichter van Alex):</strong><br>Sinds de lancering van het Ordinals Protocol zijn er meer dan 5 miljoen inschrijvingen geweest met meer dan $27 miljoen aan Ordinals-kosten die aan mijnwerkers zijn betaald. Ordinals heeft opgelost <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>’s vergoedingsprobleem.)</p>
<p>Om dat in context te plaatsen, het huidige gemiddelde <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De transactiekosten zijn ongeveer $31, terwijl het in januari rond de $1 lag.</p>
<p>De stijging van transacties is voor meer dan 99% BRC-20 teksten voor munten en handel. De handelsactiviteit rondom deze tokens heeft bijgedragen aan dagelijkse transacties op de gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het netwerk heeft een recordhoogte van 534.000 bereikt, volgens gegevens van The Block.</p>
<p>En dit is een zeer belangrijke stap voor de toekomst van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> als een blockchain: Door de transactiekosten te verhogen, stimuleert Ordinals miners om het netwerk te blijven beveiligen en trekt het ontwikkelaars aan naar het ecosysteem, met meer gebruikers, meer adoptie en meer groei.</p>
<h2 id="h2-Deze20tokens20hebben20het20Bitcoinnetwerk20verstopt20en20het20tot20zijn20operationele20limieten20geduwd20Welke20impact20heeft20dit20op20het20Bitcoinecosysteem844881"><a name="Deze tokens hebben het Bitcoin-netwerk verstopt en het tot zijn operationele limieten geduwd. Welke impact heeft dit op het Bitcoin-ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Deze tokens hebben het Bitcoin-netwerk verstopt en het tot zijn operationele limieten geduwd. Welke impact heeft dit op het Bitcoin-ecosysteem?</h2><p><strong>Dr. Chiente Hsu(CEO en CoFounder van Alex):</strong><br>Netwerkcongestie is de aanjager van hogere transactiekosten. Congestie is een netto positief, het betekent <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is in trek bij gebruikers, dit betekent dat miners gestimuleerd worden om het netwerk te blijven beveiligen, dit betekent <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zal meer ontwikkelaars aantrekken, wat leidt tot nieuwe innovaties en meer aandacht en bredere acceptatie van nieuwe glen.</p>
<p>Om het in perspectief te plaatsen, hoewel er meer dan 400.000 uitstaande transacties zijn bij de gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> mempool, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is nog steeds duurder in gebruik. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> gas fees are why there has been so much developer activity around L2s like <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> en Arbitrum en onvermijdelijk <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Verstopping leidt tot L2-oplossingen.</p>
<p>Het is onvermijdelijk dat we hetzelfde zullen zien gebeuren met gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L2s. Schaalbaarheidslagen zijn essentieel voor het onboarden van 1 miljard mensen op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Alle wegen leiden naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, en alle wegen op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> leiden tot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L2s. Dit is het meest spannende moment voor de gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gemeenschap in het recente geheugen. Bijvoorbeeld, de Lightning Network gebruikt kanalen tussen deelnemers, zodat meerdere transacties kunnen worden afgehandeld zonder te wachten op het langzamere hoofdnetwerk om enkele uitwisselingen te bevestigen. Een ander voorbeeld is Stack, dat lijkt op. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> waardoor smart contracts worden afgehandeld op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>.</p>
<p>Natuurlijk zijn er wel wat Bitcoiners die boos zijn, maar ik zou het vergelijken met het hebben van een favoriet restaurant dat plotseling extreem populair wordt. Ja, jij als vaste klant kunt boos zijn omdat je nu langer moet wachten en de prijzen zijn gestegen, maar het betekent ook dat het restaurant waarschijnlijk niet zal sluiten. Eigenlijk zijn ze bezig met het bouwen van een tweede en derde verdieping om meer gasten te kunnen ontvangen!</p>
<p>Terugkijkend zullen we dit zien als het moment waarop <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosys-tem kwam tot leven.</p>
<h2 id="h2-ALEX20heeft20op20Twitter20aangekondigd20dat20het20de20snelste20BRC2020DEX20aan20het20bouwen20is20Vertel20ons20er20meer20over317497"><a name="ALEX heeft op Twitter aangekondigd dat het de snelste BRC-20 DEX aan het bouwen is. Vertel ons er meer over!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ALEX heeft op Twitter aangekondigd dat het de snelste BRC-20 DEX aan het bouwen is. Vertel ons er meer over!</h2><p><strong>Dr. Chiente Hsu(CEO and CoFounder of Alex):</strong><br>ALEX bouwt B20, het eerste orderboek voor BRC20-tokens. Het is alsof <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> voor BRC-20 tokens en andere <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>(L1) native assets. Wat hier spannend aan is, is dat B20 van ALEX het beste van beide lagen biedt door L1-indexering en L2-optimalisatie te combineren.</p>
<p>Op dit moment, als je iets wilt doen op gate, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Nu moet u een zeer hoge vergoeding betalen. L2 zoals <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> Werkt prima en elke TX aan <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> Werkt prima, omdat ze worden samengevoegd en in één keer worden afgewikkeld (en we daarom een hogere gasvergoeding als groep kunnen veroorloven). Schoonheid van L2.</p>
<p>Ook, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft geen slimme contractmogelijkheid. Iets geavanceerder, zoals DeFi-gerelateerd, zoals DEX, lenen/uitlenen, kan het niet aan. Daarom moeten we deze functionaliteiten op een L2 bouwen, zoals onze orderboek. Bovendien gebruiken we off-chain optimalisatie om de snelheid verder te verhogen, maar regelen we alles on-chain. Zo krijgen gebruikers een CeFi-achtige handelservaring. We matchen kopers en verkopers op basis van hun limiet- en marktorders. U kunt limietorders plaatsen om te kopen of verkopen tegen een specifieke prijs, en deze orders worden toegevoegd aan het orderboek. Marktomorders worden uitgevoerd tegen de best beschikbare prijs in het orderboek.</p>
<p>Het heeft meer geavanceerde handelsfuncties zoals stop-loss orders en uitleen-/leen-services.<br>Prijsontdekking is efficiënter in orderboek DEXes omdat deze is gebaseerd op de biedingen en verzoeken van marktdeelnemers in plaats van de <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> type AMM dat is gebaseerd op een wiskundige formule.</p>
<h2 id="h2-Wat20ziet20u20als20de20belangrijkste20uitdagingen20waar20BRC2020voor20staat20die20ALEX20oplost20Hoe20zal20de20tokennotering20op20B2020beginnen20en20hoe20snel20zal20het20gelanceerd20worden554247"><a name="Wat ziet u als de belangrijkste uitdagingen waar BRC-20 voor staat die ALEX oplost? Hoe zal de tokennotering op B20 beginnen en hoe snel zal het gelanceerd worden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat ziet u als de belangrijkste uitdagingen waar BRC-20 voor staat die ALEX oplost? Hoe zal de tokennotering op B20 beginnen en hoe snel zal het gelanceerd worden?</h2><p><strong>Dr. Chiente Hsu(CEO and CoFounder of Alex):</strong><br>Dus eigenlijk lost B20 By ALEX twee pijnpunten op:<br>1) De huidige marktplaatsen voor BRC20 worden verhandeld als NFT, met gefragmenteerde liquiditeit. ALEX’s B20 lost dit op door CEX-achtige ervaring te bieden met long tail activa<br>2) De huidige transactiesnelheid van de BRC20-marktplaats is afhankelijk van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blokkeer bevestigingstijd, duurt 20-40 minuten met beperkte doorvoer. B20 van ALEX maakt gebruik van roll-up technologie om de tijd van finaliteit en doorvoer aanzienlijk te verbeteren, waardoor een groter transactievolume mogelijk is met bliksemsnelle snelheid.</p>
<p>De notering van BRC20-projecten is al begonnen. En onze orderbook wordt hoogstwaarschijnlijk volgende woensdag gelanceerd. Om het te gebruiken, moet u wallets downloaden zoals Hiro en xVerse. Xverse / Hiro-wallets ondersteunen al <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>/BRC20, dus de interactie tussen L1 en L2 vanuit het portemonneeperspectief is klaar</p>
<p>We zullen binnenkort een medium artikel publiceren. Als u vragen heeft tijdens het gebruik van het orderboek, kunt u zich aansluiten bij onze gemeenschap via onze officiële website, onze gemeenschapsleider zal u helpen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits er naar Gate.io wordt verwezen. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>