R2F0ZS5pbyBBTUEgY29uIENVTFQgREFPIC0gUGVyIHBvdGVuemlhcmUgZSBmaW5hbnppYXJlIGNvbG9ybyBjaGUgY29zdHJ1aXNjb25vIGUgY29udHJpYnVpc2Nvbm8gYWwgbm9zdHJvIGZ1dHVybyBkZWNlbnRyYWxpenphdG8=

<p><img src="https://gimg2.gateimg.com/image/article/16800744831.jpg" alt=""><br><strong>Ora: 16 giugno 2022, 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 Artorias, Maester presso Cult DAO in the <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito Ufficiale: <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>Segui Cult su <a href="https://discord.com/invite/wearecultdao" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://t.me/cultdaothemany" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16800747242.png" alt=""><br><strong>Artorias - Maestro presso Cult DAO</strong></p>
<h2 id="h2-QampA20da20Gateio442372"><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-Q120Cos20Cult20DAO51830"><a name="Q1: Cos’è Cult DAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è Cult DAO?</h3><p><strong>Artorias</strong>: Cult DAO può essere meglio descritto come una piattaforma di investimento decentralizzata. I primi 50 stakeholder possono proporre un investimento in un progetto, e poi tutti al di fuori dei primi 50 voteranno per approvarlo o respingerlo. Se viene approvato, 13 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il valore di CULT viene inviato dal tesoro al progetto. 2.5 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il valore di CULT viene quindi bruciato. Una volta che il progetto ha profitti da restituire, riacquista CULT dal mercato aperto con essi, quindi ne brucia la metà e invia l’altra metà come ricompense di staking.<br><img src="https://gimg2.gateimg.com/image/article/16800747643.png" alt=""><br>Il tesoro è costruito organicamente da una tassa del 0,4% raccolta su tutte le transazioni.</p>
<h3 id="h3-Q220Cosa20diresti20che2020diverso20dagli20altri20DAO20di20investimento415550"><a name="Q2: Cosa diresti che è diverso dagli altri DAO di investimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Cosa diresti che è diverso dagli altri DAO di investimento?</h3><p><strong>Artorias</strong>: CULT è completamente decentralizzato, a differenza della maggior parte dei DAO. Non c’è coinvolgimento del team nelle meccaniche del sistema delle proposte e nessuna gestione del tesoro umano. I contratti sono stati tutti abbandonati. Ciò significa che non c’è accesso ai fondi del tesoro tramite nessun mezzo oltre alle proposte. Tutto è automatizzato fino a quando il progetto riceve il finanziamento. A quel punto possono utilizzare i fondi come necessario prima di restituire i profitti in seguito.</p>
<p>Ci sono 3 criteri principali che i Guardiani cercano nei progetti.</p>
<p>1) Favoriscono ulteriormente la decentralizzazione.<br>2) Sono una causa nobile o meritevole.<br>3) Combattono la diffusione della centralizzazione.</p>
<p>La maggior parte dei DAO si basa su una votazione, poi coloro che controllano il tesoro eseguono le azioni votate.</p>
<p>Ma questo non è una vera decentralizzazione.</p>
<h3 id="h3-Q320Che20tipo20di20investimenti20pu20fare20CULT20Ci20sono20limitazioni103314"><a name="Q3: Che tipo di investimenti può fare CULT? Ci sono limitazioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Che tipo di investimenti può fare CULT? Ci sono limitazioni?</h3><p><strong>Artorias</strong>: L’idea era quella di costruire un contratto di proposta molto semplice, che consentisse la massima flessibilità degli investimenti effettuati.</p>
<p>Nella sua forma più basilare è un contratto intelligente che dice “Invia questo” <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> indirizzo 13 eth di CULT se la maggioranza vota per approvare</p>
<p>Ciò significa che può essere utilizzato per quasi tutto, incluso andare oltre i confini della criptovaluta. La comunità ha l’ultima parola su ciò che viene approvato e ciò che non lo è, e a causa della mancanza di limiti su come i fondi vengono utilizzati dopo essere stati rilasciati dal tesoro, non si vincola nessuno a determinati processi, il che significa che ci sono pochissime limitazioni su ciò che può essere considerato un investimento.</p>
<h3 id="h3-Q420Puoi20darmi20alcuni20esempi20di20investimenti194700"><a name="Q4: Puoi darmi alcuni esempi di investimenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi darmi alcuni esempi di investimenti?</h3><p><strong>Artorias</strong>: Certo.<br>Finora abbiamo avuto una vasta gamma di proposte. Ad esempio, abbiamo alcune allocazioni che stanno lavorando su un protocollo di yield farming e incentivi LP, per generare un rendimento costante agli stakeholder.</p>
<p>Abbiamo anche avuto acquisti di altri token, come $BONE e $PEOPLE, alcuni dei quali stanno andando molto bene ora.</p>
<p>Abbiamo persino proposto donazioni, tra cui una donazione al collettivo di hacker Anonymous e una causa per la salute mentale chiamata The Unminding Project.</p>
<p>Sento che questo dà davvero un’idea di quanto sia versatile il nostro protocollo. Non siamo solo un progetto focalizzato su noi stessi, siamo un progetto che supporta altri progetti nel nostro settore!</p>
<h3 id="h3-Q520Puoi20discutere20della20tokenomica20del20progetto20Come20diresti20che20la20tokenomica2020progettata20per20sostenere20il20token20CULT462960"><a name="Q5: Puoi discutere della tokenomica del progetto? Come diresti che la tokenomica è progettata per sostenere il token CULT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi discutere della tokenomica del progetto? Come diresti che la tokenomica è progettata per sostenere il token CULT?</h3><p><strong>Artorias</strong>: CULT è molto fortunato perché ha 2 degli asset più forti nella criptovaluta.</p>
<p>Il primo di questi è la nostra comunità fedele, e il secondo è la nostra tokenomica.</p>
<p>Nei momenti difficili sul mercato, hai bisogno di una comunità forte che sia disposta a sostenerti e a sostenere ciò per cui ti batti come progetto, perché questi sono gli investitori che resteranno al tuo fianco e non ti abbandoneranno al primo segno di calo.</p>
<p>La tokenomica è progettata specificamente per aiutare a sostenere nel tempo il valore del token CULT fornendo un aspetto iper-deflazionario al progetto. A causa del fatto che il tesoro e gli investimenti sono tutti effettuati in CULT (ma al valore di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>), tutti i burn avvengono anche in CULT, quindi se il prezzo è più basso, significa che viene bruciata più CULT per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, ciò significa che l’offerta diminuisce molto più rapidamente durante un trend ribassista e i mercati orso come quelli che stiamo vivendo ora.<br><img src="https://gimg2.gateimg.com/image/article/16800747424.png" alt=""><br>Ad esempio 2.5 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> di CULT bruciato al prezzo attuale è circa 8 volte di più di CULT bruciato rispetto a quando era al massimo storico.</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 a causa della violazione del copyright.<br></div><p></p><br></div></div></div>