R2F0ZS5pbyBGcmFjdGlvbiBUb2tlbidzIC0gU3RlcmtlcmUgbGlxdWlkaXRlaXQgZW4gZ3JvdGVyZSBmbGV4aWJpbGl0ZWl0IHZvb3IgImJsdWUgY2hpcCIgTkZUJ3M=

2023-01-19, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/16741021071280X1280.jpeg" alt=""><br>Om samen te vatten, werden op 15 december 2022 de Trump Digital Trading Cards-collectie uitgebracht voor $99 per stuk. Ondanks de wijdverspreide kritiek van media, waren alle 45.000 NFT’s (met voormalig president Donald Trump in verschillende poses en kleding) binnen 12 uur na de lancering uitverkocht. Deze collectie volgt op de controversiële uitgave van de Melania Trump NFT-serie, die in januari 2022 werd geveild op Solana.</p>
<p>Belangrijk om op te merken is dat de Trump Digital Trading Cards-collectie op OpenSea een onafhankelijk initiatief is van zijn campagne voor herverkiezing. Het kopen van deze NFT’s zal zijn kansen om het ambt te heroveren niet beïnvloeden. Kopers van 45 NFT’s krijgen echter de kans om te dineren met de voormalige president. Voor degenen die niet geïnteresseerd zijn in het kopen van 45 NFT’s, is er nog steeds een kans om diverse prijzen te winnen via de Trump Sweepstakes, zoals gesigneerde merchandise en videogesprekken met de voormalige president.</p>
<p>Gezien Trump’s sociale en culturele roem als wereldwijd media- en bedrijfsicoon, heeft Gate.io op 15 januari ITRUMP uitgebracht om de liquiditeit van de collectie te versterken.</p>
<p>Zoals vermeld, heeft Gate.io in de aanloop naar ITRUMP ook verschillende gerelateerde fractionele tokens gelanceerd - IPUNKS, IAZUKI en IBAYC.</p>
<h2 id="h2-IPUNKS731597"><a name="IPUNKS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IPUNKS</h2><p>Om samen te vatten, het NFT Fraction Token initiatief is een creatieve oplossing voorgesteld door Gate.io om de voortdurende problemen rondom lage liquiditeit en hoge kosten voor topklasse NFT’s op te lossen.</p>
<p>CryptoPunks, gemaakt in 2017 door Larva Labs, is het anker voor dit initiatief. Door een originele CryptoPunk te kopen en deze aan de Treasury te beloven, gaf Gate vervolgens een overeenkomstig aantal ERC20-tokens uit die mensen konden kopen om fractioneel eigendom van de originele CryptoPunk NFT te bezitten. De uitgifteverhouding is 1:10.000 of 10.000 ERC20-tokens voor 1 x originele NFT, waarbij elk ERC20-token staat voor 1⁄100,000 eigendom van het oorspronkelijke NFT-werk.</p>
<p>Gate’s unieke NFT AMM-tool maakt het eenvoudig om ERC20-tokens uit te wisselen voor fractionele NFT’s, met de optie om de oorspronkelijke NFT in te wisselen zodra een bepaald aantal fractionele NFT’s is verzameld.</p>
<p>De ERC20-token uitgegeven voor de CryptoPunks-collectie handelt onder het label <a href="https://www.gate.io/trade/IPUNKS_USDT/?ch=GM_blog_fraction1_20230119&amp;utm_campaign=TR_scQ4dUxw&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">IPUNKS met een USDT-koppeling</a> De circulerende voorraad PUNKS is gelijk aan de totale voorraad en het aantal CryptoPunks in de CryptoPunks Liquiditeitspool. CryptoPunks in de pool kunnen te allen tijde door IPUNKS uit de Liquiditeitspool worden ingewisseld.</p>
<h2 id="h2-IBAYC200461"><a name="IBAYC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IBAYC</h2><p>Na IPUNKs kwam IBAYC - een ERC-20 token gekoppeld aan Bored Ape Yacht Club NFT’s in het bezit van Gate.io. Een IBAYC token vertegenwoordigt 1⁄10,000 BAYC in de BAYC Liquiditeitspool.<br>De circulerende voorraad van BAYC is gelijk aan de totale voorraad van BAYC in de liquiditeitspool en kan op elk moment worden ingewisseld. <a href="https://www.gate.io/trade/IBAYC_USDT/?ch=GM_blog_fraction2_20230119&amp;utm_campaign=TR_CZbopzVF&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">IBAYC heeft ook een handelspaar met USDT</a>.</p>
<h2 id="h2-IAZUKI46224"><a name="IAZUKI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IAZUKI</h2><p>Fase drie was IAZUKI.</p>
<p>De Startup Sale voor IAZUKI-tokens vond plaats van 06:00 uur op 8 januari 2023 tot 06:00 uur op 9 januari 2023 (UTC), waarbij de handel in IAZUKI/USDT-paren begon om 09:00 uur op 9 januari. Net als bij IPUNK en IBAYC wordt elke Azuki NFT gefractioneerd in 10.000 IAZUKI ERC-20-tokens en beschikbaar om te verhandelen met USDT-paren.</p>
<h2 id="h2-Hoe20helpt20de20Fraction20Token20bij20NFT20Liquiditeit323057"><a name="Hoe helpt de Fraction Token bij NFT Liquiditeit?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe helpt de Fraction Token bij NFT Liquiditeit?</h2><p>Naarmate de populariteit van NFT’s groeit, kunnen de prijzen van populaire collecties omhoog schieten, waardoor ze alleen toegankelijk zijn voor een selecte groep rijke investeerders. Door het eigendom van ERC-721- of ERC-1155-tokens te verdelen in meerdere ERC-20-tokens via fractionalisatie, worden de NFT’s betaalbaarder. Andere gerelateerde voordelen die bijdragen aan liquiditeit zijn: Democratization</p>
<p>Een van de belangrijkste voordelen van fractionele NFT’s is democratisering. De hoge kosten van sommige populaire NFT’s kunnen het moeilijk maken voor kleinere investeerders of verzamelaars om deel te nemen aan de markt. Door een dure NFT te fractionaliseren, wordt de kosten verlaagd en wordt deze toegankelijker voor een breder scala aan mensen.</p>
<h2 id="h2-Prijsontdekking331879"><a name="Prijsontdekking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijsontdekking</h2><p>Het fractionaliseren van NFT’s helpt ook bij het bepalen van de prijs. Het kan een uitdaging zijn om de juiste prijs te bepalen voor een dure NFT met beperkte transactiegeschiedenis. Door de NFT op te delen in meer betaalbare stukken kunnen meer mensen deelnemen aan de handel in het activum, waardoor het gemakkelijker wordt om de werkelijke waarde ervan te bepalen.<br>Verhoogde zichtbaarheid voor makers</p>
<p>Makers hebben ook baat bij fractionalisatie, omdat dit zorgt voor een grotere zichtbaarheid online en een meer liquide markt, waardoor ze een breder publiek kunnen bereiken.<br>Hoe profiteren houders van fractionele NFT’s?</p>
<p>Houders van Fractional NFT’s kunnen een percentage bezitten van een grotere, duurdere NFT. Afhankelijk van de NFT en het platform waarop deze is aangeschaft, kan de houder toegang hebben tot exclusieve NFT-gemeenschappen en andere voordelen zoals stemrechten. Sommige gefractioneerde NFT-projecten bieden zelfs stakingsmogelijkheden, waardoor houders hun NFT op een platform of protocol kunnen vergrendelen om stakingsbeloningen en andere voordelen te ontvangen.</p>
<h2 id="h2-Exchange20Notering20amp20toegevoegde20Liquiditeit469371"><a name="Exchange Notering &amp; toegevoegde Liquiditeit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Exchange Notering &amp; toegevoegde Liquiditeit</h2><p>Gebruikers profiteren er ook van dat de fractionele tokens op Gate.io worden vermeld, omdat dit de liquiditeit versterkt en stroomlijnt. In tegenstelling tot de meer gespecialiseerde en beperkende NFT-kluisjes op platforms zoals NFTX, zijn Gate.io fractionele tokens ERC-20 compatibel. Als zodanig kan elke gebruiker van het platform, wanneer de beurs een NFT koopt, 10.000 bijbehorende tokens uitgeeft en vermeldt, de tokens voor USDT kopen of verkopen.</p>
<h2 id="h2-NFT20Terugkoop680829"><a name="NFT Terugkoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>NFT Terugkoop</h2><p>Hoewel deze functie nog in ontwikkeling is, kan een gebruiker uiteindelijk, als hij meer dan 10.000 tokens bezit die verband houden met een specifieke NFT zoals IPUNK, de Gate.io NFT-markt bezoeken om genoemde tokens in te wisselen voor de originele en complete NFT tegen de oorspronkelijke prijs.</p>
<p>Bovendien maakt dit ook extra prikkels mogelijk, omdat gebruikers genoteerde fractionele ERC20-tokens van de markt kunnen kopen, de 10.000 tokens kunnen ruilen voor de originele NFT, en vervolgens de originele NFT kunnen doorverkopen op secundaire marktplaatsen zoals OpenSea.</p>
<h2 id="h2-Ruimere20NFTbeleggingsmogelijkheden593673"><a name="Ruimere NFT-beleggingsmogelijkheden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruimere NFT-beleggingsmogelijkheden</h2><p>Na de lancering van de fractionele tokens kunnen gebruikers ook hun eigen NFT’s toevoegen aan de liquiditeitspool, en Gate.io zal helpen bij het uitgeven van ERC-20-gekoppelde tokens.</p>
<h4 id="h4-Auteur20Gate20NFT20team790832"><a name="Auteur: Gate NFT team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Auteur: Gate NFT team</h4><p>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br>Gate.io behoudt alle rechten op dit artikel. Herpublicatie van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen wordt juridische actie ondernomen wegens schending van het auteursrecht.</p>