R2F0ZS5pbyBBTUEgbWV0IFN1YkRhbyAtIEhldCBtdWx0aWZ1bmN0aW9uZWxlIERBTy1wbGF0Zm9ybSB2b29yIGR1cmZrYXBpdGFhbCBlbiBoZXQgYmVoZWVyIHZhbiBkaWdpdGFsZSBhY3RpdmE=

<p><img src="https://gimg2.gateimg.com/image/article/1672991940FiztmgcXkAElU6l.jpeg" alt=""><br><strong>Tijd: 1 december 2022, 13:00 (UTC)</strong><br><strong>Gate.io organiseerde een AMA-sessie (Ask-Me-Anything) met de Core Contributor van SubDao, Tony bij Gate.io Exchange Community</strong><br><strong>Officiële website: <a href="https://subdao.network/" rel="nofollow noopener noreferrer" target="_blank">https://subdao.network/</a></strong><br><strong>Volg SubDao op Twitter</strong></p>
<p><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/1672991980截屏2023-01-06 14.09.06.png" alt=""><br>Tony-de kernbijdrager van SubDao</p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio42757"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-20V120Gelieve20SubDao20en20de20producten20en20functies20van20SubDAO20te20introduceren231380"><a name="## V1: Gelieve SubDao en de producten en functies van SubDAO te introduceren." class="reference-link"></a><span class="header-link octicon octicon-link"></span>## V1: Gelieve SubDao en de producten en functies van SubDAO te introduceren.</h3><p><strong>Tony</strong>: SubDAO is een DAO-protocol dat helpt bij het beheren van digitale activa via middleware, multi-sig en andere gedecentraliseerde functies.<br>In het verleden (fase één) hebben we drie <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Foundation Grants ontvangen, die allemaal zijn ingediend ter voltooiing; deze drie grants komen overeen met de drie productlijnen van het SubDAO-protocol, waaronder de SubDAO DApp, SubDAO Twitter Middleware en PolkaSign.<br>De SubDAO DApp is de belangrijkste toepassingstool en DAO-infrastructuur van het protocol, die geleidelijk verschillende DAO-functies implementeert; het is de belangrijkste manier om de visie van het SubDAO-protocol te realiseren. Het ondersteunt nu het maken van zowel multi-sig wallet als venture DAO.<br>De PolkaSign is een hulpmiddel van het SubDAO-protocol dat helpt bij het faciliteren van contracten voor organisaties via elektronische overeenkomsten. Het doel is om elektronische overeenkomsten in overeenstemming met web3.o-praktijken te bieden ter vervanging van het bestaande web2.0-systeem. In de tweede fase van onze Roadmap is een Ink-versie van de PolkaSign uitgebracht.<br>Twitter Middleware is ook een dienst op basis van het SubDAO-protocol die fungeert als een brug naar Web 2.0-gebruikers, zodat ze snel vertrouwd kunnen raken met Web 3.0-concepten.<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-Q220In20de20introductie20werd20een20middleware20product20van20SubDAO20genoemd20Dat20klinkt20interessant20Kun20je20er20meer20over20uitleggen637043"><a name="Q2: In de introductie werd een middleware product van SubDAO genoemd. Dat klinkt interessant. Kun je er meer over uitleggen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: In de introductie werd een middleware product van SubDAO genoemd. Dat klinkt interessant. Kun je er meer over uitleggen?</h3><p><strong>Tony</strong>: Middle ware is een van de producten die SubDAO zich onlangs heeft gericht op raffinage. Eerder was er al een versie voor de Substrate Ink taal uitgebracht en de functies waren niet perfect. SubDAO zal een nieuwe versie van de Twitter Middleware uitbrengen, die de nieuwste functies van de dApp zal herhalen op basis van de soliditeitstaal. De nieuwe versie zal voornamelijk verantwoordelijk zijn voor het lanceren en beheren van dApp-organisaties op Twitter, waardoor gebruikers de kernfuncties van dApps kunnen uitvoeren via de SubDAO Twitter Middleware.<br>Sinds het begin van de ontwikkeling van Web 3.0 is de deelname van veel web 2.0-individuen beperkt omdat ze het moeilijk vinden om de hoge drempel van technische details te begrijpen. De beste manier om Web 2.0-gebruikers aan boord te krijgen van Web 3.0 is door ze te integreren via dApp-interfaces die vergelijkbaar zijn met de bestaande web 2.0-apps waaraan ze al gewend zijn.<br>Het is moeilijk om een volledig onopgemerkt verschil te bereiken tussen Web 2.0-apps en Web dApps; De verschillen kunnen echter tot een minimum worden beperkt. Daarom richt SubDAO’s Twitter Middleware zich op het in staat stellen van gebruikers om Web3 DAO-tools op Web2 sociale netwerken te gebruiken zonder technische verschillen waar te nemen.<br>Met de nieuwe versie van Twitter Middleware zal SubDAO de volgende functies mogelijk maken:</p>
<ol>
<li>DAO-initiatiefnemer maakt een DAO aan op Twitter en stelt een DAO-co-manager in.</li><li>DAO-initiatiefnemer stelt beheerdersrechten in op Twitter.</li><li>DAO-initiatiefnemer geeft DAO-tokens (ERC-20 en ERC-1155) uit om geld in te zamelen en</li><li>definieer de releaseregels van DAO-tokens.</li><li>Leden nemen rechtstreeks deel aan DAO-fondsenwerving op Twitter en krijgen in ruil daarvoor DAO-tokens.<br>6.Leden stemmen rechtstreeks via Twitter over voorstellen.<br>7.DAO-beheerder(s) voeren DAO-beheergerelateerde functies uit op Twitter.</li><li>Leden gebruiken DAO-tokens voor het inwisselen van activa via Twitter.<br>SubDAO Twitter Middleware is ontworpen voor gebruikers om rechtstreeks lid te worden van DAO’s en gemakkelijk deel te nemen aan bestuurstaken, waaronder voorstellen, stemmen en ander interactief gedrag met veel mensen op het Web2-portaal (Twitter).</li></ol>
<h3 id="h3-Q320Wat20zijn20de20belangrijkste20verschillen20tussen20SubDAO20en20andere20DAOtools20en20wat20zijn20hun20voordelen824953"><a name="Q3: Wat zijn de belangrijkste verschillen tussen SubDAO en andere DAO-tools, en wat zijn hun voordelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat zijn de belangrijkste verschillen tussen SubDAO en andere DAO-tools, en wat zijn hun voordelen?</h3><p><strong>Tony</strong>: Twee belangrijke verschillen, het ene is de volledigheid van het product en het andere is innovatie. De meeste tools in de DAO-ruimte bieden momenteel geen compleet product, maar slechts een deel van het product dat betrokken is bij het hele DAO-proces. <a href="/price/gnosis-gno" target="_blank" class="blog_inner_link">Gnosis</a> biedt bijvoorbeeld alleen de mogelijkheid om wallets met meerdere handtekeningen te maken.<br>Als u de activa van portefeuilles met meerdere handtekeningen op meer DAO-manieren wilt beheren, zoals DAO-fondsenwerving, DAO-tokenuitgifte, DAO-fondsaflossingsperiode, enz., moet u andere tools vinden. De levenscyclus van een DAO omvat namelijk veel geautomatiseerde uitvoeringskoppelingen. Als gebruikers constant moeten springen om andere tools te gebruiken om een bepaalde <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> te realiseren, is dit ten eerste erg onvriendelijk en ten tweede kunnen er bepaalde beveiligingsrisico’s zijn.<br>SubDAO heeft meer overwegingen op het gebied van integriteit. Van het creëren van wallets met meerdere handtekeningen tot de uitgifte van DAO-tokens, DAO-fondsenwerving, aflossingsmechanismen, enz., de volledige DAO-levenscyclus kan op SubDAO worden voltooid.<br>Wat betreft innovatie, verwijzend naar de innovatie en iteratie van productfuncties. Hoe te voldoen aan de complexe behoeften van DAO-organisaties is een van de belangrijkste dilemma’s van een DAO-tool. Bijna alle grote DAO-organisaties ontwikkelen zelfstandig hun eigen DAO-tools. Elke DAO-organisatie heeft meestal zijn eigen unieke behoeften, zoals een uniek aflossingsmechanisme of reputatiesysteem. Aragon is een zeer succesvol DAO product. Er zijn veel sjablonen voor DAO-organisaties. Het werd in een vroeg stadium begunstigd door veel DAO-organisaties. Maar in de latere fase van de ontwikkeling zul je merken dat wat een DAO-organisatie op Aragon kan doen relatief beperkt is, vooral nu er steeds meer opkomende DAO-organisaties in opkomst zijn.<br>Als het gaat om het voldoen aan de behoeften van de gebruiker, en het constant doorbreken van het huidige DAO-toolframework, is meer innovatie, snellere iteratie, in de concurrentie bijzonder belangrijk. SubDAO ondersteunt bijvoorbeeld niet alleen ERC20-token, maar ondersteunt ook de uitgifte van NFT als DAO-token direct tijdens het creatieproces, en om aan verschillende soorten behoeften te voldoen, stellen we gebruikers in staat om te bepalen of het token wordt verspreid en hoe het wordt vrijgegeven, of het nu een lineaire of gefaseerde releasemethode is.</p>
<h3 id="h3-V420Token20economisch20model20is20een20belangrijk20onderdeel20van20een20web3project20is20er20iets20speciaals20aan20het20economische20model20van20SubDAO20Ik20zag20dat20er20een20Gamified20DAO20Governance20is20in20het20SubDAO20economisch20model20kun20je20daar20wat20meer20over20vertellen42670"><a name="V4: Token economisch model is een belangrijk onderdeel van een web3-project, is er iets speciaals aan het economische model van SubDAO? Ik zag dat er een Gamified DAO Governance is in het SubDAO economisch model, kun je daar wat meer over vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Token economisch model is een belangrijk onderdeel van een web3-project, is er iets speciaals aan het economische model van SubDAO? Ik zag dat er een Gamified DAO Governance is in het SubDAO economisch model, kun je daar wat meer over vertellen?</h3><p><strong>Tony</strong>: Met betrekking tot Gamified DAO Governance zal SubDAO binnenkort een vroege ontwerpversie van de presentatie uitbrengen. Hier kan ik er een sneak peak van geven.<br>Om een gezonde Web 3.0-ervaring voor SubDAO-gebruikers op te bouwen, is ons team van plan een Metaverse te bouwen. De SubDAO Metaverse zal een nieuwe manier van DAO-bestuur creëren, vooral in gemeenschapsgerelateerde DAO’s.<br>De SubDAO Metaverse is een community DAO-governancesysteem dat gamified governance-services biedt voor DAO’s die zijn gemaakt op het SubDAO-protocol. Afgezien van de spanning en het plezier dat gepaard gaat met gamen, zullen de prestaties in het gamified ecosysteem worden gebruikt om de bijdrage van de gemeenschap aan de DAO te berekenen en dienovereenkomstig beloningen en bestuur te geven. Kortom, het is een metaverse wereld gebouwd op het SubDAO-protocol om te dienen als de SubDAO-community DAO-governancetool.<br>DAO’s worden gemaakt van leden die dezelfde ideeën, doelen of gemeenschappelijke interesses hebben; Zijn bereid om hier tijd, moeite en geld in te steken en natuurlijk een plek voor meningen en stembeslissingen.<br>Binnen de SubDAO Metaverse kunnen gebruikers “Identity NFT’s” en andere rekwisieten verdienen door samen te werken om gameteams te bouwen, taken te voltooien en tokens op verschillende manieren in te zetten. Deze Identity NFT helpt om de identiteit van deelnemende leden van een SubDAO-gemeenschap te bevestigen, evenals tokens om deel te nemen aan DAO-governance - hoe hoger het niveau van NFT, hoe hoger het stemrecht dat het heeft.</p>
<h3 id="h3-Q520Met20welk20ecosysteem20werkt20SubDAO20momenteel20samen884065"><a name="Q5: Met welk ecosysteem werkt SubDAO momenteel samen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Met welk ecosysteem werkt SubDAO momenteel samen?</h3><p><strong>Tony</strong>: SubDAO is momenteel ingezet op netwerken zoals Ethereum, BNBChain, <a href="/price/moonbeam-glmr" target="_blank" class="blog_inner_link">Moonbeam</a> en Polygon. Onder hen hebben we meer ecosysteempartnerschappen met BNBChain en Moonbeam.<br>Aanvankelijk werd SubDAO aanbevolen door het team van <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain en nam het vervolgens deel aan het BNBChain MVB V-project; echter, op dat moment was het SubDAO-product nog niet gelanceerd. Daarom zullen we deelnemen aan het komende BNBChain MVB VI-project en bijbehorende BNBChain-activiteiten lanceren.<br>SubDAO heeft een diepgaand ecosysteempartnerschap met Moonbeam opgebouwd en zal veel leuke dingen lanceren in het Moonbeam-ecosysteem.<br>Daarnaast hebben SubDAO en tientallen Polkadot-projecten, waaronder Phala, Manta, enz., de <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> DAO Alliance opgericht om samen DAO-infrastructuur te bespreken en op te bouwen in het Polkadot-ecosysteem. Volgens de routekaart zal ook een nieuwe versie van SubDAO-inkt zo snel mogelijk opnieuw worden ingezet in Substraat.</p>