UGFuZG9yYSBjb250aW51YSBhZCBlc3NlcmUgY2FsZGEsIGNvcyfDqCBpbCB0b2tlbiBFUkM0MDQgZW1lcmdlbnRlPw==

2024-02-20, 13:36

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR152072"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Pandora è il primo token basato su ERC404, che è uno standard sperimentale open source per creatori e sviluppatori, integrando le caratteristiche di ERC20 e ERC721, con liquidità nativa e frammentazione.</p>
<p>Lo standard ERC404 non solo risolve il problema della bassa liquidità nelle NFT implementando la frammentazione della proprietà, ma sblocca ulteriormente il potenziale di liquidità delle NFT attraverso strumenti finanziari come prestiti e derivati.</p>
<p>La versione iniziale del protocollo ERC404 aveva regole per la generazione di nuovi NFT, il che potrebbe portare alla perdita dell’unicità degli NFT, una logica irragionevole di trasferimento dei token e costi elevati di esecuzione del contratto.</p>
<h2 id="h2-Introduzione110712"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Di recente, la comunità cripto ha mostrato un forte interesse in uno nuovo standard di token chiamato ERC404, che mira a migliorare la liquidità degli NFT e combina intelligentemente le caratteristiche di ERC20 e ERC721.</p>
<p>In questo contesto, il prezzo del primo token che Pandora basato sullo standard ERC404 continua a salire, addirittura battendo record. Quindi, da dove esattamente proviene ERC404? Cosa significa? E come mostrerà ERC404 le future opportunità? Questo articolo fornirà un’interpretazione approfondita.</p>
<h2 id="h2-Qual2020lo20standard20ERC404600478"><a name="Qual è lo standard ERC404?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è lo standard ERC404?</h2><p>Il token on-chain Pandora, recentemente popolare, è il primo token basato su ERC404, che ha scatenato una ondata di FOMO sul mercato. In realtà, ERC404 è uno standard sperimentale open source per creatori e sviluppatori, che integra le caratteristiche di ERC20 e ERC721, con liquidità nativa e frammentazione.</p>
<p>Secondo le informazioni pubbliche, lo standard del token è stato creato da @maybectrlfreak (ctrl) e @searnseele (Searn), e lo standard principale è stato pubblicato dall’ex ingegnere di Coinbase @0xacme su Github.<br><img src="https://gimg2.gateimg.com/image/article/1708514805img_v3_0288_fbff7929-3c4b-4d48-858f-2fc04468e8ix.jpg" alt=""><br>Sorgente: GitHub</p>
<p>ERC404 ha origine dall’evento di attacco al contratto EMERALD, che presenta una vulnerabilità che consente a chiunque di trasferire e esaurire alghe da un pool predefinito. Sebbene questo incidente abbia comportato una perdita di $30.000 per CTRL, ha anche visto il potenziale di ERC404. Dopo che CTRL, Acme e Searn hanno fallito nel fornire suggerimenti di riparazione, hanno deciso di lanciare Pandora da soli.</p>
<p>Quindi, cos’è esattamente questo ERC404? In parole semplici, si basa sui punti di forza degli standard ERC20 e ERC721, consentendo a token e NFT di coesistere armoniosamente mentre possono anche condurre acquisti e vendite indipendenti. Questo è come risolvere un grande problema, consentendo all’originariamente incompatibile ERC20 e ERC721 di coesistere pacificamente.</p>
<p>Prendi ad esempio l’ultimo Pandora. Quando un utente acquista il token Pandora sulla catena, riceverà un nuovo NFT per ogni token Pandora acquistato. Quando gli utenti vogliono scambiare questo token, il precedente NFT scomparirà e ne nascerà uno nuovo.</p>
<p>Ancora più miracolosamente, la rarità di questo NFT appena generato è ancora casuale, il che rompe la norma e crea un nuovo modo per i token e gli NFT di interagire.</p>
<h2 id="h2-Popolarit20di20Pandora20in20aumento20Graph20Coin20Exchange2020Dynamic20Rarity305474"><a name="Popolarità di Pandora in aumento: Graph Coin Exchange + Dynamic Rarity" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Popolarità di Pandora in aumento: Graph Coin Exchange + Dynamic Rarity</h2><p>Pandora, come il primo token basato sul protocollo ERC404, ha recentemente visto un aumento continuo della popolarità di mercato. Secondo CoinMarketcap, il valore di mercato della moneta è sceso dal massimo di $253M a $141M, con transazioni che hanno raggiunto $30M entro 24 ore.</p>
<p>Il gameplay di questo token è piuttosto innovativo, come già spiegato. Vediamolo brevemente qui.</p>
<p>Il progetto Pandora ha rilasciato 10.000 NFT (chiamati Pandora NFT), che non sono diversi dai comuni <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> NFT e possono essere scambiati liberamente su piattaforme NFT come OpenSea e Blur. Allo stesso tempo, ha anche emesso 10.000 token ERC-20 (Pandora ERC20), che non sono diversi dai token ERC-20 scambiati su <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> e può essere scambiato su qualsiasi DEX.</p>
<p>Questo design consente a Pandora di avere un’elevata liquidità e una negoziazione conveniente dei token ERC-20 al momento dell’emissione. Ogni volta che un utente acquista un token Pandora ERC20 su Uniswap, non solo riceve il token, ma riceve automaticamente anche un Pandora NFT con attributi casuali, che può essere uno stile normale o raro, con un totale di 5 colori per differenziare la scarsità.<img src="https://gimg2.gateimg.com/image/article/1708514855img_v3_0288_7d3495a1-519d-49a2-a82c-d903ac20faix.jpg" alt=""><br>Origine: pandora.build</p>
<p>In sintesi, lo standard ERC404 non solo risolve il problema della bassa liquidità degli NFT attraverso l’implementazione della frammentazione della proprietà, ma libera ulteriormente il potenziale di liquidità degli NFT attraverso mezzi finanziari come prestiti e derivati. Questo design di liquidità che integra le caratteristiche degli NFT e dei token ERC-20 è una caratteristica innovativa che gli attuali NFT e token ERC-20 non possiedono, liberando la liquidità degli NFT. Come puoi vedere, c’è molto spazio per l’immaginazione.</p>
<h2 id="h2-Prospettive20future20dello20standard20di20token20ERC404958778"><a name="Prospettive future dello standard di token ERC404" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future dello standard di token ERC404</h2><p>Dal momento che Pandora è emersa e ha disrupto il mercato, sono emersi anche una serie di progetti di ecosistema.</p>
<p>Ad esempio, il primo collezionabile artistico dello standard ERC404, Palatte, il protocollo di leva su catena che supporta lo standard ERC404; Wasabi Protocol, il progetto Altcoin Pandora ANON, e così via. Per un po’, molte persone hanno visto la crescita di ERC404 come un segnale di forte ripresa di ETH quest’anno.</p>
<p>Tuttavia, va notato che sebbene i token Pandora e gli standard ERC404 portino innovative soluzioni frammentate di proprietà e liquidità NFT, dobbiamo anche affrontare i loro problemi e sfide esistenti.</p>
<p>La versione iniziale del protocollo ERC404 aveva regole per la generazione di nuovi NFT, che potevano portare alla perdita dell’unicità degli NFT, alla logica di trasferimento del token non ragionevole e ai costi elevati di esecuzione del contratto gas.</p>
<p>Inoltre, l’ERC404 è ancora uno standard sperimentale. Lo standard complessivo non è stato finalizzato e il contratto non è stato sottoposto a revisione.</p>
<p>Recentemente, il team di Pandora ha adottato anche alcune misure correttive. Per garantire la sicurezza della stanza blindata, l’ufficiale ha istituito una nuova2⁄4meccanismo di multi-firma per trasferire la proprietà dei token PANDORA, dei pool di liquidità (LP) e degli asset di valore nella cassaforte al nuovo meccanismo, rafforzando ulteriormente la sicurezza nel processo di espansione e costruzione. Questi quattro firmatari sono tutti dotati di portafogli hardware dedicati appositamente progettati per effettuare operazioni di transazione attraverso un meccanismo di multi firma.</p>
<p>In generale, ERC-404 ha raggiunto il trading non solo su scambi parzialmente centralizzati (CEX), ma ha anche rivoluzionato i prodotti NFT tradizionali costruendo una singolare “relazione di simbiosi di monete grafiche”. La storia dell’industria crittografica ha dimostrato che ogni innovazione nell’emissione di asset scatena lunghi racconti e discussioni, proprio come le iscrizioni nel, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosistema, o gli standard ibridi e i token programmabili nell’ecosistema Ethereum.</p>
<p>Anche se non è possibile prevedere lo sviluppo futuro di ERC404 e se può combinarsi con altri progetti per generare nuovi punti innovativi, questo metodo di gestione che integra standard di token precedentemente incompatibili in un insieme di smart contract è senza dubbio una svolta importante e un’innovazione nel modello di emissione di asset.<img src="https://gimg2.gateimg.com/image/article/1708514906img_v3_0288_460e98bd-f764-440f-a0e9-24059a09baix.jpg" alt=""><br>Origine: @Pandora_ERC404</p>
<p>Infine, come dice il proverbio, ERC404 è sempre accompagnato da alta volatilità e il recente ritracciamento del 70% indica un enorme gioco di consenso nel mercato di Pandora. Pertanto, gli investitori devono rimanere calmi, prestare attenzione alla sicurezza e investire con cautela.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>