SGV0IHN0aWpnZW4gdmFuIE5PVCBkcmlqZnQgZGUgZXhwbG9zaWUgdmFuIEdhbWVGaSBhYW4sIHdhYXIgaXMgaGV0IHRvZWtvbXN0aWdlIHRyZW5kd2FjaHR3b29yZD8=

2024-06-07, 16:07

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR585498"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De vijfvoudige toename van NOT heeft verschillende GameFi-tokens met een lage tot middelmatige marktwaarde doen stijgen, waardoor de lang onderdrukte GameFi-track recentelijk een veelbesproken onderwerp is geworden.</p>
<p>De lancering van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF heeft steeds meer crypto-gebruikers aangetrokken. Dit soort GameFi-track dat traditionele financiën en internetfuncties integreert, heeft een basis gelegd voor zijn uitbraak.</p>
<p>De GameFi-sector wordt geleidelijk het middelpunt van de cryptomarkt. Hoewel de prijzen van veel projecttokens nog steeds laag zijn, maakt de aanhoudende groeitrend en potentiële marktkansen de GameFi-sector de moeite waard om op de lange termijn in de gaten te houden.</p>
<h2 id="h2-Introductie325042"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De GameFi-sector, die lange tijd onderdrukt is geweest, is deze week eindelijk van start gegaan, waarbij NOT, ALICE, PORTAL, PIXEL en anderen allemaal voorop lopen wat betreft winsten.</p>
<p>Waarom heeft de GameFi-sector, die altijd onderaan heeft gestaan, nog steeds niet kunnen opstijgen zoals AI, DePIN, MEME en andere sectoren? Zal de recente stijging doorgaan? Dit artikel zal u een uitgebreide interpretatie geven van het GameFi-traject.</p>
<h2 id="h2-De20opkomst20van20NOT20drijft20het20herstel20van20de20GameFisector446163"><a name="De opkomst van NOT drijft het herstel van de GameFi-sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van NOT drijft het herstel van de GameFi-sector</h2><p>Onlangs heeft het Notcoin (NOT) project een significante transformatie ondergaan van een eenvoudig en rechttoe rechtaan spel op het Telegram platform naar het ontvangen van veel aandacht van mainstream cryptocurrency exchanges en fondsen. Het meest opvallende hoogtepunt is de lancering van maar liefst 18 beurzen, waaronder Gate.io, op 16 mei. Het werd aanvankelijk volledig gecirculeerd, wat leidde tot een golf van Altcoin-spellen vergelijkbaar met Click to Earn.</p>
<p>Volgens openbare gegevens heeft Notcoin als het eerste ‘surging’ project in het Telegram ecosysteem sinds het begin van dit jaar snel veel gebruikers aangetrokken met zijn unieke MEME eigenschappen en eenvoudige Tap to Earn gameplay. Binnen een week na de lancering kreeg het 5 miljoen gebruikers, met een piek van meer dan 6 miljoen dagelijks actieve gebruikers, wat zijn sterke markt aantrekkingskracht aantoont.</p>
<p>Ondanks de recente stijging bereikte de 24-uurs handelsvolume van NOT op maandag $4,67B, waarmee het op de vierde plaats staat op het hele netwerk, alleen achter USDT, BTC en ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17177763241.jpg" alt=""><br>Bron: Gate.io</p>
<p>De aanhoudende stijging van NOT heeft ook snel de algehele opleving van de GameFi-industrie aangedreven, met een overvloed aan GameFi-tokens, zoals PIXEL, PORTAL, IMX, ALICE, RACA, enz., die het gat vullen.</p>
<p>Volgens de gegevensstatistieken van CoinGecko is de marktwaarde van de GameFi-sector gestegen tot $24B op de schrijfdatum, met een groeipercentage van 7.5% in de afgelopen zeven dagen, wat 0.59% van de totale marktwaarde van cryptocurrencies vertegenwoordigt.<br><img src="https://gimg2.gateimg.com/image/article/17177763432.jpg" alt=""><br>Bron: CoinGecko</p>
<p>De markt heeft echter verschillende meningen over of NOT zijn opwaartse trend kan voortzetten. Onder hen hebben de steun van belangrijke beurzen en TON ongetwijfeld een belangrijke impuls gegeven aan de opkomst van NO.</p>
<p>Bovendien vermindert het Notcoin-project de circulatievoorziening via zijn onderpandfunctie en is de tokenvernietiging die door de ecosysteemprojectpartij wordt uitgevoerd ook een van de belangrijkste redenen voor de prijsstijging. Volgens statistieken zijn ongeveer 18 miljoen NOT (gewaardeerd op ongeveer $ 0,35M) verbrand en permanent uit omloop genomen, waardoor de marktverkoopdruk wordt verminderd. @CryptoStreamHub, een lid van de cryptogemeenschap, wees erop dat hoewel het huidige aantal branden misschien klein lijkt, investeerders meer verbrandingsacties in de toekomst kunnen verwachten, wat een positief effect zal hebben op de prijs van NO.</p>
<p>Maar hoe dan ook, de razernij van de wekelijkse stijging van de NOT met meer dan vijf keer heeft uiteindelijk geleid tot een stijging van verschillende GameFi-tokens met een lage tot middelhoge marktwaarde. Wat zijn de hoogtepunten van de lang slapende GameFi?</p>
<h2 id="h2-MEME20GameFi20kan20na20Axie20een20nieuwe20trend20worden864267"><a name="MEME GameFi kan na Axie een nieuwe trend worden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MEME GameFi kan na Axie een nieuwe trend worden</h2><p>Het is gemakkelijk te vinden dat de GameFi-sector een nieuw project mist dat de markt kan leiden zoals de vorige bullmarkt. <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a>, wat een belangrijke reden is waarom de GameFi-sector stagneert.<br><img src="https://gimg2.gateimg.com/image/article/17177763713.jpg" alt=""><br>Bron: AXIE</p>
<p>In de huidige marktomgeving zijn beleggers over het algemeen geneigd om innovatieve projecten na te streven, omdat nieuwe projecten vaak brede marktaandacht trekken. Als er een nieuwe valuta op de GameFi-markt opduikt die goed presteert en een stijgende trend blijft vertonen, dan is de kans groot dat de hele GameFi-sector dienovereenkomstig stijgt, net zoals de stuwende rol van PEPE in de MEME-sector. Daarom is GameFi een potentieel gebied dat de moeite waard is om op lange termijn in de gaten te houden.</p>
<p>Als we een actueel perspectief innemen, hebben we enkele aanwijzingen gevonden. AAA-level GameFi is nog steeds aan het stijgen, terwijl MEME GameFi daarentegen een nieuw narratief prototype heeft laten zien vanwege hun lage participatiedrempel, gemeenschapsemotionele genen en gemak van verspreiding. De trigger voor deze golf van GameFi-stijging is niet alleen het eerder genoemde inheemse Notcoin-spel, maar ook de recente scène van individuele beleggers die vechten tegen instellingen op de Amerikaanse aandelenmarkt GameStop, wat genoeg is om op gelijke voet te staan met de emotionele besmetting van cryptocurrency-gemeenschappen die streven naar rechtvaardigheid.</p>
<p>Op 3 juni keerde Roaring Kitty, de koning van de retailbeleggers, terug na een pauze van drie jaar. Hij plaatste een screenshot van zijn positie op Reddit waarop Roaring Kitty GME-aandelen en GME-call-opties vasthield, waarbij de call-opties vervallen op 21 juni 2024. Roaring Kitty plaatste een “flip card” in een UNO-kaartspel op Twitter, wat leidde tot marktdiscussies. GameStop-gerelateerde tokens zoals GME en KITTY zagen een kortetermijnstijging.<br><img src="https://gimg2.gateimg.com/image/article/17177763954.jpg" alt=""><br>Bron: Reddit</p>
<p>Bij nadere beschouwing kunnen we dergelijke aanwijzingen verbinden. Met de lancering van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s verleggen steeds meer beleggers hun aandacht van de Amerikaanse aandelenmarkt naar de cryptocurrency markt, en de speculatieve enthousiasme van mensen voor GameStop heeft zich snel verspreid naar de GameFi sector. Ondertussen zijn Web2-gebruikers op Telegram ook snel gestimuleerd door het Notcoin-spel op de TON-keten. Deze toenemende adoptiesnelheid van cryptocurrency-realiteit heeft geleid tot een verdere verspreiding van interessante gameplay, wat ook de achtergrond is van de recente sterke stijging in GameFi.</p>
<h2 id="h2-GameFi20is20nog20niet20volledig20ontploft20met20nadruk20op20groeipotentieel166733"><a name="GameFi is nog niet volledig ontploft, met nadruk op groeipotentieel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GameFi is nog niet volledig ontploft, met nadruk op groeipotentieel</h2><p>Samengevat schrijven we de collectieve opkomst van de GameFi-sector toe aan de volgende drijvende krachten.</p>
<p>Ten eerste zorgt de voortdurende vooruitgang van blockchain-technologie voor solide technische ondersteuning voor de ontwikkeling en werking van gedecentraliseerde spellen, waaronder MEME-spellen en volledige ketenspellen geïntegreerd met AI, die aanzienlijk zijn verbeterd wat betreft speelbaarheid en schaalbaarheid.</p>
<p>Ondertussen blijft de bewustwording en acceptatie van spelers van dit nieuwe type spelvorm toenemen, waardoor de marktvraag blijft groeien en daarmee de collectieve opkomst van de GameFi-sector wordt gestimuleerd.</p>
<p>Ten tweede is de door de community gedreven ecosysteemconstructie ook een belangrijke drijvende kracht voor de opkomst van GameFi. Veel MEME GameFi-projecten richten zich op community-opbouw, het aantrekken en behouden van gebruikers via beurzen, educatieve bronnen en diverse activiteiten. Dit model bevordert de gebruikersbinding en loyaliteit en verbetert het risicobestendigheidsvermogen van het project.</p>
<p>Bovendien zijn GameFi-toepassingen waarschijnlijk meer in staat om meer verkeerswaarde vast te leggen, waardoor veel publieke ketens, beurzen en VC’s hun middelen beginnen te verleggen naar GameFi op verschillende gebieden.</p>
<p>Als voorbeeld van de succesvolle lancering van Notcoin kan het succes natuurlijk niet los worden gezien van de officiële ondersteuning van Telegram, dat een hoge gebruikersbasis van 35 miljoen heeft. Het heeft echter een ‘klik-om-te-verdienen’ virale marketingbenadering gelanceerd met extreem lage participatiebarrières in de vorm van MEME, dat populair is in de gemeenschap. Dit toont niet alleen de decentralisatie en autonomie van gemeenschapsmunten aan, maar verhoogt ook de verkeerswaarde van de TON-chain, waardoor meer spelprojecten nieuwe ontwikkelingsmodellen kunnen uitproberen.<br><img src="https://gimg2.gateimg.com/image/article/17177764285.jpg" alt=""><br>Bron: token terminal</p>
<p>Het is vermeldenswaard dat ondanks de recente sterke prestaties van de GameFi-sector, investeerders nog steeds waakzaam moeten zijn voor de betrokken risico’s. Vooral na het observeren van vandaag dat de GameFi-sector een scherpe stijging begint te zien en een trend van aanpassing ingaat, moeten investeerders voorzichtig zijn en het trendmatig volgen vermijden. Ondertussen kan het opduiken van nieuwe projecten in de toekomst het marktliquiditeit diversifiëren. Investeerders moeten de marktdynamiek in de gaten houden en op tijd hun beleggingsstrategieën aanpassen.</p>
<p>De GameFi-sector wordt geleidelijk een marktfocus, maar veel projecttokens bevinden zich nog steeds in een relatief lage prijsklasse en moeten nog een alomvattende uitbraak meemaken. We kijken uit naar de voortdurende groeitrend en zullen meer projecten met groeipotentieel verkennen.</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 standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>