Governance SDK

The core module for creating and managing governance proposals. It handles the lifecycle from submission to execution, supporting various voting mechanisms like token-weighted, quadratic, or conviction voting. Key functions include:

• Proposal creation with executable payloads.
• Vote casting with options (For, Against, Abstain).
• Quorum and threshold enforcement.
• Timelocks for execution delays.

Examples: Snapshot for off-chain signaling, OpenZeppelin's Governor contracts.

Manages the governance token that confers voting power and the logic for delegating that power. This module defines:

• Token distribution and vesting schedules.
• Delegation mechanisms, allowing token holders to delegate votes to representatives.
• Vote power calculation, which can include time-based boosts or staking requirements.
• Snapshotting to record token balances at a specific block for vote weight.

This is foundational for systems like Compound's COMP or Uniswap's UNI governance.

A secure vault module for holding and managing the protocol's assets, controlled by governance votes. It enables:

• Multi-asset support for native tokens, ERC-20s, and NFTs.
• Transaction execution for payments, grants, or investments.
• Access control with multi-signature or timelock safeguards.
• Budgeting and streaming of funds via vesting contracts.

This turns governance decisions into concrete financial actions, as seen in DAOs like Aave or Arbitrum.

Defines and enforces roles and permissions within the governance system using patterns like role-based access control (RBAC). It specifies:

• Who can create proposals (e.g., token threshold).
• Who can execute passed proposals (e.g., a timelock executor).
• Administrative roles for parameter updates.
• Guardian or pause functionality for emergency intervention.

This module is critical for security, often built using standards like OpenZeppelin's AccessControl.

Provides mechanisms to safely upgrade smart contract logic or adjust system parameters through governance. This includes:

• Proxy patterns (e.g., Transparent or UUPS) for logic upgrades.
• Parameter adjustment for fees, rewards, quorums, and voting periods.
• Grace periods and delays to allow community reaction to changes.
• Versioning and migration tools for complex upgrades.

This ensures the protocol can evolve without requiring a full migration.

Client-side libraries and APIs that allow dApp frontends to easily interact with the governance system. Features include:

• TypeScript/JavaScript SDKs for reading proposal data and submitting transactions.
• Pre-built UI components for voting interfaces and proposal explorers.
• Subgraph or indexer integrations for efficient querying of historical data.
• Wallet connection abstractions (e.g., WalletConnect, Ethers.js).

These tools drastically reduce the development time for building governance interfaces.

The pioneering on-chain governance system that inspired the Governor standard. Its implementation introduced key mechanics now considered foundational:

• Proposal Lifecycle: Defined states like Pending, Active, Canceled, Defeated, Succeeded, Queued, Expired, and Executed.
• Timelock & Guardian: A Timelock contract delays execution, while a Guardian (initially the team) holds emergency pause/undo powers.
• Governance Token (COMP): Uses a token-weighted, time-locked voting model where voting power is derived from delegated COMP.

A model that inverts the default security assumption, used by Optimism's Citizen House. Key mechanics include:

• Challenge Period: Proposals pass by default after a vote, but are subject to a dispute period (e.g., 7 days).
• Bonded Challenges: Anyone can challenge a proposal by posting a bond, triggering a dispute resolution process (often via a Token House or security council).
• Reduced Voting Fatigue: Allows for faster iteration by only requiring deep community engagement when a proposal is contested.

SDKs provide modular functions to handle the entire proposal lifecycle, from creation to execution. This includes:

• Proposal Submission: Standardized interfaces to create and submit proposals with parameters like voting delay and execution delay.
• Voting Power Calculation: Integration with token standards (e.g., ERC-20, ERC-721) or veToken models to compute voting weights.
• State Tracking: Easy querying of proposal status (Active, Succeeded, Defeated, Executed).
• Execution: Simplified methods to queue and execute successful proposals, often handling timelock interactions automatically.

Governance SDKs often include pre-built UI components (React hooks, Vue composables) and widgets to accelerate frontend development. Key features include:

• Connect Wallet: Standardized hooks for connecting user wallets and fetching their delegate status.
• Voting Interfaces: Ready-to-use components for displaying active proposals, casting votes (For, Against, Abstain), and showing real-time results.
• Proposal Creation Wizards: Guided forms for submitting new proposals, reducing user error.
• Examples: Tally, Snapshot, and Compound's Governor Frontend provide such kits.

Advanced SDKs facilitate governance across multiple chains or protocols, addressing fragmentation. They enable:

• Governance Aggregation: A single interface to view and vote on proposals from different DAOs or L2 networks.
• Message Bridging: Abstraction layers that handle the cross-chain communication required for voting and execution, often using generalized message passing protocols.
• Unified Identity: Managing a consistent delegate identity or Soulbound Token reputation across ecosystems.
• This is critical for meta-governance in DeFi protocols that hold governance tokens of other protocols.

To enhance safety, SDKs incorporate tools for secure governance operations:

• Simulation: Pre-execution simulation of proposal outcomes using Tenderly or custom EVM simulators to preview state changes.
• Access Control: Built-in patterns for role-based permissions (e.g., using OpenZeppelin's AccessControl).
• Timelock Integration: Standardized modules to interact with timelock controllers, enforcing mandatory delays between proposal passage and execution.
• Upgrade Patterns: Support for proxy patterns (Transparent/UUPS) to enable future upgrades of the governance system itself.

SDKs provide querying tools to fetch and analyze governance data, essential for dashboards and research. Capabilities include:

• Historical Data: Access to past proposals, votes, and voter turnout.
• Voter Analysis: Tools to analyze voting patterns, delegate influence, and voter apathy.
• Gas Estimation: Methods to estimate transaction costs for submitting votes or proposals.
• Event Listening: Real-time listeners for on-chain governance events (e.g., ProposalCreated, VoteCast).
• These often connect to indexed data from services like The Graph or Covalent.

A core function of SDKs is promoting standardization, allowing different DAO tools to work together. They implement:

• Common Interfaces: Adherence to emerging standards like EIP-4824 (Common Interfaces for DAOs).
• Plugin Architecture: Support for modular governance plugins (e.g., for quorum voting, token-weighted voting, multisig).
• Composability: Designed to be composed with other DeFi primitives, such as integrating with lending protocol governance or NFT membership voting.
• This reduces vendor lock-in and fosters a more interoperable DAO tooling ecosystem.