Mudit Singh (Backend-Associate Consultant L2- Development)

Decentralized Autonomous Organizations (DAOs) leverage blockchain technology and smart contracts to enable user-driven decision-making, removing the need for centralized control. By integrating the Ethereum Name Service (ENS), DAOs enhance user-friendliness and establish a clear on-chain identity. Additionally, Snapshot facilitates off-chain voting, improving the governance process by making it more efficient and streamlined. To set up a DAO, key steps include acquiring an ENS name, creating a governance token for voting power, and configuring Snapshot for off-chain voting to ensure effective and decentralized decision-making. For more related to blockchain, smart contracts, and crypto, visit our blockchain app development services. 

DAO Development with Snapshot and ENS Integration for On-Chain Governance

Acquire an ENS Domain

The first step in setting up a DAO is acquiring a decentralized identity for your organization via the Ethereum Name Service (ENS). ENS enables the association of human-readable names (e.g., yourdao.eth) with Ethereum addresses, providing both on-chain and off-chain identity for your DAO.

Steps to get your ENS domain:

• Visit the ENS Manager.(https://app.ens.domains/)
• Search for your desired ENS name (e.g., yourdao.eth).
• If available, proceed to purchase the name by paying the associated fees.
• Connect your wallet (e.g., MetaMask) to complete the transaction.
   

Once you own the ENS name, it can be used for various DAO-related tasks. For example, you can create subdomains like vote.yourdao.eth for voting or docs.yourdao.eth for documentation.

Also, Read | DAOs in Gaming : A New Governance Model

Implement Governance with a Governance Token

The second step is to create a governance token, which will serve as the voting mechanism for your DAO. The number of tokens a user holds determines their voting power on proposals.

Create the Governance Token Contract

Write and deploy a smart contract for the governance token using the ERC-20 standard. Below is an example of a simple governance ERC-20 token:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract GovernanceToken is ERC20 {
   constructor(uint256 initialSupply) ERC20("Governance Token", "GOV") {
       _mint(msg.sender, initialSupply);
   }
}

You can either deploy a new governance token using the provided contract, or use an existing ERC-20 token by integrating it into the governance framework. If using an existing token, simply reference the token's address and use its balance for governance purposes.

You may also like to explore | A Quick Guide to Developing a DAO-enabled NFT Marketplace

Add Governance to Snapshot

Once you have your ENS domain and governance token, the next step is to set up Snapshot, which allows for off-chain voting.

Create Space : Go to Snapshot and sign in with your wallet (MetaMask). After a successful login, create a new space with your ENS domain as the name (e.g., yourdao.eth). You will also need to select the chain.

Set Up Voting Strategies: Specify how the voting power should be calculated by adding one or up to 8 strategies. Snapshot provides a set of strategies on the basis of which users' votes are counted.A voting strategy is a set of conditions used to calculate a user's voting power. Strategies enable Snapshot to calculate the final result of voting on a given proposal. Snapshot provides over 400+ voting strategies. The default strategy is erc20-balance-of — it calculates the balance of a predefined ERC-20 token for each user. We can also create our own strategy. Below is a demonstration of the fields.

{
 "strategy": "erc20-balance-of",
 "params": {
   "address": "0xYourGovernanceTokenAddress",  // Governance token contract address
   "symbol": "GOV",
   "decimals": 18
 }
}

Configure Proposals: To specify who can manage the space or create proposals, fill in the appropriate fields with addresses for:

• Admins: Users able to edit the space settings and moderate proposals.
• Authors: Users able to create proposals without any constraints. Make sure that members specified in the authors field are allowed to submit a proposal.
  Define who can create proposals, the voting delay, and the voting period. The configuration ensures that only token holders can participate in decision-making and sets how long a proposal will be open for voting. 

To validate if someone can post a proposal, you can use the basic validation by default, which takes your voting power with space strategies and checks if you pass a defined threshold.

Voting
 

The voting delay is the time between the creation of the proposal and when users are allowed to vote.
The voting period is the duration that the proposal is active and votes can be cast. It is counted from the moment the proposal is created.

Quorum is the amount of voting power collectively achieved by voters, which is required for a proposal to pass.

Also, Check | How to Build a DAO | A Quick Explainer

Governance Proposal Workflow

Proposal Creation: Token holders or authorized users can propose changes or decisions within the DAO. For example, a proposal can suggest changes to the protocol or allocate treasury funds.
 

Voting Process: DAO members with voting tokens vote on the proposal. The proposal is accepted or rejected based on the voting outcome, considering quorum and voting power.
Execution (Optional): Once a proposal is approved, it can be executed either off-chain (through Snapshot) or on-chain (using smart contracts), depending on your DAO's setup.

Conclusion

In this setup, acquiring an ENS domain provides your DAO with a decentralized identity, while the governance token allows members to participate in decision-making. By configuring Snapshot, you can enable efficient off-chain voting, creating a robust governance model for your DAO. If you are looking for trusted blockchain app development, you may connect with our skilled blockchain developers to get started. 

 

Minting a Non-Fungible Token (NFT) on the Polygon network using Ethers.js is a simple and straightforward process. In this article, explore step-by-step how to do so. Ethers.js is a JavaScript library that helps us interact with smart contracts. It also allows us to call contract functions, enabling us to mint NFTs using JavaScript code easily. For more related to NFT, visit our NFT development services. 

Setup

To interact with the Polygon network, we need to install the following dependencies in our code:

Ethers.js: It is the JavaScript library that provides methods and functions to interact with the blockchain.

dotenv: For managing environment variables securely, such as the private key, which is of utmost importance to keep secure.

Additionally, we need the following:

Private Key: A private key is necessary to sign transactions and authenticate the actions performed by your wallet. It must be kept secure to prevent unauthorized access to your account and assets.

Contract Address: The contract address specifies the location of the deployed smart contract on the Polygon network. It is required to interact with the specific contract where the NFT minting functions are defined.

ABI (Application Binary Interface): The ABI defines the functions and events available in the smart contract. It is essential to correctly call the contract functions and interpret the responses.

You may also like |  How to Create a Compressed NFT on Solana

Here's how you can set up your project and interact with the smart contract to mint an NFT on the Polygon network using Ethers.js:

Installation

Install the necessary dependencies:

-npm install ethers dotenv

Interacting with the Smart Contract

The provided code demonstrates how to interact with an NFT smart contract on the Polygon chain using ethers.js. It starts by loading environment variables for the private key and contract address. Ensure that the private key belongs to the owner who deployed the contract, as only they are allowed to mint the NFT. A connection to the Polygon network is established via a JSON-RPC provider, and a wallet is created with the owner's private key. The script then initializes an instance of the NFT contract using the contract address and ABI. It attempts to mint an NFT to a specified address by calling the safeMint function, logging the transaction hash and success status.

Also, Read | A Detailed Guide to NFT Minting on Solana using Metaplex API

require('dotenv').config();
const { nftAbi } = require('./abi');
const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider('https://polygon-amoy.drpc.org');
console.log('Connected to Polygon network.');

const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
console.log('Wallet address:', wallet.address);

const contractAddress = process.env.CONTRACT_ADDRESS;
console.log('Contract address:', contractAddress);

const nftContract = new ethers.Contract(contractAddress, nftAbi, wallet);

async function main() {
  const recipientAddress = '0xE4cF33fA257Ec61918DC7F07a8e6Ece1952C01D0';

  try {
    console.log(`Minting NFT to address: ${recipientAddress}`);
    const tx = await nftContract.safeMint(recipientAddress);
    console.log('Transaction hash:', tx.hash);
    console.log('NFT minted successfully!');
  } catch (error) {
    console.error('Error minting NFT:', error);
  }
}

main().catch((error) => {
  console.error('Script error:', error);
  process.exit(1);
});

Also, Explore |  NFT-Based Loyalty Programs: Revamping Customer Engagement

Conclusion

Minting NFTs on the Polygon network using Ethers.js is a straightforward process that leverages JavaScript's capabilities to interact with smart contracts. By setting up your environment with the necessary dependencies and securely managing your private key, you can easily work with NFT contracts. This guide walks you through the essential steps, from installing the required libraries to executing code that interacts with your smart contract. With the provided example, you can see how to connect to the Polygon network, create a wallet, and call the safeMint function to mint NFTs to any specified address. If you have a similar project in mind that you want to bring into reality, connect with our skilled NFT developers to get started. 

TRC-20 is a standard for smart contract development and fungible token development on the TRON blockchain. It is similar to Ethereum's ERC-20 standard but tailored for the TRON network. TRC-20 ensures that all tokens created on TRON can work seamlessly with various decentralized applications (dApps) and other smart contracts within the TRON ecosystem

Setup

Deploying a TRC-20 token on the TRON blockchain involves several steps, from setting up the development environment to writing, compiling, and deploying the smart contract. Here's a comprehensive guide to help you through the process.

Install the following dependencies to set up your project:

• Hardhat: For project management and to compile the Solidity code, which then provides us with the ABI and bytecode necessary for contract deployment and interaction 
• TronWeb: For interacting with the TRON blockchain and deploying our contract. It is also used to interact with the contract by creating its instance.
• OpenZeppelin Contracts: It provides secure and reliable smart contract libraries that follow industry best practices, and it simplifies the development process by offering well-tested, reusable components.
• dotenv: For managing environment variables securely, such as the private key, which is of utmost importance to be kept securely.

You may also like | How to Transfer SOL and SPL Tokens Using Anchor

TRC-20 Token

This Solidity code defines a TRC-20 token smart contract for the TRON blockchain, following the ERC-20 standard. Named TRC20Token, it inherits from OpenZeppelin's ERC20 contract. The constructor accepts the token's name, symbol, and initial supply as parameters, setting these values and minting the total supply to the deployer's address with 18 decimal places. 18 decimal places are defined in the ERC-20 token standard.

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract TRC20Token is ERC20 {
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply * (10 ** uint256(decimals())));
    }
}

