AstroDAO

All right, we're live. GM, GA, GE, everybody. Welcome to what's going to be another great DevNTell. If you didn't know, DevNTell is a 30-minute window for builders to showcase something they're passionate about or been working on in Web3. This could be an awesome project they've been working on, demonstrating unit testing best practices, automation goodies, smart contracts, how to structure a project, etc. Basically, if you've got a passion for something, this is your opportunity to share it with the Web3 community. And today, I am happy to have on the show Patrick, who is going to be giving us an overview of AstroDAO. Patrick, maybe you want to start off with a brief introduction about yourself?

Yeah, yeah. So I'm just a fellow builder, or 'Buidler' as folks like to say in the community. I've been mainly building on the NEAR protocol for the past year, working on things like wallets and onboarding, and DAO tooling and DAO frameworks. One of those DAO frameworks is AstroDAO. And yeah, I'm just super excited to be here.

It's a pleasure to have you. Yeah, so the floor is yours whenever you want to start.

All right, cool. Cool. So AstroDAO is really just a framework to allow people to easily create DAOs. You can check it out here. One sec. Looks like—okay, I'll be right back. Sorry. (Technical difficulties). There we go. All right. So what was I saying? Yeah, it's mainly a DAO framework to allow you to easily create DAOs. So if you're familiar with TallyDAO or I believe MolochDAO, there's a lot of DAO frameworks on ETH. And then this helps anyone create a DAO, become a DAO operator, add members, etc., within a couple of minutes, and then apply the appropriate governance framework that you'd like to do. So if it's like, you know, single-weighted voting, token-weighted voting, stake-weighted voting, one person, one vote—it's whatever you're trying to implement. So let me give a quick overview of how it looks.

So this is the testnet version of it on testnet.app.astrodao.com. You can see here. And then in order for you to use the application, there's a mainnet version—it's just app.astrodao.com. But I just wanted to kind of demo the testnet so you guys could take a look at it, play around with it. And if it works, then yeah, use it. If it doesn't, then just, you know, give feedback or use the tool that best suits your needs. Oh, okay, a little bit of a heads-up too: I was also an advisor at Utopia Labs. So, you know, working on different tooling to help DAOs is kind of what I'm passionate about. But if you click Connect Wallet, and you click MyNearWallet, which is one of the wallets I have here, devdao.near.testnet. I click Next. This is a web-based wallet, but there's a lot of other wallets in the ecosystem. You can learn about the different wallets in the ecosystem by checking out awesomenear.com as well as a bunch of other dApps in the ecosystem. Click Connect. This is going to give an access key to allow the dApp to basically connect to your account. And then from there, it'll allow you to like sign transactions and so forth.

And the other thing about NEAR is that NEAR has account abstraction. So one of the cool things is you could set up like full access keys, limited access keys. If you ever feel like your account's compromised, you could rotate your keys as well. That's pretty cool. And then it has named accounts by default as well, so instead of some random hash, you could actually have a named account—or you could have a hash if you want to. So here we're going to go—you could explore a bunch of different testnet DAOs, right? These are the proposals in the global feed. And then these are my DAOs. If you look at Bounties areas, these are like bounties that DAO community members created. So you could scroll through them if you're a bounty hunter and find out which bounties you'd like to tackle.

If you click on Actions Library, Actions Library is like a set of actions that the community members have used. One of the things you could do in a DAO is basically invoke a function call. So from the DAO, you know, you'll create a proposal and then people could vote to invoke a particular function of a smart contract. And based on the outcome of the vote, it'll invoke that function or not invoke that function. But, you know, writing that stuff from scratch can be like super painful. So one of the things we created was this utility so that people could create templates and then share those templates or create private templates, and then you could use this in your DAO or not. But let's go ahead and just for fun create a DAO. We'll call this like devdao, and testnet version of devdao.

