QW5hbHlzZWVyIENhdC10aGVtZWQgTUVNRXMgbWV0IHJlY2VudCBzdGVya2UgcmVib3VuZA==

2024-07-12, 02:25

<p><img src="https://gimg2.gateimg.com/image/article/17207508231690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR990456"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>De strijd tussen kat en hond tussen maart en april van dit jaar heeft een reeks katten-thematische MEME’s veroorzaakt, wat een verschuiving markeert in de dominante positie van honden MEME’s sinds 2021.</p>
<p>Op dit moment is de meest waardevolle kattenMEME POPCAT, en MEW heeft ook eens de toppositie in marktwaarde uitgedaagd.</p>
<p>Cat type MEME, als een pas populair dierlijk type MEME-munt, heeft momenteel een kleine marktwaarde en toont meer explosief potentieel in vergelijking met hond-type MEME-munten.</p>
<h2 id="h2-Introductie649306"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De MEME-munt met kattenthema wordt een nieuwe hotspot in de MEME-sector. De marktfocus verschuift van honden en kikkers naar katten, en veel investeerders zijn ook van plan te speculeren op katten MEME.</p>
<p>Onlangs heeft de markt de voortdurende fermentatie van kat-gerelateerde memes op sociale media waargenomen. Ondanks de slappe markt blijven er verschillende kat MEMEs opduiken op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>/Basis keten, die de leidende positie van dog MEMEs probeert uit te dagen.</p>
<p>We zullen deze bekende en populaire MEME’s met kattenthema introduceren op volgorde van marktwaarde.</p>
<h2 id="h2-Popcat20POPCAT20Afkomstig20van20ondeugende20kattenuitdrukkingen20heeft20de20kattensector20de20hoogste20marktkapitalisatie634175"><a name="Popcat (POPCAT): Afkomstig van ondeugende kattenuitdrukkingen, heeft de kattensector de hoogste marktkapitalisatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Popcat (POPCAT): Afkomstig van ondeugende kattenuitdrukkingen, heeft de kattensector de hoogste marktkapitalisatie</h2><p>Als de meest waardevolle kat-thematische MEME-munt op dit moment, is POPCAT ontstaan uit de veelbesproken ondeugende kattenemoji op internet. Deze afbeelding draagt niet alleen een ontspannen en humoristische gemeenschapssfeer met zich mee, maar integreert ook slim de kenmerken van snelle verspreiding van de internetviruscultuur en de bloeiende ontwikkeling van de cryptowereld.<img src="https://gimg2.gateimg.com/image/article/17207508901.jpg" alt=""><br>Bron: @POPCATSOLANA</p>
<p>Ondanks dat Xavier, de eigenaar van Popcat, openlijk zijn afkeuring heeft uitgesproken over cryptocurrency en beweert dat ‘mijn kat mijn kat is, ik ben volledig tegen cryptocurrency’, heeft dit de voortdurende stijging van de populariteit van POPCAT op de cryptomarkt niet belemmerd.</p>
<p>Integendeel, POPCAT heeft meer aandacht gekregen vanwege IP-auteursrechtkwesties en de populariteit ervan is niet afgenomen. In plaats daarvan heeft de sociale belangenindex voortdurend nieuwe hoogtepunten bereikt en is het het best gerangschikte MEME-muntproject met kattenthema van het Solana-ecosysteem geworden.</p>
<h2 id="h2-Kat20in20een20Hondenwereld20MEW20Gericht20op20Antihond20Themas20en20Actief20Samenwerken20Over20Grenzen926957"><a name="Kat in een Hondenwereld (MEW): Gericht op Anti-hond Thema’s en Actief Samenwerken Over Grenzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kat in een Hondenwereld (MEW): Gericht op Anti-hond Thema’s en Actief Samenwerken Over Grenzen</h2><p>Sinds de lancering in maart 2024 heeft MEW, dat zich richt op anti-hondenthema’s, snel de leidende positie ingenomen in door katten geïnspireerde MEME-munten. De unieke marktstrategie begon met gulle airdrops naar BONK, WIF en <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Saga 2-telefoonhouders, wat niet alleen veel aandacht trok, maar ook een solide gebruikersbasis legde voor de toekomstige ontwikkeling van MEW.<img src="https://gimg2.gateimg.com/image/article/17207509182.jpg" alt=""><br>Bron: @MewsWorld</p>
<p>Bovendien blijft MEW nieuwe kunst, kleding en entertainmentproducten lanceren op basis van karakter IP, dat steeds populairder wordt in de mainstream cultuur.</p>
<p>Om dit doel te bereiken, zoekt MEW actief grensoverschrijdende samenwerking, waarbij het 3D-animatieproject met LOCUS bijzonder opmerkelijk is. Deze samenwerking trekt niet alleen de aandacht van film- en televisiepubliek, maar kondigt ook de brede perspectieven van MEW aan op het gebied van visueel entertainment in de toekomst.</p>
<p>Het is vermeldenswaardig dat MEW ooit POPCAT voorbijgestreefd is om de grootste katten-MEME te worden qua marktwaarde, en momenteel op de tweede plaats staat.</p>
<h2 id="h2-Wen20WEN20Innovatiescore20met20het20hoogste20aantal20NFT20Coinhoudende20adressen965260"><a name="Wen (WEN): Innovatiescore met het hoogste aantal NFT Coin-houdende adressen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wen (WEN): Innovatiescore met het hoogste aantal NFT Coin-houdende adressen</h2><p>De WEN, die bijna 280K adressen bevat, is afkomstig uit het gedicht “Een liefdesbrief aan Wen Bros” gemaakt door @weremeow, de oprichter van het Solana DeFi-aggregatieplatform Jupiter. Dit gedicht is een oprecht bekentenis aan Wen Bros en een bron van inspiratie voor de creativiteit van het WEN-token.</p>
<p>Volgens het ontwerp vertegenwoordigt elke WEN-token een digitale authenticatie van gedeeltelijk eigendom van dit gedicht, een digitale innovatie van het traditionele concept van eigendom. Het is niet alleen de eerste community-token die is gemaakt op basis van gesplitste NFT’s (niet-vervangbare tokens), maar ook de eerste die wordt vermeld op het LFG-platform van Jupiter. Als de eerste NFT die voldoet aan de Wen New Standard (WNS) NFT-standaard, introduceert het nieuwe normen en mogelijkheden in het Solana-ecosysteem.<img src="https://gimg2.gateimg.com/image/article/17207509473.jpg" alt=""><br>Bron: @wenwencoin</p>
<p>Concreet ligt de essentie van WEN in de fractionele NFT, die gedeeltelijk eigendom verleent van de poëzie van @weremeow. Net als meesterwerken die gesegmenteerd zijn, is elk stuk een hoek van het geheel, en WEN behandelt poëzie op deze manier. WEN-tokenhouders monopoliseren NFT niet, maar delen een deel van de NFT van poëzie. Deze aanpak maakt kostbare digitale activa toegankelijk en bevordert het delen en eigendom van culturele werken.</p>
<p>De innovatie van WEN komt niet alleen tot uiting in de technologische implementatie, maar ook in het principe van eerlijke verdeling. Meer dan een miljoen actieve Solana-portemonneegebruikers hebben distributie van WEN-tokens ontvangen, wat het engagement van het projectteam voor eerlijkheid aantoont.</p>
<p>Onlangs verwierf WEN het grootste op katten gerichte account op X, @ShouldHaveCat, waarmee het zijn positie in het ecosysteem verder verstevigde.</p>
<h2 id="h2-MANEKI20Afkomstig20van20de20Japanse20Gelukskat654801"><a name="MANEKI: Afkomstig van de Japanse Gelukskat" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MANEKI: Afkomstig van de Japanse Gelukskat</h2><p>MANEKI, Geïnspireerd door de ‘Money Cat’ in de Japanse cultuur, die klanten aantrekt en geluk en rijkdom brengt, hebben we dit culturele element ingenieus gecombineerd met moderne cryptotechnologie om een uniek MEME-project te creëren. Deze katten worden meestal afgebeeld terwijl ze met hun voorpoten zwaaien en traditionele Japanse stropdassen dragen, wat schattig en symbolisch is.</p>
<p>De innovatie van het MANEKI-project ligt in het uitgiftemodel zonder voorverkoop tokens, geen teamaandelen en een nieuw online handelsconcept dat NFT’s combineert met gebruikersprogramma’s. Deze ongekende poging trok snel de aandacht van de markt en spon een enorm potentieel verhaal van honderdvoudige muntgroei.</p>
<p>Hoewel MANEKI de consistente stijl van MEME-series projecten volgt, die een onafhankelijk ecosysteem en praktische implementatie mist, heeft het team erachter buitengewone veerkracht, praktisch inzicht, romantische verbeeldingskracht en een hoog uitvoeringsvermogen getoond.</p>
<p>Net als MEW, blijft het MANEKI-project ook aandringen op het bijwerken van sociale media-inhoud en het versturen van airdrops naar Solana-telefoons. Onlangs is Maneki actief op zoek naar grensoverschrijdende exposure, nadat Dvalishvil, de best geplaatste professionele MMA-speler in het UFC middengewicht, de officiële woordvoerder van Maneki is geworden.<img src="https://gimg2.gateimg.com/image/article/17207509864.jpg" alt=""><br>Bron: @MerabDvalishvil</p>
<h2 id="h2-michi20Populaire20MEMEs20op20Pump41006"><a name="michi: Populaire MEMEs op Pump" class="reference-link"></a><span class="header-link octicon octicon-link"></span>michi: Populaire MEMEs op Pump</h2><p>Michi is een populaire kattenMEME die is uitgebracht op pump.fun en impliceert dat het de meest gemakkelijk te herinneren kat op het internet is.<img src="https://gimg2.gateimg.com/image/article/17207510065.jpg" alt=""><br>Bron: @michionsolana</p>
<p>De oprichter @psykogem is een ervaren MEME-speler en KOL. In de beginfase van de release betaalde hij persoonlijk 40 SOLs ter waarde van Mickey’s Disease Return, waardoor de munt een marktwaarde van $60.000 bereikte. Later, tijdens het promotieproces, bleef hij momentum opbouwen door middel van airdrops, reclame, betalingen aan kunstenaars om alleen emoji’s te maken, en uiteindelijk promootte hij de hype van de munt via verschillende onderwerpen.</p>
<p>Het is vermeldenswaard dat er nog een Shark Cat op pump.fun is, dit is ook een katten-MEME die nauwlettend de populariteit van Michael volgt.</p>
<h2 id="h2-Mog20Coin20MOG20Afkomstig20van20Fun20Jokes20Bevordering20van20Vertrouwen20en20Uitmuntendheid281635"><a name="Mog Coin (MOG): Afkomstig van Fun Jokes, Bevordering van Vertrouwen en Uitmuntendheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mog Coin (MOG): Afkomstig van Fun Jokes, Bevordering van Vertrouwen en Uitmuntendheid</h2><p>MOG is ontstaan uit een leuke grap onder een groep vrienden in de zomer van 2023. De culturele basis is diep geworteld in het kernconcept van ‘gemakkelijke universele dominantie’. MOG pleit voor een positieve en zelfverzekerde houding ten opzichte van het leven. Of het nu gaat om persoonlijke groei of gemeenschapsontwikkeling, MoG stimuleert haar leden om de moed te hebben om uitmuntendheid na te streven en de beste versie van zichzelf te zijn.<img src="https://gimg2.gateimg.com/image/article/17207510326.jpg" alt=""><br>Bron: @MogCoinEth</p>
<p>Dit project ontstond in de vorm van memes door middel van de eerlijke uitgifte van <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V2 LP, snel het conventionele kader van traditionele tokenuitgifte doorbreken.</p>
<h2 id="h2-Keyboard20Cat20KEYCAT20Afgeleid20van20Keyboard20Cat501641"><a name="Keyboard Cat (KEYCAT): Afgeleid van Keyboard Cat" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Keyboard Cat (KEYCAT): Afgeleid van Keyboard Cat</h2><p>KEYCAT is gebouwd op de BASE-chain, geïnspireerd door een populaire MEME-video van een kat die piano speelt op YouTube.</p>
<p>KEYCAT is ontstaan in 1984 en werd geproduceerd door Charlie Schmidt uit Spokane, Washington, VS. Hij filmde een video van een vrouwelijke kat genaamd Fatso die ‘speelde’ op de Ensoniq Mirage sampling keyboard. In de video droeg Fatso een babyblauw T-shirt, terwijl Schmidt Fatso’s poten bedekte met het shirt buiten het scherm, waardoor de illusie ontstond dat de kat leek te spelen op de piano.<br><img src="https://gimg2.gateimg.com/image/article/17207510547.jpg" alt=""><br>Bron: @KeyboardCatBase</p>
<p>Deze video is oorspronkelijk gemaakt uit verveling, maar in 2007, 20 jaar na de dood van Fatso, digitaliseerde Schmidt het en plaatste het op YouTube onder de titel “Charlie Schmidt’s Keyboard Cat! - Originele versie.” Met de verspreiding van gerelateerde parodievideo’s en commerciële interacties is KEYCAT een bekende kattenMEME geworden in Noord-Amerika.</p>
<p>Op de schrijfdatum heeft het adres van de munthouder 81,65K bereikt, en de marktwaarde is $10,81M.</p>
<h2 id="h2-Samenvatting20Cat20MEME20blijft20kracht20uitoefenen20wat20mogelijk20het20viral20gaan20effect20van20Dog20MEME20kan20herhalen595251"><a name="Samenvatting: Cat MEME blijft kracht uitoefenen, wat mogelijk het ‘viral gaan’ effect van Dog MEME kan herhalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting: Cat MEME blijft kracht uitoefenen, wat mogelijk het ‘viral gaan’ effect van Dog MEME kan herhalen</h2><p>Met de voortdurende opwarming van MEME-projecten op verschillende ketens, is de MEME-markt verschoven van een kortetermijntrend naar een langetermijntrend. Het thema is geleidelijk overgegaan van honden en kikkers naar de huidige populaire katten, wat een verschuiving markeert in de dominante positie van honden MEME sinds 2021.</p>
<p>In de vorige crypto bullmarkt schitterden MEME-munten zoals DOGE en SHIB helder met entertainment, storytelling en lage marktwaarde kenmerken, aangedreven door beroemdheden zoals Musk, en werden ze het middelpunt van de markt.</p>
<p>Als een pas populair dierlijk type MEME-munt, heeft de kat-type MEME, hoewel momenteel met een kleine marktwaarde, een enorm groeipotentieel laten zien in de ‘kat-hondoorlog’ in maart en april van dit jaar, vooral in vergelijking met hond-type MEME-munten.<img src="https://gimg2.gateimg.com/image/article/17207510808.jpg" alt=""><br>Bron: CoinGecko</p>
<p>MEME is nog nooit een solo-carnaval geweest, maar een groepscarnaval. Onder dit consensus leiden meerdere kat MEME-projecten een nieuwe trend in de MEME-sector met hun unieke creatieve oorsprongen, diepgaande culturele kern, innovatieve tokenisatie-ontwerp en sterke gemeenschapsopbouwcapaciteiten.</p>
<p>Op dit moment worden deze bekende kat MEME-munten ondersteund door spot trading op het Gate.io-platform, waardoor beleggers een handig kanaal hebben om deel te nemen. Naarmate de markt evolueert, kijken we uit naar meer interessante en creatieve MEME’s die verschijnen. Natuurlijk moeten beleggers ook aandacht besteden aan risicobeheersing en matige deelname aan hun deelname.</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 enkele beleggingssuggestie.<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 er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>