RWVuIE1hZ2lzY2hlIE9tbWVrZWVyOiBLYW55ZSBXZXN0IFZlcmFuZGVydCBaaWpuIFN0YW5kcHVudCBlbiBQbGFudCBkZSBMYW5jZXJpbmcgdmFuIGVlbiBDcnlwdG9jdXJyZW5jeSAkWVpZ

2025-02-26, 08:42

<p><img src="https://gimg2.gateimg.com/image/article/17405596331.png" alt=""></p>
<h2 id="h2-TLDR660398"><a name="TL,DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL,DR</h2><p>Rapper Kanye West is naar verluidt bezig met het plannen van de lancering van zijn persoonlijke cryptocurrency, “$YZY”, in een poging een nieuwe inkomstenstroom voor zijn Yeezy-merk te creëren. Uit de tokendistributiestructuur blijkt echter dat Kanye 70% van de totale tokenvoorraad zal behouden, wat aanleiding geeft tot bezorgdheid over het grijpen van contant geld en marktmanipulatie. Gecombineerd met zijn recente zakelijke problemen veroorzaakt door controversiële opmerkingen en de frequente mislukkingen van tokenprojecten van beroemdheden, blijft de toekomst van $YZY onzeker.</p>
<h2 id="h2-Van20het20weigeren20van20crypto20tot20het20voorbereiden20van20YZY177379"><a name="Van het weigeren van crypto tot het voorbereiden van $YZY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Van het weigeren van crypto tot het voorbereiden van $YZY</h2><p>Kanye West heeft herhaaldelijk openlijk zijn sterke wantrouwen tegenover cryptocurrencies geuit.</p>
<p>Eerder dit jaar plaatste hij zelfs op sociale media waarin hij beweerde een voorstel voor een token van $2 miljoen te hebben afgewezen en cryptomunten bestempelde als ‘een zwendel om fans uit te buiten.’ Deze uitspraak trok destijds veel aandacht, waarbij velen het zagen als een kritiek op het fenomeen van de celebrity-cryptocurrency. Echter, slechts enkele maanden later heeft zijn standpunt een dramatische ommekeer ondergaan. Volgens de laatste berichten bereidt Kanye zich nu voor om zijn persoonlijke cryptomunt, ‘$YZY,’ te lanceren.</p>
<p>In feite hebben er in het verleden soortgelijke omkeringen plaatsgevonden met Kanye. In 2021 brachten Kanye en zijn medewerkers verschillende NFT-merchandiseproducten uit. Echter, tegen februari 2022 verklaarde Kanye plotseling op sociale media: “Stop met me te vragen om NFT’s te doen,” bewerend dat hij zich richtte op creaties in de echte wereld zoals voedsel en mode. Toch diende hij slechts drie maanden later handelsmerken in voor metaverse en NFT-gerelateerde producten onder zijn Yeezus-merk en verwijderde zelfs zijn eerdere negatieve opmerkingen over NFT’s.</p>
<p>Volgens rapporten heeft Kanye’s nieuwste tokenproject tot doel $YZY te gebruiken als betaalmethode voor producten van het merk Yeezy, waarmee verboden worden omzeild die zijn opgelegd door reguliere e-commerceplatforms zoals Shopify. Uit het tokendistributieplan blijkt echter dat Kanye 70% van het totale aanbod zal behouden, waarbij slechts 10% wordt toegewezen voor marktcirculatie en 20% voor vroege investeerders. Deze distributieverhouding heeft geleid tot wijdverbreide kritiek, waarbij velen het project ervan beschuldigen een geldklopperij te zijn in plaats van echte blockchain-innovatie.</p>
<p>Hoewel het team van Kanye heeft geprobeerd om $YZY te positioneren als een vooruitstrevend betalingsmiddel, blijft het publiek ongelovig. Sommige netizens bespotten het project en zeggen: “Zijn tokens geen oplichterij? 70% voor jezelf houden - is dat echt liefde voor je fans?” Anderen wezen erop dat dit token distributiemechanisme Kanye absolute controle geeft over de tokenprijs, wat aanzienlijke risico’s met zich meebrengt.</p>
<h2 id="h2-Cryptocurrency20Kanyes20Tool20for20a20Comeback816"><a name="Cryptocurrency: Kanye’s Tool for a Comeback?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptocurrency: Kanye’s Tool for a Comeback?</h2><p>In de afgelopen jaren heeft het zakelijke rijk van Kanye West te kampen gehad met ernstige crises als gevolg van een reeks controversiële opmerkingen en acties.</p>
<p>In 2022 maakte hij antisemitische opmerkingen en prees hij Hitler publiekelijk, waardoor merken als Adidas en Balenciaga hun samenwerking met hem beëindigden, waardoor de inkomsten van Yeezy aanzienlijk daalden. Geschat wordt dat de beëindiging van zijn Adidas-deal alleen al resulteerde in een verlies van meer dan $ 1 miljard aan inkomsten.</p>
<p>Dit jaar zorgde Kanye opnieuw voor verontwaardiging door producten met nazi-symbolen op sociale media te plaatsen, wat er uiteindelijk toe leidde dat Shopify zijn online winkel sloot. Deze incidenten hebben Kanye’s merkimago en zakelijke samenwerkingen bijna vernietigd. Tegen deze achtergrond heeft hij zich tot de cryptocurrency-ruimte gewend, in de hoop een nieuwe inkomstenstroom voor het merk Yeezy te creëren door $YZY te lanceren.</p>
<p>Echter heeft dit plan de publieke scepsis niet weggenomen. Ten eerste heeft Kanye’s recente gedrag van hem een zeer controversiële figuur gemaakt, waarbij het vertrouwen van mainstream bedrijven en het publiek op een dieptepunt ligt. Ten tweede ontbreekt het aan transparantie in het $YZY lanceringplan, met beperkte informatie over de specifieke gebruiksmogelijkheden van de token, technische ondersteuning en langetermijnstrategie voor ontwikkeling. Het belangrijkste is dat Kanye’s hoge mate van controle over de tokenvoorraad zorgen heeft gewekt over de mogelijkheid dat dit zou kunnen uitmonden in een speculatief ‘pump-and-dump’ schema.</p>
<p>Op sociale media heeft Kanye geprobeerd de geloofwaardigheid van $YZY te versterken door in contact te komen met leiders in de cryptobranche. Hij heeft openlijk advies gezocht van verschillende prominente figuren in de cryptowereld. Echter, die personen hebben verklaard dat er geen verdere samenwerking heeft plaatsgevonden, waardoor deze interacties meer op publiciteitsstunts lijken dan op echte technische partnerschappen.</p>
<h2 id="h2-Risicos20van20Celebrity20Tokens332915"><a name="Risico’s van Celebrity Tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risico’s van Celebrity Tokens</h2><p>Het fenomeen van beroemdheden die cryptocurrencies lanceren is niet nieuw, maar de meeste van dergelijke projecten mislukken uiteindelijk vanwege een gebrek aan echte waarde.</p>
<p>Het lanceringsplan voor $YZY heeft de volgende zorgen opgeworpen:</p>
<p>Ten eerste is de tokendistributie sterk geconcentreerd, waardoor aanzienlijke risico’s op marktmanipulatie ontstaan. Volgens rapporten zal Kanye West 70% van de $YZY tokenvoorraad in handen hebben. Deze sterk gecentraliseerde toewijzing betekent dat hij absolute controle heeft over de prijs van het token. Theoretisch zou hij de marktliquiditeit kunnen manipuleren om de prijs kunstmatig op te drijven en vervolgens uit te betalen. Dergelijke “pump-and-dump”-schema’s zijn niet ongebruikelijk in de cryptocurrency-ruimte, en veel vergelijkbare projecten hebben geleid tot aanzienlijke verliezen voor investeerders.</p>
<p>Ten tweede ontbreekt het project aan transparantie, waardoor het moeilijk is voor investeerders om risico’s te ueren. Momenteel is er zeer beperkte informatie beschikbaar over de specifieke gebruiksscenario’s en technische ondersteuning voor $YZY. Hoewel het team van Kanye beweert dat de token zal worden gebruikt voor betalingen van Yeezy-producten, zijn er geen gedetailleerde technische implementatieplannen of partnerschapinformatie verstrekt. Bovendien is het onduidelijk of $YZY te maken zal krijgen met toezicht van regelgevende instanties. Gezien Kanye’s controversiële acties in de afgelopen jaren, is het twijfelachtig of zijn team in staat is om een ​​conform cryptocurrency-project te lanceren.</p>
<p>Bovendien hebben beroemdheidstokens te veel waarschuwende verhalen achtergelaten. In het verleden zijn veel door beroemdheden gesteunde cryptoprojecten mislukt. Zo raakte het tokenproject Centra, gepromoot door bokser Floyd Mayweather en muziekproducent DJ Khaled, verwikkeld in schandalen. Dergelijke glen hebben aanzienlijk afbreuk gedaan aan de geloofwaardigheid van beroemdheidstokens. Of $YZY in de voetsporen van deze mislukte projecten zal treden, moet nog blijken.</p>
<p>Geconfronteerd met de lancering van $YZY, moeten investeerders kalm blijven en voorkomen dat ze worden beïnvloed door beroemdheden en markthype. Voor $YZY moeten investeerders bepalen of het echt op lange termijn waarde kan bieden voor het Yeezy-merk, in plaats van alleen te dienen als een kortetermijnspeculatief instrument. Er zijn zelfs meldingen opgedoken waarin wordt gesuggereerd dat Kanye zijn Twitter-account heeft verkocht, met beweringen dat de inhoud die verband houdt met de token is geplaatst door het tokenteam in plaats van Kanye zelf. Verschillende cryptoinfluencers hebben zich afgevraagd of het account van Kanye West is verkocht, mogelijk met betrokkenheid van het BarkMeta-team, dat is gelinkt aan eerdere cryptoscamprojecten.</p>
<p>Ongeacht dat is Kanye’s $YZY-project ongetwijfeld een zeer controversiële onderneming. Voor fans betekent het ondersteunen van hun idool niet per se deelnemen aan tokeninvesteringen; voor investeerders zijn rationele analyse en voorzichtige besluitvorming cruciaal om verliezen te vermijden. In de cryptowereld kan beroemde invloed weliswaar kortetermijnmarktspanning genereren, maar projecten die de tand des tijds doorstaan, vereisen vaak een solide technische basis en duidelijke langetermijnwaarde. Of $YZY een innovatie zal zijn of een geldklopperij, moet nog blijken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Orisi.T</strong>, Gate.io-onderzoeker<br><div>Vertaler: Orisi.T<br><div class="info-tips"><em>Dit artikel geeft alleen de mening van de onderzoeker weer en bevat geen beleggingssuggesties. Alle beleggingen brengen inherente risico's met zich mee; Verstandige besluitvorming is essentieel.<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 wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>