Next step. KYC—so, you know, explain your DAO's legal status and jurisdiction or attach a link to the legal status of the DAO. One of the things we were looking at working on integrating was integrating with Legal Nodes, so that Legal Nodes—if you go to legalnodes.com—helps DAOs structure their legal entity if they're looking to do stuff like that. So by integrating with that, that's going to be another thing. And the other part was also showing DAO members an integration with Opolis. So Opolis is a company—or a DAO tool—to basically allow individual contributors to get, at least in the US and I think they're working internationally, to basically get a lot of like payroll benefits like healthcare and a bunch of a lot of really great benefits. And they take care of tax deductions. So if you're a contributor that contributes to multiple DAOs, it's really a useful tool to leverage so that you can get all these other employee-based benefits, but then as a DAO member, you don't really have those things. So it's a really cool tool. So that's the reason we're going to add that flow here.

Links and socials—so if you have like a Twitter account. So let's just look up devdao... add this Twitter handle. You could add groups. So I'm going to create different groups. I'll create a developer group. Actually, let me go back. Why? I should be able to create a group. Looks like there's a bug. Sorry. So I'm going to just add this to this particular group. Normally you should be able to create multiple groups. And I'll get into that because different groups have different—you could configure different proposal permissions. For example, here I could say, hey, anyone could create a bounty, anyone—but only council members could mark it done. I don't want to allow anyone to invoke a transfer, that seems kind of odd. Anyone can make a proposal for a poll, anyone can make a proposal to add a member or remove a member, whatever, right? And then voting permissions: anyone could basically vote on a poll, or they could also vote to see if the add or remove is done. I think that's okay. Click Next. You could add like little logos for your DAO to represent your DAO or whatnot. So you click Create New DAO. Cost 6 NEAR to create the DAO. This is really just the storage cost of the DAO creation. AstroDAO doesn't take any fees associated with the DAO creation. AstroDAO's really non-custodial by all nature and it's from NEAR's perspective right now, it's really just a public good.

And that's it. I've got my DAO. I've got my members. I could create a proposal. And I could propose a myriad of different activities to do. These are some of the templates that we have as defaults. Roketo streams is interesting because like if you're paying DAO contributors regularly, like every two weeks, it's a way to kind of stream payments—kind of similar to what Utopia does. But that's AstroDAO. Under the hood, the contract that it interacts with is called SputnikDAO. It's kind of odd, but you could kind of see right here that the address you'll see is called Sputnik. And if you go to this address, sputnikv2.testnet, on Explorer—so we could actually go to Explorer here—you'll see the actual contract that got deployed there. Right here. Once Explorer works with the appropriate indexers... looks like Explorer is having some issues right now, we'll come back to that.

But you'll see here the way all of this works is that there's this JavaScript client called near-api-js. Oh, there we go. So Explorer, you'll see the contract here that got deployed is this particular code hash. I think for another time I could show you how to pull down the appropriate WASM, inspect that WASM, do whatever you want. The actual contract is deployed to—is actually sourced from here, under neardao/sputnik-dao-contract. It's really just a multi-sig with like governance added to it. Yeah, and you could validate that this last commit is the actual contract by actually building it, comparing the code hash, and then you could actually see.

But that's all cool. One of the things I really wanted to kind of showcase here is this notion of a function call. Now typically, if you wanted to upgrade a particular contract for a dApp, there's one of two things. The common thing, which is kind of scary, is that DAO members would vote on an outcome and then once the voting outcome's in favor of this contract upgrade, they'll ping a DAO contributor—maybe a developer—and that developer will deploy that upgrade. That doesn't seem too safe to me because that tells me that that developer has the full access key of the DAO, of the contract, which is kind of scary. So here you could actually make a proposal, vote on an upgrade call, and then if the vote outcome passes, then you could actually self-upgrade. And you could even do this to the DAO. You could even create a proposal to upgrade the DAO itself. If you do version update, if this was on an older version and there's like a new version, you could click Propose Update, it would vote on this new update that will deploy—that basically has a new contract already stored on-chain, and it'll basically point this DAO to the new code hash. And I think that's a lot safer, and what this tells me that at least no one has the full access key.

