DGF Prototype

Decentralized Governance Framework

• Specification

• Demo

• Wiki

Project Architecture

directory	description
ethereum	Solidity smart contracts and associated deploy scripts
backend	Node.js application with an HTTP API that also functions as a Matrix bot and Ethereum client
frontend	React.js frontend with a WebApp route and a Matrix Widget route

Data Flow Diagram

flowchart TD
    Blockchain <-- ethers --> API
    Blockchain <-- Web3<br>+ MetaMask --> WebApp
    Blockchain <-- Web3<br>+ MetaMask --> Widget
    WebApp <-- HTTPS --> API
    Widget <-- HTTPS --> API
    Widget <-- matrix-widget-api --> Matrix
    API <-- matrix-bot-sdk --> Matrix

Rollup

Instead of calling DAO.initiateValidationPool(), a contract can call Rollup.addItem().

We demonstrate this by extending our base Work contract as RollableWork.

Our work contract normally triggeres a validation pool when the customer submits work approval. Instead, the fee and worker availability stakes are transferred to the Rollup contract.

The Rollup contract itself uses the Availability contract to assign a batch worker. This worker is responsible for making sure off-chain pools are conducted.

When ready, the worker submits the current batch on-chain by calling DAO.addPost() to create a batch post and then calling Rollup.submitBatch(), which initiates a validation pool targeting the batch post.

sequenceDiagram
    participant client as Staking client
    participant matrix as Matrix room
    box Blockchain
    participant worker as Worker
    participant customer as Customer
    participant work as Work contract
    participant rollup as Rollup contract
    participant vp as Validation pool
    participant forum as Forum
    end


    worker ->> work : Availability stake<br />(REP)
    activate worker
    activate work
    customer ->> work : Request work<br />(fee)
    activate customer
    worker ->> work : Submit work evidence<br />(postId)
    deactivate worker
    customer ->> work : Submit work approval
    deactivate customer
    work ->> rollup : Add item<br />(fee, REP, postId)
    activate rollup
    deactivate work

    rollup ->> client : Event: BatchItemAdded
    activate client
    client ->> matrix : io.dgov.pool.start<br />(postId)
    activate matrix
    matrix -->> client : 
    client ->> matrix : io.dgov.pool.stake<br />(postId, REP, inFavor)
    matrix -->> client : 
    client ->> matrix : io.dgov.pool.result<br />(postId, votePasses, quorumMet)
    matrix -->> client : 

    note right of client : All staking clients<br/>record each other's stakes

    client ->> forum : Add post<br />(batchPostId)
    activate forum
    client ->> rollup : Submit batch<br />(batchPostId)
    client ->> matrix : io.dgov.rollup.submit
    matrix -->> client : 
    deactivate matrix
    rollup ->> vp : Initiate validation pool<br />(fee, REP, batchPostId)
    activate vp
    note right of vp : Mints REP in<br />proportion to fee
    deactivate rollup

    vp ->> client : Event: ValidationPoolInitiated

    note right of client : Each staking client <br />verifies the rollup post

    client ->> vp : Stake for/against
    client ->> vp : Evaluate outcome
    
    vp ->> client : REP rewards for policin
    deactivate client
    vp ->> forum : Minted REP
    deactivate vp
    forum ->> worker : REP rewards for batch post authors
    deactivate forum

Local development setup

Clone this repository to a directory on your machine

git clone https://gitea.dgov.io/DGF/dgf-prototype

Nginx

1. Install nginx

    brew install nginx
   

2. Install mkcert

    brew install mkcert
   

3. Install root CA

    mkcert -install
   

4. Create a certificate

    mkcert dgfprototype.dev
   

5. Create certificates directory

    sudo mkdir /etc/nginx/certs
   

6. Move the certificate to the certificates directory

    sudo mv dgfprototype.*.pem /etc/nginx/certs/
   

7. Add the following to the http section of /etc/nginx/nginx.conf

    map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
    }
   

8. Add the following to a new file /etc/nginx/sites-available/dgfprototype_dev

    server {
            listen 443 ssl;
   
            server_name dgfprototype.dev;
            ssl_certificate     /etc/nginx/certs/dgfprototype.dev.pem;
            ssl_certificate_key /etc/nginx/certs/dgfprototype.dev-key.pem;
   
            location /api/ {
                    proxy_pass http://127.0.0.1:3003/;
            }
   
            location / {
                    proxy_pass http://127.0.0.1:3002/;
                    proxy_http_version 1.1;
                    proxy_set_header Upgrade $http_upgrade;
                    proxy_set_header Connection $connection_upgrade;
                    proxy_set_header Host $host;
            }
    }
   

9. Create a symbolic link in sites-enabled/

    sudo ln -s /etc/nginx/sites-available/dgfprototype_dev /etc/nginx/sites-enabled
   

10. Restart nginx

     sudo systemctl restart nginx
    

    or

     sudo brew services restart nginx
    

11. Edit /etc/hosts to add the domain alias

     127.0.0.1  dgfprototype.dev
    

API

1. In a new terminal window, navigate to dgf-prototype/backend

2. Install the project

    npm install
   

3. Copy the example configuration file

    cp .env.example .env
   

4. Edit .env and set the following values

    PORT=3003
   

5. Create the data directory

    mkdir data
   

6. Run the daemon

    node src/index.js
   

Hardhat

1. In a new terminal window, navigate to dgf-prototype/ethereum

2. Install the project

    npm install
   

3. Copy the example configuration file

    cp .env.example .env
   

4. In .env, set a value for SEED_PHRASE or LOCAL_PRIVATE_KEY

5. Run a hardhat node

    npx hardhat node
   

6. In a separate terminal window, navigate again to dgf-prototype/ethereum

7. Build and deploy the contracts

    npm run deploy-local
   

Metamask

1. Install the Metamask extension in your browser

2. In the Metamask extension, click the list of networks in the top left, and click "Add Network"

3. At the bottom of the list of popular networks, click "Add a network manually"

   • Network name: Hardhat local
   • RPC URL: http://127.0.0.1:8545/
   • Chain ID: 1337
   • Currency symbol: ETH

Frontend

1. In a new terminal window, navigate to dgf-prototype/frontend

2. Install the project

    npm install
   

3. Install vite

    npm i -g vite
   

4. Run the development server

    vite dev
   

5. Now you should be able to open the site at https://dgfprototype.dev

To run automatic staking

1. Clone this repository to a directory on your machine

    git clone https://gitea.dgov.io/DGF/dgf-prototype
   

2. Change to the ethereum directory

    cd ethereum
   

3. Install the project using npm

    npm install
   

4. Copy the example configuration file

    cp .env.example .env
   

5. Export your Sepolia private key from MetaMask and add it to your .env file

    SEPOLIA_PRIVATE_KEY="YOURKEY"
   

6. Run the automatic staking script

    npm run automatic-staking-sepolia