Disposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
Historical Significance
This is what an execution account looked like when gas was the binding constraint and the caller was a program rather than a person. Nothing about the calldata layout is ABI encoded, because ABI encoding would have meant paying for padding on every call. The address sits at offset 8 rather than offset 4 for one reason: it puts the twenty bytes exactly where a single memory word can be masked to reach them.
The design also separates two powers that later account abstraction work would keep separate on purpose. Slot 1 gives the account a standing implementation that anyone can reach through the fallback. proxy() gives a short list of privileged callers the ability to route a one off call or delegatecall through the account without changing that implementation. Deploying many of them in a single transaction, all under one controller, is the 2018 answer to a question smart accounts are still answering.
Token Information
Key Facts
Description
Two storage slots and two entry points. Slot 0 holds an owner, slot 1 holds an optional implementation, and everything else is inline assembly.
The fallback is a proxy. If slot 1 is set, the whole calldata is delegatecalled into it and the return data is passed straight back, so the account can be given behaviour after deployment without redeploying. If slot 1 is empty the fallback accepts plain ether and does nothing else.
The named entry point is proxy(), and it reads none of its arguments the way Solidity would. Callers pack them by hand: one flags byte at offset 7, a twenty byte target at offset 8, and the payload from offset 28 onward, which is why the function declares no parameters and the body starts by copying calldata into memory at 0x18 so that a single mload lands on the address. The low nibble of the flags byte selects call or delegatecall, the high nibble selects whether return data is forwarded or discarded, and anything else reverts. Three callers are allowed through: the owner in slot 0, and two addresses written into the code at compile time.
One of those two hardcoded addresses is the account's own deployer, which created these in batches within single transactions. The owner slot points at a separate controller contract whose interface reads createAccounts, importAccounts, getAccounts, accounts and getAccountCount, alongside its own proxy() and a withdraw(). That controller is where the name comes from: to the system that built them, these are accounts, not proxies.
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.24;
contract Account {
address owner;
address target;
function proxy() public payable {
require(msg.sender == owner
|| msg.sender == address(0x4a4c35280bc7e7f426453db48e5faf66f47398b6)
|| msg.sender == address(0x825d5d0df3b2d59f69cc673f041ca91a296b8183));
require(msg.data.length >= 0x1c);
assembly {
calldatacopy(0x18, 0, calldatasize)
let w := mload(0)
let mode := and(w, 0x0f)
let ret := and(w, 0xf0)
let to := and(mload(0x14), 0xffffffffffffffffffffffffffffffffffffffff)
let ptr := 0x34
let len := sub(calldatasize, 0x1c)
let ok := 0
switch mode
case 0 { ok := call(gas, to, callvalue, ptr, len, 0, 0) }
case 1 { ok := delegatecall(gas, to, ptr, len, 0, 0) }
default { revert(0, 0) }
switch ret
case 0 { if iszero(ok) { revert(0, 0) } stop() }
case 0x10 {
returndatacopy(0, 0, returndatasize)
if iszero(ok) { revert(0, returndatasize) }
return(0, returndatasize)
}
default { revert(0, 0) }
}
}
function () public payable {
assembly {
let v := sload(1)
let t := and(v, 0xffffffffffffffffffffffffffffffffffffffff)
if t {
calldatacopy(0, 0, calldatasize)
let ok := delegatecall(gas, t, 0, calldatasize, 0, 0)
returndatacopy(0, 0, returndatasize)
if iszero(ok) { revert(0, returndatasize) }
return(0, returndatasize)
}
if v { revert(0, 0) }
stop()
}
}
}External Links
Related contracts
Account
Same deployerDisposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
0xd1277c...b817d3June 12, 2018Account
Same deployerDisposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
0xe1ea1d...5095e0June 12, 2018Account
Same deployerDisposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
0xf24761...a8ee99June 12, 2018Account
Same deployerDisposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
0x329e96...f66aa1June 12, 2018Account
Same deployerDisposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
0x126c67...d09e49June 12, 2018Account
Same deployerDisposable execution account from a 2018 fleet: a delegatecall proxy with a hand packed calldata entry point that lets its controller call or delegatecall anything through it.
0xf81dc4...2cf2e2June 12, 2018