DAO 与链上治理:Snapshot、Tally、治理代币与投票机制

深度解析 DAO 组织架构与链上治理全链路,涵盖 Snapshot 链下投票、Tally 提案执行、Compound Governor Bravo 框架、委托投票与二次方投票机制,剖析 Gnosis Safe 多签托管与常见治理攻击的防御策略。

导语:从公司到 DAO,治理范式的链上迁徙

去中心化自治组织(Decentralized Autonomous Organization,DAO)是区块链治理的终极实验。与传统公司不同,DAO 不靠章程和董事会,而靠智能合约编码规则、靠治理代币分配话语权、靠投票机制决定资金流向。从 Uniswap 到 MakerDAO,从 ConstitutionDAO 到 Nouns DAO,链上治理已经成为 Web3 协议运行的核心基础设施。

本文将系统梳理 DAO 的完整技术栈:治理代币的经济模型、Snapshot 和 Tally 的分工、Compound Governor Bravo 的框架设计、以及委托投票和二次方投票等进阶机制。

一句话总结:DAO 的本质是把"公司章程"替换成不可篡改的智能合约,把"股东投票"替换成代币加权的链上治理——它的去中心化程度取决于代币分布、投票机制与合约安全的综合设计。


1. DAO 的核心架构

1.1 DAO 的三层组件

一个典型的链上 DAO 由三层组件构成:

┌─────────────────────────────────────────────────┐
│  用户层:持币者、委托人、提案人                    │
│     ↓ 投票 / 委托 / 提案                          │
├─────────────────────────────────────────────────┤
│  治理层:Governor 合约(投票计数、执行判定)       │
│     ↓ 检查 quorum(最低票数)、for 超过 against    │
├─────────────────────────────────────────────────┤
│  资金层:Timelock + Treasury + Gnosis Safe       │
│     ↓ 延迟执行,给社区留反应时间                   │
└─────────────────────────────────────────────────┘

1.2 治理代币(Governance Token)

治理代币是 DAO 的投票权载体。持有者可以:

interface IGovernanceToken {
    // 委托自己的投票权给 delegatee,自身保留代币所有权
    function delegate(address delegatee) external;

    // 查询某地址当前持有的投票权(含被委托的)
    function getVotes(address account) external view returns (uint256);
}
// 以 Compound 风格的治理代币为例
contract GovernanceToken is ERC20, ERC20Votes {
    constructor() ERC20("DAO Token", "DT") ERC20Permit("DAO Token") {
        _mint(msg.sender, 10_000_000 * 10**decimals());
    }

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override(ERC20, ERC20Votes) {
        super._afterTokenTransfer(from, to, amount);
    }

    function _mint(address to, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._mint(to, amount);
    }

    function _burn(address account, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._burn(account, amount);
    }
}

ERC20Votes 是 OpenZeppelin 的核心扩展,它在每次转账后快照式地记录投票权。这意味着投票权是基于某个历史区块高度的余额快照,而不是实时余额,防止闪电贷等攻击。

一句话总结:治理代币不是简单的 ERC-20——ERC20Votes 用检查点(checkpoints)机制把余额历史化,让每个提案都能在固定的区块高度上计算投票权,抵御了闪电贷操纵。


2. Snapshot:链下投票的零成本利器

2.1 为什么需要链下投票

链上投票每一步操作都要消耗 gas,一次全员投票可能花费数千美元。Snapshot 的解决方案是:投票签名放在链下,只在链上执行最终结果。

流程:
  1. 提案人在 Snapshot 上创建提案(链下,0 gas)
  2. 持币者用钱包签名投票(链下,0 gas)
  3. Snapshot 服务器聚合签名结果
  4. 结果由多签或 Governor 合约在链上执行(一步链上交易)

2.2 Snapshot 的投票策略

Snapshot 支持多种投票策略(strategy):

策略说明
erc20-balance-of按 ERC-20 余额计票(最基础)
erc20-balance-of-delegation考虑委托关系的余额
multichain跨链余额汇总(如 ETH + BSC 上的同一代币)
delegation仅计被委托的投票权
contract-call自定义合约查询函数

2.3 Snapshot 的局限

优势:
  - 零 gas 投票
  - 支持复杂策略和跨链计票
  - 丰富的 UI 和社区工具

局限:
  - 依赖 Snapshot 的中心化服务器存储投票数据
  - 签名可被伪造(虽然通常由多签 Guardian 审核)
  - 执行层仍需链上多签,存在信任假设

