Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Chapter 5: Frontier - The Minimal Viable Ethereum

At 3:26:13 PM UTC on July 30, 2015, Ethereum's genesis block was mined.1 The first entry in block #0's extra data field contained a hidden message: the hash of a recent Bitcoin block, proving the network hadn't been pre-mined. After 563 days of development since the crowdsale, the world computer had finally booted up.

Stephan Tual watched from the Ethereum DEV office in Berlin as the first blocks appeared.2 The room erupted in celebration—champagne corks popped, developers hugged, and someone started playing "The Final Countdown" on the office speakers. But the celebration was brief. Within minutes, everyone was back at their computers, monitoring network health, watching for consensus failures, and preparing for the unexpected.

The Genesis Block

The genesis block was unlike any that would follow. It contained no transactions in the traditional sense, but rather the entire initial state of Ethereum:

{
  "config": {
    "chainId": 1,
    "homesteadBlock": 1150000,
    "eip150Block": 2463000,
    "eip150Hash": "0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"
  },
  "nonce": "0x42",
  "timestamp": "0x00",
  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
  "gasLimit": "0x1388",
  "difficulty": "0x400000000",
  "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "coinbase": "0x0000000000000000000000000000000000000000",
  "alloc": {
    // 8,893 accounts with presale allocations
  }
}

The alloc section contained 8,893 accounts—everyone who had participated in the 2014 crowdsale. The total initial supply was exactly 72,009,990.50 ETH, distributed as:

  • 60,102,216 ETH to crowdsale participants
  • 11,901,484 ETH to early contributors and the Ethereum Foundation
  • 6,290 ETH to compensate for small computational errors

The Thawing Process

Frontier launched in a unique "thawed" state. For the first 100,000 blocks, the network operated under special conditions:3

Canary Contracts

The Ethereum Foundation deployed four "canary" contracts that could halt network operations if critical bugs were discovered:

contract Canary {
    address constant foundation = 0x[foundation_address];
    bool public alive = true;
    
    function kill() {
        require(msg.sender == foundation);
        alive = false;
    }
    
    modifier stillAlive() {
        require(alive);
        _;
    }
}

Clients were programmed to check these contracts before processing blocks. If killed, they would stop accepting new blocks, giving developers time to coordinate fixes.

Gas Limit Ramping

The initial gas limit was set artificially low at 5,000 gas per block—enough for basic transactions but not complex contracts. This would gradually increase as the network proved stable:

Block 0-50,000: 5,000 gas limit
Block 50,000+: Miners could vote to raise by 1/1024 per block

This conservative approach prevented potentially catastrophic smart contracts from being deployed immediately.

First Moments

Block #1

The first real block was mined at 3:26:28 PM UTC, just 15 seconds after genesis. It contained zero transactions but proved the consensus mechanism worked. The miner, identified only by address 0x05a56e2d52c817161883f50c441c3228cfe54d9f, earned 5 ETH in block rewards.4

First Transaction

The first transaction appeared in block #46,147, nearly two days after launch. It was a simple transfer:

From: 0x5abfec25f74cd88437631a7731906932776356f9
To: 0x119b364d224c4f3ac1655e6c0b7bae3f561a9955
Value: 0.000000000000000001 ETH (1 wei)
Gas Used: 21,000

The community speculated endlessly about this anticlimactic first transaction—was it a test? A symbolic gesture? The sender never revealed their intentions.5

First Smart Contract

The first smart contract was deployed in block #46,402:

contract FirstContract {
    uint256 public value;
    
    function FirstContract() {
        value = 42;
    }
    
    function setValue(uint256 newValue) {
        value = newValue;
    }
}

Simple as it was, this contract represented a new era—code executing trustlessly on a global, decentralized computer.

Mining Ecosystem

Early Mining Dynamics

Frontier's launch saw immediate mining interest:

Day 1 Statistics:

  • Network hashrate: ~200 MH/s
  • Active miners: ~50 unique addresses
  • Average block time: 15 seconds
  • Daily ETH mined: ~28,800 ETH

Early miners were primarily ideologically motivated—ETH had no market price yet, and exchanges hadn't listed it.

GPU Mining Evolution

The Ethash algorithm successfully achieved its ASIC-resistant goal. Miners used consumer GPUs:

Popular Early Mining Hardware:

  • AMD R9 290X: ~30 MH/s
  • NVIDIA GTX 970: ~20 MH/s
  • AMD R9 280X: ~25 MH/s

