投票系统是区块链应用的经典案例，展示了如何利用智能合约实现透明、不可篡改的投票机制。本文通过完整的投票系统实现，演示Solidity的实际开发流程和最佳实践。

Voting System

一、什么是投票系统

一、1 基本概念

投票系统是使用智能合约实现的去中心化投票机制，可以用于选举、提案表决、DAO治理等场景。区块链的透明性和不可篡改性使其成为实现公平投票的理想平台。

二、2 投票系统的特点

1
透明性：
  • 所有投票公开可查
  • 投票结果不可篡改
  • 实时统计
  • 可验证性
1
去中心化：
  • 无需中心化机构
  • 自动执行规则
  • 降低信任成本
  • 提高公信力
1
自动化：
  • 自动统计结果
  • 自动执行决策
  • 减少人工干预
  • 提高效率

二、如何设计投票系统

三、1 核心功能

1
提案管理：
  • 创建提案
  • 设置投票期限
  • 提案状态管理
  • 提案信息查询
1
投票功能：
  • 支持/反对投票
  • 防止重复投票
  • 投票记录
1
结果统计：
  • 自动计算票数
  • 判断投票结果
  • 执行决策
  • 结果查询

四、2 数据结构

1
提案结构：
1
2
3
4
5
6
7
8
9
10
11
12
13
struct Proposal {
    string description;
    uint256 voteCount;
    uint256 deadline;
    bool executed;
    mapping(address => bool) hasVoted;
}
`投票记录：`solidity
struct Vote {
    address voter;
    bool support;
    uint256 timestamp;
}

三、如何实现投票系统

五、1 完整实现

1
2
投票合约：
pragma solidity ^0.8.0;
1
contract VotingSystem {
}

}

1
2
3
4
address public chairperson;
Proposal[] public proposals;
mapping(uint256 => Vote[]) public proposalVotes;
mapping(address => bool) public voters;
1
2
3
event ProposalCreated(uint256 indexed proposalId, string description, uint256 deadline);
event VoteCast(uint256 indexed proposalId, address indexed voter, bool support);
event ProposalExecuted(uint256 indexed proposalId, bool result);
1
2
modifier onlyChairperson() {
    require(msg.sender == chairperson, "Not chairperson");
    _;
}

1
2
modifier onlyVoter() {
    require(voters[msg.sender], "Not a voter");
    _;
}

