Qk9NRSBoZWVmdCBlZW4gcmVjb3JkYWFudGFsIGV4cGxvc2llcyBnZWNyZcOrZXJkIGVuIGVlbiBvdmVyemljaHQgdmFuIHBvcHVsYWlyZSBTT0wtcHJvamVjdGVuIGRpZSBqZSBuaWV0IG1hZyBtaXNzZW4=

2024-03-16, 06:16

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR722059"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Na de upgrade van Ethereum’s Cancun prestaties, blijkt SOL nog opvallender te zijn. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Een reeks populaire projecten zoals MemeCoin, AI, DePIN en andere op de blockchain gebaseerde projecten domineren de markt.</p>
<p>Door zijn grote diepte en het vermogen om grote hoeveelheden kapitaal te absorberen, heeft BOME veel grote kooporders van meer dan honderd SOL aangetrokken, wat zich snel heeft verspreid in de hele cryptowereld en heeft geleid tot een aanhoudende stijging van de prijs.</p>
<p>Solana heeft zich volledig losgemaakt van de schaduw van FTX en trekt momenteel investeerders aan die op zoek zijn naar hoge rendementen vanwege zijn enorme investeringspotentieel.</p>
<h2 id="h2-Inleiding290595"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Na de upgrade van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> naar Cancún, is het verrassend dat SOL beter presteert en dat er een reeks populaire projecten zoals MemeCoin, AI en DePIN op het Solana-netwerk verschijnen. Met name de MemeCoin op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> is continu sterk gestegen, waardoor veel investeerders aanzienlijke winsten hebben behaald.</p>
<p>Op het moment van schrijven, volgens de gegevens van CoinMarketCap, is het handelsvolume van Memes24 in de afgelopen 24 uur $14B, met een marktkapitalisatie van $57.6B, wat overeenkomt met 8.5%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105694491.png" alt=""><br>Afbeelding 1 van: CoinMarketCap</p>
<p>Hier delen we eerst de meest populaire meme-families op Sol.</p>
<h2 id="h2-BOOK20OF20MEMEBOME57464"><a name="BOOK OF MEME（BOME）" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BOOK OF MEME（BOME）</h2><p>BOOK OF MEME（BOME）is een nieuwe MEME-munt gelanceerd door de bekende Pepe Meme-kunstenaar Darkfarm. Oorspronkelijk was het plan om 500 SOL te verzamelen, maar volgens de gegevens onthuld door Darkfarms, heeft hij uiteindelijk een verbazingwekkende 10131 SOL verzameld.</p>
<p>Darkfarms heeft vervolgens alle ingezamelde SOL in de LP-pool gestort met een startprijs van 0,0{3}496 USDT°.</p>
<p>Vanwege zijn diepe liquiditeit en het vermogen om grote hoeveelheden kapitaal aan te trekken, heeft het veel kopers aangetrokken met bestellingen van meer dan honderd SOL, wat heeft geleid tot een snelle stijging van de prijs die de hele cryptomarkt heeft beïnvloed. Ook de NFT-serie SMOWL, eerder gelanceerd door Darkfarms, is populair en blijft stijgen.</p>
<p>Volgens Gate.io gegevens heeft de prijs nu $ 0,0137 bereikt, een stijging van bijna 28.000%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105694902.png" alt=""><br>Afbeelding 2 Bron: Gate.io</p>
<h2 id="h2-COCO171990"><a name="COCO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>COCO</h2><p>De opwinding van BOME heeft geleid tot een reeks imitatieprojecten. Het MEME-project COCO (kleine krokodil), opgestart door KOL Kero (@KeroNFTs), heeft fondsen geworven op het X-platform. Volgens on-chain data heeft het adres ongeveer 54.696 SOL ontvangen, ter waarde van meer dan 10 miljoen dollar.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695143.png" alt=""><br>Afbeelding 3 bron: @KeroNFT</p>
<p>Gate.io zal blijven letten op of dit project de gemeenschapstrend kan stimuleren.</p>
<h3 id="h3-BonkBONK909503"><a name="Bonk（BONK）" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bonk（BONK）</h3><p>Bonk（BONK）is een mememunt met een hondenthema die op 25 december 2022 op de markt verscheen en opereert op het Solana blockchain-netwerk.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695324.png" alt=""><br>Afbeelding 4 bron: Gate.io</p>
<p>Het doel van deze token is om de liquiditeit van gedecentraliseerde exchanges (DEX) op basis van Solana te bevorderen. Het ontwikkelingsteam positioneert het als een veelzijdige community token dat breed kan worden toegepast in alle gedecentraliseerde applicaties (dApps) die gebouwd zijn op Solana.</p>
<p>De totale aanbod van BONK is ongeveer 100 biljoen munten. Om de aandacht van de Solana gemeenschap te trekken, wordt 50% van het totale aanbod gedistribueerd aan Solana gebruikers via airdrops, inclusief kunstenaars, makers en actieve gemeenschapsleden. Deze strategie is bedoeld om een levendige en betrokken gemeenschap rondom de token te creëren.</p>
<p>De lancering van BONK tijdens de kerstperiode van 2022 wordt beschouwd als een speciaal cadeau aan de Solana-gemeenschap. Het daaropvolgende snelle succes toont duidelijk aan dat het een opmerkelijk succes is in de web3-gemeenschap. Ten eerste trok BONK veel aandacht van de Solana-gemeenschap in de beginfase door middel van gratis airdrop-activiteiten, waardoor gebruikers een laagdrempelige kans kregen om deel te nemen en vervolgens verspreiding bevorderden.</p>
<p>Natuurlijk is BONK nu niet langer alleen maar een meme. Het is nu succesvol geïntegreerd in sommige Solana-gebaseerde projecten om de adoptie te vergroten. Sommige platforms bieden zelfs de mogelijkheid om NFT’s te staken om BONK-tokens te verdienen.</p>
<h2 id="h2-dogwifhat20WIF787727"><a name="dogwifhat (WIF)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>dogwifhat (WIF)</h2><p>dogwifhat cryptocurrency is born from the widespread dissemination of the ‘dogwifhat’ meme, after its founder Issa changed his profile picture on Twitter to a Shibu Inu dog wearing a hat, which quickly went viral on the internet.</p>
<p>Dit memetisch symbool is snel een symbool van gemeenschapsbinding geworden, vooral populair onder gamers en internetberoemdheden, en wordt daarom veelvuldig gebruikt als avatar op sociale media.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695575.png" alt=""><br>Afbeelding 5 bron: Gate.io</p>
<p>Het team van Dogwifhat heeft deze populaire trend opgepakt en de $dogwifhat-munt gelanceerd om de culturele invloed van memes te vieren en nieuwe energie te injecteren in het digitale verzamel- en investeringsgebied.</p>
<p>Deze token maakt gebruik van een unieke economische structuur, met nadruk op liefdadigheid, teamondersteuning en <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Liquiditeit om de langetermijnontwikkeling en gemeenschapsdeelname te waarborgen.</p>
<p>Natuurlijk, het ecosysteem op de Sol-chain omvat niet alleen MemeCoin, maar ook een reeks AI, DePIN, RWA, Gamefi en andere projecten die voortdurend de aandacht van de markt trekken, wat resulteert in de typische ‘mager protocol, dikke toepassing’ kenmerken van een bullmarkt.</p>
<p>Jupiter (JUP)<br>Jupiter is een DEX-aggregator gebaseerd op Solana, die liquiditeit biedt aan handelaren met de beste prijzen en minimale slippage.</p>
<p>Het heeft niet alleen als handelsmotor gediend, maar heeft ook verschillende producten ontwikkeld, zoals de Average Cost Dollar, Limit Order, Perpetual Trading en Launchpad, om aan verschillende gebruikersbehoeften te voldoen.</p>
<p>Na de aankondiging van de JUP-token door het project in november vorig jaar op Breakpoint, bereikte de maandelijkse transactievolume een historisch hoogtepunt van meer dan 16 miljard dollar, waarmee het de handelsaandeel van de oude toonaangevende <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> benadert.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105695946.png" alt=""><br>Bron figuur 6: Gate.io</p>
<p>Op dit moment heeft Jupiter Uniswap overtroffen, met een handelsvolume van meer dan $2,5 miljard in 24 uur, goed voor meer dan 16% van het organische handelsvolume van DEX. Dit is van groot belang voor detailhandelaren op Solana.</p>
<p>Jito（JTO）<br>Jito is het eerste liquiditeitsstakingsprotocol op Solana dat MEV-inkomsten combineert met stakingsinkomsten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17105696167.png" alt=""><br>Afbeelding 7 Bron: Gate.io</p>
<p>Hoewel Jito momenteel achterloopt op Marinade in termen van ecosysteemcombinatie, decentralisatiegraad en stakingsmodel, zullen deze verschillen geleidelijk kleiner worden naarmate Jito zich ontwikkelt. De kernvoordelen van Jito bij het vastleggen en toewijzen van MEV-waarde zullen verder worden versterkt naarmate het Solana-netwerk groeit.</p>
<p>Het is voorzienbaar dat met de toename van nieuwe activa en gebruikers van Solana en de stijging van de handelsvolume, in combinatie met de lage liquiditeitsverhouding van Solana, het LSD-protocol vertegenwoordigd door Jito naar verwachting meer TVL-stortingen zal aantrekken en het toonaangevende LSD-protocol zal worden in het Solana-ecosysteem.</p>
<h2 id="h2-IONET20IO126032"><a name="IO.NET (IO)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IO.NET (IO)</h2><p>Sinds het begin van het eerste kwartaal zijn er veel AI- en DePIN-projecten opgebouwd op de Sol-keten, waarvan IO.NET momenteel het populairst is.</p>
<p>IO.NET is een netwerk van GPU’s gebouwd op de SOL-keten door gegevens samen te voegen van onderbenutte bronnen zoals datacenters, cryptominers en meer <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">FIL</a> en <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Weergeven</a> vormt een gedecentraliseerd fysiek infrastructuurnetwerk (DePIN) met behulp van GPU’s van Gate.io en andere projecten.</p>
<p>In vergelijking met andere DePIN-computerprojecten op de markt heeft IO.NET een duidelijke focus op GPU-rekenkracht en is het erin geslaagd GPU-netwerken te bouwen die 100 keer groter zijn dan vergelijkbare projecten.<br>Het is vermeldenswaard dat IO.NET ook de eerste op het gebied van blockchain is die geavanceerde ML-technologiestacks, zoals Ray-clusters, Kubernetes-clusters en gigantische clusters, integreert in GPU DePIN-projecten en deze op grote schaal in de praktijk brengt. Dit geeft IO.Net een voordeel, niet alleen in termen van het aantal GPU’s, maar ook in termen van technologietoepassing en modeltrainingsmogelijkheden.<br>Op dit moment heeft het project nog geen munten uitgegeven en Gate.io zullen aandacht blijven besteden aan de voortgang van dit soort tracks.</p>
<h2 id="h2-Samenvatting103665"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Over het algemeen heeft Solana volledig gebroken met de schaduw van FTX en trekt het momenteel investeerders aan die hunkeren naar hoge rendementen vanwege zijn enorme investeringspotentieel. We zijn verheugd te zien dat dit ecosysteem geleidelijk sterke partnerschappen opbouwt en voortdurend geld en creatieve bouwers en gemeenschapsgebruikers aantrekt.</p>
<p>Natuurlijk moeten we ons ook realiseren dat de huidige marktomgeving investeerders gemakkelijk in de ban kan laten raken van FOMO-emoties.</p>
<p>Met de bloei van het SOL-ecosysteem komen allerlei projecten als paddestoelen uit de grond, waarbij het niet ontbreekt aan goede en slechte situaties. Hoewel het SOL-ecosysteem op de lange termijn zeker zal stralen, moeten investeerders op korte termijn toch rationeel en voorzichtig blijven en het ontwikkelingspotentieel van elk project zorgvuldig ueren.</p>
<div class="blog-details-info"><br>  <div>Auteur: <em><em>Carl Y.</em><br>  </em><div class="info-tips"><em></em> Deze tekst vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br><div>* This article is original, and the copyright belongs to Gate.io. If you need to reprint, please indicate the author and source, otherwise legal liability will be pursued.<br></div><p></p><br></div></div></div>