So a good example of it, you can see here, maybe not on testnet, but you can check on mainnet. One sec. Let's take a look at our DeFi platform called Ref Finance. We'll look up their particular contract. And you'll notice the word here 'locked'. And what locked means is that basically this contract is more than likely DAO operated. Because this tells me that there's no full access key for anyone to deploy an upgrade, and the only way upgrades are handled is through a DAO outcome. Now, that DAO could also technically be a member—a DAO of one. So you'll have to do some due diligence to look up their DAOs, look at the operations that they're doing to figure out how it all works. And that's basically it. I mean, there's a lot more to Astro and Sputnik, but I just wanted to kind of showcase what I've been working on in the past year. And yeah, super excited to see folks leverage it.

The other really cool thing I wanted to also highlight was this—again, because it's just a DAO contract that's deployed, it's just really just a user interface—you have this other application called Near Social which is really cool. It's like a decentralized storage platform and a decentralized social network. And I created this little widget here on it called Astro Bounties. And what it does is it calls the same smart contract under the hood. You could look at the view source code here and it references other widgets. So one of the things I like about Near Social is that it allows you to call other smart contracts, it allows you to call APIs, and then it allows you to compose these things. So like this person named edwardu.near, they created this widget, I just inherited that widget and I composed my widget, which is Astro Bounties, based upon a bunch of different widgets, right? So I could borrow heavily from the community. And what this allowed me to do is actually, here is my bounties list just like on AstroDAO, but here I get to actually leverage the social network where people could comment on a bounty, they could, you know, vote to—you could vote to say I want to participate in the bounty, and then DAO operators could come and select you for that. There's a lot of work obviously that has to be done on this tool, and in this particular widget. But there's all these different widgets inside the community that the community's building, and you could just borrow, fork it, and do whatever, right?

So there's this really cool one called DevGov Gigs. So they kind of show like the different things that they're working on in like a Trello-like board. And then if you're like, hey, this is cool, I want to borrow this, you could just go and fork the widget. And when you fork the widget, then you could see their source code, you could fork it to your widget editor inside of here and play around with it. You can click on Widget Preview, I think they have like a side-by-side... there you go. That's it. I mean, that's—again, you could go like deep down rabbit holes for each of these different things, but I just wanted to kind of highlight some of the things that I've been working on.

Yeah, man, this is fantastic. I guess one obvious question for me is why NEAR protocol? Why did you pick NEAR over other protocols?

Oh, yeah. So one of the things I really liked about NEAR is just developer experience. Thanks for asking that, I totally forgot why NEAR. So it has a great developer experience—they have a bunch of really cool tools. If you go to github.com/near, they have a bunch of really cool tools that help you with development, like create-near-app. I mean, it's like create-react-app, so it allows you to really easily, quickly get up to speed in building a NEAR app. They have a bunch of really great examples of contracts, so it helps you get started. It's WASM-based, so you write your contracts in Rust or JavaScript. If you use the JavaScript SDK, which is near-sdk-js, it allows you to write a smart contract using JavaScript and then deploy that contract as a WASM on-chain and get up and running really quickly. You could also write in Rust as well, I think there's other people in the community building different language support. Now this is just the SDK side for building contracts, but there's also a tool called near-api-js like I mentioned that allows the dApp to connect to an RPC node and make calls to your contract, like view calls or whatnot, so that you could like render it.

