An early Frontier-era token contract implementing a pre-ERC-20 interface, deployed on September 8, 2015 by an address associated with the ENS name collectibletr
Historical Significance
This contract is one of the earliest known Ethereum tokens to explicitly reference the proposed ERC-20 standard in its source code, predating the formal EIP-20 submission by over two months. It documents the informal community experimentation that preceded the standardization of the ERC-20 interface and provides a window into early Frontier-era token design.
Context
Ethereum Frontier launched on July 30, 2015. In the weeks that followed, developers began deploying experimental contracts and exploring what decentralized applications could look like. The ERC-20 token standard was being informally discussed in the community before Fabian Vogelsteller and Vitalik Buterin formalized it as EIP-20 on November 19, 2015. The Solidity compiler version v0.1.3 was used for this contract, representing one of the earliest compiler releases available on mainnet.
Key Facts
Description
The currency contract was deployed at block 204787 on September 8, 2015, approximately six weeks after the Ethereum Frontier launch on July 30, 2015. The deployer, whose address is associated with the ENS name collectibletrust.eth, submitted the source code for Etherscan verification. The source code begins with the comment "rfikki was here in 2015," a personal signature embedded in the contract.
The contract implements a token with a fixed supply of one trillion units. It provides functions for sending tokens between accounts, checking balances, and approving delegate transfers. A comment in the disapprove function reads "We Disapprove - 2015 - Aug - 24 Proposed ERC20 Standard - Not Final," indicating the author was implementing an early draft of what would become the ERC-20 token standard. The formal ERC-20 standard (EIP-20) was not submitted until November 19, 2015, more than two months after this contract was deployed.
The function signatures differ from the finalized ERC-20 standard. The contract uses sendCoin instead of transfer, coinBalance instead of balanceOf, and a CoinSent event instead of Transfer. However, the underlying concepts of balance tracking, transfer delegation, and approval mechanisms closely mirror the eventual standard.
This contract represents early community experimentation with token standardization on Ethereum. It was deployed in the window between the Frontier launch and the formal codification of token interfaces, a period when developers were independently exploring fungible token designs before any standard existed.
Source Verified
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 on Etherscan.
Show source code (Solidity)
// Submitted to Etherscan.io for verification for contract at 0x8494F777d13503BE928BB22b1F4ae3289E634FD3
/* rfikki was here in 2015 */
contract currency {
struct Account {
uint balance;
mapping ( address => uint) withdrawers;
}
mapping ( address => Account ) accounts;
event CoinSent(address indexed from, uint256 value, address indexed to);
/* Set Currency Maximum Balance */
function currency() {
accounts[msg.sender].balance = 1000000000000; /* There will forever be a maximum one trillion tokens */
}
/* Send _value amount of coins to address _to */
function sendCoin(uint _value, address _to) returns (bool _success) {
if (accounts[msg.sender].balance >= _value && _value < 340282366920938463463374607431768211456) {
accounts[msg.sender].balance -= _value;
accounts[_to].balance += _value;
CoinSent(msg.sender, _value, _to);
_success = true;
}
else _success = false;
}
/* Send _value amount of coins from address _from to address _to */
function sendCoinFrom(address _from, uint _value, address _to) returns (bool _success) {
uint auth = accounts[_from].withdrawers[msg.sender];
if (accounts[_from].balance >= _value && auth >= _value && _value < 340282366920938463463374607431768211456) {
accounts[_from].withdrawers[msg.sender] -= _value;
accounts[_from].balance -= _value;
accounts[_to].balance += _value;
CoinSent(_from, _value, _to);
_success = true;
_success = true;
}
else _success = false;
}
/* Get your coin balance */
function coinBalance() constant returns (uint _r) {
_r = accounts[msg.sender].balance;
}
/* Get the coin balance of another account with address _addr */
function coinBalanceOf(address _addr) constant returns (uint _r) {
_r = accounts[_addr].balance;
}
/* Allow _addr to direct debit from your account with full custody. Only implement if absolutely required and use carefully. See approveOnce below for a more limited method. */
function approve(address _addr) {
accounts[msg.sender].withdrawers[_addr] = 340282366920938463463374607431768211456;
}
/* Returns 1 if _proxy is allowed to direct debit from your account */
function isApproved(address _proxy) returns (bool _r) {
_r = (accounts[msg.sender].withdrawers[_proxy] > 0);
}
/* Makes a one-time approval for _addr to send a maximum amount of currency equal to _maxValue */
function approveOnce(address _addr, uint256 _maxValue) {
accounts[msg.sender].withdrawers[_addr] += _maxValue;
}
/* Disapprove address _addr to direct debit from your account if it was previously approved. Must reset both one-time and full custody approvals. */
function disapprove(address _addr) {
accounts[msg.sender].withdrawers[_addr] = 0; /* We Disapprove - 2015 - Aug - 24 Proposed ERC20 Standard - Not Final*/
}
}