VHV0dG8gY2nDsiBjaGUgZGV2aSBzYXBlcmUgc3VsbCdvcHBvcnR1bml0w6AgZGkgZWNvc2lzdGVtYSBCTEFTVCBhaXJkcm9wcGVkIGRpIHF1ZXN0YSBzZXR0aW1hbmE=

2024-06-25, 07:41

<p><img src="https://gimg2.gateimg.com/image/article/17193010391690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR845127"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Blast è stato lanciato da Pacman, fondatore di Blur, il 21 novembre 2023, progettato appositamente per offrire opportunità di guadagno passivo per i fondi nei conti Layer2.</p>
<p>I principali vantaggi di Blast sono più evidenti nel suo design di generazione di entrate e nella comunicazione di marketing di “guadagnare punti e attrarre persone.”</p>
<p>L’ufficiale Blast ha annunciato di recente che lancerà un evento di airdrop il 26 giugno di questa settimana.</p>
<h2 id="h2-Introduzione555351"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Blast, una blockchain pubblica di Layer2, che ha guadagnato popolarità l’anno scorso, è finalmente pronta a emettere monete. L’annuncio ufficiale di Blast ha recentemente annunciato che lancerà attività di airdrop il 26 giugno di questa settimana e i suoi progetti di ecosistema potrebbero essere lanciati o emettere monete successivamente. Blast, che scambia punti per airdrop, può contribuire alla popolarità del settore Ethereum? Quali sono i punti salienti dello sviluppo di questo ecosistema? Questo articolo approfondirà questo argomento.</p>
<h2 id="h2-I20Introduzione20a20Blast873929"><a name="I. Introduzione a Blast" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I. Introduzione a Blast</h2><p>Blast è stato lanciato da Pacman, fondatore di Blur, il 21 novembre 2023, e ha rapidamente attirato l’attenzione diffusa nella comunità cripto grazie al suo design specializzato per offrire opportunità di guadagno passive per i fondi nei conti Layer2.<br><img src="https://gimg2.gateimg.com/image/article/17193010891.jpg" alt=""><br>Origine: blast.io</p>
<p>Attraverso questa strategia completa, Blast spera di rivoluzionare l’industria cripto, fornendo agli utenti canali di apprezzamento sicuri, convenienti ed efficienti per la ricchezza e iniettando nuova liquidità nel mercato cripto attraverso il suo sistema di entrate automatico, guidando lo sviluppo di tutta l’industria.</p>
<h2 id="h2-II20Squadra20di20esplosione895446"><a name="II. Squadra di esplosione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>II. Squadra di esplosione</h2><p>Il finanziamento totale per il progetto Blast è di $20M, e i membri del team hanno un background profondo. Provengono da aziende ben note come FAANG e da prestigiose università come la Yale University, il Massachusetts Institute of Technology, la Nanyang Technological University e la Seoul University. Hanno esperienza nello sviluppo di protocolli DeFi negli ecosistemi <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> come MakerDAO.</p>
<p>Il fondatore di Blast è Pacman, che in precedenza ha fondato Blur, il più grande protocollo di mercato NFT sulla catena Ethereum, con oltre 330.000 utenti e transazioni di NFT del valore di $7 miliardi. Blur ha anche condotto il quinto airdrop più grande nella storia di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> fino ad oggi.</p>
<h2 id="h2-III20Momenti20salienti20del20progetto487956"><a name="III. Momenti salienti del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>III. Momenti salienti del progetto</h2><p>Come la blockchain di secondo livello di <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> Rollup, Blast garantisce una compatibilità perfetta con la rete Ethereum, facilitando il processo di migrazione e distribuzione delle applicazioni a basso costo per gli sviluppatori. Tuttavia, ciò significa anche che il progetto non ha molti punti di forza tecnologici e i suoi principali vantaggi sono più evidenti nel suo modello di guadagno e nella comunicazione di marketing basata su “guadagnare punti e attirare persone”.</p>
<ol>
<li><p>Meccanismo di guadagno nativo: Blast fornisce agli utenti un guadagno nativo in Ethereum (ETH), incluso un Automatic Annual Percentage Yield (APY) del 5%, senza ulteriore intervento dell’utente.</p>
</li><li><p>Rendimento ETH: In quanto pioniere nella piattaforma Layer 2, Blast utilizza la piattaforma Lido per lo staking liquido dell’ETH depositato dagli utenti, consentendo all’ETH di aumentare automaticamente di valore nel tempo in base al rapporto di staking dell’ETH.</p>
</li><li><p>Investimento in stablecoin: Dopo che gli utenti depositano Stablecoin come USDC, USDT e DAI su Blast, tali asset verranno investiti nel protocollo RWA e i profitti generati verranno restituiti direttamente agli utenti.</p>
</li><li><p>Assegnazione dei costi del gas: Blast rialloca direttamente ai developer di DApp tutti i ricavi generati dalla rete, consentendo loro di scegliere se conservare il ricavo o assegnarlo ai rispettivi utenti della DApp.<br><img src="https://gimg2.gateimg.com/image/article/17193011282.jpg" alt=""><br>Sorgente: blast.io</p>
</li><li><p>Ricompense di Airdrop: Blast lancia un programma di incentivazione anticipata per premiare gli utenti con punti Blast e token GOLD.</p>
</li></ol>
<h2 id="h2-IV20Sviluppo20dellEcosistema36984"><a name="IV. Sviluppo dell’Ecosistema" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IV. Sviluppo dell’Ecosistema</h2><p>In termini di costruzione dell’ecosistema, Blast ha formato un ecosistema relativamente completo, che copre più campi come portafogli, exchange, DeFi, GameFi, Social, applicazioni DAO, ecc., con progetti GameFi particolarmente importanti. <img src="https://gimg2.gateimg.com/image/article/17193011673.jpg" alt=""><br>Sorgente: L2BEAT</p>
<p>Secondo i dati di DappRadar e L2BEAT, il TVL sulla catena Blast è alto fino a $2.95B, classificandosi al quarto posto. Ci sono 121 Dapps, con un totale di indirizzi di portafoglio di oltre 1.55M, un indirizzo attivo mensile (UAW) di oltre 1.29M, e un volume di transazioni mensile di oltre $25B.</p>
<h2 id="h2-V20Modello20di20economia20dei20token20e20situazione20di20lancio20dei20token643488"><a name="V. Modello di economia dei token e situazione di lancio dei token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V. Modello di economia dei token e situazione di lancio dei token</h2><p>Si sospetta che l’offerta totale di token Blast sia di 100 miliardi e il sito web ufficiale ha dichiarato che gli airdrop della community saranno assegnati ai membri che hanno visitato in anticipo (50%) e ai developer (50%), ma finora non sono state ancora pubblicate regole chiare sugli airdrop.</p>
<p>Crypto KOL CBB0FE ha recentemente pubblicato su X che il suo token BLAST previsto, che rappresenta il 14% dell’offerta totale, sarà utilizzato per gli airdrop. Considerando alcune stime e test on-chain, circa il 4% dell’offerta totale di token BLAST potrebbe essere investito al momento del lancio, il che significa che l’offerta circolante rappresenta il 10%. Inoltre, il 3% di BLAST potrebbe essere allocato ai market maker.</p>
<p>Secondo la dichiarazione ufficiale di Blast, se gli utenti hanno Oro o punti e questi beni sono associati a account di proprietà esterni (EOA), questi utenti devono accedere al cruscotto di Blast almeno una volta ricevendo inviti o collegando i loro EOA agli account Blast esistenti per assicurarsi che i loro account siano inclusi nel calcolo delle attività di airdrop. Nel frattempo, tutte le applicazioni decentralizzate (DApps) devono inviare tutto l’Oro o i punti ai loro utenti prima delle 20:00 ora di Pechino del 25 giugno.</p>
<p>Infine, va notato che Gate.io ha sviluppato autonomamente un portafoglio crittografico sicuro e conveniente non custodiale, Gate Wallet（ <a href="https://www.gate.io/web3" target="_blank">https://www.gate.io/web3</a>), che può essere comodamente utilizzato per interagire con l’ecosistema Blast e accedere al portafoglio sul sito ufficiale per controllare i propri punti e lo stato dell’airdrop.<img src="https://gimg2.gateimg.com/image/article/17193012044.jpg" alt=""><br>Fonte: blast.io</p>
<h2 id="h2-In20sintesi433336"><a name="In sintesi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In sintesi</h2><p>L’innovazione di Blast risiede nell’uso della caccia alle teste per guadagnare punti, che apre nuovi metodi di marketing per la comunicazione. Nel frattempo, si basa sulla trasformazione di ETH inattive e altri asset in reddito nativo, risolvendo il problema del rischio di interesse gratuito degli asset cripto su Layer 2. Questo ha attirato molta attenzione e capitale, ed è previsto che cambi il modello di rendimento degli asset cripto, offrendo nuovi modi per cercare ritorni sugli asset.</p>
<p>Nonostante la controversia, l’impegno di Blast per la trasparenza, l’innovazione e la governance della comunità preannuncia il suo continuo sviluppo e l’impatto delle criptovalute. Con il lancio di Blast, non vediamo l’ora di assistere ai cambiamenti che porta.</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. Sarà consentito il riposting dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>