R2F0ZS5pbyBBTUEgbWV0IEFLSVRBIE5ldHdvcmsgLSBUaHVpc2Jhc2lzIHZhbiBkZSBnZWxvdmlnZW4gaW4gZWNodGUgZ2VtZWVuc2NoYXBza3JhY2h0

<p><img src="https://gimg2.gateimg.com/image/article/16989095311.png" alt=""><br><strong>Tijd: 1 november 2023, 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 Arthur, Steward van AKITA DAO in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Uitwisseling Gemeenschap</a>.</strong><br><strong>Officiële Website: <a href="https://akita.network/" rel="nofollow noopener noreferrer" target="_blank">https://akita.network/</a></strong><br><strong>Telegram: <a href="https://t.me/akitatoken" rel="nofollow noopener noreferrer" target="_blank">https://t.me/akitatoken</a></strong><br><strong>Volg AKITA Network op <a href="https://t.me/akitatoken" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/AKITA_network?s=09." rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16989097592.jpeg" alt=""><br><strong>Arthur — beheerder van AKITA DAO</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio579855"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-V120Vertel20ons20alstublieft20over20Akita20Network20en20Akita20Inu20token979655"><a name="V1: Vertel ons alstublieft over Akita Network en $Akita Inu token." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Vertel ons alstublieft over Akita Network en $Akita Inu token.</h3><p><strong>Arthur</strong>: Ik denk dat de meeste mensen ons al kennen.</p>
<p>Op 1 februari 2021 werd de AKITA-token gelanceerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk (ook gekoppeld aan <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a>(blockchain). Akita Inu is een van de oorspronkelijke ‘meme coins’, volgend op DOGE en vervolgens SHIB, gelanceerd met een maximale voorraad van 100 biljoen (100.000.000.000.000) AKITA-tokens.</p>
<p>AKITA is zo OG dat er geen belastingen of kosten worden gemaakt bij overdrachten, verkopen of aankopen. Als een ‘sociaal experiment’ of marketingtruc hebben ze ook 50% van de voorraad naar de portemonnee van Vitalik Buterin gestuurd, in een poging om deze tokens ‘effectief verbrand’ te noemen. Dit zijn de basisprincipes voor AKITA INU.</p>
<h3 id="h3-V220Dus20wat20maakt20jou20anders20dan20andere20projectengemeenschappen20in20de20ruimte73952"><a name="V2: Dus wat maakt jou anders dan andere projecten/gemeenschappen in de ruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Dus wat maakt jou anders dan andere projecten/gemeenschappen in de ruimte?</h3><p><strong>Arthur</strong>: Nou, het is moeilijk om anders te zijn als er zoveel andere projecten om ons heen zijn.</p>
<p>Maar we hebben een paar sleutel elementen. Dat geeft ons een voordeel en maakt ons ook anders.</p>
<p>Allereerst zijn het de mensen in onze gemeenschap! Betrouwbaar en ondersteunend!</p>
<p>Ten tweede. Zoals al vermeld, zijn we OG #Meme. Battle tested.</p>
<p>De volgende is erg belangrijk. We hebben onze eigen DAO! Dat is een grote stap vooruit voor ons!<br><img src="https://gimg2.gateimg.com/image/article/16989098163.jpg" alt=""><br>En tot slot. We hebben een beveiligde financieringsstroom. Die zal duren tot 2027 Q1. Niet veel andere projecten hebben financieringsstromen!</p>
<h3 id="h3-Q320Dus20je20hebt20wat20financieringsstromen20genoemd20Hoe20denk20je20dat20die20stromen20Akita20helpen890501"><a name="Q3: Dus je hebt wat financieringsstromen genoemd. Hoe denk je dat die stromen Akita helpen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Dus je hebt wat financieringsstromen genoemd. Hoe denk je dat die stromen Akita helpen?</h3><p><strong>Arthur</strong>: De financiering. We zijn erin geslaagd financiering te krijgen van <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>. Het is 10T $AKITA. Met behulp van Funding konden we onze eigen DAO lanceren. Funding zal ons ook helpen om enkele nieuwe CEX-vermeldingen te maken voor AKITA INU (ook HACHI). We streven naar Tier 1 CEXs in de toekomst. Er is veel mogelijk wanneer je een gegarandeerde Funding-stroom hebt. Dingen zullen echt beginnen te stijgen wanneer de markt aantrekt! Ik denk dat veel mensen nog steeds niet weten dat we deze Funding hebben. Die bedoeld is voor het AKITA-NETWORK-ecosysteem.</p>
<h3 id="h3-Q420U20vermeldt20dat20u20uw20eigen20DAO20heeft20gelanceerd20Dat20is20behoorlijk20cool20Vertel20ons20meer20over20Akita20Dao20en20wat20het20doel20ervan20is302730"><a name="Q4: U vermeldt dat u uw eigen DAO heeft gelanceerd? Dat is behoorlijk cool. Vertel ons meer over Akita Dao en wat het doel ervan is." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: U vermeldt dat u uw eigen DAO heeft gelanceerd? Dat is behoorlijk cool. Vertel ons meer over Akita Dao en wat het doel ervan is.</h3><p><strong>Arthur</strong>: Het doel van AKITA DAO is om onze gemeenschap actiever te maken.</p>
<p>We willen dat leden van de gemeenschap echt de kracht van DAO begrijpen. We hebben een tool die je kan helpen bij het realiseren van je visie/idee voor gemeenschapsvoordelen.</p>
<p>Als er iemand is met goede ideeën en steun van de gemeenschap, zullen er geweldige dingen gebeuren.</p>
<p>Voor meer informatie kunt u controleren <a href="https://akita-dao.gitbook.io/akita-dao/" rel="nofollow noopener noreferrer" target="_blank">https://akita-dao.gitbook.io/akita-dao/</a></p>
<p>En nog iets <a href="https://discourse.akita.network/?discourse_app=1" rel="nofollow noopener noreferrer" target="_blank">https://discourse.akita.network/?discourse_app=1</a></p>
<h3 id="h3-V520Dus20het20lijkt20erop20dat20jullie20behoorlijk20openstaan20voor20iedereen20met20deze20aanpak20toch20Misschien20kunnen20jullie20ons20meer20vertellen20over20wie20en20hoe20er20kan20deelnemen20aan20Akita20Dao393717"><a name="V5: Dus het lijkt erop dat jullie behoorlijk openstaan voor iedereen met deze aanpak, toch? Misschien kunnen jullie ons meer vertellen over wie en hoe er kan deelnemen aan Akita Dao?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Dus het lijkt erop dat jullie behoorlijk openstaan voor iedereen met deze aanpak, toch? Misschien kunnen jullie ons meer vertellen over wie en hoe er kan deelnemen aan Akita Dao?</h3><p><strong>Arthur</strong>: Ja. Absoluut.</p>
<p>Voor iemand die deze letters DAO (gedecentraliseerde autonome organisatie) hoort.</p>
<p>Het is verwarrend.<br>Dus.</p>
<p>AKITA DAO is voor iedereen. Het maakt niet uit waar je bent. Je hebt alleen een goed idee nodig om te beginnen. Er is geweldige ondersteuning van OG-leden die je met alles zullen helpen.</p>
<p>Je kunt ook deelnemen als actief gemeenschapslid dat altijd graag praat over nieuwe ideeën. Je kunt ook deelnemen door te stemmen op je favoriete AKITA DAO-voorstel. Het enige wat je nodig hebt is wat HACHI in je privéportemonnee om in aanmerking te komen om te stemmen.</p>
<h3 id="h3-Q620Kunt20u20meer20uitleg20geven20over20het20Akita20Dao20governancetoken20Gaat20het20Akita20vervangen499333"><a name="Q6: Kunt u meer uitleg geven over het Akita Dao governance-token? Gaat het $Akita vervangen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Kunt u meer uitleg geven over het Akita Dao governance-token? Gaat het $Akita vervangen?</h3><p><strong>Arthur</strong>: Ja.</p>
<p>Ik zie nog steeds dat sommige communityleden/nieuwkomers denken dat $HACHI de volgende $AKITA is.</p>
<p>Het antwoord is erg simpel. Er zal altijd AKITA INU zijn.</p>
<p>De EEN en enige Hond.</p>
<p>HACHI is onze Governance Token. Momenteel is dat de enige functionaliteit.</p>
<p>Als je niet telt dat je je $HACHI kunt gebruiken voor DAO-stemming.</p>
<p>Maar we denken ook dat HACHI ons kan helpen om ons AKITA DAO-schatkist te vergroten.</p>
<p>Als je de Tokenomics voor HACHI controleert, zul je zien dat HACHI ook bedoeld is voor andere dingen.<br><img src="https://gimg2.gateimg.com/image/article/16989098274.png" alt=""><br>Het is voor toekomstige marketing, leiderschap en gemeenschap. Als we HACHI waardevoller kunnen maken, betekent dit ook dat het het hele AKITA-NETWORK-ecosysteem kan helpen.</p>
<h3 id="h3-Vraag20720Wie20zijn20de20mensenhet20team20achter20het20project544016"><a name="Vraag 7: Wie zijn de mensen/het team achter het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 7: Wie zijn de mensen/het team achter het project?</h3><p><strong>Arthur</strong>: Het is niet alsof er een Team is. Het is nu DAO. Gemeenschapsleden nemen beslissingen/voorstellen.</p>
<p>Er zijn drie Stewards die u zullen helpen bij het begeleiden van alle noodzakelijke processen om deel uit te maken van Community Leading. Momenteel kan ik zeggen dat er niet zoveel activisten zijn met interessante ideeën. Maar ik ben er meer dan zeker van dat dit zal veranderen wanneer de markt nog beter wordt!</p>
<h3 id="h3-Q820Heb20je20eerder20gezegd20dat20jullie20op20eth20en20avax20zitten20toch20Zijn20er20plannen20om20in20de20toekomst20naar20andere20L1s20of20L2s20te20bridgen423624"><a name="Q8: Heb je eerder gezegd dat jullie op eth en avax zitten, toch? Zijn er plannen om in de toekomst naar andere L1’s of L2’s te bridgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Heb je eerder gezegd dat jullie op eth en avax zitten, toch? Zijn er plannen om in de toekomst naar andere L1’s of L2’s te bridgen?</h3><p><strong>Arthur</strong>: Ja. Dat klopt. Op dit moment bevinden we ons op de ETH- en AVAX-blockchains.</p>
<p>Wanneer de tijd rijp is, zullen we meer dan klaar zijn voor het nieuwe DAO-voorstel daarvoor. Momenteel zijn we beperkt met ons budget, dus we proberen slimme beslissingen te nemen!</p>
<h3 id="h3-Vraag20920Laatste20vraag20een20beetje20meer20algemeen2020waar20zie20je20het20project20over2012420jaar20naartoe20gaan2020in20termen20van20de20routekaart725562"><a name="Vraag 9: Laatste vraag een beetje meer algemeen - waar zie je het project over 1/2/4 jaar naartoe gaan - in termen van de routekaart." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 9: Laatste vraag een beetje meer algemeen - waar zie je het project over 1/2/4 jaar naartoe gaan - in termen van de routekaart.</h3><p>Het is aan de gemeenschap. Maar ik kan zien dat AKITA-NETWORK zal blijven groeien.</p>
<p>Ik kan grote CEX-listings zien, ik kan interessante samenwerkingen zien, ik kan nieuwe bruggen zien naar nieuwe ketens.</p>
<p>Het AKITA-NETWORK-netwerk wordt een levensstijl!</p>
<p>Zorg ervoor dat je ons volgt!</p>
<p>Voor alle laatste informatie en updates.<br><a href="https://x.com/AKITA_network?t=hGnveNi_nxaneNB-Eeysiw&amp;s=09" rel="nofollow noopener noreferrer" target="_blank">https://x.com/AKITA_network?t=hGnveNi_nxaneNB-Eeysiw&amp;s=09</a> <a href="https://t.me/akitatoken" rel="nofollow noopener noreferrer" target="_blank">https://t.me/akitatoken</a></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 opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>