One of Ethereum's earliest pyramid-style chain letter contracts, deployed 9 days after genesis. Required 10 ETH per entry and distributed payouts to earlier par
Historical Significance
One of the earliest known smart contracts on Ethereum to implement an automated pyramid or chain letter scheme. Deployed just 9 days after genesis, it demonstrates that programmable money attracted both legitimate experimentation and adversarial financial schemes from the very beginning. The contract's architecture - automatic payout distribution with no admin controls - was a novel application of trustless execution that would later become a recurring pattern in Ethereum's history. The 130 ETH permanently locked in the contract remains a tangible artifact of Frontier-era activity.
Context
During Ethereum's first weeks (the Frontier release, July 30, 2015), the network was being explored by a small community of early adopters. ETH had minimal market value ($0.50-$3.00), and developers were experimenting with what smart contracts could do. Chain letter and Ponzi contracts appeared almost immediately alongside legitimate experiments like the Greeter tutorial, name registries, and early token contracts. This contract was deployed the same day as several FirstCoin tutorial tokens, illustrating the full spectrum of activity on the nascent network.
Key Facts
Description
EarlyChainLetter10ETH was deployed on August 7, 2015, at block 49,931 - just nine days after the Ethereum Frontier genesis block. It is one of the earliest known pyramid-style smart contracts on Ethereum.
The contract implements a classic chain letter scheme: each participant sends exactly 10 ETH, and the contract automatically distributes portions of each new deposit to earlier participants, with a diminishing share structure. The deployer and earliest investors receive the largest cumulative payouts.
The deployer (0x881b0a4e) created three chain letter contracts in rapid succession within the same hour. The first variant (0x109c4f2c, block 49,924) required only 1 ETH per entry and attracted minimal activity (5 transactions). The second - this contract - raised the threshold to 10 ETH and became significantly more active. A third variant (0xbaa54d6e, block 49,936) was deployed minutes later with slightly different bytecode and attracted 44 transactions.
Activity was intense from the start: 30+ deposits arrived within the first 7 hours of deployment, all during August 7-8, 2015. The contract attracted 134 total transactions from 54 unique participants. Of these, 106 were successful and 27 failed. Total ETH deposited exceeded 1,300 ETH.
The contract has no withdrawal or self-destruct function. Approximately 130 ETH remains permanently locked in the contract - worth over $250,000 at March 2026 prices.
Remarkably, people continued sending 10 ETH to the contract years after deployment. The most recent transaction was recorded on August 21, 2023 - over 8 years after the original deployment.
The contract was compiled with Solidity v0.1.1 and exposes a single read function: getNumInvestors(). It uses pre-modern Solidity patterns including an unnamed fallback function as the entry point and send() for ETH transfers (before transfer() and call() became standard).
The source code (decompiled and bytecode-verified) refers to the contract internally as "MyScheme." The top recipients were the deployer (0x881b0a4e, 51.10 ETH) and the first external participant (0xa14cf6ce, 46.10 ETH).
Source Verified
Exact runtime bytecode match. soljson v0.1.1.
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 MyScheme {
uint treeBalance;
uint numInvestorsMinusOne;
uint treeDepth;
address[] myTree;
function MyScheme() {
treeBalance = 0;
myTree.length = 6;
myTree[0] = msg.sender;
numInvestorsMinusOne = 0;
}
function getNumInvestors() constant returns (uint a){
a = numInvestorsMinusOne+1;
}
function() {
uint amount = msg.value;
if (amount>=10000000000000000000){
numInvestorsMinusOne+=1;
myTree[numInvestorsMinusOne]=msg.sender;
amount-=10000000000000000000;
treeBalance+=10000000000000000000;
if (numInvestorsMinusOne<=2){
myTree[0].send(treeBalance);
treeBalance=0;
treeDepth=1;
}
else if (numInvestorsMinusOne+1==myTree.length){
for(uint i=myTree.length-3*(treeDepth+1);i<myTree.length-treeDepth-2;i++){
myTree[i].send(5000000000000000000);
treeBalance-=5000000000000000000;
}
uint eachLevelGets = treeBalance/(treeDepth+1)-1;
uint numInLevel = 1;
for(i=0;i<myTree.length-treeDepth-2;i++){
myTree[i].send(eachLevelGets/numInLevel-1);
treeBalance -= eachLevelGets/numInLevel-1;
if (numInLevel*(numInLevel+1)/2 -1== i){
numInLevel+=1;
}
}
myTree.length+=treeDepth+3;
treeDepth+=1;
}
}
treeBalance+=amount;
}
}