R2F0ZS5pbyBBTUEgbWV0IENoaWNrZW5jb2lu

<p><img src="https://gimg2.gateimg.com/image/article/171349766220240417-165354.png" alt=""><br><strong>Tijd: 18 april 2024, 10:00 uur UTC</strong><br><strong>Gate.io organiseerde een AMA (Ask-Me-Anything) sessie met The Chicken Man, vertegenwoordiger van Chickencoin, in de Gate.io Exchange Community.</strong><br><strong>Officiële website: <a href="https://www.chickencoin.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.chickencoin.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/chickencoin_eth" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/chickencoin_eth</a></strong><br><strong>Volg Chickencoin op <a href="https://t.me/chickencoin_eth" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/chickencoin_eth" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<h2 id="h2-V120Kunt20u20ons20een20overzicht20geven20van20het20project411270"><a name="V1: Kunt u ons een overzicht geven van het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u ons een overzicht geven van het project?</h2><p><em>Zeker. Zoals het op onze website staat bij <a href="https://chickencoin.com" rel="nofollow noopener noreferrer" target="_blank">https://chickencoin.com</a>. Chickencoin is een meme coin gelanceerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain en geforked van het PEPE smart contract. We hebben honden, katten en zelfs kikkers, maar niet te veel goede oude kippen.</em></p>
<p><em>We zijn een fork van PEPE, wat betekent dat we een totale voorraad hebben van 69T en het officiële contract 0xD55210Bb6898C021a19de1F58d27b71f095921Ee is en onze officiële ticker CHKN is.</em></p>
<h2 id="h2-V220Wie20is20Silo331520"><a name="V2: Wie is Silo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Wie is Silo?</h2><p><em>Silo is de mascotte van Chickencoin, we hebben besloten om wat plezier met hem te hebben en houders de kans te geven om zijn reis te zien terwijl het project vordert. We zijn op paaszondag gelanceerd, waardoor hij op die dag uitkwam. Hij is een groot onderdeel van Chickencoin en zijn thema, we zijn er zeker van dat iedereen ervan zal genieten om hem met ons te zien opgroeien.</em></p>
<h2 id="h2-Q320Is20het20waar20dat20de20ontwikkelaars20meer20dan2025000020USD20hebben20uitgegeven20aan20het20uitdelen20van20CHKN20aan20PEPEhouders439496"><a name="Q3: Is het waar dat de ontwikkelaars meer dan $250.000 USD hebben uitgegeven aan het uitdelen van $CHKN aan $PEPE-houders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Is het waar dat de ontwikkelaars meer dan $250.000 USD hebben uitgegeven aan het uitdelen van $CHKN aan $PEPE-houders?</h2><p><em>Ja, meer. De ontwikkelaars wilden iets doen voor de gemeenschap en besloten de munt als luchtdaling uit te voeren, aangezien we een fork zijn van PEPE. Aangezien we PEPE hebben geforked, is het alleen maar eerlijk dat we het aan hen luchtdruppelen. Veel luchtdruppels vereisen dat houders gas uitgeven. Wij hebben dit gasvrij gedaan en het vereiste nul interactie van bestaande pepe-houders, het is waarschijnlijk dat sommigen nog steeds niet weten dat ze het hebben! De snapshot van houders was op blok 19420069, let op de cijfers.
</em></p>
<h2 id="h2-Q420Het20project20zegt20dat20het20een20fairlaunch20is20Wat20maakt20jullie20een20fair20launch20project780548"><a name="Q4: Het project zegt dat het een fairlaunch is? Wat maakt jullie een fair launch project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Het project zegt dat het een fairlaunch is? Wat maakt jullie een fair launch project?</h2><p><em>Naast de airdrop die we hebben gedaan en die goed was voor 40% van de voorraad, hebben de ontwikkelaars nog eens 53,1% in een <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Pool voor de gemeenschap. Er is een 6,9% oprichtersallocatie die zich bevindt in een multi-sig wallet met 6 handtekeningen.</em></p>
<h2 id="h2-Q520Heeft20het20project20enige20verbrandingen20gedaan393345"><a name="Q5: Heeft het project enige verbrandingen gedaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Heeft het project enige verbrandingen gedaan?</h2><p><em>We krijgen vaak vragen over verbrandingen. Niet veel mensen zullen dit hebben opgemerkt, maar de ontwikkelaars hebben eigenlijk de oorspronkelijke uniswap-tokens verbrand door ze naar het Chickencoin-contract te sturen dat werd verlaten. We hebben in feite $250k USD verbrand door dit te doen.</em></p>
<h2 id="h2-V620Wat20kun20je20ons20vertellen20over20het20team151285"><a name="V6: Wat kun je ons vertellen over het team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V6: Wat kun je ons vertellen over het team?</h2><p><em>Het team is anoniem, dus ik kan geen specifieke details over hen delen. Wat ik wel kan zeggen, is dat ze iets ongekends hebben gedaan met de gasvrije airdrop en het verbranden van de uniswap-tokens. Ze zijn dol op memes en hebben een obsessie met getallen, wat sommigen van jullie misschien hebben gemerkt. Ze zijn actief en leggen een grote nadruk op de gemeenschap. We hebben enkele grote aankondigingen gedaan en richten ons op samenwerkingen met plaatsen zoals jij. Veiligheid is ook belangrijk, daarom hebben we een Certik-audit als prioriteit voltooid. Je kunt het vinden op <a href="https://skynet.certik.com/projects/chickencoin" rel="nofollow noopener noreferrer" target="_blank">https://skynet.certik.com/projects/chickencoin</a> Ze hebben niet ontworpen voor een snelle lancering en gekte tactieken zoals andere ketens die het op dit moment doen (geen haat!). CHKN heeft tot doel een leuk langetermijnexperiment te zijn voor memes en avontuurlijke activiteiten.</em></p>
<h2 id="h2-V720Welk20advies20zou20je20persoonlijk20aan20onze20gemeenschap20en20die20van20jou20geven22854"><a name="V7: Welk advies zou je persoonlijk aan onze gemeenschap en die van jou geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V7: Welk advies zou je persoonlijk aan onze gemeenschap en die van jou geven?</h2><p><em>Ik geloof sterk in de bijdrage van de gemeenschap aan een project. Hoewel marketing geweldig is en het team zeker een rol te spelen heeft, denk ik dat het belangrijk is dat de gemeenschap betrokken raakt, vooral bij een meme-project. Ik moedig onze gemeenschap regelmatig aan om memes te maken, te delen en te plaatsen. Dit omvat ook actief zijn op Twitter (X) en elkaar leren kennen. We zijn een memecoin, we zijn hier voor de lol, leer elkaar kennen en heb er plezier mee terwijl je betrokken raakt.</em></p>
<h2 id="h2-Q820Wat20is20iets20wat20je20hebt20geleerd20tijdens20je20betrokkenheid20bij20de20lancering20van20Chickencoin736312"><a name="Q8: Wat is iets wat je hebt geleerd tijdens je betrokkenheid bij de lancering van Chickencoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Wat is iets wat je hebt geleerd tijdens je betrokkenheid bij de lancering van Chickencoin?</h2><p><em>Ik ben al lange tijd betrokken bij verschillende projecten, dus ik heb heel wat gezien. Wat me echter opviel bij Chickencoin, hoewel dat niet uniek is voor ons, is dat er een ongekend aantal oplichtingspraktijken op Twitter (X) waren, met valse airdrops, valse Telegramgroepen en andere geavanceerde oplichtingspraktijken gericht op gebruikers. Dit is niet uniek voor ons en zal niet stoppen bij ons. Ik raad de gemeenschap en de cryptogemeenschap in het algemeen aan om waakzaam te blijven, ongeacht het project dat je volgt, nooit je geheime zin te delen, nooit je portemonnee aan onbekende dapps te koppelen, en altijd dubbel te controleren op Twitter (X), Telegram of andere handvatten waar je mee in contact komt. Blijf veilig en blijf waakzaam.</em></p>
<div class="blog-details-info"><br><div>Auteur:<strong> Gate.io Gemeenschap.</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>