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 4: The Olympic Era

On May 9, 2015, at block #0, the Olympic testnet came to life. Within minutes, transactions began flowing—some sending test ether between addresses, others deploying increasingly complex smart contracts designed to push the system to its limits. One participant deployed a contract that attempted to calculate the millionth Fibonacci number on-chain, promptly consuming all available gas and demonstrating exactly why gas limits existed.

The Olympic testnet was Ethereum's final dress rehearsal before the main performance. Named after the competitive spirit it hoped to inspire, Olympic invited the global community to attack, stress-test, and break Ethereum in every conceivable way. The reward? Real ether in the upcoming mainnet for those who found the most critical bugs.

The Road to Olympic

The months leading to Olympic had been intense. The development team, now distributed across Berlin, London, Amsterdam, and Toronto, worked in a synchronized sprint toward testnet readiness.

Technical Milestones

By early 2015, several critical components had crystallized:

Genesis Block Format: The team finalized how the initial state would be encoded, including all crowdsale purchases and early contributor allocations:

{
  "nonce": "0x0000000000000042",
  "timestamp": "0x0",
  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
  "gasLimit": "0x1388",
  "difficulty": "0x400000000",
  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "coinbase": "0x0000000000000000000000000000000000000000",
  "alloc": {
    "address1": {"balance": "amount1"},
    "address2": {"balance": "amount2"}
    // ... thousands more entries
  }
}

Network Protocol Stability: The devp2p wire protocol reached version 3, incorporating lessons from earlier testnets about peer discovery, block propagation, and state synchronization.

Gas Price Discovery: The team implemented a gas price oracle, allowing wallets to suggest appropriate fees based on network congestion—a feature Bitcoin lacked.

Security Preparations

Stephan Tual, Ethereum's CCO, coordinated a comprehensive security effort:1

  • Formal verification attempts on critical components
  • External security audits by firms like Least Authority
  • Internal red team exercises
  • Automated fuzzing of the EVM

The team knew that once mainnet launched with real value at stake, fixing critical bugs would become exponentially harder.

Launch and Early Days

The Announcement

Vitalik announced Olympic with characteristic understatement on the Ethereum blog:2

"Olympic is the Ethereum network's last major milestone before the release of Frontier. It is meant to test the network under high load conditions, test security, and test the mining ecosystem."

Within hours, nodes began joining from around the world. The initial network hash rate climbed steadily as miners configured their GPUs for Ethash mining.

Mining Ecosystem Development

Olympic provided the first real test of Ethereum's mining dynamics:

GPU Mining Software: Developers released optimized miners:

  • Genoil's ethminer for NVIDIA cards
  • Claymore's dual miner allowing simultaneous Ethereum and Decred mining
  • Open-source implementations for AMD cards

Pool Infrastructure: Mining pools emerged to allow smaller miners to participate:

Miner -> Pool -> Block Found -> Reward Distribution
         |
         +-> Share submission for proportional rewards

Early Mining Economics: With no real value yet, miners participated for:

  • Future ether rewards from the bug bounty
  • Testing their infrastructure for mainnet
  • Ideological support for the project

Smart Contract Explosion

Olympic saw an explosion of experimental smart contracts as developers explored possibilities:

The Pyramid Scheme Contract: Someone deployed a transparent pyramid scheme to test the limits of "code is law":

contract Pyramid {
    address[] public investors;
    mapping(address => uint) public invested;
    
    function invest() payable {
        invested[msg.sender] += msg.value;
        investors.push(msg.sender);
        // Pay earlier investors with new money
        distributeReturns();
    }
}

The Casino: Gambling contracts proliferated, testing random number generation:

contract Dice {
    function roll() payable returns (bool won) {
        // Insecure randomness - educational purposes only!
        uint random = uint(keccak256(block.timestamp, msg.sender));
        won = (random % 6) >= 3;
        if (won) {
            msg.sender.transfer(msg.value * 2);
        }
    }
}

Decentralized Exchange Attempts: Early DEX implementations emerged, though they struggled with the lack of token standards.

Bug Bounty Program

The bug bounty program was unprecedented in scale and scope. The Ethereum Foundation allocated 25,000 ETH for security researchers who could find vulnerabilities.

Bounty Categories

Rewards scaled with severity:

  • Consensus bugs: Up to 5,000 ETH for bugs that could fork the network
  • EVM vulnerabilities: 3,000 ETH for virtual machine exploits
  • DoS vectors: 2,000 ETH for denial-of-service attacks
  • Client bugs: 1,000 ETH for implementation-specific issues

Notable Discoveries

The CALL Stack Depth Attack: Researchers discovered that the CALL opcode could fail silently if the stack depth exceeded 1024:

contract Vulnerable {
    function withdraw() {
        // This could fail silently if called with deep stack
        if (!msg.sender.call.value(balances[msg.sender])()) {
            throw;
        }
        balances[msg.sender] = 0;
    }
}

This led to a critical protocol change limiting call stack depth and changing failure semantics.

State Tree Corruption: A bug in the C++ client's Merkle Patricia Tree implementation could corrupt state under specific conditions. The fix required careful coordination between client teams.

Memory Expansion Attacks: Researchers found ways to force excessive memory allocation:

contract MemoryBomb {
    function explode() {
        assembly {
            // Attempt to allocate huge memory
            mstore(0xffffffff, 1)
        }
    }
}

This led to refined gas costs for memory expansion.

Community Participation

The bug bounty attracted diverse participants:

  • Professional security researchers
  • Academic computer scientists
  • Curious hackers
  • Competing blockchain developers

The transparent process, with public disclosure after fixes, built confidence in Ethereum's security posture.3

Stress Testing at Scale

Beyond individual bug hunting, Olympic enabled unprecedented stress testing:

Transaction Flooding

