Qmxhc3QgTWFpbm5ldCBHZWxhbmNlZXJkIC0gRWVuIE5pZXV3ZSBMYXllcjIgU3RlciBtZXQgRWVuIEFuZGVyZSBBYW5wYWs/

2024-03-04, 08:39

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TDLR282617"><a name="TD;LR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TD;LR</h2><p>In minder dan vijf maanden, het aantrekken van $2.3 miljard aan TVL - als je aandacht besteedt aan cryptocurrency informatie, moet je gehoord hebben van de trend veroorzaakt door Blast.</p>
<p>Het team van Blast is ook een toonaangevende NFT-markt, terwijl het operationele team van Blur zeer bedreven is in het begrijpen en creëren van hete onderwerpen, waarbij spelersaandacht wordt vastgelegd met innovatieve verhalen. We kunnen ook een glimp opvangen van enkele van de successen van Blast.</p>
<p>Op 29 februari lanceerde Blast de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2-mainnet ontgrendelen van $2,3 miljard aan gecollateraliseerde cryptocurrency. Sindsdien hebben ongeveer 180.000 Blast-gebruikers $400 miljoen uit het netwerk opgenomen.</p>
<p>Hoe heeft dit jonge L2-project de bullmarkt doorbroken? Welk potentieel en welke risico’s heeft het en welke acties zijn ondernomen? We kunnen het kort analyseren.</p>
<h2 id="h2-Blasts20Strategie132293"><a name="Blast’s Strategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Blast’s Strategie</h2><p>Volgens de gegevens van DeFiLlama bereikte de totale waarde die door Blast (TVL) is vergrendeld een hoogtepunt van $2,27 miljard op 29 februari en daalde met 17,5%. Na de lancering van het mainnet is het gedaald naar $1,87 miljard, waarbij minder dan $400 miljoen is opgenomen.</p>
<p>Terug naar november, toen het nieuws van het hele Blast-project net bekend werd gemaakt, is het niet moeilijk om te zien dat het Blast-team meer bedreven is in strategie of marketingtactieken dan in technische ondersteuning en andere aspecten. Ten eerste, als een nieuw project van het Blur-team en tegelijkertijd uitgebracht met de derde ronde van BLUR-luchtdroppen op dat moment, had Blast een aanzienlijk niveau van exposure.</p>
<p>Op basis hiervan nam Blast tijdens de testfase een andere aanpak door gebruik te maken van het “uitnodigingssysteem”, wat betekent dat u een uitnodigingscode moet invoeren om deel te nemen aan het netwerk. Dit lijkt misschien een drempel, maar het creëert ook nieuwsgierigheid en betrokkenheid onder gebruikers. Gecombineerd met het systeem van “uitnodigen en samenwerken kan u helpen bij het efficiënter verzamelen van punten”, zal het gebruikers ook meer proactief maken en een verspreidingseffect creëren.</p>
<p>Daarna bleef Blast actief bezig met het onderhouden en beheren van zijn ecosysteem, waarbij de grootste inspanning werd geleverd om de “Big Bang” competitie te lanceren. Deze door ontwikkelaars gecentreerde competitie duurde van 16 januari tot 18 februari, waarbij 3000 projecten deelnamen en concurreerden om een van de eerste projecten te worden die op het mainnet worden uitgebracht.</p>
<p>Deze competitie biedt een startkans voor de opgebouwde TVL van Blast, een belangrijke toewijzing van aankomende airdrops en directe en voortdurende ondersteuning van Blast-investeerders en -exploitanten.<br><img src="https://gimg2.gateimg.com/image/article/1709541370image.jpg" alt=""><br>Bron: explosie</p>
<h2 id="h2-De20Kenmerken20van20Blast640925"><a name="De Kenmerken van Blast" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Kenmerken van Blast</h2><p>De inheemse omzet- en gaskostenverdelingsfunctie van Blast kan worden gezegd dat het zijn kenmerkende kenmerken zijn. Met andere woorden, Blast is momenteel de L2 die rechtstreeks ETH en stablecoins kan verdienen.</p>
<p>De omzet van Blast komt uit ETH-waardering en RWA-protocol. De voordelen die worden gegenereerd door deze gedecentraliseerde protocollen zullen automatisch worden teruggegeven aan Blast-gebruikers. Het standaard rentetarief voor andere L2 is 0%. Op Blast is het standaard rentetarief voor ETH 4% en het standaard rentetarief voor stablecoins 5%. Door integratie met Lido en Maker DAO aan de achterkant kunnen deze activa overal op de keten worden gelokaliseerd.</p>
<p>Blast deelt ook de nettowinst van de gasvergoedingen met de dapp die deze kosten heeft gegenereerd, waardoor ontwikkelaars een andere inkomstenbron krijgen die kan worden benut. De integratie van deze stimuleringsmaatregel maakt L2 tot een plaats voor overtollige fondsen van gebruikers, en stelt ontwikkelaars ook in staat om rechtstreeks te profiteren van de bijdrage van slimme contracten.</p>
<h2 id="h2-Belangrijkste20Airdropprojecten40384"><a name="Belangrijkste Airdrop-projecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Airdrop-projecten</h2><p>Er zijn al veel projecten op Blast die expliciet zijn airdropped. Onder hen kunnen DeFi-tools, DEX en andere interactieve gedragingen zoals het gebruik van hun platforms en deelname aan gemeenschappen spelers helpen om Blast of projectpunten te accumuleren, die later kunnen worden omgezet in airdrops.</p>
<h3 id="h3-BlasterSwap255518"><a name="BlasterSwap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlasterSwap</h3><p>Het eerste spot trading en Launchpad-platform. Verdien tokens door verbinding te maken met een portemonnee, Twitter, te volgen en Discord te joinen. Blaster bevindt zich momenteel in de early bird registratieperiode en registreren, doneren aan Blaster en airdroppen kan 300 token beloningen opleveren.</p>
<h3 id="h3-Ring20protocol520693"><a name="Ring protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ring protocol</h3><p>Het spot-handelsplatform heeft DEX “Ring exchange” gelanceerd, dat de testnet heeft doorstaan en functies biedt zoals uitwisseling, Launchpad en liquiditeit.</p>
<h3 id="h3-SynFutures575730"><a name="SynFutures" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SynFutures</h3><p>SynFutures is een DEX gericht op cryptocurrency eeuwigdurende futures-handel, die zijn nieuwste versie, V3, heeft gelanceerd op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en een puntbeloningsprogramma genaamd Oyster Odyssey. SynFutures verklaarde dat zijn V3-gebruikers ook in aanmerking zullen komen voor de aankomende Blast-airdrop.</p>
<h3 id="h3-Lancering624481"><a name="Lancering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lancering</h3><p>De officiële positionering is ‘een lokaal lanceerplatform en opbrengstaggregator op basis van rendementen’ om ongebruikte opbrengsten vrij te geven.</p>
<h3 id="h3-MonoSwap269634"><a name="MonoSwap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MonoSwap</h3><p>Monoswap is een ander spot handelsplatform dat MUSD stabiele munten lanceert, met duidelijke verwachtingen voor airdrops.<br><img src="https://gimg2.gateimg.com/image/article/1709543165image.jpg" alt=""><br>Bron: Monoswap</p>
<p>Natuurlijk zijn dit slechts een paar projecten die behoren tot het Blast-ecosysteem, met maar liefst 47 winnaars in de Big Bang-competitie alleen al. Ze waren behoorlijk vroeg, en hoewel ze openlijk zijn airdropped of zelfs aangemoedigd door het projectteam, betekent dit niet dat ze veilig zijn. Er is geen goedkeuring voor deze projecten; Daarom moeten spelers die van plan zijn deel te nemen aan de interactie meer aandacht besteden aan de veiligheid van hun eigen activa.</p>
<h2 id="h2-Risicos20en20Potentile20Problemen1343"><a name="Risico’s en Potentiële Problemen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risico’s en Potentiële Problemen</h2><p>Dan Robinson, de onderzoeksdirecteur van Paradigm, een investeerder in de beginfase voor Blast, schreef in een artikel op X november dat het durfkapitaalfonds het niet eens is met de beslissing van Blast om “bruggen te initiëren voor L2 of geen opnames toe te staan voor drie maanden,” waarbij wordt gezegd dat dit “een slecht precedent schept voor andere projecten.”</p>
<p>Dit soort stemmen is niet ongewoon, en veel mensen geloven dat Blast zich alleen richt op het verpakken ervan met ogenschijnlijk nieuwe woordenschat om gebruikersfondsen vast te zetten, waardoor er een tijdelijke gegevensboom ontstaat.</p>
<p>Ondertussen is het risico op fraude niet onbestaande. Op 26 februari gebruikte een gokprotocol genaamd ‘Risk on Blast’ 420 ETH van gebruikersfondsen om fondsen te werven voor de pre-sale tokens voor marktpromotie, resulterend in de eerste vermoede exit-scam.</p>
<h2 id="h2-Conclusie218023"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Over het algemeen is het concept van Blast zeer aantrekkelijk en heeft het een brede deelname gekregen van meer dan 180.000 gebruikers, wat zeker geen klein aantal is. Er zijn echter ook enkele problemen, zoals ontevredenheid onder sommige gebruikers na de lancering van het mainnet vandaag, vanwege de hoge kosten van het migreren van Gas, de lange tijd die nodig is voor brugopnames en problemen zoals puntinflatie. Of Blast het potentieel heeft voor duurzame ontwikkeling, hangt ook af van de vraag of het team de problemen voortdurend kan handhaven en corrigeren.</p>
<p>Hoewel de huidige gegevens erg indrukwekkend zijn, is de duurzaamheid ervan nog steeds onbekend. Het wordt verwacht dat Blast in mei wordt airdropped, en we zullen nieuwe aankondigingen van het projectteam blijven observeren en opvolgen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Sherry S.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br><div>*Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div>

<p></p><p></p><div class="blog-details-info"><br>  <div>Auteur:<strong>Sherry S.</strong>Gate.io researcher<div class="info-tips"><em> Deze tekst vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.</em><div><em></em>This content is original and the copyright belongs to Gate.io. If you need to reprint, please indicate the author and the source, otherwise legal responsibility will be pursued.<br></div><p></p><br></div></div></div></div></div></div></div><p></p>