Early ERC-20 token built from the ethereum.org tutorial. Features approveAndCall for token-contract interaction and a spentAllowance tracking pattern.
Historical Significance
Representative of the earliest wave of token experimentation on Ethereum, deployed from the official tutorial that introduced most developers to Solidity smart contracts.
Context
The ethereum.org token tutorial was the entry point for thousands of early Solidity developers. This template, with its approveAndCall pattern and spentAllowance tracking, became one of the most deployed contract patterns on early Ethereum. The tutorial taught developers how to create tokens before the ERC-20 standard was formalized in November 2015.
Token Information
Key Facts
Description
Poker Chips (POKER) is a token contract deployed in March 2016 using the standard token template from the official ethereum.org website. The template was one of the most widely copied contracts in early Ethereum, with over 80 identical deployments.
The contract implements basic token functionality (transfer, transferFrom, balanceOf) plus approveAndCall, which allows a spender contract to be notified via receiveApproval in a single transaction. It tracks spent allowances separately from granted allowances, a pattern that predates the modern ERC-20 approve/transferFrom flow.
Notably, the contract contains a bug in transferFrom: it emits Transfer(msg.sender, _to, _value) instead of Transfer(_from, _to, _value), logging the caller as the sender rather than the actual token holder. The approveAndCall and transferFrom functions declare returns (bool) but never return a value.
Source Verified
Runtime + creation bytecode match. Native C++ solc v0.2.1 (webthree-umbrella v1.1.2), optimizer ON. Token: Poker Chips (POKER), 0 decimals, 10000 supply. Bug: transferFrom emits Transfer(msg.sender) instead of Transfer(_from).
Heuristic Analysis
The following characteristics were detected through bytecode analysis and may not be accurate.
Homestead Era
The first planned hard fork. Removed the canary contract, adjusted gas costs.
Bytecode Overview
Verified Source Available
Source verified through compiler archaeology and exact bytecode matching.
View Verification ProofShow source code (Solidity)
contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); }
contract MyToken {
/* Public variables of the token */
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => mapping (address => uint256)) public spentAllowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function MyToken(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) {
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
decimals = decimalUnits; // Amount of decimals for display purposes
}
/* Send coins */
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* Allow another contract to spend some tokens in your behalf */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowance[msg.sender][_spender] = _value;
tokenRecipient spender = tokenRecipient(_spender);
spender.receiveApproval(msg.sender, _value, this, _extraData);
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (spentAllowance[_from][msg.sender] + _value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
spentAllowance[_from][msg.sender] += _value;
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* This unnamed function is called whenever someone tries to send ether to it */
function () {
throw; // Prevents accidental sending of ether
}
}