Using Metagov to support DAO governance

Metagov is intended to support rapid prototyping of different governance systems. This use-case explores that value proposition through the idea of a governance hackathon. Namely: how do we think hackers will tend to use Metagov? It is inspired by the needs of the Open Web hackathon, a governance hackathon focused on DAOs and blockchains.

I assume that hackers will be familiar with a set of programming languages (e.g. Python, Rust, JS) as well as technical tools like APIs, webhooks, and code. Typically, a hackathon team will be composed of small groups of hackers, sometimes complemented by designers and other specialists.

User flow: use for planning

  1. Hacker skims the Metagov documentation and sees the list of supported tools along with descriptions of how they can be used.
  2. Hacker decides to use SourceCred, PolicyKit, and Discourse as components of their governance experiment.
  3. Hacker reads the Metagov documentation, which includes install directions for Metagov, documentation of modules APIs and ways of configuring different modules, as well as links to further, module-specific documentation.
  4. Hacker downloads and installs Metagov on their computer / server.
  5. Installing Metagov = installing PolicyKit, SourceCred, and everything else.
  6. Hacker, referring occasionally to the documentation, starts testing their local instance of PolicyKit, SourceCred, and Discourse.

Alternate flow: use for testing / exploration

  1. Hacker skims the Metagov documentation and sees the list of supported tools along with descriptions of how they can be used.
  2. Hacker decides to play with every available tool without looking too closely at their documentation.
  3. Hacker installs Metagov.
  4. Installing Metagov = installing PolicyKit, SourceCred, and everything else.
  5. Hacker, without referring to the documentation, interacts with and discovers each plugin.

TBD: what additional information or resources does a hacker typically need to build during a hackathon?

Following up with the initial flow above. Here are some possible “governance experiments” that a hacker might pursue:

  • Hackathon team designs and implement a participatory budgeting workflow for the governance of the NEAR Community Fund, e.g. methods of decentralizing governance of the NEAR Community Fund
  • Hackathon team builds a template for simple DAO-to-DAO contracts, e.g. a smart contract that NEAR’s CommunityDAO uses to fund MetagovDAO for organizing a hackathon.
  • Hackathon team builds some form of cross-platform DAOs (akin to multinational corporations), e.g. Metagov exists as an Aragon DAO on Ethereum as well as a SputnikDAO, that are linked through some sort of cross-platform service or logic.
  • Hackathon team builds a “task applet” for a specific DAO, e.g. a smart contract, linked to a Metagov oracle, that can recognize when a Medium post on a certain topic has been created and automatically rewards someone for doing so. The contract may have a review period to prevent rewarding of low-quality Medium posts.
  • Hackathon team builds a model of a piece of blockchain infrastructure (e.g. NEAR’s Rainbow Bridge) and proposes a technical solution / incentive system (e.g. an augmented bonding curve) for operating and maintaining it.

Questions: What is the “NEAR Community Fund”? (Is it a NEAR Wallet?) How is it currently governed? Is it accessible by one person or multiple people? How are funds deposited into the fund, and how are they withdrawn? Who is participating in the PB workflow in this experiment? Does the community that governs (or wants to govern) this fund exist on any social platforms?
(I don’t have any NEAR so I can’t make an account myself.)

Questions: What do you mean by “template” here? If you have an example of what a DAO-to-DAO contract looks like, that would be helpful. What does it mean for one DAO to “fund” another DAO–– is there a protocol for sending tokens across DAOs? Do you see this experiment using the Metagov prototype and/or PolicyKit, and if so, for what?

Questions: When you say “Metagov exists on…” are you talking about Metagov the community of people, or are you talking about some software? If the latter, I’m lost- can you explain in more detail?
Do you see this experiment using the Metagov prototype and/or PolicyKit, and if so, for what?

Oh this is interesting. So, when the Medium post is published, some system should make a “contract call” to the smart contract, telling it to reward the particular wallet that belongs to the author of the Medium post? This actually seems like it could be vaguely possible with PolicyKit, a Metagov “listener” plugin for Medium (notifies PolicyKit when post is published), and a Metagov “actor” plugin for NEAR (exposes an action for making a NEAR contract call).
Questions: how are NEAR contract calls authorized? would it be possible for PolicyKit to make contract calls? Is “automatically rewards someone for doing so” an action that is performed by the contract or something else? what is the reward exactly?

Questions: Do you see this experiment using the Metagov prototype and/or PolicyKit, and if so, for what?

NEAR Community Fund (5M NEAR + $1.5M) is available to ecosystem participants on NEAR’s community Discourse forum. Currently, seven individuals from NEAR Collective form the “Community Council” and are using the Discourse polling feature to vote on proposals. That process is fully off-chain and (according to NEAR themselves) is probably too centralized.

