V2FubmVlciB6YWwgaGV0IGhvb2dzdCBnZXJhbmdzY2hpa3RlIHByb2plY3QgaGV0IHRpaiBrZXJlbiB3YW5uZWVyIGFpcmRyb3BzIHRla29ydHNjaGlldGVuIGFhbiB2ZXJ3YWNodGluZ2VuPw==

2024-07-04, 06:33

<p><img src="https://gimg2.gateimg.com/image/article/1720074377sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR350489"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Recentelijk hebben airdrops van veel grootschalige projecten zoals LayerZero, zkSync, Blast, etc. gemeenschapscontroverse veroorzaakt, en de muntwaarde is sinds de lancering voortdurend gedaald, wat de markt niet heeft geaccepteerd.</p>
<p>Door niet aan de belangen van de meerderheid van de deelnemers te voldoen, maar de regels voor de airdrop oneerlijk en onpartijdig te maken, wordt er eigenlijk grootschalig verkopen gestimuleerd, wat leidt tot een win-winsituatie voor deelnemers van het eerste en tweede niveau en zelfs projectpartijen.</p>
<p>Sinds het begin van dit jaar is MEME opgekomen, dat zich meer richt op Eerlijk, en het is precies een manifestatie van de markt’s nadruk op airdrop correctie.</p>
<h2 id="h2-Introductie387871"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>12.000 adressen zonder interactie hebben zkSync-luchtdroppen gehad, LayerZero-luchtdroppen die op heksen jagen en verplichte donaties, en Blast-luchtdroppen die zich richten op welgestelde individuen. Onlangs hebben veel luchtdroppen van koningsniveau gemeenschapscontroverse veroorzaakt, en de muntkoersen zijn sinds de lancering gekelderd en worden niet door de markt geaccepteerd.</p>
<p>Tegen de achtergrond van ruime liquiditeit, zijn deze top projecten nog steeds de moeite waard om te worden gekocht door de markt, komt er een einde aan het tijdperk van luchtdrops, en waar moeten deelnemers in de toekomst op letten? Laten we samen verkennen.</p>
<h2 id="h2-LayerZero20De20Meest20Krenterige20Airdrop20in20de20Geschiedenis209841"><a name="LayerZero: De Meest Krenterige Airdrop in de Geschiedenis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LayerZero: De Meest Krenterige Airdrop in de Geschiedenis</h2><p>Onlangs hebben een reeks top projecten, spottend aangeduid als oude merk PUA door de gemeenschap, airdrops uitgebracht en tokens gelanceerd. Hun prestaties hebben echter moeite om de gemeenschap tevreden te stellen.</p>
<p>Ten eerste kondigde het cross-chain project LayerZero zijn airdrop-plan aan op 3 mei en startte een eenmaand durende heksen-censuuroperatie. Het censuurmechanisme is verdeeld in drie fasen: zelfonthulling, officiële censuur en bounty-rapportage, waarbij het bounty-rapportagemechanisme voor veel controverse op de markt zorgt. Dit mechanisme moedigt gebruikers aan om potentieel heksen-gedrag te melden, en klokkenluiders kunnen 10% van het gemelde airdrop-aandeel verkrijgen, wat resulteert in een golf van meldingen op de markt, waaronder kleine studio’s die per ongeluk gewond raken, beveiligingsbedrijven die actief deelnemen, en frequente geruchten en meldingen.</p>
<p>Door deze actie heeft LayerZero met succes een groot aantal potentiële heksadressen geïdentificeerd en verwerkt, waarbij uiteindelijk meer dan 800.000 adressen als potentiële heksen zijn bepaald, waarvan 338.000 adressen zichzelf hebben blootgegeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17200744641.jpeg" alt=""><br>Bron: @PrimordialAA</p>
<p>Deze stap heeft echter ook controverse in de gemeenschap veroorzaakt over de rationaliteit en noodzaak van het rapportagemechanisme, waarbij sommige gebruikers van mening zijn dat het projectteam de positieve bijdrage van de haarclippers heeft verwaarloosd.</p>
<h2 id="h2-ZkSync20Airdrops20in20twijfel20getrokken20vanwege20ondoorzichtigheid20en20oneerlijkheid763672"><a name="ZkSync: Airdrops in twijfel getrokken vanwege ondoorzichtigheid en oneerlijkheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ZkSync: Airdrops in twijfel getrokken vanwege ondoorzichtigheid en oneerlijkheid</h2><p>Als LayerZero kan worden beschouwd als de meest gierige airdrop, dan bevat de airdroplijst van zkSync meerdere bekende heksadressen, die ook breed bekritiseerd zijn.</p>
<p>Op 11 juni kondigde ZK Nation, een van de vier reuzen van de gevestigde L2 openbare keten, het economische model en de airdrop-regels aan voor ZK-tokens, en kondigde aan dat 17,5% van de totale voorraad zal worden gebruikt voor airdrop, met twee kwalificatiecriteria: gebruikers (89%) en bijdragers (11%). Gebruikers moeten voldoen aan een reeks transactie- of interactievoorwaarden, terwijl bijdragers zich kwalificeren op basis van hun positieve bijdragen aan het zkSync-ecosysteem.</p>
<p>Echter raakte zkSync later verwikkeld in een reeks controverses. Ten eerste zijn er beschuldigingen dat er ook 12000 zero interaction-adressen werden airdropped, wat vragen oproept over de eerlijkheid van de kwalificatiebeoordeling.</p>
<p>De bekende KOL Cryptop heeft een uitgebreid artikel gepubliceerd waarin hij drie belangrijke twijfels uit, waaronder abnormale schommelingen in TVL, het verkrijgen van airdrop-kwalificaties zonder handelsportefeuilles en de concentratie van airdrop-tokens, wat erop wijst dat er mogelijk onjuiste handelingen zijn tijdens het airdrop-proces.<br><img src="https://gimg2.gateimg.com/image/article/17200747362.jpeg" alt=""><br>Bron: @cryppinfluence</p>
<p>Bovendien wees ‘Witch Hunter’ Artemis erop dat er naar verluidt een groot aantal ‘muizenmagazijn’-adressen op de airdrop-lijst staan, die zijn gecreëerd en gestort via specifieke patronen en verdacht worden van het gebruik van bewerkingen om een groot aantal tokens te verkrijgen. Deze adressen overlappen sterk met de heksenlijst die is gemeld door het cross-chain platform LayerZero, wat de bezorgdheid van de gemeenschap over eerlijkheid verder verergert.</p>
<p>Nog verrassender is dat veel in aanmerking komende gebruikers geen airdrops konden ontvangen, terwijl sommige adressen veel meer tokens ontvingen dan normaal, waardoor de controverse verder werd verergerd.</p>
<h2 id="h2-Blast20Point20Mechanisme20wordt20PUA20marktgiganten20staan20voor20een20neergang293351"><a name="Blast: Point Mechanisme wordt “PUA”, marktgiganten staan voor een neergang" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Blast: Point Mechanisme wordt “PUA”, marktgiganten staan voor een neergang</h2><p>De L2 openbare keten Blast, die zich richt op inheemse inkomsten, heeft onlangs airdrops uitgebracht. In vergelijking met LayerZero en zkSync besteedt het meer aandacht aan regels, maar het effect van de airdrop is nog steeds onbevredigend.</p>
<p>De belangrijkste controverses onder de deelnemers zijn geconcentreerd in drie aspecten. Ten eerste zijn de spelregels voor Blast’s puntgebaseerde gameplay-berekening ondoorzichtig en worden ze vaak gewijzigd, wat resulteert in ernstige PUA voor gebruikers. Ten tweede is het proces van het verzamelen van tokens omslachtig, waarbij gebruikers lange video’s moeten bekijken en apps moeten downloaden om meerdere taken te voltooien. Ten slotte worden de top 1% van de activiteitsgerangschikte adressen geconfronteerd met een lineaire ontgrendelingsperiode van maximaal 6 maanden.<br><img src="https://gimg2.gateimg.com/image/article/17200747633.jpeg" alt=""><br>Bron: blast.io</p>
<p>Ondanks de controverse heeft Blast in vergelijking met andere recente projecten relatief minder negatieve beoordelingen ontvangen in de gemeenschap, wat aangeeft dat het airdrop-mechanisme enige inspanningen heeft geleverd om de belangen van grote fondsen en particuliere beleggers in evenwicht te brengen. De prestatie van de muntkoers is echter ook onbevredigend.</p>
<h2 id="h2-Hoe20de20markt20betaalt20voor20airdrop20geschillen20en20zwakke20valutaprijzen874343"><a name="Hoe de markt betaalt voor airdrop geschillen en zwakke valutaprijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de markt betaalt voor airdrop geschillen en zwakke valutaprijzen</h2><p>In feite zijn de recente luchtdruppeleffecten van grootschalige projecten zoals zkSync (ZK), LayerZero (ZRO) en Blast (BLAST) niet bevredigend geweest. Dit komt niet alleen door de krappe liquiditeitsmarkt, maar ook doordat ze niet kunnen voldoen aan de belangen van de meeste deelnemers en de luchtdruppelregels oneerlijk en eerlijk maken, wat leidt tot grootschalige verkoop. Als gevolg hiervan is er een win-winsituatie ontstaan voor primaire en secundaire marktdeelnemers en zelfs projectpartijen.</p>
<p>In feite, wanneer we terugkijken op airdrops, zijn ze vol van complexe en subtiele interdependentie en confrontatie tussen het projectteam en de Maoïstische Partij. Van Auroracoin’s eerste proef met een klein mes tot de DeFi-hype veroorzaakt door <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, de airdrop-strategie is geleidelijk geëvolueerd van simpelweg deelnemen aan de gemeenschap tot een hoogdrempelig model van diepe interactie, heks screening en zelfs gemengde fondsverificatie.</p>
<p>In feite ligt het huidige overlevingsdilemma van Web3-projecten in de schaarste aan effectieve vraag en de schaarste aan vroege gebruikers, waardoor airdrop een sleutelgereedschap is geworden om snel nieuwe klanten aan te trekken en de markt te activeren. Deze strategie heeft echter ook geleid tot een gespecialiseerde en grootschalige grooming-industrieketen, die tot doel heeft hoogwaardige airdrops te verkrijgen en meer overvloedige interactieve gegevens en verkoopdruk op tokens te brengen. Het radicale heksenjachtbeloningsmechanisme van LayerZero is een extreme manifestatie van deze trend. Ondanks aanhoudende controverse, kan het model op de lange termijn nog steeds worden overgenomen door grootschalige projecten.</p>
<p>Vergelijkbaar met de subsidiestrijd in het Web2-tijdperk is de essentie van airdrops projectsubsidies na investeringen door gebruikers, maar de duurzaamheid van projecten hangt uiteindelijk af van hun zelfgenererend vermogen. Het is te voorzien dat met de toename van airdrop-drempels en de opkomst van op punten gebaseerde en, traditionele kansen voor interactie tussen gebruikers en projectpartijen steeds schaarser worden en de cognitieve kloof tussen gebruikers en projectpartijen zich verbreedt.</p>
<p>Natuurlijk hebben de huidige marktdownturn, ontoereikende liquiditeit, de arrogantie van projectpartijen en de verkeerde verwachtingen van interactieve gebruikers de negatieve effecten van airdrops verder verergerd. Sinds het begin van dit jaar weerspiegelt de opkomst van onbezeten MEME, dat zich meer richt op Fair, de nadruk van de markt op airdrop-correctie.<br><img src="https://gimg2.gateimg.com/image/article/17200747744.jpeg" alt=""><br>Bron: MarketVector</p>
<p>Kortom, als een belangrijk middel om snel nieuwe klanten aan te trekken en populariteit te activeren, evolueren airdrops ook met de marktomgeving. De recente controverses over airdrops voor meerdere grootschalige projecten hebben niet alleen de technische moeilijkheden van airdrop-toewijzing aan het licht gebracht en de menselijke uitdagingen waarmee projectpartijen worden geconfronteerd, maar ook aangegeven dat het zoeken naar de kernprojecten die er werkelijk behoefte aan hebben de sleutel is tot duurzame ontwikkeling in de branche.</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 opvattingen van de onderzoeker en vormt geen beleggingsadvies.<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 zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>