R2F0ZS5pbyBBTUEgY29uIEZFRy1Db3N0cnV6aW9uZSBkaSBUcnVlIERlRmk=

<p><img src="https://gimg2.gateimg.com/image/article/167627415311.jpeg" alt=""><br><strong>Ora: 23 settembre 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con il Global Project Manager di FEG, RTRcrypto nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community di scambio Gate.io</a>.</strong><br><strong>Sito ufficiale: <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>Segui FEG su <a href="https://twitter.com/FEGtoken" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/fegchat" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/167627457922.jpg" alt=""><br><strong>RTRcrypto - Project Manager Globale di FEG</strong></p>
<h2 id="h2-QampA20da20Gateio202783"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Perch20non20iniziamo20con20una20breve20introduzione20su20di20te20e20sul20progetto307562"><a name="Q1: Perché non iniziamo con una breve introduzione su di te e sul progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Perché non iniziamo con una breve introduzione su di te e sul progetto?</h3><p><strong>RTRcrypto</strong>: Sono RTRcrypto, Global Project Manager per FEED EVERY GORILLA (FEG) Token.</p>
<p>FEGtoken è attivo dal gennaio 2021 sulla blockchain ETH e dal febbraio 2021 sulla catena BSC.</p>
<p>In precedenza avevamo utilizzato FEGtoken come token di governance per il nostro scambio decentralizzato costruito su misura; tuttavia, attualmente stiamo cambiando la nostra utilità per concentrarci su una piattaforma di trading Peer-2-Peer con ordini limitati non custodiali per criptovalute e NFT, il nostro Crypto Token Launchpad e un aggregatore/router per il trading di mercato dei progetti decentralizzati.</p>
<p>Tutto ciò funzionerà inizialmente su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Etereum</a> &amp; Binance Smart Chains e si espanderà su molteplici blockchain EVM, incentrati sul nuovo token “FEG” che verrà lanciato con la nostra tecnologia SmartDeFi nel Q4 del 2022.<br><img src="https://gimg2.gateimg.com/image/article/167627455644.png" alt=""><br>Maggiori informazioni su questa migrazione a SmartDeFi sono disponibili all’indirizzo: <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-migration-information</a>.</p>
<h3 id="h3-Q220Abbiamo20sentito20che20FEG20sta20cambiando20la20tokenomics20Puoi20darci20qualche20informazione20in20merito20e20parlare20anche20delle20tasse165352"><a name="Q2: Abbiamo sentito che FEG sta cambiando la tokenomics. Puoi darci qualche informazione in merito e parlare anche delle tasse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Abbiamo sentito che FEG sta cambiando la tokenomics. Puoi darci qualche informazione in merito e parlare anche delle tasse?</h3><p><strong>RTRcrypto</strong>: Quando il token FEG è stato lanciato inizialmente, non c’erano commissioni integrate per la crescita, come il Marketing &amp; lo Sviluppo.</p>
<p>Quando migreremo il token FEG e lo posizioneremo sulla nostra tecnologia SmartDeFi, stiamo incorporando tasse per aiutare a far crescere il progetto in un modo in cui ci siamo trovati limitati in passato.</p>
<p>Siamo molto eccitati di vedere dove questo ci può portare!</p>
<p>Siamo anche entusiasti di notare che in precedenza c’era un’imposta sul trading del 2%, in quanto il token era iper-deflazionario (il 60% e in crescita di quel 2% andava all’indirizzo di masterizzazione e il resto alla comunità), in futuro ci sarà un’imposta del 2% che andrà direttamente alle ricompense per lo staking!</p>
<p>Questo è solo uno dei vari modi in cui gli stakers di FEG verranno ricompensati nell’ecosistema in futuro, ulteriori spiegazioni arriveranno durante questa AMA.</p>
<h3 id="h3-Q320Cosa20diresti20essere20lutilit20futura20dei20token20FEG234946"><a name="Q3: Cosa diresti essere l’utilità futura dei token FEG?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cosa diresti essere l’utilità futura dei token FEG?</h3><p><strong>RTRcrypto</strong>: Ottima domanda, dammi un attimo per mettere a fuoco la risposta per te!</p>
<p>Una volta migrato FEGtoken, sarà la Governance dell’interamente nuovo ecosistema attualmente in fase di sviluppo e di testing e successivamente sottoposto a verifica di terze parti!</p>
<p>Come token di governance dell’ecosistema, i suoi detentori avranno la possibilità di scommettere il token e guadagnare passivamente da molteplici posizioni:</p>
<p>Il 2% del volume totale viene premiato agli staker di FEG</p>
<p>La piattaforma di trading peer-to-peer “From The Wallet” o “FTW” avrà commissioni per transazione o una quota di modello di abbonamento che verrà utilizzata per marketing, sviluppo e premi di staking</p>
<p>Nota: FTW verrà lanciato inizialmente su ETH e BSC, ma abbiamo intenzione di espandere questa tecnologia anche ad altre blockchain EVM nel tempo, le commissioni delle quali saranno utilizzate anche per alimentare gli Staker di FEGeth e FEGbsc.</p>
<p>La tecnologia SmartDeFi launchpad che porterà la creazione di nuovi token di criptovaluta a progetti con una vasta gamma di versatilità ha una piccola commissione integrata su acquisti e vendite per tutti i progetti, che verrà utilizzata anche in parte per premiare gli Stakers.</p>
<p>Nota: SmartDeFi verrà lanciato inizialmente su ETH e BSC, ma abbiamo intenzione di espandere questa tecnologia ad altre blockchain EVM nel tempo, le commissioni delle quali saranno utilizzate anche per alimentare gli stakeholder di FEGeth e FEGbsc.</p>
<h3 id="h3-Q420Ho20visto20che20hai20menzionato20FTW20l20Puoi20darci20maggiori20dettagli20a20riguardo20Cosa20lo20render20unico20rispetto20ad20altre20piattaforme966231"><a name="Q4: Ho visto che hai menzionato FTW lì. Puoi darci maggiori dettagli a riguardo? Cosa lo renderà unico rispetto ad altre piattaforme?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ho visto che hai menzionato FTW lì. Puoi darci maggiori dettagli a riguardo? Cosa lo renderà unico rispetto ad altre piattaforme?</h3><p>“From The Wallet” o “FTW” è una piattaforma di trading di ordini limitati che consente all’utente di scambiare direttamente dal proprio portafoglio ad altri utenti e viceversa.</p>
<p>Questa piattaforma è COMPLETAMENTE decentralizzata in quanto l’utente mantiene il possesso della propria criptovaluta o NFT durante l’intero processo!</p>
<p>Questo è l’apice del trading P2P (peer-to-peer) nello spazio delle criptovalute e degli NFT, con la possibilità di fare trading in modo assolutamente sicuro senza cedere il controllo dei propri asset a terzi.<br><img src="https://gimg2.gateimg.com/image/article/167627453233.png" alt=""><br>Abbiamo svolto molte ricerche di mercato per quanto riguarda le piattaforme OTC e tutte utilizzano contratti per il loro trading, questo NON è il caso di FTW e siamo entusiasti di portare la forma più pura di trading decentralizzato ai suoi utenti!</p>
<h3 id="h3-Q520Una20domanda20molto20comune20che20gli20utenti20spesso20fanno20riguarda20le20verifiche20Diresti20che20le20verifiche20sono20una20parte20importante20del20modello20di20business20del20progetto11370"><a name="Q5: Una domanda molto comune che gli utenti spesso fanno riguarda le verifiche. Diresti che le verifiche sono una parte importante del modello di business del progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Una domanda molto comune che gli utenti spesso fanno riguarda le verifiche. Diresti che le verifiche sono una parte importante del modello di business del progetto?</h3><p><strong>RTRcrypto</strong>: Tutti i contratti intelligenti da utilizzare nel nuovo ecosistema sviluppato saranno completamente auditati da servizi di audit di terze parti.</p>
<p>La sicurezza è di massima importanza per il team e la comunità!</p>
<p>Attualmente sono state avviate diverse linee di comunicazione con servizi di revisione, le discussioni includono accordi di non divulgazione per proteggere la proprietà intellettuale che abbiamo sviluppato come progetto e i potenziali costi (nessun costo finale è stato fornito in quanto i servizi di revisione necessitano dei contratti prima di fornire un preventivo, ciò è necessario perché il prezzo viene calcolato sulla base della lunghezza e della complessità del codice).</p>
<p>Una volta che i contratti sono stati sottoposti a test/miglioramenti interni, è possibile firmare gli NDA e consegnare i contratti alle aziende per i preventivi.</p>
<h3 id="h3-Q620Puoi20parlare20del20sistema20SmartDefi20del20progetto180281"><a name="Q6: Puoi parlare del sistema SmartDefi del progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Puoi parlare del sistema SmartDefi del progetto?</h3><p><strong>RTRcrypto</strong> Assolutamente, questo è un argomento così emozionante!</p>
<p>I token SmartDeFi 2.0 saranno negoziabili su qualsiasi Centralized Exchange (CEX) o Decentralized Exchange (DEX) e potranno essere abbinati a QUALSIASI TOKEN presente sul mercato (e.g., ETH, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, WBTC, USDC, USDt, BUSD, ecc.)</p>
<p>Il lancio di SmartDeFi Token Launchpad ti permetterà di:</p>
<p>Scegli se il token è Riflettente (RFI) o non riflettente (invio passivo dei token ai portafogli dei detentori con acquisti/vendite/trasferimenti)!</p>
<p>Creare il token!</p>
<p>Organizza una pre-vendita interna con una serie di opzioni per lanciare con la quantità desiderata di liquidità!</p>
<p>Assegna una percentuale del token di nuova emissione a un fondo di crescita per sviluppi futuri (detenuto dal team)!</p>
<p>Bloccare la liquidità per X periodo di tempo e/o impostare un periodo di dilazionamento per i token!</p>
<p>Imposta una percentuale desiderata di tassazione basata sull’attivo per ogni acquisto/vendita (una quantità di tasse che viene inviata a un pool di liquidità separato che aumenta solo, indipendentemente dal movimento del mercato, e può essere scambiato ‘bruciando’ il tuo token all’indirizzo inutilizzato)!</p>
<p>Utilizza la nostra funzione SmartLend, che consente agli utenti di ottenere un prestito senza interessi per 30 giorni contro il valore del loro token in base all’importo di copertura degli asset!</p>
<p>Crea il tuo pool di staking con le percentuali di ricompensa desiderate!</p>
<p>La bellezza dell’utilizzo della piattaforma di lancio SmartDeFi è che il Deployer da cui partirai sarà completamente auditato!</p>
<p><em>Creare un token COMPLETAMENTE AUDITATO</em> con il clic di pochi pulsanti e sapere che è costruito correttamente <em>SENZA COSTI di lancio</em>!</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il re-post dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>