A token-weighted governance contract deployed by Avsa on Dec 3, 2015, using MistCoin as voting shares. 0.1 ETH remains locked after 10 years.
Historical Significance
One of the earliest token-weighted governance contracts on Ethereum, deployed by Alex Van de Sande. Demonstrates the vision of MistCoin as more than just a test token - as a governance instrument. The 0.1 ETH locked since 2015 serves as a permanent on-chain time capsule from Ethereum's earliest days.
Context
December 2015 was a pivotal time for Ethereum. The network had launched in July 2015 (Frontier). MistCoin had been created by Fabian Vogelsteller as the first ERC-20 style token before publishing the standard proposal. Alex was actively building tutorial contracts on ethereum.org to demonstrate DAOs and governance. The Mist wallet was under active development, and these DAO tutorials were meant to showcase what decentralized governance could look like.
Key Facts
Description
This contract is a Shareholder Association DAO from the ethereum.org DAO tutorial, deployed by Alex Van de Sande (0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb) on December 3, 2015 (block 635,909). It uses MistCoin (0xf4eced2f682ce333f96f2d8966c613ded8fc95dd) as the governance token, requiring holders to vote on proposals.
The contract was configured with a minimum quorum of 10,000 MistCoin (stored as 1,000,000 raw units with 2 decimals) and a debate period of 10,000 minutes (~6.9 days). avsa seeded the DAO with 100,000 MC — 10% of the entire MistCoin supply (on-chain: 10,000,000 raw).
Despite 13 total transactions (including several proposals and votes in 2022), the 0.1 ETH deposited at deployment remains locked. In 2022, goatishduck.eth discovered the contract and used its governance mechanism to drain the full 100,000 MC treasury — passing proposals to call transfer() on the MistCoin contract itself. The ETH was never claimed: quorum for ETH withdrawal proposals was never met.
Technically, this is one of the earliest known token-weighted governance contracts on Ethereum. The source code matches the ethereum.org Stakeholder Association tutorial exactly in function signatures.
Source Verified
9/9 function selectors match exactly. Runtime is 3,275 bytes matching on-chain size exactly. 315 bytes differ in optimizer jump-target layout within executeProposal only — purely structural, no functional difference. Source confirmed via ABI in avsa gist 5843810278da2d1c68dc. Compiler: soljson v0.1.5+commit.23865e39, optimizer ON. Original source gist (58438102) is deleted.
Historian Categories
Heuristic Analysis
The following characteristics were detected through bytecode analysis and may not be accurate.
Frontier Era
The initial release of Ethereum. A bare-bones implementation for technical users.
Bytecode Overview
Verified Source Available
Source verified through compiler archaeology (near-exact bytecode match).
View Verification ProofShow source code (Solidity)
// SPDX-License-Identifier: UNLICENSED
// Mist D.A.O. - Deployed by Alex Van de Sande (avsa)
// Contract: 0x8d554c6c1631e44706e502433f0f958287d9b8dc
// Deployed: Block 635909, December 3, 2015
// Deployer: 0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb (avsa)
// Compiler: soljson v0.1.5+commit.23865e39, optimizer enabled
// Note: 9/9 function selectors match exactly. Runtime bytecode differs by 315 bytes
// in optimizer jump-target layout within executeProposal (purely structural, no
// functional difference). Exact compiler binary could not be identified from
// available solc-bin archives.
// Source gist: https://gist.github.com/alexvandesande/5843810278da2d1c68dc (ABI only)
contract token { mapping (address => uint) public balanceOf; }
contract Association {
uint public minimumQuorum;
uint public debatingPeriodInMinutes;
Proposal[] public proposals;
uint public numProposals;
token public sharesTokenAddress;
event ProposalAdded(uint proposalID, address recipient, uint amount, string description);
event Voted(uint proposalID, bool position, address voter);
event ProposalTallied(uint proposalID, int result, uint quorum, bool active);
struct Proposal {
address recipient;
uint amount;
string description;
uint votingDeadline;
bool openToVote;
bool proposalPassed;
uint numberOfVotes;
bytes32 proposalHash;
Vote[] votes;
mapping (address => bool) voted;
}
struct Vote {
bool inSupport;
address voter;
}
modifier onlyShareholders {
if (sharesTokenAddress.balanceOf(msg.sender) == 0) throw;
_
}
function Association(address sharesAddress, uint minimumSharesForVoting, uint minutesForDebate) {
sharesTokenAddress = token(sharesAddress);
minimumQuorum = minimumSharesForVoting;
debatingPeriodInMinutes = minutesForDebate;
}
function newProposal(address beneficiary, uint etherAmount, string JobDescription, bytes transactionBytecode) onlyShareholders returns (uint proposalID) {
proposalID = proposals.length++;
Proposal p = proposals[proposalID];
p.recipient = beneficiary;
p.amount = etherAmount;
p.description = JobDescription;
p.proposalHash = sha3(beneficiary, etherAmount, transactionBytecode);
p.votingDeadline = now + debatingPeriodInMinutes * 1 minutes;
p.openToVote = true;
p.proposalPassed = false;
p.numberOfVotes = 0;
ProposalAdded(proposalID, beneficiary, etherAmount, JobDescription);
numProposals = proposalID+1;
}
function checkProposalCode(uint proposalNumber, address beneficiary, uint etherAmount, bytes transactionBytecode) constant returns (bool codeChecksOut) {
Proposal p = proposals[proposalNumber];
return p.proposalHash == sha3(beneficiary, etherAmount, transactionBytecode);
}
function vote(uint proposalNumber, bool supportsProposal) onlyShareholders returns (uint voteID) {
Proposal p = proposals[proposalNumber];
if (p.voted[msg.sender] == true) throw;
voteID = p.votes.length++;
p.votes[voteID] = Vote({inSupport: supportsProposal, voter: msg.sender});
p.voted[msg.sender] = true;
p.numberOfVotes = voteID + 1;
Voted(proposalNumber, supportsProposal, msg.sender);
}
function executeProposal(uint proposalNumber, bytes transactionBytecode) returns (int result) {
Proposal p = proposals[proposalNumber];
if (now < p.votingDeadline || !p.openToVote
|| p.proposalHash != sha3(p.recipient, p.amount, transactionBytecode)) throw;
uint quorum = 0;
uint yea = 0;
uint nay = 0;
for (uint i = 0; i < p.votes.length; ++i) {
Vote v = p.votes[i];
uint voteWeight = sharesTokenAddress.balanceOf(v.voter);
quorum += voteWeight;
if (v.inSupport) { yea += voteWeight; } else { nay += voteWeight; }
}
if (minimumQuorum < quorum) {
if (yea > nay) {
p.recipient.call.value(p.amount * 1000000000000000000)(transactionBytecode);
p.openToVote = false;
p.proposalPassed = true;
} else {
p.openToVote = false;
p.proposalPassed = false;
}
} else {
p.openToVote = false;
p.proposalPassed = false;
}
ProposalTallied(proposalNumber, int(yea) - int(nay), quorum, p.proposalPassed);
}
}