TG9nYW4gUGF1bCBpcyB2YW4gcGxhbiBvbSBlZW4gamFhciBuYSB6aWpuIGJlbG9mdGUgdG90IHRlcnVnYmV0YWxpbmcgQ3J5cHRvWm9vIE5GVCdzIHRlcnVnIHRlIGtvcGVu

2024-01-17, 08:44

<p><img src="https://gimg2.gateimg.com/image/article/1705480688RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR264778"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Paul Logan heeft beloofd om de slachtoffers van CryptoZoo NFT terug te betalen. Elke in aanmerking komende NFT-houder krijgt 0,1 ETH per NFT.</p>
<p>Logan heeft de hoofdontwikkelaars van CryptoZoo aangeklaagd voor het falen van het spel.</p>
<h2 id="h2-Introductie274107"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het unieke van digitale activa is dat ze gemakkelijk te ontwikkelen en te lanceren zijn, hoewel ze grote investeringen vereisen. Maar het droevige is dat sommige van deze activa slecht kunnen presteren op de markt, wat kan leiden tot verlies van geïnvesteerde fondsen.</p>
<p>Vandaag beoordelen we hoe CryptoZoo NFT’s er niet in slaagden om veel investeerders en fanaten aan te trekken. We kijken ook naar het plan van Logan Paul om elke ontevreden en in aanmerking komende NFT-investeerder terug te betalen.</p>
<h2 id="h2-Logan20Paul20kondigt20plan20aan20om20ontevreden20NFTinvesteerders20terug20te20betalen917803"><a name="Logan Paul kondigt plan aan om ontevreden NFT-investeerders terug te betalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Logan Paul kondigt plan aan om ontevreden NFT-investeerders terug te betalen</h2><p>Logan Paul, een crypto-beïnvloeder en Youtuber, is van plan om zijn ontevreden investeerders te compenseren voor het mislukte <a href="https://www.gate.io/price/cryptozoo-zoo" target="_blank">CryptoZoo NFT</a> Na een jaar belofte heeft Logan zijn toewijding bevestigd om NFT-teruggaven te geven aan personen die hebben geïnvesteerd in het CryptoZoo-spel.</p>
<p>Dus heeft hij $2.3 miljoen opzij gezet voor NFT-game terugbetaling. Hij zal dat bedrag gebruiken om Basiseieren en Basisdieren terug te kopen tegen de prijs waarvoor elke investeerder heeft betaald.</p>
<p>CryptoZoo was een play-to-earn spel dat nooit is uitgebracht vanwege verschillende technische problemen. Als het zou worden uitgebracht, zouden spelers exotische dieren kunnen kopen, fokken, verhandelen en verkopen, vertegenwoordigd door NFT’s. Veel NFT-investeerders hebben meer dan 3.009 keer gehandeld. <a href="https://opensea.io/collection/cryptozoo-co/analytics" rel="nofollow noopener noreferrer" target="_blank">CryptoZoo NFT’s op OpenSea</a>.</p>
<p>Logan deed de aankondiging om CryptoZoo NFT-slachtoffers terug te betalen op zijn X-account. Hij zei: “Ik ben ongelooflijk blij om aan te kondigen dat ik mijn belofte nakom om Base Egg en Base Animal CryptoZoo NFT’s terug te kopen voor hun oorspronkelijke aankoopprijs.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705480868Logan Paul 1.png" alt=""><br>Bron: x.com</p>
<p>Hij voegde eraan toe: “Net als jij was ik zeer teleurgesteld dat het spel niet werd geleverd.” Logan stuurde de NFT-slachtoffers om hun claims in te dienen bij “ <a href="http://eggnftbuyback.com/" rel="nofollow noopener noreferrer" target="_blank">EGGNFTBUYBACK.COM</a> De investeerders die getroffen zijn door de crash van CryptoZoo hebben tot 8 februari om hun claims in te dienen.</p>
<p>Niettemin moeten de eisers verschillende voorwaarden van het NFT-terugkoopprogramma in acht nemen. Ten eerste zal elke eiser 0,1 ETH ontvangen, wat equivalent is aan ongeveer $224, voor elke in aanmerking komende CryptoZoo NFT. Bovendien mogen de slachtoffers hun NFT’s niet uit hun portefeuilles verwijderen nadat ze in aanmerking zijn gekomen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2148/how-to-avoid-nft-scam" target="_blank">Hoe je niet te laten vallen voor NFT-oplichting</a></p>
<p>Niet alle CryptoZoo NFT’s komen echter in aanmerking voor het terugkoopprogramma. Logan zal bijvoorbeeld geen hybride dier NFT’s kopen. Hierover zei hij: “Deze terugkoop is een manier voor mij om degenen die van plan waren CryptoZoo te spelen, weer heel te maken. De terugkoop is niet bedoeld om degenen te compenseren die gegokt hebben op de cryptomarkt en verloren hebben.”</p>
<h2 id="h2-De20huidige20stand20van20het20CryptoZoospel556427"><a name="De huidige stand van het CryptoZoo-spel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige stand van het CryptoZoo-spel</h2><p>Logan maakte het duidelijk dat het CryptoZoo-spel niet gelanceerd zal worden, hoewel hij er veel geld in heeft geïnvesteerd.</p>
<p>Hij verduidelijkte <a href="https://twitter.com/LoganPaul/status/1742965334645276708" rel="nofollow noopener noreferrer" target="_blank">op X.com</a>, ‘Het spel zelf wordt niet uitgebracht. Ik heb persoonlijk $400.000 uitgegeven om het te laten ontwikkelen en na de voltooiing ervan begin 2023 en nog wat verder onderzoek, zijn er helaas te veel regelgevende obstakels die moeten worden overwonnen waar ik oorspronkelijk geen rekening mee had gehouden en die deze terugkoop uiteindelijk nog verder zouden vertragen.’</p>
<p>De crypto-influencer zei ook dat hij geen inkomen uit het spel haalde. Hij voegde eraan toe: ‘Ik heb nooit een cent verdiend aan het project, punt. Sterker nog, het tegenovergestelde is waar, omdat ik honderdduizenden dollars heb uitgegeven om het te laten gebeuren.’</p>
<h2 id="h2-Van20ambitie20tot20realiteit20Paul20Logans20reis20met20CryptoZoo595870"><a name="Van ambitie tot realiteit: Paul Logan’s reis met CryptoZoo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Van ambitie tot realiteit: Paul Logan’s reis met CryptoZoo</h2><p>Logan ontwierp CryptoZoo als een play-to-earn spel vergelijkbaar met Pokémon. Het spel begon goed met een belofte van intrige en een verhaal van aspiratie. Omdat het veel leek te bieden aan de gaming gemeenschap, promootte Logan het actief. Hij stelde het voor als “een echt leuk spel dat geld oplevert.”</p>
<p>Hoewel Logan meer dan $400.000 investeerde in het spel en investeerders meer dan 10.000 NFT’s kochten, verkocht tegen 0,1 ETH per stuk, waren er veel hindernissen die leidden tot de daling van de NFT. Naast de NFT’s was er ook de Logan Paul-crypto, ZOO, die het gamingplatform moest aandrijven.</p>
<p>In feite slaagde het team er niet in om zich aan zijn beloftes te houden, omdat het de deadlines steeds veranderde. Als gevolg daarvan groeide de ontevredenheid onder de investeerders. Later waren er beschuldigingen van frauduleuze activiteiten die leidden tot juridische gevechten. Uiteindelijk distantieerde Logan zich van het spel, wat het begin van het einde markeerde.</p>
<p>Op 2 februari 2023 hebben advocaten van Ellzey &amp; Associates en Attorney Tom &amp; Associates een collectieve rechtszaak aangespannen tegen Logan Paul en zijn collega’s in het Western District of Texas. Die juridische actie zou Logan kunnen hebben gedwongen om de NFT’s terug te kopen en een einde te maken aan zijn ambitieuze play-to-earn game.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/cryptozoo-zoo" target="_blank">Hoe CryptoZoo te kopen op Gate.io</a></p>
<h2 id="h2-Juridische20actie20ontketend20Het20nastreven20van20sleutelfiguren20in20de20val20van20CryptoZoo909418"><a name="Juridische actie ontketend: Het nastreven van sleutelfiguren in de val van CryptoZoo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Juridische actie ontketend: Het nastreven van sleutelfiguren in de val van CryptoZoo</h2><p>Logan kondigde ook een tegenclaim-rechtszaak aan die hij heeft ingediend bij een federale rechtbank in Texas tegen Eduardo Ibanez en Jake Greenbaum, de twee hoofdontwikkelaars van CryptoZoo. In de in februari 2023 ingediende rechtszaak werden Logan, Ibanez en Greenbaum beschuldigd van het exploiteren van een frauduleuze onderneming gericht op het uitvoeren van een rugpull.</p>
<p>Desalniettemin schoof Logan de schuld naar de twee belangrijkste ontwikkelaars, Ibanez en Greenbaum, die hij beschuldigde van interne sabotage van het spelproject.</p>
<p>In zijn eigen woorden, <a href="https://twitter.com/LoganPaul/status/1742965334645276708" rel="nofollow noopener noreferrer" target="_blank">zei hij</a>, “CryptoZoo werd ontspoord door slechte acteurs. Slechte acteurs die inderdaad geld hebben gestolen en ons team hebben verraden terwijl ze intern het spel saboteerden. Dit is nu bevestigd door een uitgebreid onderzoek dat een forensische analyse van blockchain-activiteit en de beoordeling van duizenden communicaties omvat.”</p>
<p>Het doel van de rechtszaak tegen Ibanez en Greenbaum is om hen verantwoordelijk te houden voor hun schandelijke handelsactiviteiten die hebben geleid tot het verlies van investeerdersfondsen. Ze zijn ook verantwoordelijk voor het falen van het CryptoZoo-spel. Hoewel het team het spel niet zal vrijgeven, zoekt Logan juridische oplossingen voor de genoemde problemen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2066" target="_blank">Pas op voor NFT-oplichting - Hoe onderscheid te maken tussen echte en valse NFT?</a></p>
<h2 id="h2-Conclusie827337"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De crypto-influencer en Youtuber, Paul Logan, heeft beloofd de NFT-slachtoffers terug te betalen. Elke houder van basiseieren en basisdieren zal 0,1 ETH per NFT ontvangen nadat hij/zij een claim in die zin heeft ingediend. Ondertussen heeft Logan de twee hoofdontwikkelaars van CryptoZoo, Ibanez en Greenbaum, aangeklaagd voor schimmige handel en het falen van het spel.</p>
<h2 id="h2-Veelgestelde20vragen20over20cryptoZoo20NFT20Game891308"><a name="Veelgestelde vragen over cryptoZoo NFT Game" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over cryptoZoo NFT Game</h2><h3 id="h3-Wat20is20Cryptozoo383662"><a name="Wat is Cryptozoo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Cryptozoo?</h3><p>Cryptozoo is een play-to-earn spel waarmee spelers exotische dieren kunnen kopen, verhandelen, bezitten en verkopen. Dit NFT spel dat toebehoorde aan Paul Logan is mislukt vóór de lancering.</p>
<h3 id="h3-Wie20is20Logan20Paul771215"><a name="Wie is Logan Paul?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Logan Paul?</h3><p>Logan Paul is een Youtuber en crypto-influencer die betrokken was bij de ontwikkeling van het CryptoZoo-spel. Eduardo Ibanez en Jake Greenbaum, die de hoofdontwikkelaars waren, dragen de schuld voor het falen van cryptoZoo omdat ze de ontwikkeling saboteerden.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herdrukken van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>