R2F0ZS5pbyBBTUEgbWV0IElnbm9yZSBGdWQgLSBFZW4gbmlldXcgc29vcnQgTWVtZSBUb2tlbiBkYXQgRGVGaSBlbiBCbG9ja2NoYWluIElubm92YXRpZXMgb25kZXJzdGV1bnQ=

<p><img src="https://gimg2.gateimg.com/image/article/16854196391.jpg" alt=""><br><strong>Tijd: 29 mei 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hoste een AMA (Ask-Me-Anything) sessie met WeLovePassive, de vertegenwoordiger en communityleider bij Ignore Fud 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://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>Volg Ignore Fud op <a href="https://t.me/lgnorefud" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/qv8sfdGgPQ" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16854199012.png" alt=""><br><strong>WeLovePassive - Vertegenwoordiger en gemeenschapsleider bij Ignore Fud</strong></p>
<h2 id="h2-QampA20van20Gateio578541"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-V120Kunt20u20ons20alstublieft20een20korte20introductie20van20uzelf20en20uw20team20geven906707"><a name="V1: Kunt u ons alstublieft een korte introductie van uzelf en uw team geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u ons alstublieft een korte introductie van uzelf en uw team geven?</h3><p><strong>WeLovePassive</strong>: Oké zeker. Ik ben WeLovePassive, de vertegenwoordiger en communityleider van Ignore Fud. Het team bestaat uit JOU, ONS en iedereen in de gemeenschap die aan het project werkt en helpt het te laten groeien. Het staat open voor ieders bijdrage, daarom hebben we alleen een openbare lancering gedaan en is er geen tokentoewijzing voor het ontwikkelingsteam.<br><img src="https://gimg2.gateimg.com/image/article/16854199243.jpg" alt=""><br>WIJ zijn het TEAM, en dit project is VAN ONS. Laten we Fud negeren.</p>
<h3 id="h3-Q220Overgaan20naar20jouw20project20Kun20je20ons20een20eenvoudige20introductie20geven20van20IgnoreFud20Wat20is20de20motivatie20voor20het20bouwen20van20dit20project20en20wat20is20de20naam20van20de20token422028"><a name="Q2: Overgaan naar jouw project. Kun je ons een eenvoudige introductie geven van IgnoreFud? Wat is de motivatie voor het bouwen van dit project en wat is de naam van de token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Overgaan naar jouw project. Kun je ons een eenvoudige introductie geven van IgnoreFud? Wat is de motivatie voor het bouwen van dit project en wat is de naam van de token?</h3><p><strong>WeLovePassive</strong>: Ik vind deze vraag leuk. Ignore Fud is een nieuw soort meme-token dat DeFi en blockchain-innovaties ondersteunt.</p>
<p>Het Ignore Fud Project is opgericht om Coredao, Binance en de cryptocurrency-industrie als geheel te helpen meer mensen cryptocurrencies te laten gebruiken en adopteren. We bieden een gemeenschapsgericht meme-ecosysteem, een unieke hold-to-earn met blootstelling aan een grote en sterke gemeenschap van gebruikers van over de hele wereld.</p>
<p>Bovendien is dit een beweging die is samengesteld om FUD te bestrijden die af en toe in onze branche verschijnt.</p>
<p>4TOKEN is de officiële token van Ignore Fud. 4TOKEN is een hold-to-earn stablecoin. De vereiste voor het verdienen van passief inkomen is het vasthouden van 400.000 4TOKEN, equivalent aan $USDT.<br><img src="https://gimg2.gateimg.com/image/article/16854199434.png" alt=""><br>en binnenkort Stake 4TOKEN om 4TOKEN te verdienen.</p>
<p>Herinnering:<br>❌Geen nieuwe token<br>✅We zullen #4TOKEN beloningen gebruiken uit de circulerende voorraad</p>
<h3 id="h3-Q320En20meme20tokens20nemen20de20laatste20tijd20een20grote20plaats20in20op20de20markt20Ik20kijk20uit20naar20het20succes20van20het20IgnoreFudtoken20Dus20wat20maakt20IgnoreFud20en204TOKEN20speciaal20Hoe20is20dit20beter20dan20andere20mememunten20die20er20zijn296011"><a name="Q3: En meme tokens nemen de laatste tijd een grote plaats in op de markt. Ik kijk uit naar het succes van het IgnoreFud-token. Dus wat maakt IgnoreFud en 4TOKEN speciaal? Hoe is dit beter dan andere meme-munten die er zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: En meme tokens nemen de laatste tijd een grote plaats in op de markt. Ik kijk uit naar het succes van het IgnoreFud-token. Dus wat maakt IgnoreFud en 4TOKEN speciaal? Hoe is dit beter dan andere meme-munten die er zijn?</h3><p><strong>WeLovePassive</strong>: 4TOKEN is ontworpen om problemen te vermijden die vaak voorkomen in de cryptocurrency-industrie, zoals ‘rugpull’, ‘pump and dump’, ‘niet genoeg liquiditeit’, etc.</p>
<p>Ten eerste is 4TOKEN een hold-to-earn token, waarbij we USDT kunnen verdienen door het vast te houden. Je moet minimaal 400k 4TOKENs vasthouden om in aanmerking te komen. De USDT-reflecties en beloningen die door houders worden verdiend, komen voort uit de DEX-verkooptaks gegenereerd door verkochte 4TOKENs.</p>
<p>4TOKEN heeft een verkoopbelasting van 8% voor DEX. Dit is bedoeld om mensen aan te moedigen hun 4TOKEN bij ons te houden op de lange termijn terwijl we voldoen aan de use cases die de hele community ten goede zullen komen.</p>
<p>Desalniettemin, als ze besluiten te verkopen, zal het nog steeds de gemeenschap helpen door de verkoopbelasting en gunstig zijn voor het hele ecosysteem. Weet je waarom?</p>
<p>Vanwege de 8% verkoopbelasting, waarbij:<br>3% gaat naar reflecties of beloningen voor houders.<br>2% wordt toegevoegd aan 4TOKEN/CORE-liquiditeit. Dit is een automatisch LP-mechanisme om ervoor te zorgen dat we op de lange termijn voldoende liquiditeit hebben.<br>2% wordt verbrand om de voorraad van 4TOKEN te verminderen. Merk op dat dit een automatisch-verbrandingsmechanisme is.<br>1% wordt omgezet naar CORE/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> voor operationele kosten en het groeifonds om nutsvoorzieningen te bouwen.</p>
<p>Onze visie is dat als iemand verkoopt, gekwalificeerde houders verdienen + overwerkvoorziening afneemt.</p>
<h3 id="h3-Q420Waarom20heb20je20ervoor20gekozen20om20een20brug20te20bouwen20en20MultiChain20te20gaan43107"><a name="Q4: Waarom heb je ervoor gekozen om een brug te bouwen en MultiChain te gaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Waarom heb je ervoor gekozen om een brug te bouwen en MultiChain te gaan?</h3><p><strong>WeLovePassive</strong>: Ja 1 aanbod aan alle ketens.</p>
<p>Een begrip van #4TOKEN met slechts 1 aanbod over alle ketens. #4TOKEN deflatoir aanbod zal circuleren naar alle ketens via een BRUG.</p>
<p>De mint- en burn-functie van onze brug worden aangedreven door LayerZero_Labs en zijn gecontroleerd door @CertiK!</p>
<p>Zodra u #4TOKEN van het CORE-netwerk naar het BSC-netwerk overbrugt, zullen de volgende voorwaarden van toepassing zijn:<br>(1) Uw #4TOKEN zal worden vergrendeld in een CORE Bridge Contract (0x795c4a5e03cc6f4ed349caf076da6cb7f60d6921) en er zal een gelijke hoeveelheid #4TOKEN worden bijgemaakt op het BSC-netwerk.<br>Dit komt doordat onze #BSC-keten begint met nul #4TOKEN-aanbod.<br>(2) Wanneer u #4TOKEN van het BSC-netwerk terug overbrugt naar het CORE-netwerk, zal uw #4TOKEN op BSC worden verbrand en zal het Bridge Contract #4TOKEN vrijgeven op het CORE-netwerk.</p>
<p>Het GOEDE NIEUWS is dat we het EIGENDOM van de Brugcontracten hebben VERBRAND/VERWERPEN.</p>
<p>Daarom hoef je je geen zorgen te maken over het slaan van $4TOKEN op welke keten dan ook, omdat we altijd dezelfde deflatoire voorraad zullen hebben.</p>
<p>NIEMAND KAN ONZE $4TOKEN-VOORRAAD VERANDEREN OF BEWERKEN TOT HET EINDE DER TIJD!</p>
<p>Deze voorwaarden zijn binnenkort ook van toepassing op andere ketens. En binnenkort zal Gate.io ondersteuning bieden voor CORE- en ETH-stortingen/opnames omdat 4TOKEN nu op Gate.io staat genoteerd.</p>
<h3 id="h3-V520Wat20zijn20uw20toekomstige20gebruiksmogelijkheden20voor204TOKEN552045"><a name="V5: Wat zijn uw toekomstige gebruiksmogelijkheden voor 4TOKEN?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Wat zijn uw toekomstige gebruiksmogelijkheden voor 4TOKEN?</h3><p><strong>We houden van passief</strong>: In eerste instantie een meme-token. Maar in de toekomst zullen we de volgende use cases maken:</p>
<ol>
<li>Maak een Blockchain Validator/Staking Node zoals CORE Staking Node, ADA Staking, <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Staking, Cosmos Staking Node, New Blockchains met Staking Node en zelfs andere potentiële Tokens die staking beloningen verdienen. 50% van de maandelijkse omzet zal worden gebruikt om 4TOKEN terug te kopen (spotprijs) en te verbranden.</li><li>NFT-marktplaats met 4,000 negeer Fud NFT-collecties.</li><li>Compounding Crypto Asset “Vaults” richten zich op stablecoins, LP en Single Assets.</li><li>Decentralized Stable Swap (DEX) richt zich op Stable Coin Swap en opnieuw zal 50% van de maandelijkse inkomsten worden gebruikt om 4TOKEN terug te kopen en te verbranden.</li><li>De rest zijn suggesties en ideeën van de gemeenschap.</li></ol>
<p>We houden van onze gemeenschap, dus we staan open voor ideeën van de gemeenschap die kunnen helpen bij het laten groeien en groter worden van het project.</p>
<h3 id="h3-Q620IgnoreFud20is20door20CoredaoOrg20en20Certikaudit20KYC20gegaan20dus20naast20beveiliging20willen20we20weten20hoe20dit20project20in20de20toekomst20zijn20bedrijfsvoering20en20groei20kan20handhaven158111"><a name="Q6: IgnoreFud is door Coredao_Org en Certik-audit KYC gegaan, dus naast beveiliging, willen we weten hoe dit project in de toekomst zijn bedrijfsvoering en groei kan handhaven." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: IgnoreFud is door Coredao_Org en Certik-audit KYC gegaan, dus naast beveiliging, willen we weten hoe dit project in de toekomst zijn bedrijfsvoering en groei kan handhaven.</h3><p><strong>WeLovePassive</strong>: Ja! We hebben de problemen die door Certik zijn gevonden succesvol opgelost.</p>
<p>Auditrapport: <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>Om het project te ondersteunen, verzamelen we 1% belastingkosten voor operationele kosten en een groeifonds om in de toekomst nutsvoorzieningen te bouwen. We zullen doorgaan en onze huidige diensten aan de gemeenschap verbeteren en we zullen gebruiksscenario’s blijven bouwen voor de gemeenschap totdat we een marktkapitalisatie van $100M tot $1B bereiken. We willen blijven uitbreiden, dus gaan we multichain zoals BSC, ETH, ARB chain. <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, FTM, MATIC enzovoort.</p>
<p>We hebben geen routekaart, maar we hebben een kaart van wat we hebben gedaan.</p>
<p>We zijn toegewijd aan voortdurende innovatie en adoptie van wat er komen gaat.</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 standpunten van de onderzoeker en vormt geen beleggingsadvies.<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 schending van het auteursrecht.<br></div><p></p><br></div></div></div>