🏛️ Decentralized Voting DAO System

A complete Decentralized Autonomous Organization (DAO) system with transparent on-chain governance, quadratic voting, and Sybil-resistant mechanisms.

✨ Features

🗳️ Core Governance

Quadratic Voting: Vote cost = votes² to prevent plutocracy
Token-based Membership: ERC-20 governance tokens with delegation
Proposal System: IPFS-stored metadata with on-chain voting
Sybil Resistance: Token thresholds, cooldowns, and vote limits
Treasury Management: Multi-token treasury with automated execution

🔐 Security & Transparency

OpenZeppelin Integration: Battle-tested security patterns
Vote Delegation: Liquid democracy with delegation chains
Emergency Controls: Pausable contracts and emergency withdrawals
Comprehensive Testing: 22 passing tests covering all scenarios

📊 Advanced Features

IPFS Integration: Decentralized metadata storage with pinning
Budget Management: Category-based spending with approval workflows
Analytics: Vote distribution analysis and Gini coefficients
Real-time Tracking: Live proposal status and voting progress

🏗️ Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  GovernanceToken│    │   DAOGovernance │    │   DAOTreasury   │
│                 │    │                 │    │                 │
│ • ERC-20 + Votes│◄──►│ • Proposals     │◄──►│ • Multi-token   │
│ • Delegation    │    │ • Quadratic Vote│    │ • Budget Mgmt   │
│ • Minting/Burn  │    │ • IPFS Metadata │    │ • Auto Execute  │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                 │
                    ┌─────────────────┐
                    │  IPFS Network   │
                    │                 │
                    │ • Metadata      │
                    │ • Attachments   │
                    │ • Pinning       │
                    └─────────────────┘

🚀 Quick Start

Prerequisites

Node.js 18+
npm or yarn
IPFS node (optional, uses public gateways as fallback)

Installation

# Clone the repository
git clone <repository-url>
cd decentralized-autonomous-organization

# Install dependencies
npm install

# Compile contracts
npm run compile

# Run tests
npm test

# Deploy to local network
npm run node          # Terminal 1: Start local Hardhat network
npm run deploy:localhost  # Terminal 2: Deploy contracts

Deployment

# Deploy to testnet (configure network in hardhat.config.ts)
npm run deploy:sepolia

# Verify contracts on Etherscan
npx hardhat verify --network sepolia <contract-address> <constructor-args>

📁 Project Structure

├── contracts/              # Smart contracts
│   ├── GovernanceToken.sol  # ERC-20 governance token
│   ├── DAOGovernance.sol    # Main DAO contract
│   ├── DAOTreasury.sol      # Treasury management
│   └── VotingMechanisms.sol # Voting utilities
├── scripts/                # Deployment scripts
│   └── deploy.ts           # Main deployment script
├── ipfs/                   # IPFS integration
│   ├── client.js           # IPFS client setup
│   ├── metadata.js         # Metadata management
│   ├── pinning.js          # Pin management
│   └── example.js          # Usage examples
├── frontend/               # React frontend (TODO)
├── tests/                  # Test suites
│   └── DAO.test.ts         # Comprehensive tests
└── docs/                   # Documentation

🎯 Usage Examples

Creating a Proposal

// 1. Upload metadata to IPFS
const proposalData = {
  title: "Fund Open Source Library",
  description: "Proposal to fund development...",
  proposer: "0x742d35Cc6634C0532925a3b8D4C9db96590c6C87",
  // ... additional fields
};

const { hash } = await metadataService.uploadProposalMetadata(proposalData);

// 2. Create on-chain proposal
await daoGovernance.propose("Fund Open Source Library", hash);

Quadratic Voting

// Vote with 4 votes (costs 16 tokens)
const votes = 4;
const cost = votes * votes; // 16 tokens

// Approve token spending
await governanceToken.approve(daoGovernance.address, ethers.parseEther("16"));

// Cast vote
await daoGovernance.vote(proposalId, votes);

Vote Delegation

// Alice delegates her voting power to Bob
await daoGovernance.connect(alice).delegateVotes(bob.address);

// Bob can now vote with Alice's tokens + his own
const bobVotingPower = await governanceToken.getVotes(bob.address);

