R2F0ZS5pbyBBTUEgbWV0IFNob2VGeSAtIEhldCBlZXJzdGUgbXVsdGktY2hhaW4gM0QgTkZULXJhY2VzcGVsIG9wIGFsbGUgYXBwYXJhdGVu

<p><img src="https://gimg2.gateimg.com/image/article/16902690421.jpeg" alt=""><br><strong>Tijd: 16 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Michal Horvarth, Chief Marketing Officer van ShoeFy in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://www.shoefy.io/nft" rel="nofollow noopener noreferrer" target="_blank">https://www.shoefy.io/nft</a></strong><br><strong>Twitter: <a href="https://twitter.com/ShoeFyio" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ShoeFyio</a></strong><br><strong>Volg ShoeFy op <a href="https://twitter.com/ShoeFyio" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/ShoeFy_Official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16902692742.jpg" alt=""><br><strong>Michal Horvarth - Chief Marketing Officer van ShoeFy</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio156752"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Vraag20120Kunt20u20zich20voorstellen20en20ons20een20korte20achtergrond20geven527362"><a name="Vraag 1: Kunt u zich voorstellen en ons een korte achtergrond geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 1: Kunt u zich voorstellen en ons een korte achtergrond geven?</h3><p><strong>Michal</strong> Leuk om hier te zijn, ik ben al sinds eind 2016 actief in de cryptowereld, dus je kunt me wel een crypto OG noemen, aangezien ik al twee bullmarkten heb meegemaakt. In maart 2017 hield ik mijn eerste Ted-talk over gedistribueerde grootboektechnologie en blockchain, waarbij ik me bewust werd van de voordelen van dergelijke technologie.</p>
<p>In maart van dit jaar ben ik mijn eigen durfkapitaalbedrijf voor blockchain, genaamd Catena Venture Capital, begonnen, en zo kwam ik in contact met een aantal getalenteerde mensen, waarvan een van hen de oprichter van ShoeFy is.</p>
<h3 id="h3-Q220Kun20je20ons20een20korte20uitleg20geven20van20wat20ShoeFy20is20Wat20heeft20je20ook20doen20besluiten20om20platforms20in20de20NFTruimte20te20creren142622"><a name="Q2: Kun je ons een korte uitleg geven van wat ‘ShoeFy’ is? Wat heeft je ook doen besluiten om platforms in de NFT-ruimte te creëren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je ons een korte uitleg geven van wat ‘ShoeFy’ is? Wat heeft je ook doen besluiten om platforms in de NFT-ruimte te creëren?</h3><p><strong>Michal</strong>: ShoeFy is een innovatief gedecentraliseerd platform dat Non-Fungible Tokens (NFT) en Fungible Tokens (FT) combineert. Het is een futuristisch NFT-project dat gebruikmaakt van geavanceerde DeFi-tools om rendementen te maximaliseren. ShoeFy kan het potentieel van NFT’s versterken door zowel farming als staking op te nemen om passief inkomen te genereren.</p>
<p>ShoeFy zal twee tokens hebben, namelijk $SHOE (ERC-20), de inheemse fungibele token en sNFT’s (ERC-721) die willekeurig op de keten worden gegenereerd. Elke NFT is een algorithmisch geprogrammeerd uniek digitaal paar schoenen op het platform.</p>
<p>De huidige markten van NFT’s beperken zich tot kopen, vasthouden en verkopen, wat een gebrek aan liquiditeit met zich meebrengt. ShoeFy monetiseert de sNFT’s die worden gebruikt in tools zoals farming en staking op het platform om passief inkomen te genereren.</p>
<p>Daarnaast is ShoeFy een platform waar NFT’s en FT’s waarde uitwisselbaarheid zullen hebben.</p>
<h3 id="h3-Q320Dat20is20heel20interessant20Hoe20zal20de20ervaring20en20achtergrond20van20jullie20team20het20succes20van20jullie20project20benvloeden53830"><a name="Q3: Dat is heel interessant! Hoe zal de ervaring en achtergrond van jullie team het succes van jullie project beïnvloeden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Dat is heel interessant! Hoe zal de ervaring en achtergrond van jullie team het succes van jullie project beïnvloeden?</h3><p><strong>Michal</strong>: Het project wordt geleid door een team van ervaren blockchain-durfkapitalisten, creatieve NFT-ontwikkelaars en vooraanstaande marketingexperts die zich uitstrekken van Europa tot Canada en tot Zuid-Korea en Thailand in Zuidoost-Azië. Onze teamleden delen gemeenschappelijke doelen en voorzien een enorme kans in de NFT- en DeFi-markt. Wat hun achtergrond betreft, zijn sommigen van hen oprichters van verdienstelijke VC-bedrijven en ook marketingexperts. Andere leden hebben ervaring met gerenommeerde cryptoprojecten en beurzen. We hebben ook een technisch team van superieur talent aan boord genomen om ons platform te bouwen. Dus de teamleden hebben verschillende achtergronden met veel ervaring en kennis, we hebben er alle vertrouwen in dat dit project het echt goed zal doen in de markt.</p>
<h3 id="h3-V420Kun20je20nu20met20ons20delen20over20de20ShoeFy20Tokenomics20en20het20vesting20schema20dat20jullie20gepland20hebben20En20vertel20ons20ook20over20het20nut20van20de20SHOE20token843933"><a name="V4: Kun je nu met ons delen over de ShoeFy Token-omics en het vesting schema dat jullie gepland hebben? En vertel ons ook over het nut van de $SHOE token." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Kun je nu met ons delen over de ShoeFy Token-omics en het vesting schema dat jullie gepland hebben? En vertel ons ook over het nut van de $SHOE token.</h3><p><strong>Michal</strong>: $SHOE-token zal worden gebruikt als de inheemse token om Nuttigheid toe te voegen aan NFT via staking, farming en LP die passief inkomen genereert.</p>
<p>$SHOE-token zal worden gebruikt voor de Governance, DAO.</p>
<p>$SHOE zal ook worden gebruikt als het toegangsticket tot de ShoeVerse (metaverse van het shoefy-platform) en in een later stadium als beloning in het play-to-earn-spel, zoals schoenengevechten, schoenenwedstrijden en schoenmodeshows.</p>
<p>$SHOE zal worden gebruikt als de SWAP-vergoeding voor de NFT SWAP.</p>
<p>Voor het maken/kweken van nieuwe schoen-NFT’s op het shoeFy-platform moet de $SHOE-token worden betaald.</p>
<h3 id="h3-Vraag20520En20de20laatste20vraag20voordat20we20de20chat20openen20voor20vragen20van20het20publiek20Tot20nu20toe20op20hoeveel20launchpads20heb20je20de20IDOs20gedaan20en20hoe20was20de20reactie20van20de20gemeenschap20Wat20verwacht20je20van20de20notering20op20Gateio497819"><a name="Vraag 5: En de laatste vraag voordat we de chat openen voor vragen van het publiek. Tot nu toe, op hoeveel launchpads heb je de IDO’s gedaan en hoe was de reactie van de gemeenschap? Wat verwacht je van de notering op Gate.io?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 5: En de laatste vraag voordat we de chat openen voor vragen van het publiek. Tot nu toe, op hoeveel launchpads heb je de IDO’s gedaan en hoe was de reactie van de gemeenschap? Wat verwacht je van de notering op Gate.io?</h3><p><strong>Michal</strong> We hadden een geweldige lanceringssweek en alle lanceringpads waren erg snel uitverkocht. Sterker nog, op multipad waren we binnen 5 seconden na de tweede ronde uitverkocht. Op dezelfde manier waren we binnen 55 seconden uitverkocht op moonstarter en binnen de eerste 3 minuten op polkabridge. Vervolgens waren we op de volgende dagen van de lanceringssweek opnieuw uitverkocht op Duckdao, KwikStarter, TruePNL en Oxbull. Nu zijn we bezig met onze openbare verkoop-whitelist op onze website, die ook al overtekend is. Er is zoveel haast onder gemeenschappen om onze kostbare $SHOE-tokens te bemachtigen. Al met al was het een zeer succesvolle lanceringssweek.<br><a href="https://twitter.com/ShoeFyio/status/1447914005641662465?s=20" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ShoeFyio/status/1447914005641662465?s=20</a> <a href="https://twitter.com/dao_duck/status/1448296041690935298?s=20" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/dao_duck/status/1448296041690935298?s=20</a></p>
<p>We zijn nu erg enthousiast om gelanceerd te worden op gatestartup en later genoteerd te worden op Gate.io. Mensen weten dat ShoeFy hier is om te blijven en ze geloven in ons project. Dus we zijn er ook van overtuigd dat we dezelfde vraag en drukte zullen hebben in de Gate-gemeenschap.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>