1
2
3
4
constructor(address[] memory _voters) {
    chairperson = msg.sender;
    for (uint256 i = 0; i < _voters.length; i++) {
        voters[_voters[i]] = true;
    }

1
2
function createProposal(string memory description, uint256 duration) 
    public 
    onlyChairperson 

1
returns (uint256) 
{

1
2
3
4
5
6
uint256 proposalId = proposals.length;
proposals.push();
Proposal storage proposal = proposals[proposalId];
proposal.description = description;
proposal.deadline = block.timestamp + duration;
proposal.executed = false;
1
2
emit ProposalCreated(proposalId, description, proposal.deadline);
return proposalId;
}

1
2
3
function vote(uint256 proposalId, bool support) public onlyVoter {
    require(block.timestamp < proposal.deadline, "Proposal expired");
    require(!proposal.hasVoted[msg.sender], "Already voted");
1
2
3
proposal.hasVoted[msg.sender] = true;
if (support) {
    proposal.voteCount++;
    }
    

1
2
3
4
5
proposalVotes[proposalId].push(Vote({
    voter: msg.sender,
    support: support,
    timestamp: block.timestamp
}));
1
emit VoteCast(proposalId, msg.sender, support);
}

1
function getProposal(uint256 proposalId) 
    view 

1
returns (string memory, uint256, uint256, bool) 
{

1
return (
        proposal.description,
        proposal.voteCount,
        proposal.deadline,
        proposal.executed
    );
}

1
2
function getVoteCount(uint256 proposalId) public view returns (uint256) {
    return proposals[proposalId].voteCount;
}

1
2
function getVotes(uint256 proposalId) public view returns (Vote[] memory) {
    return proposalVotes[proposalId];
}

1
2
3
function executeProposal(uint256 proposalId) public {
    require(block.timestamp >= proposal.deadline, "Proposal not ended");
    require(!proposal.executed, "Already executed");
1
2
bool result = proposal.voteCount > 0;
proposal.executed = true;
1
emit ProposalExecuted(proposalId, result);
1
2
3
// 根据结果执行相应操作
if (result) {
    // 执行通过的操作
    }

1
2
function addVoter(address voter) public onlyChairperson {
    voters[voter] = true;
}

1
2
function removeVoter(address voter) public onlyChairperson {
    voters[voter] = false;
}

1
2
3
4
5
6
7

### 六、2 使用示例

部署合约：
```javascript
```javascript
const voters = [
'0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
'0x8ba1f109551bD432803012645Hac136c22C9e8c',
'0x1234567890123456789012345678901234567890'

];

1
2
3
const VotingSystem = await ethers.getContractFactory("VotingSystem");
const voting = await VotingSystem.deploy(voters);
await voting.deployed();

`创建提案：```javascript

1
const tx = await voting.createProposal(
"是否增加开发预算？",
7 * 24 * 60 * 60  // 7天

);

1
await tx.wait();

`投票：```javascript

1
2
await voting.vote(0, true);  // 支持
await voting.vote(0, false); // 反对

`查询结果：```javascript

1
2
const voteCount = await voting.getVoteCount(0);
console.log('支持票数:', voteCount.toString());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

## 四、应用场景

### 七、1 DAO治理

项目治理：
- 功能开发决策
- 资金使用投票
- 参数调整
- 社区提案

实际案例：
- MakerDAO治理
- Uniswap治理
- Compound治理
- 各种DeFi协议

### 八、2 企业投票

股东投票：
- 重大决策
- 董事会选举
- 分红方案
- 合并收购

员工投票：
- 福利方案
- 工作制度
- 活动安排
- 内部决策

### 九、3 社区投票

开源项目：
- 功能优先级
- 技术选型
- 版本发布
- 社区规则

在线社区：
- 内容审核
- 规则制定
- 活动策划
- 社区管理

## 五、功能扩展

### 十、1 加权投票

基于代币：
mapping(address => uint256) public tokenBalances;

function vote(uint256 proposalId, bool support, uint256 weight) public {
    require(tokenBalances[msg.sender] >= weight, "Insufficient tokens");
    
        proposal.voteCount += weight;
    }

十一、2 委托投票

1
2
投票委托：
mapping(address => address) public delegates;
1
2
function delegate(address to) public {
    delegates[msg.sender] = to;

}

1
2
3
4
function vote(uint256 proposalId, bool support) public {
    address voter = delegates[msg.sender];
    if (voter == address(0)) {
        voter = msg.sender;
}

1
// 使用voter投票

}

1
2
3
4
5
6
7
8
9
10

### 十二、3 时间锁

延迟执行：
mapping(uint256 => uint256) public executionTime;

    require(block.timestamp >= executionTime[proposalId], "Still in timelock");
    // 执行提案
}

六、最佳实践

十三、1 安全考虑

1
防止重复投票：

时间验证：solidity
权限控制：solidity
_;
}

1
2
3
4
5
6
7
8

### 十四、2 Gas优化

批量操作：
function batchAddVoters(address[] memory _voters) public onlyChairperson {
    }
`事件记录：`solidity
// 使用事件替代存储历史

十五、3 用户体验

1
2
清晰接口：
function getProposalInfo(uint256 proposalId) 
view 

1
returns (
    string memory description,
    uint256 voteCount,
    uint256 deadline,
    bool executed,
    bool canVote
)

{

1
2
3
canVote = block.timestamp < proposal.deadline && 
          !proposal.hasVoted[msg.sender] && 
          voters[msg.sender];
    proposal.executed,
    canVote
);

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

## 七、测试

### 十六、1 单元测试

测试脚本：
describe("VotingSystem", function() {
    it("Should create proposal", async function() {
        const tx = await voting.createProposal("Test", 86400);
        const proposal = await voting.getProposal(0);
        expect(proposal.description).to.equal("Test");
    });
    
    it("Should allow voting", async function() {
        await voting.vote(0, true);
        expect(voteCount).to.equal(1);
    });
    
    it("Should prevent double voting", async function() {
        await expect(voting.vote(0, false)).to.be.revertedWith("Already voted");
    });

八、总结

投票系统是展示Solidity实际应用的优秀案例。关键要点：

1
核心功能：
  • 提案管理
  • 投票机制
  • 结果统计
  • 自动执行
1
设计要点：
  • 时间控制
  • 权限管理
  • 结果透明
1
应用场景：
  • DAO治理
  • 企业投票
  • 社区决策
  • 各种表决场景

通过实现投票系统，可以深入理解智能合约的开发流程，掌握Solidity的实际应用，为开发更复杂的去中心化应用打下坚实基础。

本文标题： Solidity编程实战投票系

发布时间： 2023年02月01日 00:00

最后更新： 2025年12月30日 08:54

原始链接： https://haoxiang.eu.org/c3e11a52/

版权声明： 本文著作权归作者所有，均采用CC BY-NC-SA 4.0许可协议，转载请注明出处！

赏
× 喜欢就赞赏一下呗！
打赏二维码