QWxsZXMgd2F0IGplIG1vZXQgd2V0ZW4gb3ZlciBkZSBCTEFTVCBFY29zeXN0ZW0gT3Bwb3J0dW5pdHkgQWlyZHJvcHBlZCBUaGlzIFdlZWs=

2024-06-25, 07:41

<p><img src="https://gimg2.gateimg.com/image/article/17193010391690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR642346"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Blast werd gelanceerd door Blur-oprichter Pacman op 21 november 2023 en is speciaal ontworpen om passieve inkomstenmogelijkheden te bieden voor fondsen in Layer2-accounts.</p>
<p>De kernvoordelen van Blast komen meer tot uiting in het inkomstenontwerp en de marketingcommunicatie van ‘punten verdienen en mensen aantrekken’.</p>
<p>De officiële Blast heeft onlangs aangekondigd dat het deze week op 26 juni een airdrop-evenement zal lanceren.</p>
<h2 id="h2-Introductie673983"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Blast, een Layer2 openbaar blockchainplatform dat vorig jaar populair werd, staat eindelijk op het punt om munten uit te geven. De officiële aankondiging van Blast onlangs aangekondigd dat het deze week op 26 juni lanceringsactiviteiten voor airdrops zal houden en dat de ecosysteemprojecten waarschijnlijk later zullen worden gelanceerd of munten zullen worden uitgegeven. Kan Blast, dat punten uitwisselt voor airdrops, bijdragen aan de populariteit van de Ethereum-sector? Wat zijn de hoogtepunten van de ontwikkeling van dit ecosysteem? In dit artikel gaan we dieper in op dit onderwerp.</p>
<h2 id="h2-I20Inleiding20tot20Blast483145"><a name="I. Inleiding tot Blast" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I. Inleiding tot Blast</h2><p>Blast werd gelanceerd door Blur-oprichter Pacman op 21 november 2023 en kreeg snel veel aandacht in de cryptogemeenschap vanwege het gespecialiseerde ontwerp om passieve inkomstenmogelijkheden te bieden voor fondsen in Layer2-accounts.<br><img src="https://gimg2.gateimg.com/image/article/17193010891.jpg" alt=""><br>Bron: blast.io</p>
<p>Met behulp van deze uitgebreide strategie hoopt Blast de cryptobranche te revolutioneren, gebruikers te voorzien van veilige, handige en efficiënte kanalen voor vermogenswaardering, en nieuwe liquiditeit in de cryptomarkt te injecteren via haar geautomatiseerde inkomstensysteem, waardoor de ontwikkeling van de gehele branche wordt gestimuleerd.</p>
<h2 id="h2-II20Blast20Team515758"><a name="II. Blast Team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>II. Blast Team</h2><p>De totale financiering voor het Blast-project is $20M en de teamleden hebben een diepgaande achtergrond. Ze komen van bekende bedrijven zoals FAANG en prestigieuze universiteiten zoals Yale University, Massachusetts Institute of Technology, Nanyang Technological University en Seoul University. Ze hebben ervaring in het ontwikkelen van DeFi-protocollen in Web3-ecoen zoals MakerDAO.</p>
<p>De oprichter van Blast is Pacman, die eerder Blur heeft opgericht, het grootste NFT-marktprotocol op de Ethereum-keten, met meer dan 330.000 gebruikers en $7B aan NFT-transacties. Blur heeft ook de op vier na grootste airdrop in de geschiedenis van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> tot nu toe uitgevoerd.</p>
<h2 id="h2-III20Project20Hoogtepunten67586"><a name="III. Project Hoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>III. Project Hoogtepunten</h2><p>Als de tweede laag blockchain van <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Rollup, Blast zorgt voor naadloze compatibiliteit met het Ethereum-netwerk, waardoor het voor ontwikkelaars gemakkelijk is om applicaties tegen lage kosten te migreren en implementeren. Dit betekent echter ook dat het project niet veel technologische hoogtepunten heeft en de kernvoordelen meer worden weerspiegeld in het inkomstenontwerp en de marketingcommunicatie van ‘punten verdienen en mensen aantrekken’.</p>
<ol>
<li>Inheems inkomstenmechanisme: Blast biedt gebruikers inheemse Ethereum (ETH) inkomsten, inclusief een automatisch jaarlijks rendement (APY) van 5%, zonder extra gebruikersinmenging.</li></ol>
<p>2.ETH Opbrengst: Als pionier op het Layer 2-platform gebruikt Blast het Lido-platform voor Liquid Staking van door gebruikers gestorte ETH, waardoor ETH automatisch in waarde toeneemt na verloop van tijd op basis van de ETH-stake-verhouding.</p>
<ol>
<li><p>Stablecoin-investering: Nadat gebruikers Stablecoins zoals USDC, USDT en DAI op Blast hebben gestort, zullen deze activa worden geïnvesteerd in het RWA-protocol en de gegenereerde winsten zullen rechtstreeks aan de gebruikers worden teruggegeven.</p>
</li><li><p>Gas kostentoewijzing: Blast wijst alle netto-inkomsten van het netwerk rechtstreeks toe aan DApp-ontwikkelaars, zodat ze kunnen kiezen om de inkomsten te behouden of toe te wijzen aan hun respectievelijke DApp-gebruikers.<br><img src="https://gimg2.gateimg.com/image/article/17193011282.jpg" alt=""><br>Bron: blast.io</p>
</li><li><p>Airdrop beloningen: Blast lanceert een vroeg stimuleringsprogramma om gebruikers te belonen met Blast-punten en GOLD-tokens.</p>
</li></ol>
<h2 id="h2-IV20Ecosysteemontwikkeling148255"><a name="IV. Ecosysteemontwikkeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IV. Ecosysteemontwikkeling</h2><p>Op het gebied van ecosysteemconstructie heeft Blast een relatief compleet ecosysteem gevormd, dat meerdere gebieden bestrijkt zoals portefeuilles, beurzen, DeFi, GameFi, Sociaal, DAO-toepassingen, enz., waarbij GameFi-projecten bijzonder prominent zijn.<img src="https://gimg2.gateimg.com/image/article/17193011673.jpg" alt=""><br>Bron: L2BEAT</p>
<p>Volgens gegevens van DappRadar en L2BEAT is de TVL op de Blast chain zo hoog als $2,95 miljard, op de vierde plaats. Er zijn 121 Dapps, met in totaal meer dan 1,55 miljoen portefeuille-adressen, een maandelijks actief adres (UAW) van meer dan 1,29 miljoen en een maandelijks transactievolume van meer dan $25 miljard.</p>
<h2 id="h2-V20Token20Economie20Model20en20Token20Lancering20Situatie696509"><a name="V. Token Economie Model en Token Lancering Situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V. Token Economie Model en Token Lancering Situatie</h2><p>De totale voorraad Blast-tokens wordt vermoedelijk op 100 miljard geschat, en de officiële website vermeldde dat gemeenschapsairdrops zullen worden toegewezen aan vroege bezoekers (50%) en ontwikkelaars (50%), maar er zijn nog geen duidelijke airdropregels vrijgegeven.</p>
<p>Crypto KOL CBB0FE plaatste onlangs op X dat zijn voorspelde BLAST token, die goed is voor 14% van de totale voorraad, zal worden gebruikt voor airdrops. Rekening houdend met enkele schattingen en on-chain testing, kan ongeveer 4% van de totale voorraad van BLAST tokens worden geïnvesteerd bij de lancering, wat betekent dat de circulerende voorraad goed is voor 10%. Bovendien kan 3% van BLAST worden toegewezen aan market makers.</p>
<p>Volgens de officiële verklaring van Blast moeten gebruikers, als ze Gold of punten hebben en deze activa zijn gekoppeld aan externe accounts (EOA’s), ten minste één keer inloggen op het dashboard van Blast door uitnodigingen te ontvangen of hun EOAs te koppelen aan bestaande Blast-accounts om ervoor te zorgen dat hun accounts zijn opgenomen in de bereikberekening van airdrop-activiteiten. Ondertussen moeten alle gedecentraliseerde toepassingen (DApps) alle Gold of punten naar hun gebruikers sturen vóór 20.00 uur Peking-tijd op 25 juni.</p>
<p>Tenslotte moet worden opgemerkt dat Gate.io zelfstandig een veilige en handige niet-bewaar crypto wallet heeft ontwikkeld, Gate Wallet（ <a href="https://www.gate.io/web3" target="_blank">https://www.gate.io/web3</a> ）, die handig gebruikt kan worden voor interactie met het Blast-ecosysteem en voor het inloggen bij de portemonnee op de officiële website om punten en de status van de airdrop te controleren.<br><img src="https://gimg2.gateimg.com/image/article/17193012044.jpg" alt=""><br>Bron: blast.io</p>
<h2 id="h2-Samenvattend643528"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>De innovatie van Blast ligt in het gebruik van headhunting om punten te verdienen, wat nieuwe marketingmethoden opent voor communicatie. Tegelijkertijd steunt het op het transformeren van overtollige ETH en andere activa in inkomsten, waardoor het probleem van het rentevrije risico van crypto-activa op Layer 2 wordt opgelost. Dit heeft veel aandacht en kapitaal aangetrokken en men verwacht dat het het rendementspatroon van crypto-activa zal veranderen en nieuwe manieren biedt om rendementen te zoeken voor activa.</p>
<p>Ondanks de controverse voorspelt de toewijding van Blast aan transparantie, innovatie en gemeenschapsbestuur de voortdurende ontwikkeling en impact van cryptocurrencies. Met de lancering van Blast kijken we uit naar het aanschouwen van de veranderingen die het met zich meebrengt.</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 mening 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>