Also, Check |  How to Develop Programmable Non-Fungible Tokens on Solana

Deploy

To deploy a TRC-20 token smart contract on the TRON blockchain using TronWeb, we start by writing the smart contract in Solidity. After that, we use Hardhat to compile the contract, which generates the ABI (Application Binary Interface) and bytecode necessary for deployment. We run npx hardhat compile to get these compiled files. In our deployment script, we first set up TronWeb with the necessary full node, solidity node, event server, and private key for the TRON network.

We then define the ABI and bytecode of our contract using the compiled artifacts. When deploying the contract, we pass the parameters for the token's name ('TRC20'), symbol ('TRC'), and initial supply (1,000,000 tokens). These parameters are specified in the parameters array of the deployment configuration. Additionally, we set other deployment options such as feeLimit, callValue, userFreePercentage and originalEnergyLimit 

TronWeb handles the deployment process and, once the contract is successfully deployed, provides the contract address. In our script, we retrieve both the hexadecimal address and the Base58Check address of the deployed contract. Finally, we console log these addresses to display the deployed token's address. This way, we can verify and interact with our deployed TRC-20 token on the TRON blockchain.

require('dotenv').config();
const TronWeb = require('tronweb');
const artifacts = require('../artifacts/contracts/TRC20Token.sol/TRC20Token.json');

