Blockchain-based Voting Systems for Electoral Transparency

Blockchain Technology offers a tamper-proof and decentralized ledger that enhances electoral processes by ensuring transparency, verifiability, and immutability. In traditional voting systems, concerns such as fraud, manipulation, and a lack of auditability undermine trust. A blockchain-based voting system enables voters to cast ballots securely, with votes recorded immutably and publicly verifiable, without revealing individual choices, thereby promoting electoral integrity.

Prerequisites

Before starting, ensure you have:

Development Environment: Node.js (v14+), npm/yarn, and Hardhat or Truffle for Ethereum development.
Solidity Knowledge: Familiarity with Solidity (version 0.8.x recommended).
Ethereum Wallet: MetaMask for testing and deployment.
Testnet Access: Sepolia or Goerli testnet (use faucets for test ETH).
Privacy Tools: Basic hashing for commitments; for zk-proofs, install Circom and SnarkJS (optional for advanced setup).
IDE: Remix IDE (online) or VS Code with Solidity extensions.
Additional Libraries: OpenZeppelin Contracts for security (e.g., access control).

Install Dependencies:

npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

npm install @openzeppelin/contracts

# For zk-SNARKs (optional):

npm install snarkjs circomlib

Initialize a Hardhat Project:

npx hardhat init

Step 1: Design the Voting System

Core Components

Voter Registry: A list of eligible voters (e.g., addresses) to prevent double-voting.
Election Structure: Candidates, voting period (start/end timestamps), and vote tallies.
Voting Mechanism: Voters submit a commitment (hash of vote + secret) to maintain anonymity; later, reveal for verification if needed.
Tallying: Smart Contract counts votes post-election; anyone can query results.
Events: Log voter participation and results for transparency.
Access Control: Only registered voters during the active period; the owner manages elections.

Data Flow

Step 1: Admin registers voters and starts the election.

Step 2: Voter submits a blinded vote (commitment) on-chain.

Step 3: Post-election, voters can optionally reveal their secret to verify inclusion.

Step 4: Contract tallies commitments (or revealed votes) and emits results.

Step 5: Auditors verify the ledger for discrepancies.

For our example, an election with 3 candidates (A, B, C). Use Merkle Trees for efficient voter list management (via OpenZeppelin MerkleProof).

Architecture

On-Chain: Voter registry, commitments, tallies.
Off-Chain: Voter apps for generating commitments; optional reveal phase.
Privacy Enhancement: In advanced setups, use zk-proofs to prove vote validity without revelation.

Step 2: Implement the Smart Contract

We'll create a Solidity contract named VotingSystem.sol. This basic version uses commitments for semi-anonymity; extend with zk-SNARKs for full privacy.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";

import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

