Fixed-fee name registry from Day 9 of Ethereum (Aug 8, 2015). Reserve names for 69 ETH, resolve addresses. A precursor to ENS.
Historical Significance
One of the earliest name registry implementations on Ethereum mainnet, deployed on Day 9. Demonstrates the community's immediate interest in decentralized naming systems. A direct precursor to the FixedFeeRegistrar in ethereum/dapp-bin and ultimately to ENS (EIP-137, deployed May 2017). Holds 314+ ETH from name reservations.
Context
Deployed during Ethereum Frontier, August 8, 2015. The Ethereum Foundation had published name registry examples in the Frontier Guide, and multiple developers raced to deploy registries in the first days. ENS would not be proposed until early 2016 (EIP-137), with mainnet deployment in May 2017. Gas was essentially free, encouraging experimentation.
Key Facts
Description
An early fixed-fee name registry deployed on August 8, 2015 (block 52,426), just 9 days after Ethereum's mainnet launch. This contract implements a straightforward name reservation system: anyone can reserve an unclaimed name by sending at least 69 ETH, then associate an Ethereum address with that name for on-chain resolution.
The contract features six functions: reserve (claim a name for 69 ETH), disown (release a name and refund the fee to a specified address), transfer (change name ownership), setAddr (set the address a name resolves to), plus read-only addr and owner lookups. All mutations emit a Changed event.
This is a simplified precursor to the FixedFeeRegistrar later published by Gavin Wood in ethereum/dapp-bin. The dapp-bin version evolved to use string parameters instead of bytes32, a 4-field struct (adding subRegistrar and content fields), contract inheritance, and a minimum name length check. This on-chain version uses a leaner 2-field struct (just addr and owner) with bytes32 name parameters.
The contract currently holds over 314 ETH from name reservations, making it one of the highest-balance unverified frontier contracts. Multiple developers were independently deploying registry contracts in Ethereum's first days, exploring what decentralized naming should look like before ENS was proposed in early 2016.
Source Verified
Exact byte-for-byte match on both creation (698 bytes) and runtime (679 bytes) bytecode. Compiled with soljson v0.1.1+commit.6ff4cd6, optimizer ON. Key compiler archaeology findings: function declaration order affects optimizer output (correct order: reserve, disown, owner, transfer, addr, setAddr), and operand order in conditions matters (0 == owner, not owner == 0).
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 and exact bytecode matching.
View Verification ProofShow source code (Solidity)
contract NameRegistry {
struct Record {
address addr;
address owner;
}
modifier onlyrecordowner(bytes32 _name) { if (m_toRecord[_name].owner == msg.sender) _ }
event Changed(bytes32 indexed name);
function reserve(bytes32 _name) {
if (0 == m_toRecord[_name].owner && msg.value >= c_fee) {
m_toRecord[_name].owner = msg.sender;
Changed(_name);
}
}
function disown(bytes32 _name, address _refund) onlyrecordowner(_name) {
delete m_toRecord[_name];
_refund.send(c_fee);
Changed(_name);
}
function owner(bytes32 _name) constant returns (address) { return m_toRecord[_name].owner; }
function transfer(bytes32 _name, address _newOwner) onlyrecordowner(_name) {
m_toRecord[_name].owner = _newOwner;
Changed(_name);
}
function addr(bytes32 _name) constant returns (address) { return m_toRecord[_name].addr; }
function setAddr(bytes32 _name, address _a) onlyrecordowner(_name) {
m_toRecord[_name].addr = _a;
Changed(_name);
}
mapping (bytes32 => Record) m_toRecord;
uint constant c_fee = 69 ether;
}