# DAOhaus Developer Track

### Target Audience:
Developers who understand basic blockchain fundamentals (ex. what a smart contract is, how it works), what a DAO is (high level understanding). Will also need some technical skills like JS/TS, React, Ethers.js (or the Celo ethers wrapper).

### Output

This 10-15 session course will take in a cohort of developers who have a decent understanding of Web3, DAOs, JS/TS and Solidity. We start by explaining DAOs, Moloch governance, and governance models to ensure that developers are building towards solutions that are values-aligned.

Then we'll dive deep into the technical, starting with a solid understanding of the contracts, the indexing layer, and the suite of front end tools that DAOhaus provides. Developers will learn how to use these tools to build practical applications that can live beyond the course itself. Finally, developers will also learn how to build their own tools and protocols that extend beyond just the DAOhaus core, allowing for technical solutions that solve the unique needs of the Celo ecosystem.

Where the community cohort is great for creating DAOs and solving problems for people who are currently on Celo, the developer cohort is about using DAO tech to create simple, UX forward applications that are capable of brining in users from other ecosystems.

### Target Outcomes:

- Apprentices learn about DAOs
- Apprentices learn about Moloch DAOs
- Apprentices learn how to interact with contracts and subgraph on Celo
- Apprentices learn the DH stack, tooling, how to build their own apps
- Apprentices learn how it all comes together, and they can prove their knowledge by building a live DAO that interacts with another protocol on Celo
- Apprentices become journeymen and feel comfortable offering their skills to prospective DAOs within the Celo ecosystem
- (Optional) Journeymen dive deep into protocol development with shamans and can extend DAO functionality into the cutting edge. Offering DAO functionality that only exists with the Celo ecosystem.

### Design Considerations:
- This course is difficult, but attainable to anyone who meets the minimum requirement and can apply themselves.
- This course is engaging.
- This course tests the competence of the students and ensures that they can deliver
- This course removes the fear and intimidation associated with DAO and Web3 development by offering a safe space to blow things up.
- Students of this course try their hand at building real world applications that will see use within Celo ecosystem.
- This course is designed to create a hot-bed of DAO development and a core knowledge base that is rooted within the Celo ecoystem.

## #1 Intro to Moloch
(5 days)

- Basics of Moloch
- extensible / modular framework
- add/remove modules as needed
- built-in minority protection through ragequit
- sybil-resistant (permissioned)
- shares/loot for instrumenting ownership
- allows for customized setup & upgradeable treasury through governance
- rugpulls with snapshot/multisig
- governance attact with Comp gov
- Hellscape with no structure
- Downsides of Moloch DAOs. How we can mitigate those downsides.
- When to use a MolochDAO
- What is a MolochDAO
- How does it work? How do proposals, vaults, shares, loot, treasury parameters each work in tandem? Explain the jargon (proposalThreshold, quorum)
- How to use a MolochV3
- summoning
- make a proposal/vote
- add members
- using treasury
- ragequit
- multicall
- edit DAO parameters
- Esoterica
- Going deep on non-transferable vs. transderable tokens
- What it's like to be in a Moloch DAO (guest speaker)

Practical test examples
- Summon a DAO with wallet address 1
- Add wallet address 2 into DAO
- Add fake token into treasury
- Ragequit token
- Create multicall proposal to interact with an external protocol

## Unit #2 DAOhaus Application Infrastructure
(5 days. Could offer extra time for practical project)
- Contracts overview (factories)
- Subgraph (how it works, what is it for, what does it index?)
- Application Tooling
- UI
- Connect (with and without UI)
- MolochContext (getting data from the subgraph dropping data into the app)
- TXBuilder (writing transactions as static data, multicall in-depth, why use TXbuilder)
- FormBuilder (Getting data from a user, building custom components, external API calls)
- First look at Shaman contracts (explain how they work)

**Practical Project:**

Split into groups. Build a DAO interface that interacts with an external protocol on Celo.

## Unit #3 Advanced DAO Development: Shaman Contracts, Alternate governance
(5 days)

This unit is optional and could be taught later if we're seeing developer traction beyond the last unit.

- How shamans work
- Why shamans?
- How to bring one into your DAO?
- How to write a shaman contract
- How to deploy a shaman contract and factory
- Subgraphs
- Deploy a hosted subgraph instance
- Write custom subgraph mappings to index events from your shaman
- A look at the DH Monorepo
- How to make PRs and add functionality to the base application infrastructure (if ever needed)

**Practical Project**

Break into groups. Write a shaman contract. Index those events with the subgraph. Bring in custom UI into the app completed in Unit 2.

#### Opportunities
- Could take on sponsors to provide bounties for this phase. Perhaps a popular protocol is looking to build an app that wants integrate DAOs, they could offer an award for an MVP.
- Could get a bounty from an existing DAO to build a custom DAO interface
- Could offer bounties for Celo infrastructure. As an example, we know that we can easily upgrade existing multisigs to MolochDAOs. What if we made an app to do that on Celo?

#### Extra Offerings
- Priority tech support for Celo devs for a given amount of time (private channel + discord server for graduated Celo DAO devs, guarnanteed response time.)
- Summon a verification and credentials DAO. Award an SBT (Non-transferable NFT) to those who complete the course. We, of course, could build this while teaching.