April 2018 'Lambo' ERC-20 with permissionless mint() — one free token per address. mintMore() gives 3 more LAMBO for a 1 finney payment.
Historical Significance
A small joke / faucet-style ERC-20 from the spring-2018 era of casual experimental tokens. Notable not for trading volume but as a near-minimal example of a permissionless-mint ERC-20 with a paid 'mintMore' side door — and as a paired deployment: this is one of two near-identical Lambo contracts deployed within an hour of each other on April 12, 2018 by two unrelated addresses, differing only in the payment threshold and bonus size in mintMore.
Context
The pair. Two Lambo contracts were deployed on Ethereum on April 12, 2018, within roughly an hour of each other (blocks 5428442 and 5428754). They share the same source modulo two lines in mintMore: the payment threshold (1 finney vs 1 wei) and the per-call bonus (3 LAMBO vs 10 LAMBO). The selectors, ERC-20 surface, and storage layout are otherwise identical. The other deployment is at 0xae3350fdec3819e4d2a30b97835f0ccfe0973a21.
This deployment. Compiled with solc v0.4.21+commit.dfe3193c, optimizer ON (200 runs). Deployer 0x690f34053ddc11bdff95d44bdfeb6b0b83cbab58 is an EOA with no ENS and no public tags; it has deployed other small contracts in the same era but none are clearly linked to a public project. mintMore collects 1 finney (0.001 ETH) per call and pays it through to the contract owner with owner.transfer(msg.value).
Token Information
Key Facts
Description
Lambo is a tiny ERC-20 token contract deployed on Ethereum on April 12, 2018. Anyone can call mint(address) and receive 1 LAMBO (18 decimals), with a hard constraint of one free mint per address — require(balanceOf[who] == 0) blocks a second free mint to the same address. A separate mintMore(address) function is payable and lets the caller buy more: this deployment requires 1 finney (0.001 ETH) per call and credits 3 LAMBO per call to the recipient, forwarding the payment to the contract owner. A burn(uint256) function lets any holder send tokens to the zero address.
The rest of the surface is a standard ERC-20: transfer, transferFrom, approve, allowance, balanceOf, plus the name/symbol/decimals metadata (Lambo / LAMBO / 18).
On-chain activity. As of the most recent block read, this deployment has recorded 488 mint events (from-address 0x0 Transfers) distributed across 277 unique recipients, with a total minted supply of 516 LAMBO. Active period: April 12, 2018 → 2018-06-05.
Source Verified
Source byte-for-byte verified against on-chain bytecode (only the swarm metadata hash differs). solc v0.4.21+commit.dfe3193c, optimizer ON (200 runs). Already verified on Etherscan and Sourcify; matches independently.. Optimizer: ON (200 runs)
Heuristic Analysis
The following characteristics were detected through bytecode analysis and may not be accurate.
Byzantium Era
First Metropolis hard fork. Added zk-SNARK precompiles, REVERT opcode, and staticcall.
Bytecode Overview
Verified Source Available
Source verified through compiler archaeology and exact bytecode matching.
View Verification ProofShow source code (Solidity)
// Submitted by EthereumHistory (ethereumhistory.com)
pragma solidity ^0.4.21;
contract Lambo {
string public name = "Lambo"; // token name
string public symbol = "LAMBO"; // token symbol
uint256 public decimals = 18; // token digit
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
uint256 public totalSupply = 0;
address owner;
modifier isOwner {
assert(owner == msg.sender);
_;
}
modifier validAddress {
assert(0x0 != msg.sender);
_;
}
function Lambo() public {
owner = msg.sender;
mint(owner);
}
function transfer(address _to, uint256 _value) public validAddress returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress returns (bool success) {
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
require(allowance[_from][msg.sender] >= _value);
balanceOf[_to] += _value;
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public validAddress returns (bool success) {
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// WTF you want to burn LAMBO!?
function burn(uint256 _value) public {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
balanceOf[0x0] += _value;
emit Transfer(msg.sender, 0x0, _value);
}
function mint(address who) public {
if (who == 0x0){
who = msg.sender;
}
require(balanceOf[who] == 0);
_mint(who, 1);
}
function mintMore(address who) public payable{
if (who == 0x0){
who = msg.sender;
}
require(msg.value >= (1 finney));
_mint(who,3);
owner.transfer(msg.value);
}
function _mint(address who, uint256 howmuch) internal {
balanceOf[who] = balanceOf[who] + howmuch * (10 ** decimals);
totalSupply = totalSupply + howmuch * (10 ** decimals);
emit Transfer(0x0, who, howmuch * (10 ** decimals));
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}