R2F0ZS5pbyBBTUEgY29uIFN1YkRhbyAtIExhIHBpYXR0YWZvcm1hIERBTyBtdWx0aS1mdW56aW9uYWxlIHBlciBpbCB2ZW50dXJlIGNhcGl0YWwgZSBsYSBnZXN0aW9uZSBkZWdsaSBhc3NldCBkaWdpdGFsaQ==
<p><img src="https://gimg2.gateimg.com/image/article/1672991940FiztmgcXkAElU6l.jpeg" alt=""><br><strong>Ora: 1° dicembre 2022, 13:00 (UTC)</strong><br><strong>Gate.io ha ospitato una sessione AMA (Ask-Me-Anything) con il Core Contributor di SubDao, Tony, presso la Community di Gate.io Exchange</strong><br><strong>Sito Web ufficiale: <a href="https://subdao.network/" rel="nofollow noopener noreferrer" target="_blank">https://subdao.network/</a></strong><br><strong>Segui SubDao su Twitter</strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/1672991980截屏2023-01-06 14.09.06.png" alt=""><br>Tony-il principale contributore di SubDao</p>
<h2 id="h2-QampA20da20Gateio710059"><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-20Q120Per20favore20presentare20SubDao20e20i20prodotti20e20le20funzioni20di20SubDAO457363"><a name="## Q1: Per favore presentare SubDao e i prodotti e le funzioni di SubDAO." class="reference-link"></a><span class="header-link octicon octicon-link"></span>## Q1: Per favore presentare SubDao e i prodotti e le funzioni di SubDAO.</h3><p><strong>Stiloso</strong>: SubDAO è un protocollo DAO che aiuta a gestire gli asset digitali attraverso middleware, multi-sig e altre funzionalità decentralizzate.<br>In passato (Fase Uno), abbiamo ricevuto tre sovvenzioni della Fondazione Web3, tutte presentate per il completamento; queste tre concessioni corrispondono alle tre linee di prodotti del protocollo SubDAO, che includono la DApp SubDAO, il Twitter Middleware SubDAO e PolkaSign.<br>La DApp SubDAO è il principale strumento a livello di applicazione del protocollo e basato sull’infrastruttura DAO, che itera gradualmente varie funzioni DAO; è il modo principale per realizzare la visione del protocollo SubDAO. Ora supporta sia la creazione di un portafoglio multi-sig che di una venture DAO.<br>PolkaSign è uno strumento di protocollo SubDAO che aiuta a facilitare i contratti per le organizzazioni tramite accordi elettronici. L’obiettivo è fornire un accordo elettronico in linea con le pratiche web3.o per sostituire il sistema web2.0 esistente. Nella seconda fase della nostra Roadmap, è stata rilasciata una versione Ink di PolkaSign.<br>Twitter Middleware è anche un servizio basato sul protocollo SubDAO che funge da ponte per gli utenti del Web 2.0, consentendo loro di familiarizzare rapidamente con i concetti del Web 3.0.<br><img src="https://gimg2.gateimg.com/image/article/1672992229截屏2023-01-06 14.09.22.png" alt=""><img src="https://gimg2.gateimg.com/image/article/1672992259截屏2023-01-06 14.09.37.png" alt=""></p>
<h3 id="h3-Q22020stato20menzionato20un20prodotto20middleware20di20SubDAO20nellintroduzione20Sembra20interessante20Puoi20spiegarlo20meglio195321"><a name="Q2: È stato menzionato un prodotto middleware di SubDAO nell’introduzione. Sembra interessante. Puoi spiegarlo meglio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: È stato menzionato un prodotto middleware di SubDAO nell’introduzione. Sembra interessante. Puoi spiegarlo meglio?</h3><p><strong>Tony</strong>: Il middle ware è uno dei prodotti su cui SubDAO si è recentemente concentrata sulla raffinazione. In precedenza, era stata rilasciata una versione per il linguaggio Substrate Ink e le funzioni non erano perfette. SubDAO rilascerà una nuova versione del Twitter Middleware, che itererà le ultime funzionalità della dApp basate sul linguaggio solidity. La nuova versione sarà principalmente responsabile del lancio e della gestione delle organizzazioni di dApp su Twitter, consentendo agli utenti di eseguire le funzioni principali delle dApp attraverso il Twitter Middleware di SubDAO.<br>Da quando è iniziato lo sviluppo del Web 3.0, la partecipazione di molti individui del Web 2.0 è stata limitata perché hanno difficoltà a comprendere l’alta soglia di tecnicismi coinvolti. Il modo migliore per integrare gli utenti del Web 2.0 nel Web 3.0 è quello di integrarli tramite interfacce dApp simili alle app Web 2.0 esistenti a cui sono già abituati.<br>È difficile ottenere una differenza completamente invisibile tra le app Web 2.0 e le Web dApp; Tuttavia, le differenze possono essere ridotte al minimo. Pertanto, il Twitter Middleware di SubDAO si concentra sulla possibilità per gli utenti di utilizzare gli strumenti <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> DAO sui social network Web2 senza osservare differenze tecniche.<br>Con la nuova versione di Twitter Middleware, SubDAO abiliterà le seguenti funzionalità:</p>
<ol>
<li>L’iniziatore DAO crea una DAO su Twitter e imposta un co-gestore DAO.</li><li>L’iniziatore DAO imposta i diritti dell’amministratore su Twitter.</li><li>L’iniziatore DAO emette token DAO (ERC-20 e ERC-1155) per raccogliere fondi e</li><li>Definire le regole di rilascio dei token DAO.</li><li>I membri partecipano direttamente alla raccolta fondi DAO su Twitter e ricevono in cambio token DAO.<br>6.I membri votano direttamente le proposte tramite Twitter.<br>7.Gli amministratori delle DAO svolgono funzioni relative alla gestione delle DAO su Twitter.</li><li>I membri utilizzano i token DAO per il riscatto degli asset tramite Twitter.<br>Il middleware Twitter di SubDAO è progettato per consentire agli utenti di unirsi direttamente alle DAO e partecipare comodamente alle attività di governance, tra cui proposte, votazioni e altri comportamenti interattivi con molte persone sul portale Web2 (Twitter).</li></ol>
<h3 id="h3-Q320Quali20sono20le20principali20differenze20tra20SubDAO20e20altri20strumenti20DAO20e20quali20sono20i20loro20vantaggi446020"><a name="Q3: Quali sono le principali differenze tra SubDAO e altri strumenti DAO e quali sono i loro vantaggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quali sono le principali differenze tra SubDAO e altri strumenti DAO e quali sono i loro vantaggi?</h3><p><strong>Tony</strong>: Due differenze principali, una è la completezza del prodotto e l’altra è l’innovazione. La maggior parte degli strumenti nello spazio DAO attualmente non offre un prodotto completo, ma solo una parte del prodotto che è coinvolta nell’intero processo DAO. Ad esempio, <a href="/price/gnosis-gno" target="_blank" class="blog_inner_link">Gnosis</a> fornisce solo la creazione di portafogli multi-firma.<br>Se desideri gestire gli asset dei portafogli multi-firma in più modi DAO, come la raccolta di fondi DAO, l’emissione di token DAO, il periodo di riscatto dei fondi DAO, ecc., devi trovare altri strumenti. Il ciclo di vita di una DAO coinvolge in realtà molti collegamenti di esecuzione automatizzati. Se gli utenti hanno bisogno di saltare costantemente fuori per utilizzare altri strumenti al fine di realizzare un determinato collegamento, questo è in primo luogo molto ostile e, in secondo luogo, potrebbero esserci alcuni rischi per la sicurezza.<br>SubDAO ha più considerazioni in termini di integrità. Dalla creazione di portafogli multi-firma all’emissione di token DAO, alla raccolta fondi DAO, ai meccanismi di riscatto, ecc., l’intero ciclo di vita DAO può essere completato su SubDAO.<br>Per quanto riguarda l’innovazione, si riferisce all’innovazione e all’iterazione delle funzioni del prodotto. Come soddisfare le complesse esigenze delle organizzazioni DAO è uno dei principali dilemmi di uno strumento DAO. Quasi tutte le grandi organizzazioni DAO sviluppano i propri strumenti DAO in modo indipendente. Ogni organizzazione DAO di solito ha le proprie esigenze uniche, come un meccanismo di riscatto o un sistema di reputazione unico. Aragon è un prodotto DAO di grande successo. Esistono molti modelli per le organizzazioni DAO. È stato favorito da molte organizzazioni DAO nella fase iniziale. Ma nella fase successiva dello sviluppo, scoprirai che ciò che un’organizzazione DAO può fare su Aragon è relativamente limitato, soprattutto ora che stanno emergendo sempre più organizzazioni DAO emergenti.<br>Quando si tratta di soddisfare le esigenze degli utenti e di rompere costantemente l’attuale framework degli strumenti DAO, è particolarmente importante fare più innovazione, iterazione più veloce, nella competizione. Ad esempio, SubDAO non solo supporta il token ERC20, ma supporta anche l’emissione di NFT come token DAO direttamente durante il processo di creazione e, al fine di soddisfare diversi tipi di esigenze, consentiamo agli utenti di definire se il token viene fatto circolare e come viene rilasciato, se è un metodo di rilascio lineare o graduale.</p>
<h3 id="h3-Q420Il20modello20economico20dei20token2020una20parte20importante20di20un20progetto20web320c20qualcosa20di20speciale20nel20modello20economico20di20SubDAO20Ho20visto20che20c20una20Governance20DAO20Gamified20nel20modello20economico20di20SubDAO20puoi20approfondire20questo20argomento140337"><a name="Q4: Il modello economico dei token è una parte importante di un progetto web3, c’è qualcosa di speciale nel modello economico di SubDAO? Ho visto che c’è una Governance DAO Gamified nel modello economico di SubDAO, puoi approfondire questo argomento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Il modello economico dei token è una parte importante di un progetto web3, c’è qualcosa di speciale nel modello economico di SubDAO? Ho visto che c’è una Governance DAO Gamified nel modello economico di SubDAO, puoi approfondire questo argomento?</h3><p><strong>Tony</strong> Riguardo alla Governance DAO Gamified, SubDAO presto rilascerà una versione preliminare del design della presentazione. Qui posso darvi un’anteprima. Per costruire un’esperienza Web 3.0 completa per gli utenti di SubDAO, il nostro team ha in programma di costruire un Metaverse. Il Metaverse di SubDAO creerà un nuovo modo di governance DAO, specialmente nelle DAO legate alla comunità. Il Metaverse di SubDAO è un sistema di governance DAO della comunità che fornisce servizi di governance gamificati per le DAO create sul protocollo SubDAO. Oltre all’emozione e al divertimento tipici dei giochi, le prestazioni nell’ecosistema gamificato verranno utilizzate per calcolare il contributo della comunità alla DAO e fornire ricompense e governance di conseguenza. In breve, è un mondo metaversale costruito sul Protocollo SubDAO per fungere da strumento di governance DAO della comunità di SubDAO. Le DAO sono create da membri che hanno le stesse idee, obiettivi o interessi comuni; sono disposti a dedicare tempo, sforzi e denaro a questo scopo e naturalmente un luogo per opinioni e decisioni di voto. All’interno del Metaverse di SubDAO, gli utenti possono guadagnare “Identity NFT” e altri oggetti formando team di gioco, completando compiti e scommettendo token in vari modi. Questo Identity NFT aiuta a confermare l’identità dei membri partecipanti di una comunità di SubDAO, così come i token per partecipare alla governance DAO: maggiore è il livello di NFT, maggiore è il potere di voto che ha.</p>
<h3 id="h3-Q520Con20quale20ecosistema20lavora20attualmente20SubDAO822677"><a name="Q5: Con quale ecosistema lavora attualmente SubDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Con quale ecosistema lavora attualmente SubDAO?</h3><p><strong>Tony</strong>: SubDAO è attualmente implementato su reti come Ethereum, BNBChain, <a href="/price/moonbeam-glmr" target="_blank" class="blog_inner_link">Moonbeam</a> e Polygon. Tra questi, abbiamo più partenariati ecosistemici con BNBChain e Moonbeam.<br>Inizialmente, SubDAO è stata raccomandata dal team di <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain e ha quindi partecipato al progetto BNBChain MVB V; tuttavia, al momento, il prodotto SubDAO non era ancora stato lanciato. Pertanto, parteciperemo al prossimo progetto BNBChain MVB VI e lanceremo le relative attività di BNBChain.<br>SubDAO ha stabilito una profonda partnership ecosistemica con Moonbeam e lancerà molte cose divertenti nell’ecosistema di Moonbeam.<br>Inoltre, SubDAO e decine di progetti <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> tra cui Phala, Manta, ecc. hanno stabilito l’Alleanza Polkadot DAO per discutere e costruire insieme l’infrastruttura DAO nell’ecosistema Polkadot. Secondo la roadmap, una nuova versione di SubDAO ink verrà anche rilanciata in Substrate il prima possibile.</p>