导语:从公司到 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),投票权基于历史区块 |
| 巨鲸操纵 | 大户砸盘或买断投票权 | 二次方投票 + 代币锁定机制 |
| 治理提案挟持 | 提案含恶意 calldata | Timelock 延迟 + 社区审查窗口 |
| 电梯攻击 | 利用提案执行顺序漏洞 | 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. 总结
- DAO 架构:Governor(投票)→ Timelock(延迟)→ Treasury(资金),三层分工清晰
- 链下 vs 链上:Snapshot 降成本,Governor Bravo 保执行,两者常组合使用
- 委托与二次方:委托扩大参与面,二次方削弱巨鲸——但都需要精心设计的激励
- 安全防线: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
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。