If you want to set up an indexer... if you're making a call from your dApp to the protocol, the protocol only stores about five epochs' worth of data. It stores more than that, but like through the regular public RPC nodes that NEAR protocol supports through the NEAR Foundation, which is a nonprofit foundation, and this other for-profit entity called Pagoda, they provide these public RPC nodes free for folks to use, and you could actually make a call up to like five epochs. But if you want to get more information, you could do another thing: there's two things, you could spin up your own archival RPC node to get more historical data, or the better thing is you set up an indexer. They have instructions on how to set up an indexer, they also have this thing called Near Lake, which basically sends all that information to a S3 bucket. And what I did on AstroDAO is I basically listened to the events that are happening on that S3 bucket, and then I piped that data to my own DynamoDB, and then I then used a DynamoDB stream to pipe that data to ElasticSearch. So my entire UI is really just a search query, and yeah, that's kind of how it works. The other reason I like it is Proof of Stake, it has 1-second finality, so it's super fast, like I make a call you'll see transaction happens really quickly. I can make cross-contract calls, it has account abstraction already. Because of the efficiency of its sharded execution layer, it's highly energy efficient. So what they do is they work with the South Pole climate, the NEAR Foundation, and then they buy credits and they're actually economically certified climate neutral. So that's kind of cool. And then the last thing about it is that NEAR, whenever you write a contract, it gives for the gas fees—it has really low gas fees, but one of the cool things about this is that if your app, your smart contract, has a lot of activity, 20% of that goes back to the developer of those gas fees. So that's kind of baked in toward allowing people to build and funding public goods. So I thought that was pretty cool.

But yeah, I mean, there's a lot of things I like about NEAR. And then there's the whole EVM compatibility layer called Aurora. So if you have a Solidity application, you could leverage NEAR's like speeds, speed and performance implications by taking your Solidity app and porting it over to Aurora. So you could kind of treat it like a layer two, right?

Yeah, yeah, I mean those are all great points, and I myself have had NEAR protocol on my list of things to study on. But yeah, that was a great overview as well. Thank you. I guess a follow-up question kind of on a related note is the gas fees that you showed when you're deploying the contract. Is it a static 6 NEAR token all the time?

No, no, that's just storage. That's to pay the storage cost of your contract. And the only reason—it's not static, it's dynamic. In the case for SputnikDAO, which is the contract you're deploying... SputnikDAO contract is a factory contract that allows you to create other child contracts, right? So a NEAR's account model, let's say I had narb.near, I could create foo.narb.near, bar.narb.near, baz.narb.near as a sub-account. And then so if I deploy the main factory contract to narb.near, I could basically deploy, you know, child accounts as well. But that storage cost of deploying that contract is 6 NEAR. But that's just because SputnikDAO is pretty heavy. You know, there's ways to optimize it, I'm exploring those opportunities. So like I said, what I'm going to do is take a hybrid approach of Rust and JavaScript. So there's this guy named Peter Salomonsen, who's heavily involved in the NEAR community... he built this thing called QuickJS-Rust-NEAR. So this allows you to build a Rust contract that basically calls JavaScript functions. That's really cool. So one thing I'm looking to do is building a more modular DAO framework so that like when a DAO operator wants to leverage this particular module or this other particular module—I want token-weighted voting, or stake-weighted voting, or Sybil-resistant voting—it could vary in size, but I want to leave that flexibility up to the DAO operators to decide what they think is best, as well as prevent—you know, the other hard part is not really the code, the hard part is writing documentation. So writing supporting documentation of like why you might want to go down this avenue or why you might want to go down this other avenue. But as far as like the storage taking cost, that could vary, it's really depending on the contract size.

Gotcha, gotcha. And I think you've won kempsterrrr over, he's asking: Shall we move D_D over to AstroDAO, Patrick?

