One hundred and thirty-seven bytes: a delegatecall proxy with the implementation address burned into the code and a fixed 4096-byte return window.
Historical Significance
Fixing the implementation in the code rather than in storage makes this proxy immutable, which is the opposite of what most proxies are for. What it buys is size: no storage slot to read, no admin to protect, nothing to initialise. It is a cheap alias for one contract, deployed once per user or per role, and its cost model is the reason the same few bytes recur across whole fleets of addresses.
Key Facts
Description
There is no storage and no admin. The payable fallback hands the calldata to an internal helper that checks the target has code, delegatecalls it with ten thousand gas held back, and returns a fixed four kilobyte window of memory regardless of how much the call actually produced.
The fixed window is the tell that this predates RETURNDATASIZE being convenient to use: rather than ask how much came back, the proxy reserves more than any caller is likely to need and returns all of it. A caller decoding a single word reads the first thirty-two bytes and ignores the rest.
Failure is handled with invalid rather than revert, so a failed delegatecall consumes the whole gas allowance instead of refunding it. The extcodesize check in front is the one piece of defensive work: without it a delegatecall to an address with no code would succeed silently and the proxy would return four kilobytes of zeroes as if the call had worked.
Source Verified
Byzantium Era
First Metropolis hard fork. Added zk-SNARK precompiles, REVERT opcode, and staticcall.
Bytecode Overview
Verified Source Available
This contract has verified source code.
View Verification ProofShow source code (Solidity)
// Submitted by EthereumHistory (ethereumhistory.com)
pragma solidity ^0.4.18;
contract Proxy {
function () public payable {
forward(0x24B6eE04740ce5051539117409660f15E29ea329, msg.data);
}
function forward(address _target, bytes _data) internal {
assembly {
switch extcodesize(_target)
case 0 { revert(0, 0) }
let ret := 0x1000
let result := delegatecall(sub(gas, 10000), _target, add(_data, 0x20), mload(_data), 0, ret)
switch result
case 0 { invalid() }
return(0, ret)
}
}
}