The right to vote is a fundamental right for the citizens of democracies around the world. It is pertinent to ensuring that citizens have a say in the selection of people who represent them or solving of issues that impact them. In the days after the American independence, voting usually took place via viva voce or by voice vote. Later in 1634, Massachusetts became the first state to elect its governor using paper ballots.
For many years, democracies worldwide stuck with paper ballots and later moved on to electronic voting machines. These machines are not tamper-proof despite system checks, safeguard procedures, and election protocols. Critics believe that the proprietary code by which the electronic voting machines operate can be manipulated. As a result, governments around the world have been exploring blockchain as a medium to make general elections tamper-proof and transparent in an effort to implement a system where everyone trusts data and counterfeiting is not possible.
Why blockchain-based e-voting?
In comparison to conventional voting methods, e-voting has enhanced the efficiency and the integrity of the process. Because of its flexibility, simplicity of use, and affordable costs compared to general elections, electronic voting is widely utilized in various ways during elections.
Despite this, existing electronic voting methods face the risks of running into over-authority and manipulated details, limiting fundamental fairness, privacy, secrecy, anonymity, and transparency in the voting process. Since e-voting procedures are centralized and licensed by the critical authority that controls, measures, and monitors the process in an electronic voting system, this is a problem that might hamper a transparent voting process. Recent controversies in modern democracies such as USA and India amplify this argument and prove it true.
It is essential to ensure that assurance in voting does not diminish. In this article, we will try to leverage blockchain to fix shortcomings in the voting method used in modern elections and make the polling mechanism clear and accessible to stop illegal voting, and strengthen the data
protection to ensure a transparent outcome of the polling process.
Because of the distributed structure of the blockchain, a smart contract-based electronic voting system reduces the risks involved with electronic voting and allows for the process to be tamper-proof. Read more about Blockchain and Smart Contracts here.
Case Study
In the given case study we will be taking the general election process in India as a reference and deploying smart contracts around that. We will also be creating a web front-end to interact with the contracts with an interface to see the outcome of results as well.
Essential Requirements
Voters must have a national ID such as an Aadhaar number to be a valid citizen who is eligible to vote.
Who can vote
As per the Indian Constitution, all Indian citizens above the age of 18 years who have registered themselves as voters are eligible to vote. These individuals can vote in national, state, district, as well as local government body elections.
Every voter is allowed one vote only.
A voter can vote at the constituency where they are registered. All voter-related information such as age, state, and constituency code is associated with the Aadhaar number.
Who cannot vote
If the voter ID i.e., the Adhaar ID does not exist in the contract list updated by the election commission.
When the voter’s constituency code does not match with ongoing election constituencies.
If the voter has already casted their vote once in their constituency.
The Voting Process
Login to the election commission website via your Aadhar number. It will provide you an OTP.
If the Adhaar does not exist in the contract i.e., the voter list and the voter's constituency code match with the ongoing election, it will show up in the election commission dashboard. Else the voters are not allowed to vote. If the election process is still going on, it will prompt you with the option to vote.
Click Vote -> Select Candidate -> Done.
Voters are not allowed to vote/update-vote to different candidates again.
The final candidates list with the vote count will be displayed after the election voting process
is completed.
Smart contracts for e-voting.
Now that we have defined all the assumptions, requirements, processes and constraints. Let's get started with smart contracts. Here's the proposed flow diagram based on the above assumptions, requirements, and process:
Entities
In the process of election, there are three main parties involved, i.e., the Voters, Candidates, and Election Commission. We will start by creating a contract named Ballot and defining key entities in it. Solidity allows user to create their own data type in the form of structure. Enter the following code snippet into your console to continue:
pragma solidity >=0.4.25 <0.9.0;
contract Ballot {}
Voter
Each voter has a unique Adhaar number. as their primary identifier along with associated attributes such as name, age, state, and constituency code. Enter the following code snippet into your console to continue:
struct Voter {
uint256 aadharNumber;
string name;
uint8 age;
uint8 stateCode;
uint8 constituencyCode;
bool isAlive;
uint256 votedTo;
}
Candidate
Candidates are the key entities in the process of the election. These candidates either belong to a political party or have their personal symbols. Candidates have to file for the election. Hence each candidate in the constituency will have a unique nomination number. Use the following code snippet to continue:
struct Candidate {
string name;
string partyShortcut;
string partyFlag;
uint256 voteCount;
uint256 nominationNo;
uint8 stateCode;
uint8 constituencyCode;
}
Election Commission
The election commission is the creator of the contracts and has permissions to update the voters and candidates list and also to set the start and end times for the vote. There will generally be a list of addresses that are used to manage the entire election process. However, for our case study, we are considering a single address with admin authorities. This address is a state variable which includes the Ballot contract.
With the key entities in place, we will declare the voter and candidate as mapping to keep the list of records of voter and candidates as the key value pair, where the key is the Adhaar number and the value is the voter object. This ensures that for each key value (Adhaar number), we only have one voter record and the same goes for candidates with a unique nomination ID. Enter the code given below in your console:
pragma solidity >=0.4.25 <0.9.0;
contract Ballot {
struct Voter {
uint256 aadharNumber;
string name;
uint8 age;
uint8 stateCode;
uint8 constituencyCode;
bool isAlive;
uint256 votedTo;
}
struct Candidate {
string name;
string partyShortcut;
string partyFlag;
uint256 voteCount;
uint256 nominationNo;
uint8 stateCode;
uint8 constituencyCode;
}
address electionCommision;
uint256 private votingStartTime;
uint256 private votingEndTime;
mapping(uint256 => Voter) internal voter;
mapping(uint256 => Candidate) internal candidate;
}
The life cycle of a voter on the election commission website will be as follows:
Step 1: The voter lands on the election commission website and will receive two options to initiate his request. They can either see the result of the already conducted election(Step 8) or log in using their Aadhaar number if the elections are still ongoing. In this case, their access to the results is denied and they move to Step 7. If the user is a valid registered voter, then they will move to Step 2. For a voter to be validated, the Aadhaar number of the voter should be found in the voter mapping along with the Aadhar being the key and the voter's age should be greater than 18 and they must be alive. Enter the following code into your console to test this:
function isVoterEligible(uint256 voterAadharNumber)
public
view
returns (bool voterEligible_)
{
Voter storage voter_ = voter[voterAadharNumber];
if (voter_.age >= 18 && voter_.isAlive) voterEligible_ = true;
}
Step 2: Since the voter is a valid eligible voter, the ID of the voter will be presented based on their constituency along with the list of candidates to vote for. As voters opt to vote for a candidate, we move to Step 3 as shown below:
function getCandidateList(uint256 voterAadharNumber)
public
view
returns (Candidate[] memory)
{
Voter storage voter_ = voter[voterAadharNumber];
uint256 _politicianOfMyConstituencyLength = 0;
for (uint256 i = 0; i < candidates.length; i++) {
if (
voter_.stateCode == candidates[i].stateCode &&
voter_.constituencyCode == candidates[i].constituencyCode
) _politicianOfMyConstituencyLength++;
}
Candidate[] memory cc = new Candidate[](
_politicianOfMyConstituencyLength
);
uint256 _indx = 0;
for (uint256 i = 0; i < candidates.length; i++) {
if (
voter_.stateCode == candidates[i].stateCode &&
voter_.constituencyCode == candidates[i].constituencyCode
) {
cc[_indx] = Candidate({
name: candidates[i].name,
partyShortcut: candidates[i].partyShortcut,
partyFlag: candidates[i].partyFlag,
voteCount: 0,
nominationNo: candidates[i].nominationNo,
stateCode: candidates[i].stateCode,
constituencyCode: candidates[i].constituencyCode
});
_indx++;
}
}
return cc;
}
Refer to the image given below for further reference:
Step 3: In this step, the voter initiates the vote. As the vote is initiated, Step 4 and Step 5 are validated. As these steps are validated, the user's vote is registered against the candidate, and the candidate's vote count is incremented. Use the following code snippet to proceed:
function vote(
uint256 candidateNominationNo,
uint256 voterAadharNumber,
uint256 currentTime_
)
public
areVotingLinesOpen(currentTime_)
isEligibleVote(voterAadharNumber, candidateNominationNo)
{
voter[voterAadharNumber].voted = true;
voter[voterAadharNumber].votedTo = candidateNominationNo;
for (uint256 i = 0; i < candidates.length; i++) {
if (candidates[i].nominationNo == candidateNominationNo) {
candidates[i].voteCount++;
break;
}
}
}
Your results should match the image given below:
Step 4: Before the actual vote is registered, the contract checks if voting lines for the election are open. Once validated, the flow moves to step 5 else it moves to Step 6 as exhibited below:
modifier areVotingLinesOpen(uint256 currentTime_) {
require(currentTime_ >= votingStartTime);
require(currentTime_ <= votingEndTime);
_;
}
Step 5: In this step, several conditions are verified such as, if the voter's age is greater than 18, if the voter has already voted, and does the candidate the voter has initiated the vote for belongs to the same constituency as the voter. These checks are done through a functional modifier. Run the following code:
modifier isEligibleVote(uint256 voterAadhar_, uint256 candidateAadhar_) {
Voter storage voter_ = voter[voterAadhar_];
Candidate storage politician_ = candidate[candidateAadhar_];
require(voter_.age >= 18);
require(voter_.isAlive);
require(!voter_.voted);
require(
(politician_.stateCode == voter_.stateCode &&
politician_.constituencyCode == voter_.constituencyCode)
);
_;
}
Step 6: This step is satisfied if the voting access is denied.
Step 7: This step is satisfied if the voter can't access the result as the elections have not ended yet.
Step8: As the election process is completed, anyone can access the result from the website as shown below:
Advantages of e-voting through blockchain
Here are the advantages of conducting e-voting via blockchain:
Enhanced security as voting takes place over secure communication channels.
Low cost of setup as only the internet connection cost is required to vote across all the available e-voting platforms.
Accurate results and speed in the vote count.
Fraud prevention due to less human intervention at the polling stations.
Disadvantages of e-voting through blockchain
Here are the disadvantages of conducting e-voting via blockchain:
Internet access is not available to everyone. In fact, in most developing nations around the world, majority of the people will be unable to afford internet facilities. There could also be issues as many people will not know how to use and access the web.
When voting via the blockchain, the voter has to log in by providing their personal and ID details, which can result in a “Voter Anonymity” issue.
Conclusion
We started with blockchain and the underlying mechanism of how it works and wrote our first smart contract and a case study around electronic voting using blockchain here. The blockchain along with the smart contracts provides a platform for the development of safer, cheaper, secure, more transparent, and easy-to-use e-voting systems. Due to its consistency and widespread use along with the provision of smart contracts logic, Ethereum and its network is one of the most suitable platforms for e-voting via the blockchain.
You can find the Source Code in the link.
What's next?
In the next article, we will go through the case study of blockchain in supply chain management of critical vaccines.
This article is part of Research & Development work being done by Pushkar Kumar, Suresh konakanchi, and Ruchika Gupta. We will be covering a series of articles along with open source projects around blockchain, smart contracts, and web3 in general. Here is the list of all the articles that you can follow to start with Blockchain and write your first contract.