一句话总结:Snapshot 用"签名即投票"的链下模式解决了大规模治理的成本问题,但执行环节的信任假设意味着它适合轻量级决策,不适合资金密集型操作的最终执行。


3. Tally 与 Governor Bravo:链上治理的执行引擎

3.1 Compound Governor Bravo 架构

Governor Bravo 是目前最广泛使用的链上治理框架。它将提案生命周期编码为有限状态机:

提案生命周期:
  Pending ──(votingDelay 区块)──► Active ──(votingPeriod 区块)──►
  Succeeded ──(timelock.delay)──► Queued ──(执行窗口)──► Executed
                                   │
                                   └─ Defeated / Canceled / Expired

3.2 Governor Bravo 核心合约

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

import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";

contract DAOGovernor is
    Governor,
    GovernorCountingSimple,
    GovernorVotes,
    GovernorVotesQuorumFraction,
    GovernorTimelockControl
{
    // votingDelay:提案创建后到开始投票的区块数(给社区讨论时间)
    // votingPeriod:投票开放的区块数
    constructor(
        IVotes _token,
        TimelockController _timelock,
        string memory _name
    )
        Governor(_name)
        GovernorVotes(_token)
        GovernorVotesQuorumFraction(4)  // 4% 的流通量作为最低票数
        GovernorTimelockControl(_timelock)
    {}

    function votingDelay() public pure override returns (uint256) {
        return 1; // 约 12 秒(1 个区块)
    }

    function votingPeriod() public pure override returns (uint256) {
        return 50400; // 约 7 天(按 12 秒/区块)
    }

    function proposalThreshold() public pure override returns (uint256) {
        return 10_000 * 10**18; // 至少持有 10,000 代币才能提案
    }

    // 以下函数是 GovernorTimelockControl 需要覆盖的内部函数
    function quorum(uint256 blockNumber)
        public
        view
        override(Governor, GovernorVotesQuorumFraction)
        returns (uint256)
    {
        return super.quorum(blockNumber);
    }

    function state(uint256 proposalId)
        public
        view
        override(Governor, GovernorTimelockControl)
        returns (ProposalState)
    {
        return super.state(proposalId);
    }

    function propose(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        string memory description
    ) public override(Governor) returns (uint256) {
        return super.propose(targets, values, calldatas, description);
    }

    function _execute(
        uint256 proposalId,
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) internal override(Governor, GovernorTimelockControl) {
        super._execute(proposalId, targets, values, calldatas, descriptionHash);
    }

    function _cancel(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) internal override(Governor, GovernorTimelockControl) returns (uint256) {
        return super._cancel(targets, values, calldatas, descriptionHash);
    }

    function _executor()
        internal
        view
        override(Governor, GovernorTimelockControl)
        returns (address)
    {
        return super._executor();
    }
}

关键参数含义:

  • votingDelay:提案创建后到开始投票的冷却时间,防止闪电提案
  • votingPeriod:投票窗口期长度
  • proposalThreshold:提案人需持有的最低代币量
  • quorumFraction:通过所需的最低票数占总流通量的比例

3.3 Tally 的角色

Tally 是 Governor Bravo 的 Web 前端。它:

  • 读取链上提案数据并可视化展示
  • 提供投票界面(构造 castVote 交易)
  • 提供委托(delegate)和撤销委托的 UI
  • 追踪提案执行状态

一句话总结:Governor Bravo 把提案生命周期编码为限时状态机,Tally 降低了用户的交互门槛——但真正的安全在于 Timelock 的缓冲期和参数设定的合理性。


4. 委托投票与进阶投票机制

4.1 委托投票(Delegation)

大多数持币者并不关心日常治理细节。委托投票机制允许他们将投票权代理给活跃的治理参与者。

// 委托投票的核心逻辑
function delegate(address delegatee) external {
    _delegate(msg.sender, delegatee);
}

function _delegate(address delegator, address delegatee) internal {
    address currentDelegate = delegates(delegator);
    uint256 delegatorBalance = balanceOf(delegator);

    _delegates[delegator] = delegatee;
    emit DelegateChanged(delegator, currentDelegate, delegatee);

    // 把原代表的投票权转移给新的代表
    _moveDelegates(currentDelegate, delegatee, delegatorBalance);
}

4.2 二次方投票(Quadratic Voting)

普通加权投票的问题是:拥有 100 个代币的人,其影响力是拥有 1 个代币的人的 100 倍。二次方投票试图缓和这种不平等:

票数 = sqrt(投入代币数)

投入 1  token → 获得 1 票
投入 4  token → 获得 2 票
投入 9  token → 获得 3 票
投入 100 token → 获得 10 票

