How to Create a DAO in Solidity?

Decentralized networks attempt to lessen the certainty that users must place in one another and prevent them from exercising power or control over one another in ways that undermine network operation.

Decentralized autonomous organizations (DAOs) adopt various levels of decentralization. The adoption method is frequently determined by the solution’s maturity, incentive feature, the acceptance method over time, and the founding team’s capacity to maintain the balance.

This article offers a step-by-step guide on creating a Decentralized Autonomous Organization (DAO) in an object-oriented programming language known as Solidity.

What is a DAO in Crypto?

A Decentralised Autonomous Organisation (DAO) is a blockchain-based system that allows individuals to coordinate and govern themselves through a set of self-executing rules placed on a public blockchain.

The organization is basically “coded” into a set of smart contracts and results in functions leaderless and independent functioning. These smart contracts serve as the foundation for administration and decision-making.

A DAO is jointly owned and administered by its shareholders. Decisions are made in a DAO through proposals, which the members of the DAO can vote on and subsequently execute. To join a DAO, people must first purchase the DAO’s cryptocurrency. 

Members can examine the proposal and vote on it. The ability to vote on proposals and modifications is proportionate to the quantity of the asset held.

In addition, you can check to see if the proposal has been accepted and, if so, executed after the voting period has expired.

Because all of a DAO’s actions are recorded on the blockchain, all its financial records, choices, and other decision-making elements are visible. However, each DAO has its working style, while most adhere to the same core concepts.

What is Solidity?

Solidity is an object-oriented programming language used to create smart contracts on blockchain development platforms, the most popular of which is Ethereum.

Solidity is based on current programming languages such as C++, Python, and JavaScript; therefore, it has comparable language structures, making it easier for developers to embrace. 

As the first smart contract programming language, Solidity has a large market following and is used to develop various decentralized applications. It was created to build Ethereum smart contracts and now runs on the Ethereum Virtual Machine (EVM).

Solidity provides ideas that are found in most modern programming languages. Solidity also includes mapping data structures, such as hash tables with different key types and key-value pairs.

Solidity doesn’t have a steep learning curve if you already know how to write in popular programming languages like Python, C++, and JavaScript.

Steps for Launching a DAO

A developer or a group of developers must first create the DAO smart contract powering the organization. They may only amend the rules specified by these contracts through the governance system after the contracts have been launched.

This necessitates comprehensive testing of the contracts to verify that crucial aspects are not overlooked.

After the smart contracts are developed, the DAO must decide how to acquire financing and implement governance. For example, tokens are frequently sold to raise cash, granting holders voting rights, etc.

The DAO platform must be launched on the blockchain once everything has been set up. Stakeholders will now make decisions on the organization’s future.

The organization’s founders, who developed the smart contracts, have no more influence over the initiative than other stakeholders.

How to Code a DAO in Solidity?

To design and execute your Solidity smart contracts, you need platforms that allow you to conduct the testing framework, run tests, execute commands, and examine the state while managing how the chain works.

Remix, EthFiddle, Truffle Suite, and Hardhat are some of the examples that allow users to turn their smart contract development cycle into a cordial process.

You can use Hardhat to develop and test the contract. Hardhat’s documentation is among the most precise and most thorough.

In addition, it has console.log() capabilities for debugging, comparable to javascript. Hardhat also has plugins that expand its capabilities.

You can use npm to install Hardhat, which comes with node.js. npm is the Node JavaScript platform’s package management.

It installs modules so nodes can discover them and intelligently handle dependency issues. It may serve a wide range of use cases.

First, make a new project directory with names of your choice.

mkdir HardhatDAO
cd HardhatDAO

Type the following into a terminal window in your project directory.

npm install -d hardhat

Let’s create a new Hardhat project now that you have Hardhat installed. To accomplish so, you can utilize npx. npx helps process node. js executables.

npx Hardhat

A CLI Hardhat interface will greet you. Enter the second option, “Create an empty hardhat.config.js.”

Moving ahead, you must install the remaining requirements necessary to use Hardhat. These are essential for developing contract automation tests.

npm install –-save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle

To sign the smart contract deployment transaction, you” ll need an Ethereum wallet or address. To set up the wallet, obtain its private key and paste it into the hardhat config file. Here you can use Metamask to get a private key. 

A wallet and ETH are required to deploy smart contracts on the blockchain. The ETH is used to compensate the Ethereum network for the time it takes to add the contract to the blockchain and store the variables.

The ETH required to complete the transaction is stored in the wallet. Install MetaMask, set it up to use the Rinkeby test network, then fill up your wallet with free testnet ETH.

