In this smart contract, we will implement a voting process along with delegation. We'll use Solidity as a programming language, and Metamask for the deployment and testing. All this will be done using Binance IDE.
In this section we will briefly explain the background knowledge to make you better understand the smart contract.
- Binance IDE
- Metamask (connected to BSC Binance Smart Chain)
A voting process along with delegation smart contract is written in solidity language as it is an object-oriented, high-level programming language for implementing smart contracts. It was introduced in 2014. Smart contracts are programs that govern the behavior of accounts within the Ethereum state. Solidity was influenced by C++, Python, and JavaScript and is designed to target the Ethereum Virtual Machine (EVM). Now, it is the most commonly used programming language for Blockchain.
Before moving on, we will briefly explain the basic terms, data types, and definitions used in this smart contract for the better understanding of the audience.
-
Smart Contract- smart contracts are the lines of the code that are stored on Blockchain and execute when predetermined terms and conditions are met. A contract is the fundamental building block of Ethereum applications — all variables and functions belong to a contract, and this will be the starting point of all your projects.
-
function- Like other programming languages, solidity also uses function. A function is a block of code which only runs when it is called. You can pass data, known as parameters, into a function. Functions are used to perform certain actions, and they are important for reusing code: Define the code once, and use it many times.
-
All solidity source code should start with a "version pragma" — a declaration of the version of the Solidity compiler this code should use. This is to prevent issues with future compiler versions potentially introducing changes that would break your code. For the scope of this smart contract, we'll compile our smart contracts with any compiler version in the range of 0.4.22 (inclusive) to 0.7.0 (exclusive). It looks like this: pragma solidity >=0.4.22 <0.7.0;
In this section, we will implement and discuss in detail, a smart contract for the voting named as Ballot. The figure below shows the functions and structs used in this contract for different purposes such as to gives right to vote, summon winner name etc.
function giveRightToVote(address voter) public {
require(
msg.sender == chairperson,
"Only chairperson can give right to vote."
);
require(
!voters[voter].voted,
"The voter already voted."
);
require(voters[voter].weight == 0);
voters[voter].weight = 1;
}
2.1 First of all structs with multiple properties are declared for both Voter and Proposal, that are going to be used by functions later.
1. struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
The 'struct Voter' has four values with different data types and different purpose, 'uint weight' is used to accumulate the weight by the delegation; 'bool voted' is used to check either the voter has already voted or going to vote for the first time; 'address delegate' shows the person delegated to, and 'uint vote'is used as an index of the voted proposal.
2. struct Proposal {
// If you can limit the length to a certain number of bytes,
// always use one of bytes1 to bytes32 because they are much cheaper
bytes32 name; // short name (up to 32 bytes)
uint voteCount; // number of accumulated votes
}
2.3 Address and array are declared, and address is mapped to the Voter, and a dynamic array has been declared to store the proposal.
3. address public chairperson;
mapping(address => Voter) public voters;
Proposal[] public proposals;
2.4 Constructor is a special method which gets invoked whenever an instance of a class is created – that is correct for object-oriented programming languages. However, in Solidity, it's different; Solidity supports declaring constructor inside a smart contract and it is invoked—only once—while deploying it.
4. constructor(bytes32[] memory proposalNames) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
for (uint i = 0; i < proposalNames.length; i++) {
// 'Proposal({...})' creates a temporary
// Proposal object and 'proposals.push(...)'
// appends it to the end of 'proposals'.
proposals.push(Proposal({
name: proposalNames[i],
voteCount: 0
}));
}
}
2.5 Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.para voter address of voter.
5. function giveRightToVote(address voter) public {
require(
msg.sender == chairperson,
"Only chairperson can give right to vote."
);
require(
!voters[voter].voted,
"The voter already voted."
);
require(voters[voter].weight == 0);
voters[voter].weight = 1;
}
6. function delegate(address to) public {
Voter storage sender = voters[msg.sender];
require(!sender.voted, "You already voted.");
require(to != msg.sender, "Self-delegation is disallowed.");
while (voters[to].delegate != address(0)) {
to = voters[to].delegate;
// We found a loop in the delegation, not allowed.
require(to != msg.sender, "Found loop in delegation.");
}
sender.voted = true;
sender.delegate = to;
Voter storage delegate_ = voters[to];
if (delegate_.voted) {
// If the delegate already voted,
// directly add to the number of votes
proposals[delegate_.vote].voteCount += sender.weight;
} else {
// If the delegate did not vote yet,
// add to her weight.
delegate_.weight += sender.weight;
}
}
2.7 Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.param proposal index of proposal in the proposals array
7. function vote(uint proposal) public {
Voter storage sender = voters[msg.sender];
require(sender.weight != 0, "Has no right to vote");
require(!sender.voted, "Already voted.");
sender.voted = true;
sender.vote = proposal;
// If 'proposal' is out of the range of the array,
// this will throw automatically and revert all
// changes.
proposals[proposal].voteCount += sender.weight;
}
2.8 Computes the winning proposal taking all previous votes into account.return winningProposal_ index of winning proposal in the proposals array
8. function winningProposal() public view
returns (uint winningProposal_)
{
uint winningVoteCount = 0;
for (uint p = 0; p < proposals.length; p++) {
if (proposals[p].voteCount > winningVoteCount) {
winningVoteCount = proposals[p].voteCount;
winningProposal_ = p;
}
}
}
2.9 Calls winningProposal() function to get the index of the winner contained in the proposals array and then return winnerName_ the name of the winner
9. function winnerName() public view
returns (bytes32 winnerName_)
{
winnerName_ = proposals[winningProposal()].name;
}