const fullNode = 'https://api.nileex.io';
const solidityNode = 'https://api.nileex.io';
const eventServer = 'https://api.nileex.io';
const privateKey = process.env.PRIVATEKEY;

const tronWeb = new TronWeb(fullNode, solidityNode, eventServer, privateKey);

const contractABI = artifacts.abi;
const contractBytecode = artifacts.bytecode;

async function deployContract() {
  const contract = await tronWeb.contract().new({
    abi: contractABI,
    bytecode: contractBytecode,
    feeLimit: 1000000000,
    callValue: 0,
    userFeePercentage: 30,
    originEnergyLimit: 10000000,
    parameters: ['TRC20', 'TRC', 1000000],
  });

  const hexAddress = contract.address;
  const base58Address = tronWeb.address.fromHex(hexAddress);

  console.log('Contract deployed at address:');
  console.log('Hexadecimal: ', hexAddress);
  console.log('Base58Check: ', base58Address);
}

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

Also, Explore | Creating a Staking Smart Contract on Solana using Anchor

Interacting with the Contract

The provided code shows how to interact with a TRC-20 token smart contract on the TRON blockchain using TronWeb. It begins by configuring TronWeb with the necessary settings for the Nile testnet, including full node, solidity node, event server, and a private key. The contract's ABI and address are used to create a contract instance. The getTokenDetails function then calls the smart contract methods to fetch the token's decimals, name, symbol, and total supply. These details are printed to the console, demonstrating how to retrieve and display essential information about a TRC-20 token deployed on the TRON network.

When executed, the script logs the following values to the console:

• Decimals: 18
• Name: TRC20
• Symbol: TRC
• Total Supply: 1000000000000000000000000

This output shows that the token has 18 decimal places, is named "TRC20," has the symbol "TRC," and has a total supply of 1,000,000 tokens (accounting for the 18 decimal places). This script is useful for anyone needing to interact with and understand the properties of their TRC-20 token.

require('dotenv').config();
const TronWeb = require('tronweb');
const artifacts = require('../artifacts/contracts/TRC20Token.sol/TRC20Token.json');

// TronWeb configuration for Nile testnet
const fullNode = 'https://api.nileex.io';
const solidityNode = 'https://api.nileex.io';
const eventServer = 'https://api.nileex.io';
const privateKey = process.env.PRIVATE_KEY;

const tronWeb = new TronWeb(fullNode, solidityNode, eventServer, privateKey);

const contractAddress = 'TQtBkgDaQUKrpt2aiYYaACpDGjigJkUTum';

async function getTokenDetails() {
  try {
    const contract = await tronWeb.contract().at(contractAddress);

    const decimals = await contract.decimals().call();
    const name = await contract.name().call();
    const symbol = await contract.symbol().call();
    const totalSupply = await contract.totalSupply().call();

    console.log('Decimals:', decimals.toString());
    console.log('Name:', name);
    console.log('Symbol:', symbol);
    console.log('Total Supply:', tronWeb.toBigNumber(totalSupply).toString());
  } catch (error) {
    console.error('Error fetching token details:', error);
  }
}

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

Also, Discover | How To Create My Scalping Bot Using Node.js

Conclusion

Deploying and interacting with a TRC-20 token on the TRON blockchain is a clear process. You can easily create and manage your token by setting up the right tools and writing a compliant smart contract. Using Hardhat to compile and TronWeb to deploy ensures your token works well within the TRON ecosystem. TronWeb also lets you interact with your deployed contract to retrieve important token details, simplifying management. Whether you are a developer or a business, the TRC-20 standard provides a reliable framework for token creation and management on TRON. Looking to build your project on the Tron Blockchain? Get started by connecting with our experienced blockchain developers.