Mining profitability calculations were purely speculative:

Daily Mining Revenue = (Your Hashrate / Network Hashrate) × 28,800 ETH
Daily Cost = (GPU Power × 24 hours × Electricity Rate)
Profitability = ??? (No ETH price existed)

Pool Development

The first mining pool, Ethpool, launched on day one. Within a week, several pools emerged:

  • Ethpool (later Ethermine)
  • Nanopool
  • Dwarfpool
  • F2Pool

Pools used the stratum protocol adapted from Bitcoin mining, allowing miners to submit shares and receive proportional rewards.

Early Applications and Experiments

Despite the minimal viable nature of Frontier, developers immediately began experimenting:

Name Registry

One of the first useful contracts was a decentralized name registry:

contract NameReg {
    mapping(bytes32 => address) public names;
    mapping(address => bytes32) public owners;
    
    function register(bytes32 name) {
        if (names[name] == 0) {
            names[name] = msg.sender;
            owners[msg.sender] = name;
        }
    }
}

This simple contract sparked discussions about decentralized identity and DNS.

Prediction Markets

An early prediction market appeared, betting on when ETH would first trade on an exchange:

contract PredictionMarket {
    struct Prediction {
        uint timestamp;
        uint totalBet;
        mapping(address => uint) bets;
    }
    
    mapping(uint => Prediction) public predictions;
    
    function bet(uint timestamp) payable {
        predictions[timestamp].bets[msg.sender] += msg.value;
        predictions[timestamp].totalBet += msg.value;
    }
}

The First DAO Attempt

An ambitious developer deployed what they called "The First DAO"—a simple voting contract:

contract SimpleDAO {
    mapping(address => uint) public shares;
    mapping(uint => Proposal) public proposals;
    uint public proposalCount;
    
    struct Proposal {
        address target;
        uint value;
        bytes data;
        uint votes;
        bool executed;
    }
    
    function propose(address target, uint value, bytes data) returns (uint) {
        proposals[proposalCount++] = Proposal(target, value, data, 0, false);
        return proposalCount - 1;
    }
}

While primitive, it foreshadowed the DAO experiments to come.

Infrastructure Development

Block Explorers

Within days, the first block explorers appeared:

  • Etherscan.io: Launched by Matthew Tan, becoming the dominant explorer6
  • Etherchain.org: Focused on network statistics and charts
  • Ether.camp: Provided advanced contract interaction features

These tools were crucial for transparency and debugging.

Wallets

The official Ethereum Wallet (Mist) was still in development, so early users relied on:

  • Geth console: Command-line interface for hardcore users
  • MyEtherWallet: Web-based wallet launched shortly after Frontier
  • EthereumWallet: Basic GUI wrapper around geth

Using early Ethereum required technical sophistication:

# Creating an account in geth
> personal.newAccount("password")
"0x5e97870f263700f46aa00d967821199b9bc5a120"

# Sending a transaction
> eth.sendTransaction({
    from: eth.accounts[0],
    to: "0x...",
    value: web3.toWei(1, "ether"),
    gas: 21000
})

Exchange Integration

The first ETH/BTC trading pair appeared on Kraken on August 7, 2015, just eight days after launch. The opening price was approximately 0.002 BTC (around $0.60 USD). Within hours:

  • Volume exceeded 100,000 ETH
  • Price swung between $0.40 and $2.00
  • Market cap reached ~$150 million

Other exchanges quickly followed:

  • Poloniex: August 8, 2015
  • Bitfinex: August 10, 2015
  • Gatecoin: August 12, 2015

Challenges and Growing Pains

Network Instability

The first weeks saw several concerning issues:

Consensus Bugs: On August 20, 2015, a consensus bug caused a brief chain split between Geth and Cpp-ethereum clients. The bug involved edge cases in gas calculation:

// Buggy code
gasUsed := tx.Gas() - remainingGas

// Fixed code  
gasUsed := new(big.Int).Sub(tx.Gas(), remainingGas)

The split resolved within hours, but highlighted the importance of client diversity.

DoS Attacks: Attackers deployed contracts designed to consume excessive resources:

contract DoSAttack {
    function attack() {
        while(true) {
            // Infinite loop until gas exhausted
        }
    }
}

While these contracts simply ran out of gas, they revealed the need for better gas pricing.

User Experience Hurdles

