R2F0ZS5pbyBBTUEgY29uIElnbm9yZSBGdWQgLSBVbiBudW92byB0aXBvIGRpIHRva2VuIG1lbWUgY2hlIHN1cHBvcnRhIERlRmkgZSBpbm5vdmF6aW9uaSBibG9ja2NoYWlu

<p><img src="https://gimg2.gateimg.com/image/article/16854196391.jpg" alt=""><br><strong>Ora: 29 maggio 2023, 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 WeLovePassive, il rappresentante e responsabile della community presso Ignore Fud in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://4ignorefud.com/" rel="nofollow noopener noreferrer" target="_blank">https://4ignorefud.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/ignore_fud" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ignore_fud</a></strong><br><strong>Segui Ignora Fud su <a href="https://t.me/lgnorefud" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/qv8sfdGgPQ" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16854199012.png" alt=""><br><strong>WeLovePassive - Rappresentante e responsabile della comunità presso Ignore Fud</strong></p>
<h2 id="h2-QampA20da20Gateio142472"><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-Q120Puoi20gentilmente20darci20una20breve20introduzione20di20te20stesso20e20del20tuo20team121722"><a name="Q1: Puoi gentilmente darci una breve introduzione di te stesso e del tuo team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi gentilmente darci una breve introduzione di te stesso e del tuo team?</h3><p><strong>WeLovePassive</strong>: Va bene, certo. Sono WeLovePassive, il rappresentante e il leader della comunità di Ignore Fud. Il team siamo NOI, VOI e tutti nella comunità che lavorano sul progetto e lo aiutano a crescere. È aperto al contributo di tutti, ecco perché abbiamo fatto solo un lancio pubblico e non c’è alcuna allocazione di token per il team di sviluppo.<br><img src="https://gimg2.gateimg.com/image/article/16854199243.jpg" alt=""><br>NOI siamo il TEAM e questo progetto è NOSTRO. Ignoriamo le Fud.</p>
<h3 id="h3-Q220Passando20al20tuo20progetto20Potresti20darci20una20semplice20introduzione20a20IgnoreFud20Qual2020la20motivazione20per20la20creazione20di20questo20progetto20e20qual2020il20nome20del20token469930"><a name="Q2: Passando al tuo progetto. Potresti darci una semplice introduzione a IgnoreFud? Qual è la motivazione per la creazione di questo progetto e qual è il nome del token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Passando al tuo progetto. Potresti darci una semplice introduzione a IgnoreFud? Qual è la motivazione per la creazione di questo progetto e qual è il nome del token?</h3><p><strong>WeLovePassive</strong>: Mi piace questa domanda. Ignore Fud è un nuovo tipo di token meme che supporta DeFi e le innovazioni blockchain.</p>
<p>Il progetto Ignore Fud è stato creato per aiutare Coredao, Binance e l’intera industria delle criptovalute a ottenere più persone che utilizzino e adottino le criptovalute. Forniamo un ecosistema di meme centrato sulla community, un unico hold per guadagnare con esposizione a una grande e forte comunità di utenti provenienti da tutto il mondo.</p>
<p>Inoltre, questo è un movimento assemblato per combattere FUD che appare di tanto in tanto nella nostra industria.</p>
<p>4TOKEN è il token ufficiale di Ignore Fud. 4TOKEN è una stablecoin hold-to-earn, i requisiti di detenzione di $USDT per guadagnare passivamente sono 400.000 4TOKEN.<br><img src="https://gimg2.gateimg.com/image/article/16854199434.png" alt=""><br>e presto Stake 4TOKEN per guadagnare 4TOKEN.</p>
<p>Promemoria:<br>❌Nessun nuovo token<br>✅Useremo le ricompense #4TOKEN dall’offerta circolante</p>
<h3 id="h3-Q320E20ultimamente20i20token20meme20stanno20prendendo20un20grande20spazio20sul20mercato20Non20vediamo20lora20di20vedere20il20successo20del20token20IgnoreFud20Quindi20cosa20rende20speciale20IgnoreFud20e204TOKEN20In20che20modo2020migliore20rispetto20agli20altri20meme20coin20disponibili420907"><a name="Q3: E ultimamente i token meme stanno prendendo un grande spazio sul mercato. Non vediamo l’ora di vedere il successo del token IgnoreFud. Quindi, cosa rende speciale IgnoreFud e 4TOKEN? In che modo è migliore rispetto agli altri meme coin disponibili?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: E ultimamente i token meme stanno prendendo un grande spazio sul mercato. Non vediamo l’ora di vedere il successo del token IgnoreFud. Quindi, cosa rende speciale IgnoreFud e 4TOKEN? In che modo è migliore rispetto agli altri meme coin disponibili?</h3><p><strong>Amiamo il passivo</strong>: 4TOKEN è stato progettato per evitare problemi comuni nel settore delle criptovalute, come “rugpull”, “pump and dump”, “liquidità insufficiente”, ecc.</p>
<p>In primo luogo, 4TOKEN è un token hold-to-earn, dove possiamo guadagnare USDT semplicemente tenendolo. È necessario detenere almeno 400k di 4TOKEN per essere idonei. Le riflessioni USDT e le ricompense guadagnate dai detentori provengono dalla tassa di vendita DEX generata dalla vendita di 4TOKEN.</p>
<p>4TOKEN ha un’imposta di vendita DEX dell’8%. Questo per incoraggiare le persone a mantenere i loro 4TOKEN con noi a lungo termine, mentre soddisfiamo i casi d’uso che andranno a beneficio dell’intera comunità.</p>
<p>Tuttavia, se decidono di vendere, aiuterà comunque la comunità attraverso la tassa di vendita e sarà benefico per l’intero ecosistema. Sai perché?</p>
<p>A causa dell’imposta di vendita dell’8%, in cui:<br>Il 3% va a riflessi o premi per i detentori.<br>Il 2% verrà aggiunto alla liquidità 4TOKEN/CORE. Questo è un meccanismo auto-LP per garantire che abbiamo abbastanza liquidità a lungo termine.<br>Il 2% verrà bruciato per aiutare a ridurre l’offerta di 4TOKEN. Nota che questo è un meccanismo di auto-bruciatura.<br>Il 1% verrà convertito in CORE/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> per le spese operative e il fondo di crescita per costruire servizi pubblici.</p>
<p>La nostra prospettiva è che se qualcuno vende, i titolari qualificati guadagneranno + l’offerta a tempo extra sta diminuendo.</p>
<h3 id="h3-Q420Perch20hai20scelto20di20costruire20un20ponte20e20passare20a20MultiChain258852"><a name="Q4: Perché hai scelto di costruire un ponte e passare a MultiChain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Perché hai scelto di costruire un ponte e passare a MultiChain?</h3><p><strong>WeLovePassive</strong>: Sì 1 fornitura a tutte le catene.</p>
<p>Una comprensione di #4TOKEN che ha solo 1 fornitura su tutte le catene. L’offerta deflazionistica di #4TOKEN circolerà su tutte le catene attraverso un PONTE.</p>
<p>La funzione di conio e bruciatura del nostro ponte è alimentata da LayerZero_Labs ed è stata auditata da @CertiK!</p>
<p>Una volta effettuato il #4TOKEN di collegamento dalla rete CORE alla rete BSC, si verificheranno le seguenti condizioni:<br>(1) Il tuo #4TOKEN sarà bloccato in un contratto ponte CORE (0x795c4a5e03cc6f4ed349caf076da6cb7f60d6921), quindi una quantità uguale di #4TOKEN sarà coniata sulla rete BSC.<br>Questo perché la nostra catena di #BSC inizia con un’offerta di #4TOKEN pari a zero.<br>(2) Quando l’utente effettua il #4TOKEN di collegamento dalla rete BSC alla rete CORE, il #4TOKEN dell’utente su BSC verrà bruciato e il Contratto ponte #4TOKEN rilascerà all’utente sulla rete CORE.</p>
<p>La BUONA NOTIZIA è che abbiamo BRUCIATO/RINUNCIATO alla PROPRIETÀ dei Contratti del Ponte.</p>
<p>Quindi, non c’è bisogno di preoccuparsi della coniazione di $4TOKEN su qualsiasi catena, poiché avremo solo la stessa offerta deflazionistica per sempre.</p>
<p>NESSUNO PUÒ CAMBIARE O MODIFICARE IL NOSTRO FORNITURA DI TOKEN $4 FINO ALLA FINE DEI TEMPI!</p>
<p>Queste condizioni saranno presto applicabili anche ad altre catene. E presto Gate.io supporterà depositi/prelievi di CORE ed ETH perché 4TOKEN è ora quotato su Gate.io.</p>
<h3 id="h3-Q520Quali20sono20i20tuoi20futuri20casi20duso20per204TOKEN391679"><a name="Q5: Quali sono i tuoi futuri casi d’uso per 4TOKEN?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono i tuoi futuri casi d’uso per 4TOKEN?</h3><p><strong>WeLovePassive</strong>: All’inizio un token meme. Ma in futuro, creeremo i seguenti casi d’uso:</p>
<ol>
<li>Crea un validatore/nodo di staking Blockchain come il nodo di staking CORE, lo staking ADA, lo staking BNB, il nodo di staking Cosmos, le nuove blockchain con nodo di staking e persino altri potenziali token che guadagnano ricompense per lo staking. Il 50% delle entrate mensili sarà utilizzato per il riacquisto (prezzo spot) e la masterizzazione di 4TOKEN.</li><li>Mercato NFT con 4.000 collezioni Ignore Fud NFT.</li><li>Composizione dei “caveau” di criptovalute si concentrano su stablecoin LP e singoli asset.</li><li>Lo Stable Swap (DEX) decentralizzato si concentra sullo Stable Coin Swap e ancora una volta il 50% delle entrate mensili verrà utilizzato per riacquistare e bruciare 4TOKEN.</li><li>Il resto sono suggerimenti e idee della comunità.</li></ol>
<p>Amiamo la nostra comunità, quindi saremo aperti alle idee della comunità che possono aiutare il progetto a crescere e diventare più grande.</p>
<h3 id="h3-Q620IgnoreFud2020stato20sottoposto20a20KYC20da20CoredaoOrg20e20Certik20audit20quindi20oltre20alla20sicurezza20vogliamo20sapere20come20questo20progetto20pu20sostenere20la20sua20operativit20e20crescita20in20futuro392758"><a name="Q6: IgnoreFud è stato sottoposto a KYC da Coredao_Org e Certik audit, quindi oltre alla sicurezza, vogliamo sapere come questo progetto può sostenere la sua operatività e crescita in futuro." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: IgnoreFud è stato sottoposto a KYC da Coredao_Org e Certik audit, quindi oltre alla sicurezza, vogliamo sapere come questo progetto può sostenere la sua operatività e crescita in futuro.</h3><p><strong>Amiamo Passivo</strong>: Sì! Abbiamo risolto con successo i problemi riscontrati da Certik.</p>
<p>Rapporto di audit: <a href="https://skynet.certik.com/projects/ignore-fud" rel="nofollow noopener noreferrer" target="_blank">https://skynet.certik.com/projects/ignore-fud</a></p>
<p>Per sostenere il progetto, raccogliamo una tassa del 1% per le spese operative e un fondo di crescita per costruire utilità in futuro. Continueremo a migliorare i nostri servizi attuali per la comunità e continueremo a creare casi d’uso per la comunità finché non raggiungeremo una capitalizzazione di mercato compresa tra 100 milioni e 1 miliardo di dollari. Vogliamo continuare ad espanderci, quindi passare a più catene come BSC, ETH, ARB chain. <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, FTM, MATIC e etc.</p>
<p>Non abbiamo una road map, ma abbiamo una mappa di quello che abbiamo fatto.</p>
<p>Siamo impegnati nell’innovazione continua e nell’adozione di ciò che verrà.</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 il punto di vista 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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>