Funds exist in a NEAR wallet (so deposits are made through NEAR transfers, from other wallets) which I believe is controlled by a single treasurer of some sort, though there are plans for wallet control to eventually get passed to a SputnikDAO.

The PB workflow in this experiment involves the 7 members of the Community Council, but potentially everybody on the Discourse instance.

And yes, the entire community exists mainly on Discourse (for general discussions) and on Telegram (for small group discussions). I believe that the NEAR Collective / NEAR Foundation, who are the people handling operations for the blockchain, have a separate Slack instance of some sort.

By “template” I just mean a smart contract with blanks for things like addresses, configuration options, etc.

To be honest, there are not that many examples of DAO-to-DAO interactions; this is very much new stuff. Zargham, one of our advisors in #metagov-prototype, co-wrote this research digest on possible DAO-to-DAO interactions.

Having one DAO fund another DAO can be as simple as, "poorDAO (i.e. a blockchain address x01234) submits a proposal to richDAO (i.e. a blockchain address x98765) to do XYZ, richDAO votes on and approves proposal, then richDAO transfers $$$ to poorDAO. This can already be done without any new code at all.

I don’t see this experiment using PolicyKit, but I could see a contract invoking metagov.get_resource whenever it needs an oracle in the contract, i.e. an API call to SourceCred or PK or some service integrated through Metagov. Or even some sort of PK policy, assuming that PK can emit resources.

Sorry, I meant “Metagov the community” is represented through both an Ethereum DAO as well as a NEAR DAO.

TBH, I don’t see this happening right now, unless we somehow build integrators to both Sputnik DAO and to Aragon DAO, in which case a cross-platform policy through Metagov, written in PK, would suffice to integrate the two. That said, the interactions supported by this kind of Metagov bridge would be defined off-chain, so this kind of bridge doesn’t have the same guarantees that a “true” cross-chain bridge such as Rainbow Bridge (between NEAR and Ethereum) or Sifchain (currently between Ethereum and Cosmos) would have.

I’m not sure how NEAR contract calls are authorized! But perhaps we can reserve these questions for next week’s meeting with NEAR? The main resources on SputnikDAOs Launching Sputnik DAOs - #3 by jlwaugh - DAOs - NEAR Forum, and the code base is here: near-daos · GitHub. I’ll add you to a Telegram chat with NEAR folks that can answer some of these questions.

I believe the reward action would be automatically performed by the contract (perhaps contingent on some human review process, i.e. a person with a specific NEAR wallet address logs in and approves the expense). That said, this kind of automatic dispersal / bounty system is supported by lots of other entities that specialize in it, e.g. Gitcoin or Colony, so it might actually be a use-case for cross-chain integration.

The reward, presumably, would be NEAR tokens of some pre-set amount.

I don’t think this experiment would use the current Metagov prototype and/or PK. It might use some of the other research that I’m producing with Seth and @aleksandarpetrov though.

I’m thinking of Metagov<>DAO connection in 3 broad categories:

  1. We want to access data from off-chain platforms from within a DAO contract.

    Example: The contract uses SourceCred cred values to weight votes from council members.

    Approach A: metagov sends data to the contract using a function call. We can write a PolicyKit policy that pushes Cred values to the contract on a regular basis by making a function call.

    Approach B: the contract requests data from metagov (oracle). If the contract is making a request for data, we need an oracle contract and oracle node. The “oracle node” is an off-chain machine making that is continually polling the oracle contract and fulfilling requests. We can use a separate oracle node, or we could maybe have metagov act as the oracle node, I’m not sure yet. Here’s an example of a setup with Client Contract + Oracle Contract, that is meant to work with Chainlink as the Oracle Node: GitHub - smartcontractkit/near-protocol-contracts

    Note: In order to use cred as weights for voting, the contract would need to have its own mapping from wallets to Discourse usernames (or GitHub handles, or whatever SourceCred is using). I think that could be implemented using something like near-auth.

  2. We want some off-chain event to trigger a policy evaluation that makes a contract call (either to read or update the contract state).

    Example: When a Discourse post is created with a certain tag, it should automatically generate a new Proposal in a SputnikDAO.
    Approach: This can be expressed in a PolicyKit policy that makes a function call to the contract. (It will always be the same account making the call. Is that OK?)

  3. We want the contract to trigger an event in the outside world.

    Example: When a proposal for an invoice passes, approve the related invoice on Open Collective
    Approach: The contract needs to somehow notify Metagov that the proposal has passed. See “Approach B…Oracle” it would need to be a similar approach, I think. Then we can write a PolicyKit policy that is triggered by the request from the contract.

Approach B: the contract requests data from metagov (oracle).

It would certainly be interesting to try to put together a Metagov oracle. Do you think it’s feasible for the hackathon? Or is this exactly the use-case that would require an indexer?

I think this would make sense as a hackathon challenge. Eg “a DAO that makes a request to Metagov.”