contract VotingSystem is Ownable {

struct Election {

string name;

uint256 startTime;

uint256 endTime;

bool isActive;

mapping(uint256 => uint256) candidateVotes; // Candidate ID => Vote count

bytes32[] commitments; // List of vote commitments

}

struct Voter {

bool hasVoted;

bytes32 commitment;

}

Election public currentElection;

mapping(address => Voter) public voters;

bytes32 public merkleRoot; // Root of voter Merkle tree

uint256 public candidateCount;

event ElectionStarted(string name, uint256 startTime, uint256 endTime);

event VoteCommitted(address voter, bytes32 commitment);

event ElectionEnded(uint256[] voteCounts);

event VoterRegistered(bytes32[] proof);

modifier onlyDuringElection() {

require(block.timestamp >= currentElection.startTime && block.timestamp <= currentElection.endTime, "Election not active");

}

modifier onlyRegisteredVoter(bytes32[] calldata proof) {

require(MerkleProof.verify(proof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "Not a registered voter");

}

constructor() {

candidateCount = 0;

}

// Admin: Set up election

function startElection(string memory _name, uint256 _startTime, uint256 _endTime, bytes32 _merkleRoot, uint256 _candidateCount) external onlyOwner {

require(_startTime > block.timestamp && _endTime > _startTime, "Invalid times");

require(currentElection.isActive == false, "Election already active");

currentElection = Election({

name: _name,

startTime: _startTime,

endTime: _endTime,

isActive: true

});

merkleRoot = _merkleRoot;

candidateCount = _candidateCount;

emit ElectionStarted(_name, _startTime, _endTime);

}

// Voter: Submit commitment (hash(vote + salt))

function commitVote(bytes32 _commitment, bytes32[] calldata proof) external onlyDuringElection onlyRegisteredVoter(proof) {

require(!voters[msg.sender].hasVoted, "Already voted");

voters[msg.sender].commitment = _commitment;

voters[msg.sender].hasVoted = true;

currentElection.commitments.push(_commitment);

emit VoteCommitted(msg.sender, _commitment);

}

// Admin: End election and tally (simplified; in reality, tally revealed votes or use zk)

function endElection() external onlyOwner {

require(block.timestamp > currentElection.endTime, "Election ongoing");

require(currentElection.isActive, "No active election");

// Placeholder tally: In production, process revelations or zk-proofs

// For demo, assume manual input or off-chain tally pushed on-chain

uint256[] memory voteCounts = new uint256[](candidateCount);

// Simulate tally logic here (e.g., loop through commitments if revealed)

currentElection.isActive = false;

emit ElectionEnded(voteCounts);

}

// Query results (post-election)

function getResults() external view returns (uint256[] memory) {

require(!currentElection.isActive, "Election ongoing");

uint256[] memory voteCounts = new uint256[](candidateCount);

// Fetch from mapping

for (uint256 i = 0; i < candidateCount; i++) {

voteCounts[i] = currentElection.candidateVotes[i];

}

return voteCounts;

}

// Voter: Reveal vote for verification (optional, post-election)

function revealVote(uint256 _candidateId, bytes32 _salt) external {

require(!currentElection.isActive, "Election ongoing");

bytes32 commitment = keccak256(abi.encodePacked(_candidateId, _salt));

require(commitment == voters[msg.sender].commitment, "Invalid reveal");

// Increment tally if verified

currentElection.candidateVotes[_candidateId]++;

}

Key Notes on Code

Anonymity: Commitments hide the vote; salt (random secret) prevents linkage. For full anonymity, you must replace with zk-SNARKs (e.g., prove "I voted for X without revealing X").
Voter Registry: You can use a Merkle tree for scalable proof of eligibility without storing all addresses on-chain.
Security: Inherits Ownable for admin control; add timelocks and multi-sig for production. Prevent front-running with the commit-reveal scheme.
Limitations: This is basic; revelations compromise some anonymity. Use libraries like Semaphore for signal-based anonymous voting.

Step 3: Deploy and Test the Contract

Deployment with Hardhat

Place VotingSystem.sol in contracts/.
Update hardhat.config.js for Sepolia:

require("@nomicfoundation/hardhat-toolbox");

module.exports = {

solidity: "0.8.19",

networks: {

sepolia: {

url: "https://sepolia.infura.io/v3/YOUR_INFURA_KEY",

accounts: ["YOUR_PRIVATE_KEY"]

}

};

Deploy Script (scripts/deploy.js):

const hre = require("hardhat");

async function main() {

const VotingSystem = await hre.ethers.getContractFactory("VotingSystem");

const votingSystem = await VotingSystem.deploy();

await votingSystem.waitForDeployment();

console.log("VotingSystem deployed to:", await votingSystem.getAddress());

}

main().catch((error) => {

console.error(error);

process.exitCode = 1;

});

Compile and Deploy:

npx hardhat compile

npx hardhat run scripts/deploy.js --network sepolia

Testing

Write tests in test/VotingSystem.test.js using Chai:

const { expect } = require("chai");

const { ethers } = require("hardhat");

describe("VotingSystem", function () {

let votingSystem, owner, voter1;

beforeEach(async function () {

VotingSystem = await ethers.getContractFactory("VotingSystem");

votingSystem = await VotingSystem.deploy();

[owner, voter1] = await ethers.getSigners();

});

it("Should start election", async function () {

// Mock Merkle root and proof

const merkleRoot = ethers.keccak256(ethers.toUtf8Bytes("mock"));

const proof = []; // Simplified

await votingSystem.startElection("Test Election", Math.floor(Date.now() / 1000) + 60, Math.floor(Date.now() / 1000) + 120, merkleRoot, 3);

expect(await votingSystem.merkleRoot()).to.equal(merkleRoot);

});

it("Should allow registered voter to commit", async function () {

// Setup election...

const commitment = ethers.keccak256(ethers.toUtf8Bytes("vote1"));

const proof = []; // Mock

await votingSystem.startElection("Test", 0, 9999999999, ethers.keccak256(ethers.toUtf8Bytes(voter1.address)), 3);

await votingSystem.connect(voter1).commitVote(commitment, proof);

expect(await votingSystem.voters(voter1.address)).to.have.property("hasVoted", true);

});

Run Tests: npx hardhat test and use Ganache for local testing; generate Merkle proofs with libraries like merkletreejs.

Step 4: Integrate with Frontend and External Systems

Frontend: Build a DApp with React and Ethers.js. Voters connect wallets, generate commitments (e.g., hash(candidateId + randomSalt)), and submit.

Example (Ethers.js):

import { ethers } from 'ethers';

const provider = new ethers.BrowserProvider(window.ethereum);

const signer = await provider.getSigner();

const contract = new ethers.Contract(contractAddress, ABI, signer);

// Generate commitment

const salt = ethers.keccak256(ethers.toUtf8Bytes(Math.random().toString()));

const commitment = ethers.keccak256(ethers.AbiCoder.defaultAbiCoder().encode(["uint256", "bytes32"], [candidateId, salt]));

// Submit (with Merkle proof)

const proof = []; // Compute from tree

await contract.commitVote(commitment, proof);

Voter App: Mobile/web app for offline commitment generation; integrate QR codes for verification.
Audit Tools: Use Etherscan for transaction transparency; build dashboards (e.g., with The Graph) for vote analytics.
Off-Chain Components: Voter registration via KYC (e.g., integrate with Civic); post-election reveals via secure channels.
Advanced Privacy: Use Circom to compile zk-circuits:

Define a circuit for “prove vote is valid”.
Generate proof off-chain.
Submit proof of the contract for verification.

Search This Blog

The Blockchain Brief