UGFuZG9yYSBibGlqZnQgaGVldCwgd2F0IGlzIGRlIG9wa29tZW5kZSBFUkM0MDQgVG9rZW4/

2024-02-20, 13:36

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR44252"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Pandora is de eerste token gebaseerd op ERC404, een open source experimentele standaard voor makers en ontwikkelaars, met de kenmerken van ERC20 en ERC721, met eigen liquiditeit en fragmentatie.</p>
<p>De ERC404-standaard lost niet alleen het probleem van lage liquiditeit in NFT’s op door eigendomsfragmentatie te implementeren, maar ontketent ook verder het liquiditeitspotentieel van NFT’s door financiële middelen zoals leningen en derivaten.</p>
<p>De eerste versie van het ERC404-protocol had regels voor het genereren van nieuwe NFT’s, wat zou kunnen leiden tot verlies van NFT-uniekheid, onredelijke tokenoverdrachtslogica en hoge uitvoeringskosten voor contracten.</p>
<h2 id="h2-Introductie201433"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Onlangs heeft de cryptogemeenschap sterke interesse getoond in een nieuwe tokenstandaard genaamd ERC404, die tot doel heeft de liquiditeit van NFT’s te verbeteren en op slimme wijze de kenmerken van ERC20 en ERC721 combineert.</p>
<p>In deze context blijft de prijs van de eerste token die Pandora gebaseerd is op de ERC404-standaard stijgen, zelfs records breken. Dus, waar komt ERC404 precies vandaan? Wat betekent het? En hoe zal ERC404 toekomstige kansen laten zien? Dit artikel zal een grondige interpretatie geven.</p>
<h2 id="h2-Wat20is20de20ERC404standaard211798"><a name="Wat is de ERC404-standaard?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de ERC404-standaard?</h2><p>De recentelijk populaire on-chain token Pandora is de eerste token gebaseerd op ERC404, wat een golf van FOMO op de markt heeft veroorzaakt. In feite is ERC404 een open source experimentele standaard voor makers en ontwikkelaars, waarin de kenmerken van ERC20 en ERC721 zijn geïntegreerd, met native liquiditeit en fragmentatie.</p>
<p>Volgens publieke informatie werd de token standaard gecreëerd door @maybectrlfreak (ctrl) en @searnseele (Searn), en de kern standaard werd gepubliceerd door voormalig Coinbase ingenieur @0xacme op Github.<br><img src="https://gimg2.gateimg.com/image/article/1708514805img_v3_0288_fbff7929-3c4b-4d48-858f-2fc04468e8ix.jpg" alt=""><br>Bron: GitHub</p>
<p>ERC404 komt voort uit het EMERALD contractaanvalsevenement, dat een kwetsbaarheid heeft waardoor iedereen zeewier kan overdragen en uit een vooraf bepaald zwembad kan putten. Hoewel dit incident resulteerde in het verlies van $30.000 voor CTRL, zag hij ook het potentieel van ERC404. Na mislukte reparatievoorstellen van CTRL, Acme en Searn besloten ze om Pandora zelf te lanceren.</p>
<p>Dus, wat is precies deze ERC404? Simpel gezegd, het maakt gebruik van de sterke punten van de ERC20- en ERC721-standaarden, waardoor tokens en NFT’s harmonieus kunnen samengaan en tegelijkertijd onafhankelijk kunnen worden gekocht en verkocht. Dit is als het oplossen van een groot probleem, waardoor de oorspronkelijk onverenigbare ERC20 en ERC721 vreedzaam kunnen samenleven.</p>
<p>Neem bijvoorbeeld het recente Pandora. Wanneer een gebruiker de Pandora-token op de keten koopt, ontvangt hij voor elke Pandora-token die hij koopt een gloednieuwe NFT. Wanneer gebruikers deze token willen overdragen, zal de vorige NFT verdwijnen en een gloednieuwe NFT geboren worden.</p>
<p>Nog miraculeuzer is dat de zeldzaamheid van deze nieuw gegenereerde NFT nog steeds willekeurig is, wat de norm doorbreekt en een nieuwe manier creëert voor tokens en NFT’s om met elkaar te communiceren.</p>
<h2 id="h2-Pandoras20Populariteit20Stijgt20Explosief20Graph20Coin20ExchangeDynamische20Zeldzaamheid257540"><a name="Pandora’s Populariteit Stijgt Explosief: Graph Coin Exchange+Dynamische Zeldzaamheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pandora’s Populariteit Stijgt Explosief: Graph Coin Exchange+Dynamische Zeldzaamheid</h2><p>Pandora, als de eerste token gebaseerd op het ERC404-protocol, heeft de laatste tijd een voortdurende toename van populariteit op de markt gezien. Volgens CoinMarketcap is de marktwaarde van de munt gedaald van het hoogste punt van $253M naar $141M, waarbij transacties binnen 24 uur $30M hebben bereikt.</p>
<p>De gameplay van deze token is behoorlijk nieuw, zoals eerder uitgelegd. Laten we het hier kort uiteenzetten.</p>
<p>Het Pandora-project heeft 10.000 NFT’s (genaamd Pandora NFT’s) uitgebracht, die niet verschillen van gewone <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> NFT’s en kunnen vrij verhandeld worden op NFT-platforms zoals OpenSea en Blur. Tegelijkertijd heeft het ook 10.000 ERC-20 tokens (Pandora ERC20) uitgegeven, die niet verschillen van ERC-20 tokens die verhandeld worden op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> en kan worden verhandeld op elke DEX.</p>
<p>Dit ontwerp stelt Pandora in staat om bij uitgifte een hoge liquiditeit en gemakkelijke handel in ERC-20 tokens te hebben. Telkens wanneer een gebruiker een Pandora ERC20-token koopt op Uniswap, ontvangen ze niet alleen de token, maar ook automatisch een Pandora NFT met willekeurige eigenschappen, die een normale of zeldzame stijl kan zijn, met in totaal 5 kleuren voor schaarste differentiatie.<img src="https://gimg2.gateimg.com/image/article/1708514855img_v3_0288_7d3495a1-519d-49a2-a82c-d903ac20faix.jpg" alt=""><br>Bron: pandora.build</p>
<p>Samengevat lost de ERC404-standaard niet alleen het probleem van lage liquiditeit in NFT’s op door eigendomsfragmentatie te implementeren, maar ontgrendelt ook verder het liquiditeitspotentieel van NFT’s door financiële middelen zoals lenen en derivaten. Deze liquiditeitsontwerp dat de kenmerken van NFT’s en ERC-20 tokens integreert, is een innovatieve functie die bestaande NFT’s en ERC-20 tokens niet bezitten, waardoor de liquiditeit van NFT’s wordt ontsloten. Zoals je kunt zien, is er veel ruimte voor verbeelding.</p>
<h2 id="h2-Toekomstperspectieven20van20de20ERC404tokenstandaard288069"><a name="Toekomstperspectieven van de ERC404-tokenstandaard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectieven van de ERC404-tokenstandaard</h2><p>Sinds Pandora opkwam en de markt verstoord heeft, zijn er ook een reeks ecosysteemprojecten ontstaan.</p>
<p>Bijvoorbeeld, het eerste kunstverzamelobject van de ERC404-standaard, Palatte, het on-chain hefboomprotocol dat de ERC404-standaard ondersteunt; Wasabi Protocol, Pandora Altcoin project ANON, enzovoort. Een tijdlang zagen veel mensen de opkomst van ERC404 als een signaal van een sterke ETH-herstel dit jaar.</p>
<p>Het moet echter worden opgemerkt dat hoewel Pandora-tokens en ERC404-standaarden innovatieve gefragmenteerde NFT-eigendom en liquiditeitsoplossingen met zich meebrengen, we ook hun bestaande problemen en uitdagingen moeten aanpakken.</p>
<p>De initiële versie van het ERC404-protocol had regels voor het genereren van nieuwe NFT’s, wat kon leiden tot verlies van NFT-uniekheid, onredelijke tokenoverdrachtslogica en hoge gasuitvoerkosten van het contract.</p>
<p>Bovendien is ERC404 nog steeds een experimentele standaard. De algehele standaard is nog niet definitief vastgesteld en het contract is nog niet gecontroleerd.</p>
<p>Onlangs heeft het Pandora-team ook enkele herstellende maatregelen genomen. Om de veiligheid van de kluis te waarborgen, heeft de officiële instantie een nieuwe opgezet.2⁄4multi-signing mechanism om de eigendom van PANDORA-tokens, liquiditeitspools (LP) en waardevolle activa in de kluis over te dragen naar het nieuwe mechanisme, waardoor de beveiliging verder wordt versterkt in het proces van uitbreiding en bouwpraktijken. Deze vier ondertekenaars zijn allemaal uitgerust met speciale hardware wallets die speciaal zijn ontworpen om transactiehandelingen uit te voeren via een multi-handtekeningenmechanisme.</p>
<p>Over het algemeen heeft ERC-404 de handel niet alleen op gedeeltelijk gecentraliseerde beurzen (CEX) bereikt, maar ook de traditionele NFT-producten gerevolutioneerd door een unieke “grafisch munt symbiose relatie” op te bouwen. De geschiedenis van de crypto-industrie heeft bewezen dat elke innovatie in vermogensuitgifte lange verhalen en discussies teweegbrengt, net zoals de inies in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem, of de hybride standaard en programmeerbare tokens in het Ethereum-ecosysteem.</p>
<p>Hoewel het niet mogelijk is om de toekomstige ontwikkeling van ERC404 te voorspellen en of het kan samenvloeien met andere projecten om nieuwe innovatieve punten te genereren, is deze beheersmethode om voorheen onverenigbare tokenstandaarden te integreren in een set slimme contracten ongetwijfeld een belangrijke doorbraak en innovatie in het model voor het uitgeven van activa.<br><img src="https://gimg2.gateimg.com/image/article/1708514906img_v3_0288_460e98bd-f764-440f-a0e9-24059a09baix.jpg" alt=""><br>Bron: @Pandora_ERC404</p>
<p>Ten slotte, zoals het gezegde luidt, gaat ERC404 altijd gepaard met hoge volatiliteit, en de recente 70% terugval duidt op een groot spel van consensus op de Pandora-markt. Daarom moeten investeerders kalm blijven, letten op veiligheid en voorzichtig investeren.</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 standpunten 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 wordt er juridische actie ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>