Community members coordinated to flood the network with transactions:

# Stress test script example
def flood_network(node_url, account, target):
    w3 = Web3(HTTPProvider(node_url))
    nonce = w3.eth.getTransactionCount(account)
    
    for i in range(10000):
        tx = {
            'to': target,
            'value': 1,
            'gas': 21000,
            'gasPrice': w3.toWei('20', 'gwei'),
            'nonce': nonce + i
        }
        signed = w3.eth.account.signTransaction(tx, private_key)
        w3.eth.sendRawTransaction(signed.rawTransaction)

These tests revealed:

  • Block propagation delays under high load
  • Memory pool management issues
  • Need for transaction replacement mechanisms

State Bloat Experiments

Participants created contracts designed to bloat the state:

contract StorageFiller {
    mapping(uint => uint) public data;
    
    function fill(uint start, uint count) {
        for (uint i = start; i < start + count; i++) {
            data[i] = i;
        }
    }
}

These experiments informed future discussions about state rent and storage economics.

Network Partition Testing

The community simulated network partitions, testing Ethereum's ability to recover from splits:

  • Geographic isolation tests
  • Latency injection
  • Packet loss simulation

Results showed Ethereum's consensus mechanism was robust but highlighted areas for network layer improvement.

Developer Ecosystem Growth

Olympic catalyzed developer tool creation:

Development Frameworks

Embark: One of the first development frameworks emerged:

// Embark configuration
module.exports = {
  contracts: ["contracts/*.sol"],
  buildDir: "dist/",
  config: "config/",
  plugins: {
    "embark-solium": {}
  }
};

Browser-Based Tools: The community created web-based tools for:

  • Contract deployment
  • ABI encoding/decoding
  • Transaction debugging

Documentation Efforts

The testnet period saw massive documentation improvements:

  • Solidity documentation expanded
  • Best practices guides emerged
  • Security patterns documented

The community wiki grew to hundreds of pages, capturing collective knowledge.4

Preparing for Mainnet

As Olympic progressed, the team made final preparations for Frontier:

The "Thawing" Process

The team designed a unique launch strategy. Frontier would launch "frozen" with a difficulty bomb making mining nearly impossible. Then, at a predetermined block, it would "thaw":5

// Simplified thawing logic
func calcDifficulty(time, parentTime uint64, parentDiff *big.Int) *big.Int {
    if blockNumber < thawingBlock {
        return params.GenesisDifficulty
    }
    // Normal difficulty calculation after thawing
    return CalcDifficulty(time, parentTime, parentDiff)
}

This gave time to ensure the network was stable before real mining began.

Client Readiness

Each client team raced to address Olympic findings:

Geth: Jeffrey Wilcke's team focused on:

  • Performance optimizations
  • Memory usage reduction
  • Improved sync algorithms

Eth (C++): Gavin Wood's team refined:

  • EVM implementation
  • State database efficiency
  • Mining optimizations

PyEthereum: Vitalik's reference implementation ensured:

  • Consensus rule clarity
  • Test case generation
  • Protocol documentation

Community Coordination

The Ethereum Foundation organized:

  • Developer calls every two weeks
  • Public testnet status updates
  • Countdown communications

The community felt like a movement preparing for launch.

Lessons Learned

Olympic provided invaluable lessons:

Technical Insights

  1. Gas Pricing: Initial estimates needed adjustment based on real-world usage
  2. Network Layer: P2P protocol needed optimization for global scale
  3. State Management: State size growth would be a long-term challenge
  4. Client Diversity: Multiple implementations caught bugs single-client networks would miss

Social Dynamics

  1. Incentive Alignment: Bug bounties effectively motivated security research
  2. Community Building: Shared challenges created strong bonds
  3. Expectation Management: Clear communication prevented disappointment
  4. Global Participation: 24/7 testnet activity required global coordination

Security Philosophy

Olympic established Ethereum's security culture:

  • Transparency over security through obscurity
  • Community participation in security
  • Rapid iteration and fixing
  • Defense in depth

The Final Countdown

By late June 2015, Olympic had achieved its goals:

  • Thousands of bugs fixed
  • Network proven stable under load
  • Mining ecosystem established
  • Developer tools maturing
  • Community battle-tested and ready6

The team announced Frontier's launch date: July 30, 2015.

Why This Mattered

Olympic was more than a testnet—it was a community-building exercise that:

  1. Proved Viability: Demonstrated Ethereum could work at scale
  2. Built Confidence: Security researchers' participation increased trust
  3. Created Ecosystem: Tools and infrastructure developed for Olympic would serve mainnet
  4. Established Culture: Set precedents for open development and community participation
  5. Refined Vision: Real usage clarified what Ethereum could become

Looking Ahead

As Olympic wound down, anticipation reached fever pitch. The infrastructure was ready, the bugs were fixed, and the community was prepared. After nearly two years of development, Ethereum was about to become real.

The final blog post before launch captured the mood:

"The Olympic testnet has been a resounding success. We've pushed the network to its limits, fixed critical bugs, and built an amazing community. Now it's time for Frontier. See you on the mainnet."

In a few days, block #0 would be mined, and the world computer would boot up for the first time.

References

  1. Tual, S. (2015). "Olympic: Frontier Pre-Release" Ethereum Blog ↩

  2. Wood, G. (2015). "Ethereum Launches Olympic Test Network" Ethereum Blog ↩

  3. Various contributors. (2015). Olympic Bug Bounty Submissions and Fixes ↩

  4. Community contributors. (2015). Ethereum Wiki Olympic Documentation ↩

  5. Buterin, V. (2015). "The Thawing: Frontier Launch Process" Ethereum Blog ↩

  6. Ethereum Foundation. (2015). "Olympic Testnet Statistics and Lessons Learned" ↩