An early Ethereum contract that returns the string “Hello World!” when called.
Historical Significance
This contract is part of the earliest wave of Ethereum contracts that demonstrated interactive on-chain programs with predictable execution and return values. It shows that smart contracts could behave like conventional programs, responding to calls and returning structured data, not just storing state.
The repetition of this deployment reinforces that executable runtime code had moved from experimentation to something reusable, even within Ethereum’s first weeks.
Context
In August 2015, Ethereum development was still happening directly on mainnet. Tooling was minimal, Solidity was immature, and many developers worked at the bytecode level. Simple demonstrations such as returning a string required careful manual construction of memory and control flow.
This contract reflects that formative period, when even a “Hello World” deployment was a meaningful proof that the EVM could support interactive programs, laying groundwork for higher-level languages, ABIs, and application frameworks that followed.
Key Facts
Description
The deployed runtime code includes function dispatch logic, memory allocation, and return data construction sufficient to return the UTF-8 string "Hello World!" to callers. The string is embedded directly in the contract’s bytecode and assembled in memory at call time.
The contract also includes owner-gated control flow that allows the deployer to trigger contract self-destruction under specific conditions. Aside from this lifecycle control, the contract’s primary observable behavior is responding to calls with a fixed string value.
This deployment reuses the same executable bytecode seen in nearby blocks, indicating deliberate redeployment of a known-working runtime artifact rather than a one-off experiment.
This contract was deployed shortly after the first executable runtime contract by the same deployer in August 2015. It contains callable logic that responds to function selectors and returns a static UTF-8 string, demonstrating a more expressive example of on-chain execution.
Source Verified
The official Ethereum Greeter tutorial contract (mortal + greeter). Compiled with soljson v0.1.1+commit.6ff4cd6, optimizer off. 692 bytes + 96 bytes constructor arg = 788 bytes. Self-destructed.
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
Source verified through compiler archaeology and exact bytecode matching.
View Verification ProofShow source code (Solidity)
contract mortal {
address owner;
function mortal() { owner = msg.sender; }
function kill() { if (msg.sender == owner) suicide(owner); }
}
contract greeter is mortal {
string greeting;
function greeter(string _greeting) public {
greeting = _greeting;
}
function greet() constant returns (string) {
return greeting;
}
}