R2F0ZS5pbyBBTUEgbWV0IEZFRy1CdWlsZGluZyBUcnVlIERlRmk=

<p><img src="https://gimg2.gateimg.com/image/article/167627415311.jpeg" alt=""><br><strong>Tijd: 23 september 2022, 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 de Global Project Manager van FEG, RTRcrypto 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://fegtoken.com/" rel="nofollow noopener noreferrer" target="_blank">https://fegtoken.com/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/FEGtoken" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/FEGtoken</a></strong></p>
<p><strong>Volg FEG op <a href="https://twitter.com/FEGtoken" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/fegchat" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/167627457922.jpg" alt=""><br><strong>RTRcrypto — Global Project Manager of FEG</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio93665"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Waarom20zullen20we20niet20beginnen20met20een20korte20introductie20over20jezelf20en20het20project85471"><a name="Waarom zullen we niet beginnen met een korte introductie over jezelf en het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zullen we niet beginnen met een korte introductie over jezelf en het project?</h3><p><strong>RTRcrypto</strong>: Ik ben RTRcrypto, Global Project Manager voor FEED EVERY GORILLA (FEG) Token.</p>
<p>FEGtoken is sinds januari 2021 actief op de ETH-blockchain en sinds februari 2021 op het BSC-netwerk.</p>
<p>Eerder gebruikten we FEGtoken als het bestuurlijke token voor onze op maat gemaakte Decentralized Exchange; echter, we zijn momenteel onze utility aan het verleggen om ons te richten op een niet-bewaarbare Peer-2-Peer Limit Order-handelsplatform voor Cryptocurrencies &amp; NFT’s, onze Crypto Token Launchpad, en Aggregator/router voor markthandel van Decentralized projecten.</p>
<p>Alles wat in eerste instantie zal draaien op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> &amp; Binance Smart Chains en uitbreiden naar meerdere EVM Blockchains, draait om de nieuwe “FEG” token die wordt gelanceerd op basis van onze SmartDeFi Technology in Q4 van 2022.<br><img src="https://gimg2.gateimg.com/image/article/167627455644.png" alt=""><br>Meer informatie over deze migratie naar SmartDeFi is te vinden op: <a href="https://docs.fegtoken.com/new-v2-hybrid-token/feg-migration-information" rel="nofollow noopener noreferrer" target="_blank">https://docs.fegtoken.com/new-v2-hybrid-token/feg-migratie-informatie</a>.</p>
<h3 id="h3-Q220We20hebben20gehoord20dat20FEG20de20tokenomics20verandert20Kunt20u20ons20daar20wat20meer20achtergrond20over20geven20en20ook20ingaan20op20belastingen984182"><a name="Q2: We hebben gehoord dat FEG de tokenomics verandert. Kunt u ons daar wat meer achtergrond over geven en ook ingaan op belastingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: We hebben gehoord dat FEG de tokenomics verandert. Kunt u ons daar wat meer achtergrond over geven en ook ingaan op belastingen?</h3><p><strong>RTRcrypto</strong>: Toen FEG Token aanvankelijk werd gelanceerd, waren er geen geïntegreerde kosten voor groei zoals marketing en ontwikkeling.</p>
<p>Wanneer we FEG-token migreren en het op onze SmartDeFi-technologie plaatsen, incorporeren we belastingen om het project te laten groeien op een manier waarop we in het verleden beperkt waren.</p>
<p>We zijn erg enthousiast om te zien waar dit ons naartoe kan brengen!</p>
<p>We zijn ook enthousiast om op te merken dat er eerder een handelstaks van 2% was, omdat de token hyperdeflationair was (60% en groeiend van die 2% gaat naar het verbrandingsadres en de rest gaat naar de gemeenschap), vanaf nu is er een belasting van 2% die allemaal rechtstreeks naar staking rewards zal gaan!</p>
<p>Dit is slechts een van de verschillende manieren waarop FEG-stakers beloond zullen worden in het ecosysteem in de toekomst, meer uitleg volgt tijdens deze AMA.</p>
<h3 id="h3-Q320Wat20zou20je20zeggen20is20het20toekomstige20nut20van20FEGtokens408785"><a name="Q3: Wat zou je zeggen is het toekomstige nut van FEG-tokens?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat zou je zeggen is het toekomstige nut van FEG-tokens?</h3><p><strong>RTRcrypto</strong>: Geweldige vraag, geef me even de tijd om dit voor je uit te leggen!</p>
<p>Zodra FEGtoken is gemigreerd, wordt het de gouverneur van het volledig nieuwe ecosysteem dat momenteel in ontwikkeling is en wordt getest en vervolgens wordt onderworpen aan een audit door een derde partij!</p>
<p>Als de Governance-token van het ecosysteem zullen de houders de mogelijkheid hebben om de token te staken en passief inkomen te verdienen vanuit meerdere locaties:</p>
<p>2% van het totale volume wordt beloond aan FEG-stakers</p>
<p>Peer-2-Peer handelsplatform “From The Wallet” of “FTW” zal per transactiekosten hebben of een abonnementsmodelkosten die zullen worden gebruikt voor marketing, ontwikkeling en staking beloningen</p>
<p>Opmerking: FTW wordt aanvankelijk gelanceerd op ETH en BSC, maar we zijn van plan om deze technologie in de loop van de tijd uit te breiden naar meer EVM-blockchains, waarvan de kosten ook worden gebruikt om Stakers van zowel FEGeth als FEGbsc te voeden.</p>
<p>De SmartDeFi launchpad technologie, die de creatie van nieuwe cryptocurrency tokens naar projecten met een breed scala aan veelzijdigheid zal brengen, heeft een kleine geïntegreerde vergoeding op aankopen en verkopen voor alle projecten, die ook gedeeltelijk zal worden gebruikt om Stakers te belonen.</p>
<p>Let op: SmartDeFi zal in eerste instantie worden gelanceerd op ETH en BSC, maar we zijn van plan om deze technologie in de loop van de tijd uit te breiden naar meer EVM-blockchains, waarvan de kosten ook zullen worden gebruikt om stakers van zowel FEGeth als FEGbsc te voeden.</p>
<h3 id="h3-Q420Ik20zag20dat20je20het20daar20had20over20FTW20Kun20je20ons20daar20meer20details20over20geven20Wat20zal20er20uniek20aan20zijn20ten20opzichte20van20andere20platforms406345"><a name="Q4: Ik zag dat je het daar had over FTW. Kun je ons daar meer details over geven? Wat zal er uniek aan zijn ten opzichte van andere platforms?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ik zag dat je het daar had over FTW. Kun je ons daar meer details over geven? Wat zal er uniek aan zijn ten opzichte van andere platforms?</h3><p>“From The Wallet” of “FTW” is een Limit-Order handelsplatform waarmee de gebruiker rechtstreeks vanuit zijn portemonnee met andere gebruikers kan handelen en vice versa.</p>
<p>Dit platform is VOLLEDIG gedecentraliseerd omdat de gebruiker de controle houdt over zijn cryptocurrency of NFT gedurende het hele proces!</p>
<p>Dit is het hoogtepunt van P2P (peer-to-peer) handel in de Cryptocurrency en NFT ruimte, handel op een absoluut veilige manier zonder controle over uw activa aan een ander te geven.<br><img src="https://gimg2.gateimg.com/image/article/167627453233.png" alt=""><br>We hebben heel wat marktonderzoek gedaan als het gaat om OTC-platforms en ze gebruiken allemaal contracten voor hun handel, dit is NIET het g voor FTW en we zijn enthousiast om de zuiverste vorm van gedecentraliseerde handel naar zijn gebruikers te brengen!</p>
<h3 id="h3-V520Een20zeer20veel20voorkomende20vraag20die20gebruikers20vaak20stellen20betreft20audits20Zou20je20zeggen20dat20audits20een20belangrijk20onderdeel20zijn20van20het20businessmodel20van20het20project731286"><a name="V5: Een zeer veel voorkomende vraag die gebruikers vaak stellen, betreft audits. Zou je zeggen dat audits een belangrijk onderdeel zijn van het businessmodel van het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Een zeer veel voorkomende vraag die gebruikers vaak stellen, betreft audits. Zou je zeggen dat audits een belangrijk onderdeel zijn van het businessmodel van het project?</h3><p><strong>RTRcrypto</strong>: Alle Smart Contracts die worden gebruikt in het nieuw ontwikkelde ecosysteem worden volledig gecontroleerd door externe controleurs.</p>
<p>Veiligheid is van het grootste belang voor het team en de gemeenschap!</p>
<p>Op dit moment zijn er meerdere communicatielijnen opgezet met controle- en auditdiensten. De discussies omvatten geheimhoudingsovereenkomsten om het intellectuele eigendom dat we als project hebben ontwikkeld te beschermen, evenals mogelijke kosten (er zijn nog geen definitieve kosten gegeven omdat de controle- en auditdiensten de contracten nodig hebben voordat ze een offerte kunnen uitbrengen; ze baseren de prijs op de lengte en complexiteit van de code).</p>
<p>Zodra de contracten intern zijn getest/verbeterd, kunnen NDA’s worden ondertekend en kunnen de contracten aan de bedrijven worden gegeven voor offertes.</p>
<h3 id="h3-Q620Kun20je20ons20iets20vertellen20over20het20SmartDefiecosysteem20van20het20project203323"><a name="Q6: Kun je ons iets vertellen over het SmartDefi-ecosysteem van het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Kun je ons iets vertellen over het SmartDefi-ecosysteem van het project?</h3><p><strong>RTRcrypto</strong>: Absoluut, dit is zo’n spannend onderwerp!</p>
<p>SmartDeFi 2.0-tokens zullen verhandelbaar zijn op elke Centralized Exchange (CEX) of Decentralized Exchange (DEX) en kunnen worden gekoppeld aan ELKE TOKEN op de markt (bijv. ETH, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, WBTC, USDC, USDt, BUSD, etc.)</p>
<p>SmartDeFi Token Launchpad stelt u in staat om:</p>
<p>Kies of de token reflecterend (RFI) of niet-reflecterend is (tokens passief naar de portemonnees van houders sturen bij aankoop/verkoop/overdrachten)!</p>
<p>Munt (creëer) de token!</p>
<p>Organiseer een interne Presale met verschillende opties om te lanceren met een gewenste hoeveelheid liquiditeit!</p>
<p>Wijs een percentage van de nieuw gemunte token toe aan een Groeifonds voor toekomstige ontwikkelingen (in handen van het team)!</p>
<p>Vergrendel de liquiditeit voor X hoeveelheid tijd en/of stel een Verstrijkingstijd in voor tokens!</p>
<p>Stel een gewenst belastingpercentage voor elke koop/verkoop in dat wordt gestuurd naar een aparte liquiditeitspool die alleen maar stijgt, ongeacht de marktbeweging, en die kan worden uitgewisseld door uw token naar het dode adres te “verbranden”!</p>
<p>Gebruik onze SmartLend-functie, waarmee gebruikers gedurende 30 dagen rentevrij een lening kunnen afsluiten tegen de waarde van hun token in een actiefondersteunend bedrag!</p>
<p>Maak je eigen Staking pool met gewenste beloningspercentages!</p>
<p>Het mooie van het gebruik van het SmartDeFi-launchpad is dat de Deployer van waaruit u wordt gelanceerd, volledig wordt gecontroleerd!</p>
<p><em>Maak een VOLLEDIG GECONTROLEERDE token</em> met een paar klikken en weten dat het correct is gebouwd <em>GRATIS te lanceren</em>!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadviezen.<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 juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>