Early Ethereum was not user-friendly:

  • Syncing the blockchain took days
  • No standardized token interface
  • Contract interaction required ABI knowledge
  • Gas estimation was often wrong
  • Lost private keys meant lost funds forever

The community rallied to create tools and documentation, but the learning curve remained steep.

Community Response

Developer Enthusiasm

Despite challenges, developer interest exploded:

  • GitHub repositories mentioning Ethereum grew 10x
  • StackOverflow saw hundreds of Ethereum questions
  • Local meetups formed in major cities
  • Online tutorials and courses appeared

Media Coverage

Mainstream media began covering Ethereum:

  • The New York Times: "A Bitcoin-Style Currency for Corporations"
  • Forbes: "Ethereum Launches, Bringing Smart Contracts to Life"
  • Wired: "The Ambitious Plan to Make the Internet More Like Bitcoin"

Coverage was generally positive but struggled to explain smart contracts to mainstream audiences.

Early Governance

With no formal governance structure, decisions happened through:

  • GitHub issue discussions
  • Reddit threads
  • Developer calls
  • Blog post proposals

This "rough consensus" approach would be tested as the network grew.

The Numbers Tell the Story

By the end of August 2015, one month after launch:

Network Statistics:

  • Total blocks: ~200,000
  • Average block time: 15.5 seconds
  • Network hashrate: 2.5 TH/s
  • Active nodes: ~7,500
  • Total transactions: ~80,000

Economic Metrics:

  • ETH price: ~$1.20 USD
  • Market cap: ~$90 million
  • Daily volume: ~$2 million
  • Exchange listings: 8 platforms

Development Activity:

  • Smart contracts deployed: ~500
  • Unique contract creators: ~200
  • GitHub contributors: ~100
  • DApp projects announced: ~50

Technical Achievements

Frontier successfully demonstrated several breakthrough capabilities:

Turing-Complete Computation

Complex algorithms could run on-chain:

contract Fibonacci {
    function calculate(uint n) returns (uint) {
        if (n <= 1) return n;
        uint a = 0;
        uint b = 1;
        for (uint i = 2; i <= n; i++) {
            uint temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }
}

Stateful Smart Contracts

Contracts maintained persistent state across transactions:

contract Counter {
    uint public count = 0;
    mapping(address => uint) public userCounts;
    
    function increment() {
        count++;
        userCounts[msg.sender]++;
    }
}

Inter-Contract Communication

Contracts could call other contracts, enabling composability:

contract Oracle {
    function getPrice() returns (uint);
}

contract Consumer {
    Oracle oracle = Oracle(0x...);
    
    function checkPrice() returns (uint) {
        return oracle.getPrice();
    }
}

Why This Mattered

Frontier's launch was historic for several reasons:

  1. Proof of Concept: After years of development, Ethereum actually worked
  2. New Paradigm: Smart contracts were no longer theoretical
  3. Global Computer: A decentralized, unstoppable computer was now running
  4. Economic Innovation: Programmable money became reality
  5. Community Achievement: A global, volunteer effort had succeeded

The minimal viable approach proved wise—launching with basic functionality allowed real-world testing while managing risk.

Looking Ahead

As August 2015 ended, the Ethereum community was euphoric but realistic. Frontier was explicitly labeled as experimental, suitable only for developers. The road ahead included:

  • Homestead: The first production-ready release
  • Metropolis: Adding sophisticated features
  • Serenity: The eventual transition to Proof of Stake

But those were future concerns. For now, the world computer was running, processing transactions, executing smart contracts, and laying the foundation for a decentralized future.

Vitalik's blog post captured the moment:

"Frontier is the first milestone in the Ethereum project, but it is only the beginning. Over the coming months, we will be releasing a series of updates to the platform, adding features, improving usability, and fixing bugs. The journey to build a decentralized web has begun."

The ambitious vision from the 2013 whitepaper was no longer just an idea—it was running code, secured by a global network, and limited only by imagination.

References

  1. Ethereum Foundation. (2015). "Frontier is Coming" Ethereum Blog ↩

  2. Tual, S. (2015). "Ethereum Launches!" Ethereum Blog ↩

  3. Buterin, V. (2015). "The Thawing: Frontier is Launched" Ethereum Blog ↩

  4. Etherscan.io. (2015). Genesis Block and Early Transaction Data ↩

  5. Various contributors. (2015). Ethereum Reddit Launch Threads ↩

  6. Tan, M. (2015). "Building Etherscan: The First Month" Medium ↩