Ballot

Utility

0x56ce77217867...535147b44745

FrontierContract #306Exact Bytecode MatchEdit this contract

Deployed August 18, 2015 (11 years ago)Block 105,249

Delegated voting with a proposal count fixed at deployment

Frontier EraVerified Source

Context

Deployed in August 2015, three weeks after Frontier launched, and compiled with solc v0.1.1.

Key Facts

Deployer

0xdd38c6...3a0a51

Deployment Block

105,249

Deployment Date

Aug 18, 2015, 07:50 AM

Code Size

1.8 KB

Gas at Deploy

498,914

Deployment Transaction: 0xf8b93a50d22dbda2...36203afe8d267891

Description

The struct form of the Solidity Ballot example. Each address maps to a Voter record holding a weight, a voted flag, the chosen proposal and a delegate, and the proposals array is sized by the constructor argument. The deployer becomes chairperson, is given a weight of one, and is the only account that may call giveRightToVote. A voter either votes directly or delegates, and delegate walks the delegation chain to its end before moving the weight. winningProposal scans the tallies for the leader, but its loop advances the counter twice per iteration, once in the for header and once in the body, so it inspects only every second proposal.

Source Verified

Exact bytecode match(1,829 bytes)

Compiler: v0.1.1+

View verification proof

Heuristic Analysis

The following characteristics were detected through bytecode analysis and may not be accurate.

Detected Type: Utility

Frontier Era

The initial release of Ethereum. A bare-bones implementation for technical users.

Block span: 0 — 1,149,999

July 30, 2015 — March 14, 2016

Bytecode Overview

Opcodes1,829

Unique Opcodes80

Jump Instructions61

Storage Operations46

Verified Source Available

Source verified through compiler archaeology and exact bytecode matching.

Verified on Etherscan

View Verification Proof

Show source code (Solidity)

// Submitted by EthereumHistory (ethereumhistory.com)
contract Ballot {
    struct Voter {
        uint weight;
        bool voted;
        uint8 vote;
        address delegate;
    }
    struct Proposal {
        uint voteCount;
    }

    address chairperson;
    mapping(address => Voter) voters;
    Proposal[] proposals;

    /// Create a new ballot with $(_numProposals) different proposals.
    function Ballot(uint8 _numProposals) {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;
        proposals.length = _numProposals;
    }

    /// Give $(voter) the right to vote on this ballot.
    /// May only be called by $(chairperson).
    function giveRightToVote(address voter) {
        if (msg.sender != chairperson || voters[voter].voted) return;
        voters[voter].weight = 1;
    }

    /// Delegate your vote to the voter $(to).
    function delegate(address to) {
        Voter sender = voters[msg.sender]; // assigns reference
        if (sender.voted) return;
        while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
            to = voters[to].delegate;
        if (to == msg.sender) return;
        sender.voted = true;
        sender.delegate = to;
        Voter delegate = voters[to];
        if (delegate.voted)
            proposals[delegate.vote].voteCount += sender.weight;
        else
            delegate.weight += sender.weight;
    }

    /// Give a single vote to proposal $(proposal).
    function vote(uint8 proposal) {
        Voter sender = voters[msg.sender];
        if (sender.voted || proposal >= proposals.length) return;
        sender.voted = true;
        sender.vote = proposal;
        proposals[proposal].voteCount += sender.weight;
    }

    function winningProposal() constant returns (uint8 winningProposal) {
        uint256 winningVoteCount = 0;
        for (uint8 proposal = 0; proposal < proposals.length; proposal++) {
            if (proposals[proposal].voteCount > winningVoteCount) {
                winningVoteCount = proposals[proposal].voteCount;
                winningProposal = proposal;
            }
            ++proposal;
        }
    }
}