Frontier-era mineable token (Feb 8, 2016). Anyone can call Mint(quota) to receive 100*quota CLC from the contract's stash.
Historical Significance
One of the earliest known on-chain "open mining" tokens — predates ERC-20 (no totalSupply, no allowance, no transferFrom) and lets anyone bootstrap a balance without an ICO, presale, or whitelisting. The Mint(value) function requires the caller to pass the current quota as a proof-of-attention, increments it, and pays 100*quota tokens, so the marginal mint reward grows linearly. Because rewards grow but the contract's initial 100,000 CLC stash doesn't, balanceOf[this] underflowed around mint #45 — leaving the contract with an effective 2^256 supply and turning a deliberately self-exhausting curve into an infinite faucet. The token also has a quirky "sticky" transfer: sending CLC back to the contract address doubles the credit (balanceOf[this] += 2 * _value) instead of conserving supply.
Context
Deployed Feb 8, 2016 at 16:19 UTC (block 973,483) on the Frontier network, six weeks before the Homestead hard fork. The deployer (0xcd7642260fb84ce6d28730f6579d4f6ab26c8369) was an active Frontier-era tinkerer who pushed ten-plus contracts in a four-day burst Feb 5-9, 2016, iterating on the same mineable-token template — sibling contracts at 0xee6760ea (ChydCoin), 0xa86acc2d, and 0x59bfd39c share the exact storage layout (organizer / name / symbol / decimals / target / quota / balanceOf). Compiled with soljson v0.1.7+commit.b4e666cc (optimizer ON), which was the latest stable solc release at deployment time (v0.2.0 had shipped three weeks earlier but had not yet been broadly adopted). The original 2016 mining wave got the quota to roughly 8 before the deployer moved on; a separate address (0xf66ac2c8...0af6) returned in July 2025 to mint 37 more positions sequentially, pushing the live quota counter to 47 — past the underflow point, where the curve mathematically should have stopped.
Token Information
Key Facts
Description
CoolCoin (CLC), a 2016-02-08 mineable token deployed on the Frontier network at block 973,483. Initial supply 100,000 CLC (decimals=2) is held by the contract itself. Anyone can call Mint(value) where value must equal the current public quota counter; on success, quota increments and the caller receives 100*quota tokens drawn from the contract's balance, so each successful mint pays out more than the last. The mining curve self-exhausts after roughly 44 mints. transfer() carries a quirk: sending tokens back to the contract credits double (balanceOf[this] += 2 * _value), which folds value back into the mintable pool. Runtime byte-for-byte verified against soljson v0.1.7+commit.b4e666cc (optimizer ON).
Source Verified
Byte-for-byte runtime match (1018 bytes). soljson v0.1.7+commit.b4e666cc, optimizer ON. Source reconstructed.. Optimizer: ON (200 runs)
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
This contract has verified source code.
View Verification ProofShow source code (Solidity)
// Submitted by EthereumHistory (ethereumhistory.com)
contract CoolCoin {
address public organizer;
string public name;
string public symbol;
uint8 public decimals;
uint256 public target;
uint256 public quota;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function CoolCoin(uint256 _target, string _name, string _symbol, uint8 _decimals) {
if (_target == 0) _target = 10000;
organizer = msg.sender;
balanceOf[this] = _target;
name = _name;
symbol = _symbol;
quota = 0;
decimals = _decimals;
}
function Mint(uint256 value) {
address t = this;
if (value != quota) return;
quota++;
balanceOf[msg.sender] += 100 * quota;
balanceOf[t] -= 100 * quota;
Transfer(t, msg.sender, quota);
}
function transfer(address _to, uint256 _value) {
address t = this;
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
if (_to == t) {
balanceOf[_to] += 2 * _value;
} else {
balanceOf[_to] += _value;
}
quota++;
Transfer(msg.sender, _to, _value);
}
}