You know, there's—again, I'm no longer actually part of Astro officially, in an official capacity, I'm just working as an open-source contributor. So I think that's one option we could look at. There's other DAO frameworks. I really want to make sure that DAO operators choose what's best for their community, right? I would say the only thing is like if you're... one of the things that was initially painful, but we solved recently—oh, well not my team, but there's this other team called Proximity that solved—is that... because I had this user research DAO led by Georgia Rakusen and they basically explored all the different DAO operators, MolochDAO people, just a whole bunch. And then one of the things that they came out to was to why they wouldn't use NEAR protocol had to do with switching costs. So typically, people in the Web3 community are familiar with MetaMask, but onboarding onto NEAR required that you create a NEAR wallet, etc. And that was a higher switching cost and cause for friction because at the time we didn't have MetaMask support. But now we have MetaMask support, so you could actually use NEAR, MetaMask on NEAR protocol. So what that allows you to do is just sign transactions using MetaMask and use AstroDAO. But yeah, I'll leave it up to the team and the community. I wouldn't use AstroDAO, I would probably end up using Near Social. Because like I said, Near Social's cool because if you're familiar with WeChat, WeChat has like a bunch of little applets that you can use. That's kind of what Near Social is, right? Like Near Social has a bunch of these little widgets that does a bunch of different things. Like here I want to create a social avatar... randomized it... and I'm going to mint this NFT. And that cost me 5.3 NEAR, I'm guessing because it's storing this... (demonstrating). But what's really cool is like you've got all these little widgets, right? So you could explore all the widgets here, you could even look up all widgets... and you'll see here all the different widgets people created. Illia here, root.near, he's the co-founder of NEAR protocol and he's an active developer contributor, he does all this stuff. You can look up his widgets. The creator of Near Social is here who's constantly creating these widgets. And if you look at things here, you'll see all the widgets, like home page is a widget in itself. So you could actually fork this widget, you could even create a custom home page if you want for yourself. But yeah, and under the hood it deals with a contract—smart contract—called SocialDB. And you could look up the documentation if you go to docs.near.org and read up on documentation on how to use NEAR. But yeah, for DevDAO, I'd probably leverage Near Social and then just call SputnikDAO contracts under the hood so that you get the social element, you get the DAO tooling element. And then later on with Near Social it's going to support other things like Octopus Network for creating parachain/appchain kind of stuff, or Calimero Network which allows you to have a private shard. So if there's some transactions you want to do privately... you could do that on the private shard which is Calimero. And then you could bridge that functionality from your private shard to on-chain, so there's this off-ramp/on-ramp functionality that comes with Calimero Network. But again, all—how does this all—like all these different federated applications, one of the biggest problems is that everything's all over the place, right? Should I use Utopia? Should I use TallyDAO? Should I use, you know, all these different tools? They're all great at one thing, but then now how do you bring that all together for your community members? And Near Social helps to do that, right? And the composability aspect of being able to create widgets on yourself and create your own custom view of your experience allows that as well. So I'd propose that if any kind of tooling is brought from DevDAO to explore opportunities using Near Social.

Excellent. Great to know. And this unfortunately brings us to time. No, no worries, no worries, we're having a good time. So thank you so much, Patrick, for coming on. I guess what's the best way for folks to keep up with you and/or AstroDAO?

Oh, you know, on—you can just find me on Near Social as urbanite.near. You'll see here... I should really write some real words, I put like 'Lorizzle' like ipsum but it's like as if it was spoken by Snoop Dogg. And then you'll find my other social—centralized social handles like my GitHub is AgileUrbanite and my Twitter handle is PatrickWoo, which is me. But yeah, you can find me there. And yeah, I'm all over the place. So I'm mainly working on NEAR, I'm starting to get back into ETH and Filecoin, super excited by Filecoin Virtual Machine with FVM. And yeah, just constantly building, looking to build things to help creators create and innovators innovate. Like that's my goal, it's just build tools to enable people to do their jobs.

Love it. Love it. Yeah, and love what you're doing, man. Keep it going. And just want to leave the gang off here with a note about our fundraising operators. So did you know that D_D's fundraising operators Chuck and Wickist are here to help you fundraise your projects? In the fundraising hub on the Discord server, you can find support in writing grant applications, learning about fundraising, budgeting, pitching, and they can even introduce you to grant leads from different protocols. So be sure to drop by their office hours twice a week or schedule a one-on-one with them because they're here to help you get that money, so to speak. But with that, I just want to wish everybody a very happy Friday, happy weekend, and I've dropped the POAP link in—oh, it didn't come out very nicely in the comment section here, but I will drop it properly again. And I will also drop the same link in the Developer DAO server. But with that, we'll see you back here next week. See you, gang.

Thank you. Bye.