🧪 Demo Scenario: Alice, Bob & Carol

The system includes a complete demo scenario:

Alice proposes funding for an open-source library
Bob votes with 4 votes (16 tokens deducted via quadratic cost)
Carol delegates her votes to Bob
Voting closes, quorum is met, proposal passes
Treasury automatically executes fund transfer

# Run the demo
npm test -- --grep "Complete Proposal Lifecycle"

🔧 Configuration

Voting Parameters

struct VotingConfig {
    uint256 proposalThreshold;      // 1,000 tokens to create proposal
    uint256 votingDelay;           // 1 day delay before voting starts
    uint256 votingPeriod;          // 7 days voting duration
    uint256 quorumThreshold;       // 100,000 tokens minimum participation
    uint256 maxVotesPerWallet;     // 10,000 max votes per wallet
    uint256 proposalCooldown;      // 1 day cooldown between proposals
}

IPFS Configuration

const IPFS_CONFIG = {
  host: process.env.IPFS_HOST || 'localhost',
  port: process.env.IPFS_PORT || 5001,
  protocol: process.env.IPFS_PROTOCOL || 'http',
  timeout: 30000
};

📊 Testing Results

✅ 22 tests passing
📊 100% test coverage for core functionality
🔐 Security patterns verified
⚡ Gas optimization confirmed

Test Categories

GovernanceToken: Minting, burning, delegation
DAOGovernance: Proposals, voting, delegation
DAOTreasury: Deposits, budgets, spending
Integration: Complete proposal lifecycle

🛡️ Security Features

Sybil Resistance

Token Threshold: Minimum tokens required to create proposals
Vote Limits: Maximum votes per wallet to prevent centralization
Cooldowns: Time delays between actions from same address
Quadratic Cost: Exponential cost scaling discourages vote buying

Access Control

Role-based Permissions: Owner, treasury managers, emergency managers
Pausable Contracts: Emergency stop functionality
Reentrancy Guards: Protection against reentrancy attacks
Safe Math: Overflow protection with Solidity 0.8+

🌐 IPFS Integration

Metadata Storage

Structured Format: JSON schema for proposal metadata
Attachment Support: Images, documents, data files
Pinning Management: Automatic pinning with retention policies
Fallback Gateways: Multiple IPFS gateways for reliability

Example Metadata Structure

{
  "version": "1.0.0",
  "type": "dao-proposal",
  "proposal": {
    "title": "Fund Open Source Library",
    "description": "...",
    "proposer": "0x...",
    "budget": { "total": "50,000 DAOGOV" }
  },
  "attachments": [...],
  "links": [...]
}

🚧 Roadmap

Phase 1: Core System ✅

Smart contracts development
IPFS integration
Comprehensive testing
Deployment scripts

Phase 2: Frontend (In Progress)

Phase 3: Advanced Features

Snapshot.js integration
Multi-signature proposals
Lens Protocol integration
Mobile application

🤝 Contributing

Fork the repository
Create a feature branch
Write tests for new functionality
Ensure all tests pass
Submit a pull request

📄 License

MIT License - see LICENSE file for details.

🙏 Acknowledgments

OpenZeppelin: Security-focused smart contract library
Hardhat: Ethereum development environment
IPFS: Decentralized storage network
Ethers.js: Ethereum library for JavaScript

👨‍💻 Made by

Subaskar_S

Full-Stack Developer & Blockchain Enthusiast

"Building the future of cross-chain infrastructure, one commit at a time."

🌟 About the Developer

Passionate about blockchain technology and decentralized systems, I specialize in creating robust, scalable solutions for the Web3 ecosystem. This project represents my commitment to building production-ready tools that enhance the security and reliability of cross-chain operations.

Areas of Expertise:

🔗 Blockchain Development (Ethereum, Polygon, BSC)
⚛️ Full-Stack Development (React, Node.js, TypeScript)
🔒 Security & Anomaly Detection Systems
📊 Real-Time Data Processing & Visualization
🏗️ Scalable System Architecture

⭐ Star this repository if you find it useful!

🔔 Watch this repository to stay updated with the latest features and improvements!

Subaskar-S/Decentralized_Voting_DAO