二次方投票的 Solidity 近似实现:

contract QuadraticVoting {
    // BPS = basis point,10000 = 100%
    uint256 public constant MAX_BPS = 10000;

    // 计算二次方根(牛顿迭代法近似)
    function sqrt(uint256 x) internal pure returns (uint256 y) {
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    function castQuadraticVote(
        uint256 proposalId,
        uint256 tokensToSpend,
        bool support
    ) external {
        require(
            governanceToken.transferFrom(msg.sender, address(this), tokensToSpend),
            "Transfer failed"
        );
        uint256 votes = sqrt(tokensToSpend);
        _castVote(proposalId, msg.sender, votes, support);
    }
}

一句话总结:委托投票让治理民主化到了"参与即可委托"的程度,二次方投票则尝试用经济学公式稀释巨鲸的话语权——但后者在链上难以完全实现(需要防止 Sybil 攻击)。


5. Timelock 与 Gnosis Safe:资金安全的最后一道防线

5.1 Timelock 延迟执行

Governor Bravo 不直接执行提案,而是把执行权委托给 Timelock 合约。提案通过后需要排队(queue),在延迟时间(通常 2 天到 2 周)后才能执行。

// OpenZeppelin TimelockController 核心逻辑
contract TimelockController {
    uint256 public minDelay;

    function schedule(
        address target,
        uint256 value,
        bytes calldata data,
        bytes32 predecessor,
        bytes32 salt,
        uint256 delay
    ) external onlyRole(PROPOSER_ROLE) {
        require(delay >= minDelay, "Delay too short");
        bytes32 id = hashOperation(target, value, data, predecessor, salt);
        _timestamps[id] = block.timestamp + delay;
    }

    function execute(
        address target,
        uint256 value,
        bytes calldata data,
        bytes32 predecessor,
        bytes32 salt
    ) external payable onlyRole(EXECUTOR_ROLE) {
        bytes32 id = hashOperation(target, value, data, predecessor, salt);
        require(
            _timestamps[id] <= block.timestamp && _timestamps[id] > 1,
            "Not ready"
        );
        _timestamps[id] = 1; // 标记为已执行
        (bool success, ) = target.call{value: value}(data);
        require(success, "Execution failed");
    }
}

5.2 Gnosis Safe 多签托管

DAO 的 Treasury 通常由 Gnosis Safe(现 Safe)多签钱包托管。常见的配置是:

Gnosis Safe 配置示例:
  - 多签持有者:7 人(核心贡献者、投资人代表、社区代表)
  - 门槛:4/7(需要至少 4 人签名才能执行)
  - 多签地址 → 控制 Treasury 的资金流出
  - Timelock 的 PROPOSER_ROLE 可设置为 Governor 合约

Gnosis Safe 的一个关键特性是模块化:可以通过模块合约让 Governor Bravo 自动触发 Treasury 操作,而不需要每次人工多签。

一句话总结:Timelock 的延迟执行和 Gnosis Safe 的多签机制,构成了 DAO 资金安全的"双保险"——即使治理合约被攻破,攻击者也需要在延迟窗口内突破多签防线。


6. 治理攻击与防御

6.1 常见攻击向量

攻击类型描述防御措施
闪电贷攻击借大量代币投票后立即归还使用投票快照(checkpoints),投票权基于历史区块
巨鲸操纵大户砸盘或买断投票权二次方投票 + 代币锁定机制
治理提案挟持提案含恶意 calldataTimelock 延迟 + 社区审查窗口
电梯攻击利用提案执行顺序漏洞predecessor 机制,强制依赖顺序
投票冷漠大多数持币者不投票委托机制 + 投票激励

6.2 治理攻击的典型案例

Beanstalk 治理攻击(2022):
  攻击者通过闪电贷获得大量治理代币
  → 在前一个区块买入代币(快照点之后)
  → 提案通过,耗尽 Treasury
  
教训:
  - 提案阈值不能太低
  - votingDelay 必须足够长,让社区有时间审查危险提案
  - 关键提案应要求更高的 quorums

获取快照(checkpoints)机制是防御闪电贷的核心:

// ERC20Votes 的检查点机制
function getPastVotes(address account, uint256 blockNumber)
    public
    view
    returns (uint256)
{
    require(blockNumber < block.number, "Not determined");
    return _checkpointsLookup(_checkpoints[account], blockNumber);
}

投票权不是"现在有多少代币",而是"在提案创建的前一个区块有多少代币"。闪电贷无法跨区块回溯。

一句话总结:治理安全不是单点防御——检查点抗闪电贷、Timelock 留反应时间、多签做最终把关,三者缺一不可。


7. 总结

  1. DAO 架构:Governor(投票)→ Timelock(延迟)→ Treasury(资金),三层分工清晰
  2. 链下 vs 链上:Snapshot 降成本,Governor Bravo 保执行,两者常组合使用
  3. 委托与二次方:委托扩大参与面,二次方削弱巨鲸——但都需要精心设计的激励
  4. 安全防线:checkpoints + Timelock + Gnosis Safe 构成了 DAO 的纵深防御体系

相关阅读


延伸阅读


以下是一个完整的 DAO 治理合约(Governor Bravo + Timelock + Governance Token)的 Solidity 实现,可直接用于测试网部署:

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

import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
import "@openzeppelin/contracts/governance/TimelockController.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

// ── 治理代币 ──
contract GovToken is ERC20, ERC20Permit, ERC20Votes {
    constructor() ERC20("DAO Gov Token", "DGT") ERC20Permit("DAO Gov Token") {
        _mint(msg.sender, 10_000_000 * 10 ** decimals());
    }

    function _afterTokenTransfer(address from, address to, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._afterTokenTransfer(from, to, amount);
    }

    function _mint(address to, uint256 amount) internal override(ERC20, ERC20Votes) {
        super._mint(to, amount);
    }

    function _burn(address account, uint256 amount) internal override(ERC20, ERC20Votes) {
        super._burn(account, amount);
    }
}

// ── Governor Bravo 实现 ──
contract DAOBravoGovernor is
    Governor,
    GovernorCountingSimple,
    GovernorVotes,
    GovernorVotesQuorumFraction,
    GovernorTimelockControl
{
    uint256 private _votingDelay;
    uint256 private _votingPeriod;
    uint256 private _proposalThreshold;

    constructor(
        string memory name,
        IVotes token,
        TimelockController timelock,
        uint256 votingDelay_,
        uint256 votingPeriod_,
        uint256 proposalThreshold_,
        uint256 quorumFraction_
    )
        Governor(name)
        GovernorVotes(token)
        GovernorVotesQuorumFraction(quorumFraction_)
        GovernorTimelockControl(timelock)
    {
        _votingDelay = votingDelay_;
        _votingPeriod = votingPeriod_;
        _proposalThreshold = proposalThreshold_;
    }

    function votingDelay() public view override returns (uint256) {
        return _votingDelay;
    }

    function votingPeriod() public view override returns (uint256) {
        return _votingPeriod;
    }

    function proposalThreshold() public view override returns (uint256) {
        return _proposalThreshold;
    }

    function quorum(uint256 blockNumber)
        public
        view
        override(Governor, GovernorVotesQuorumFraction)
        returns (uint256)
    {
        return super.quorum(blockNumber);
    }

    function state(uint256 proposalId)
        public
        view
        override(Governor, GovernorTimelockControl)
        returns (ProposalState)
    {
        return super.state(proposalId);
    }

    function propose(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        string memory description
    ) public override(Governor) returns (uint256) {
        return super.propose(targets, values, calldatas, description);
    }

    function execute(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) public payable override(Governor) returns (uint256) {
        return super.execute(targets, values, calldatas, descriptionHash);
    }

    function _execute(
        uint256 proposalId,
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) internal override(Governor, GovernorTimelockControl) {
        super._execute(proposalId, targets, values, calldatas, descriptionHash);
    }

    function _cancel(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) internal override(Governor, GovernorTimelockControl) returns (uint256) {
        return super._cancel(targets, values, calldatas, descriptionHash);
    }

    function _executor()
        internal
        view
        override(Governor, GovernorTimelockControl)
        returns (address)
    {
        return super._executor();
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(Governor, GovernorTimelockControl)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

// ── 部署脚本说明 ──
// 1. 部署 GovToken
// 2. 部署 TimelockController(2 days, [proposers], [executors], admin)
//    - proposers: [Governor 合约地址](Governor 创建后 update)
//    - executors: [address(0)](任何人可执行)
// 3. 部署 DAOBravoGovernor(name, token, timelock, votingDelay, votingPeriod, threshold, quorum)
// 4. 将 Timelock 的 PROPOSER_ROLE 授予 Governor 合约
// 5. 将资金转入 Timelock 合约作为 DAO Treasury

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「blockchain」更多文章

  1. DePIN 去中心化物理基础设施网络
  2. DeFi 衍生品:期权、永续合约与合成资产
  3. 智能合约形式化验证:Certora 与 K 框架