Early Frontier-era name registry contract (Aug 8, 2015, block 51807) implementing reserve, register, and setContent functions for on-chain name resolution.
Historical Significance
Among the earliest name registry contracts on Ethereum mainnet. Represents an early experiment in decentralized name resolution that would eventually inspire ENS (Ethereum Name Service). The deployment on August 8, 2015 — just 9 days after Frontier launch — shows name resolution was an immediate priority for early developers.
Context
Deployed during the Ethereum Frontier era (July 30 – September 7, 2015). The Ethereum Frontier Guide included a name registry section, describing a NameReg contract as infrastructure for decentralized applications. ENS (Ethereum Name Service) would not be proposed until 2016 (EIP-137) and deployed until May 2017. These early registry experiments from 2015 represent the first attempts at on-chain naming on Ethereum.
Key Facts
Description
The contract implements the standardized registry interface defined in Ethereum’s official documentation prior to mainnet launch. It exposes functions to reserve names, transfer ownership, associate primary addresses, attach content identifiers, delegate to sub-registrars, and relinquish ownership.
Names are claimed on a first-come, first-served basis via a reserve function. Ownership and metadata are stored in mappings keyed by the name hash, while reverse lookup is supported through address-to-name mappings. Although the code contains extensive commented plans for auctions, renewals, and bidding mechanisms, the deployed logic focuses on the core functionality of name ownership and resolution.
The Linagee Name Registrar, deployed on August 8, 2015, is the first smart contract to implement an on-chain naming system on Ethereum. It allows users to reserve unique bytes32 names, assign ownership, associate addresses and content hashes, and perform forward and reverse name resolution directly on-chain.
The deployed contract implements a global registrar model in which names are scarce, transferable, and independently owned, establishing naming as a native blockchain primitive rather than an off-chain convention.
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)
contract NameRegister {
function addr(bytes32 _name) constant returns (address o_owner) {}
function name(address _owner) constant returns (bytes32 o_name) {}
}
contract Registrar is NameRegister {
event Changed(bytes32 indexed name);
event PrimaryChanged(bytes32 indexed name, address indexed addr);
function owner(bytes32 _name) constant returns (address o_owner) {}
function addr(bytes32 _name) constant returns (address o_address) {}
function subRegistrar(bytes32 _name) constant returns (address o_subRegistrar) {}
function content(bytes32 _name) constant returns (bytes32 o_content) {}
function name(address _owner) constant returns (bytes32 o_name) {}
}
contract GlobalRegistrar is Registrar {
struct Record {
address owner;
address primary;
address subRegistrar;
bytes32 content;
uint value;
uint renewalDate;
}
function Registrar() {
// TODO: Populate with hall-of-fame.
}
function reserve(bytes32 _name) {
// Don't allow the same name to be overwritten.
// TODO: bidding mechanism
if (m_toRecord[_name].owner == 0) {
m_toRecord[_name].owner = msg.sender;
Changed(_name);
}
}
/*
TODO
> 12 chars: free
<= 12 chars: auction:
1. new names are auctioned
- 7 day period to collect all bid bytes32es + deposits
- 1 day period to collect all bids to be considered (validity requires associated deposit to be >10% of bid)
- all valid bids are burnt except highest - difference between that and second highest is returned to winner
2. remember when last auctioned/renewed
3. anyone can force renewal process:
- 7 day period to collect all bid bytes32es + deposits
- 1 day period to collect all bids & full amounts - bids only uncovered if sufficiently high.
- 1% of winner burnt; original owner paid rest.
*/
modifier onlyrecordowner(bytes32 _name) { if (m_toRecord[_name].owner == msg.sender) _ }
function transfer(bytes32 _name, address _newOwner) onlyrecordowner(_name) {
m_toRecord[_name].owner = _newOwner;
Changed(_name);
}
function disown(bytes32 _name) onlyrecordowner(_name) {
if (m_toName[m_toRecord[_name].primary] == _name)
{
PrimaryChanged(_name, m_toRecord[_name].primary);
m_toName[m_toRecord[_name].primary] = "";
}
delete m_toRecord[_name];
Changed(_name);
}
function setAddress(bytes32 _name, address _a, bool _primary) onlyrecordowner(_name) {
m_toRecord[_name].primary = _a;
if (_primary)
{
PrimaryChanged(_name, _a);
m_toName[_a] = _name;
}
Changed(_name);
}
function setSubRegistrar(bytes32 _name, address _registrar) onlyrecordowner(_name) {
m_toRecord[_name].subRegistrar = _registrar;
Changed(_name);
}
function setContent(bytes32 _name, bytes32 _content) onlyrecordowner(_name) {
m_toRecord[_name].content = _content;
Changed(_name);
}
function owner(bytes32 _name) constant returns (address) { return m_toRecord[_name].owner; }
function addr(bytes32 _name) constant returns (address) { return m_toRecord[_name].primary; }
// function subRegistrar(bytes32 _name) constant returns (address) { return m_toRecord[_name].subRegistrar; } // TODO: bring in on next iteration.
function register(bytes32 _name) constant returns (address) { return m_toRecord[_name].subRegistrar; } // only possible for now
function content(bytes32 _name) constant returns (bytes32) { return m_toRecord[_name].content; }
function name(address _owner) constant returns (bytes32 o_name) { return m_toName[_owner]; }
mapping (address => bytes32) m_toName;
mapping (bytes32 => Record) m_toRecord;
}