R2F0ZS5pbyBBTUEgbWV0IENVTFQgREFPIC0gT20gZGVnZW5lbiBkaWUgYm91d2VuIGVuIGJpamRyYWdlbiBhYW4gb256ZSBnZWRlY2VudHJhbGlzZWVyZGUgdG9la29tc3QgdGUgdmVyc3RlcmtlbiBlbiB0ZSBmaW5hbmNpZXJlbg==

<p><img src="https://gimg2.gateimg.com/image/article/16800744831.jpg" alt=""><br><strong>Tijd: 16 juni 2022, 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 Artorias, Maester bij Cult DAO 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://cultdao.io/" rel="nofollow noopener noreferrer" target="_blank">https://cultdao.io/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/wearecultdao" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/wearecultdao</a></strong></p>
<p><strong>Volg Cult op <a href="https://discord.com/invite/wearecultdao" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/cultdaothemany" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16800747242.png" alt=""><br><strong>Artorias — Maester bij Cult DAO</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio108348"><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-Q120Wat20is20Cult20DAO821966"><a name="Q1: Wat is Cult DAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat is Cult DAO?</h3><p><strong>Artorias</strong>: Cult DAO kan het best worden omschreven als een gedecentraliseerd investeringsplatform. De top 50 stakers kunnen een investering in een project voorstellen en vervolgens zal iedereen buiten de top 50 stemmen om het goed te keuren of af te wijzen. Als het wordt goedgekeurd, krijgen de top 13 stakeholders een deel van de opbrengsten van het project. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> waarde van CULT wordt van de schatkist naar het project gestuurd. 2,5 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Er wordt dan CULT ter waarde van 10% van de winst verbrand. Zodra het project winst heeft om terug te geven, koopt het CULT terug van de open markt met deze winst, verbrandt de helft en stuurt de helft als stakingsbeloningen.<br><img src="https://gimg2.gateimg.com/image/article/16800747643.png" alt=""><br>De schatkist wordt organisch opgebouwd uit een belasting van 0,4% die wordt geheven op alle transacties.</p>
<h3 id="h3-Q220Wat20zou20je20zeggen20dat20anders20is20dan20andere20investeringsDAOs1030"><a name="Q2: Wat zou je zeggen dat anders is dan andere investerings-DAO’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat zou je zeggen dat anders is dan andere investerings-DAO’s?</h3><p><strong>Artorias</strong>: CULT is volledig gedecentraliseerd, in tegenstelling tot de meeste DAO’s.<br>Er is geen team betrokkenheid bij het mechanisme van het voorstelssysteem, noch enig menselijk schatkistbeheer. De contracten zijn allemaal afgezworen. Dit betekent dat er geen toegang is tot schatkistfondsen via enig ander middel dan de voorstellen. Alles is geautomatiseerd totdat het project financiering ontvangt. Op dat moment kunnen ze de fondsen gebruiken zoals nodig is voordat er winst wordt teruggegeven.</p>
<p>Er zijn 3 belangrijke criteria waar de Guardians naar kijken bij projecten.</p>
<p>1) Ze bevorderen verdere decentralisatie.<br>2) Ze zijn een nobel of waardig doel.<br>3) Ze bestrijden de verspreiding van centralisatie.</p>
<p>De meeste DAO’s vertrouwen op het houden van een stemming, waarna degenen die de schatkist beheren de gestemde acties uitvoeren.</p>
<p>Maar dit is geen echte decentralisatie.</p>
<h3 id="h3-Q320Wat20voor20soort20investeringen20kan20CULT20maken20Zijn20er20beperkingen946922"><a name="Q3: Wat voor soort investeringen kan CULT maken? Zijn er beperkingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat voor soort investeringen kan CULT maken? Zijn er beperkingen?</h3><p><strong>Artorias</strong>: Het idee was om een zeer eenvoudig voorstelcontract te bouwen, dat maximale flexibiliteit zou bieden bij de gedane investeringen.</p>
<p>In zijn meest basale vorm is het een smart contract dat zegt: “Stuur dit” <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> adres 13 eth van CULT als de meerderheid stemt om goed te keuren”.</p>
<p>Dit betekent dat het voor bijna alles kan worden gebruikt, inclusief het overstijgen van de wereld van crypto. De gemeenschap heeft het laatste woord over wat wel en niet wordt goedgekeurd, en vanwege de openheid van hoe de fondsen worden gebruikt nadat ze zijn vrijgegeven door de schatkist, worden mensen niet vastgelegd aan bepaalde processen, waardoor er zeer weinig beperkingen zijn in wat kan worden gezien als een investering.</p>
<h3 id="h3-V420Kun20je20wat20voorbeelden20van20investeringen20geven304185"><a name="V4: Kun je wat voorbeelden van investeringen geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Kun je wat voorbeelden van investeringen geven?</h3><p><strong>Artorias</strong>: Natuurlijk.<br>Tot nu toe hebben we een breed scala aan voorstellen gehad. Zo hebben we bijvoorbeeld enkele toewijzingen die werken aan een opbrengstboerderijprotocol en LP-prikkels, om een ​​gestage opbrengst te genereren voor stakers.</p>
<p>We hebben ook aankopen van andere tokens gehad, zoals $BONE en $PEOPLE, waarvan sommige het nu erg goed doen.</p>
<p>We hebben zelfs donaties voorgesteld, waaronder een donatie aan hackercollectief Anonymous, en een mentaal gezondheidsdoel genaamd The Unminding Project.</p>
<p>Ik heb het gevoel dat dit echt een idee geeft van hoe veelzijdig ons protocol is. We zijn niet alleen een project gericht op onszelf, we zijn een project dat andere projecten in onze ruimte ondersteunt!</p>
<h3 id="h3-Q520Kunt20u20de20tokenomics20van20het20project20bespreken20Hoe20zou20u20zeggen20dat20de20tokenomics20zijn20ontworpen20om20de20CULTtoken20te20ondersteunen557392"><a name="Q5: Kunt u de tokenomics van het project bespreken? Hoe zou u zeggen dat de tokenomics zijn ontworpen om de CULT-token te ondersteunen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kunt u de tokenomics van het project bespreken? Hoe zou u zeggen dat de tokenomics zijn ontworpen om de CULT-token te ondersteunen?</h3><p><strong>Artorias</strong>: CULT heeft het geluk dat het 2 van de sterkste assets in crypto heeft.</p>
<p>De eerste daarvan is onze loyale gemeenschap, en de tweede is onze tokenomics.</p>
<p>In moeilijke tijden op de markt heb je een sterke gemeenschap nodig die bereid is om je te steunen en waar je voor staat als project, want dit zijn de investeerders die bij je zullen blijven en niet zullen dumpen bij het eerste teken van een neerwaartse trend.</p>
<p>De tokenomics zijn specifiek ontworpen om de waarde van de CULT-token in de loop van de tijd te ondersteunen door een hyperdeflationair aspect aan het project te bieden. Doordat de schatkist en investeringen allemaal in CULT worden gedaan (maar naar de waarde van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>), alle verbrandingen vinden ook plaats in CULT, dus als de prijs lager is, betekent dit dat er meer CULT wordt verbrand per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, wat betekent dat het aanbod veel sneller afneemt tijdens een neerwaartse trend en berenmarkten zoals we nu meemaken.<br><img src="https://gimg2.gateimg.com/image/article/16800747424.png" alt=""><br>Bijvoorbeeld 2.5 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> van CULT die op de huidige prijs wordt verbrand, is ongeveer 8 keer meer CULT verbrand dan op ons allerhoogste prijsniveau.</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op 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 schending van het auteursrecht.<br></div><p></p><br></div></div></div>