For obtaining the private key, select Rinkeby network and click on the three dots near the icon in the top right corner.

Click on “Account details” and select “Export Private Key.”

Click on confirm after entering your password. It will show you your private key.

Copy and save the private key for further use.

Follow the Rinkeby Faucet instructions to send 0.5 test ETH to your MetaMask wallet address. By clicking your account name in MetaMask, you may copy your wallet address. You should have 0.5 ETH in your MetaMask wallet on the Rinkeby testnet after the faucet completes the transaction. 

An Ethereum Rinkeby node is required to deploy your contract on Ethereum’s Rinkeby network. Endpoints of your needs can be obtained from several platforms such as Geth, Quicknode, or OpenEthereum.

After selecting Ethereum as your main chain and Rinkeby as your testnet, make the necessary purchases. Copy your HTTP Provider endpoint after you’ve built your Ethereum endpoint. Save the HTTP Provider endpoint as you will need it later.

Open the hardhat.config.js file and paste the following into it to set the config file:

require("@nomiclabs/hardhat-waffle");

/**
 * @type import('hardhat/config').HardhatUserConfig
 */

const Private_Key = "ADD_YOUR_PRIVATE_KEY_HERE"

module.exports = {
  solidity: "0.7.3",
  networks: {
  	ropsten: {
  		url: `ADD_YOUR_QUICKNODE_URL_HERE`,
  		accounts: [`0x${Private_Key}`]
  	}
  }
};

Replace  “ADD_YOUR_PRIVATE_KEY_HERE” with the private key obtained from your Metamask account and replace “ADD_YOUR_QUICKNODE_URL_HERE” with the HTTP endpoint node URL obtained from the previous step.

Create a new directory named “contracts” for your first contract and place a new file “Helloworld.sol” inside. This example demonstrates how to set and retrieve variables in a smart contract on the Ethereum blockchain.

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.3;

contract HelloWorld {

    string saySomething;

    constructor() {
        saySomething = "Hello World!";
    }

    function speak() public view returns(string memory) {
        return saySomething;
    }
}

Using the following command, compile the contract.

• npx hardhat compile

After successful compilation, the result provided below will be shown.

• Create a deploy.js file in a new directory and type the following commands inside the file to deploy the contract.

async function main() {

	const [deployer] = await ethers.getSigners();

	console.log(
	"Deploying contracts with the account:",
	deployer.address
	);

	console.log("Account balance:", (await deployer.getBalance()).toString());

	const HelloWorld = await ethers.getContractFactory("HelloWorld");
	const contract = await HelloWorld.deploy();

	console.log("Contract deployed at:", contract.address);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
	console.error(error);
	process.exit(1);
  });

To deploy the contract, save the file and run the commands below.

• npx hardhat run scripts/deploy.js –network rinkeby

You will obtain an output containing the address of the deployed contract when the contract has been successfully deployed. The deployment can be verified by copying and pasting the contract’s address on Etherscan.

• After creating your smart contracts, you can transfer ownership to the address of the DAO built using one of the tools and administer your DAO using interfaces like Aragon.

You can create a DAO project with the help of Aragon dApp. Aragon is an Ethereum dApp that makes launching a DAO extremely simple. 

Your Metamask wallet can be connected to the Aragon account with Rinkeby as your testnet. As discussed, you can have 0.5 ETH in your wallet through the Rinkeby Faucet. After clicking the connect account icon, select Metamask and accept the request from Metamask.

• Click on ‘Create an organization’ and select a suitable template for your organization. Here you can choose the ‘Company’ template as an example. 

• Select the template and click ‘Use this template,’ then type your DAO’s name.

• After providing it with a name, you are supposed to set the following parameters;

• Support percentage – This is the percentage of tokens necessary to approve voting in favor of a yes.
• Minimum approval percentage is the needed proportion of yes votes from the remaining token pool to pass the proposal.
• Vote Duration – duration within which the participants or members can vote.

After setting up the necessary parameters, set up a name for your organization and a symbol for your token. Finally, enter the addresses of token holders and allocate tokens to them. 

• The MetaMask window will appear at this point, requesting transaction permission. Confirm the transaction, and you should be ready to go.

• After the transaction, a window will be shown where it indicates that you are ready to go. After this, you can work on several options such as voting, token enhancement, and other public activities. The Aragon DAO is prepared to go!

Conclusion

You have seen how to work with a Hardhat here. You can quickly develop tests for your contracts and debug them with Hardhat. You also learned  DAOs, how to set up a node in MetaMask, how to receive test ETH, and, last but not least, the steps involved in setting up a DAO on Aragon and vote in one. 

Frequently Asked Questions