Minimal Proxy

A minimal proxy (also known as an ERC-1167 proxy) is a smart contract pattern that deploys a tiny, fixed-bytecode contract whose sole function is to delegate all calls to a pre-defined implementation contract. This creates a clone that shares the logic of the master contract but maintains its own independent storage and balance. The primary advantage is extreme gas efficiency; deploying a minimal proxy costs a fraction of deploying a full contract, as it reuses the immutable logic already on-chain. This pattern is foundational for systems requiring many identical contract instances, such as decentralized exchanges for user trading pairs or NFT projects for individual user vaults.

The technical specification, formalized as EIP-1167, defines a bytecode sequence of just 45 bytes. When a call is made to the proxy, its fallback function uses the DELEGATECALL opcode to execute the code from the implementation contract within the proxy's own context. This means the logic runs as if it were part of the proxy, allowing each clone to have unique state—like token balances or owner addresses—while the expensive logic code is deployed only once. Key considerations include ensuring the implementation contract is immutable and secure, as any upgrade or bug in the logic affects all linked proxies.

Common use cases extend beyond simple cloning. The minimal proxy factory pattern involves a master contract that deploys these proxies on-demand, enabling scalable systems like liquidity pools for each asset pair or multi-signature wallets for different teams. Developers must be aware of the trade-offs: while deployment and storage are cheap, each transaction incurs a small additional gas overhead for the delegate call. Furthermore, because the proxy's logic address is immutable, upgradeability requires more advanced patterns, like the proxy beacon (ERC-1538), which allows many minimal proxies to reference an upgradeable beacon contract holding the current logic address.

A minimal proxy (also known as an ERC-1167 proxy) is a tiny, standardized smart contract whose bytecode contains a hardcoded address for a master implementation contract. Its core mechanism is simple: upon deployment, it uses the DELEGATECALL opcode to forward all incoming calls—including the function selector and calldata—to this implementation. The key is that the proxy's storage context is used, meaning any state changes from the delegated logic are written to the proxy's own storage slot. This creates a clone that shares logic but maintains independent state, all while minimizing deployment costs.

The efficiency stems from its extremely compact bytecode, which is typically around 45 bytes. This is achieved through a clever construction: the proxy's runtime code is just enough to read the implementation address from its own bytecode and perform the DELEGACALL. In contrast, deploying a full new instance of a complex contract can cost millions of gas. By deploying only this minimal stub, projects can create thousands of instances (like individual user wallets in a vault system or unique NFTs in a collection) for a fraction of the cost. The trade-off is a minor runtime gas overhead for each call due to the extra DELEGATECALL step.

A critical security consideration for minimal proxies is ensuring the implementation contract is stable and secure, as an upgrade requires deploying a new proxy. The pattern is inherently non-upgradeable for the individual proxy instance; the code it points to is immutable. However, systems can be designed where new proxies point to a newer implementation. Developers must also be cautious of storage collisions; because the proxy delegates logic but uses its own storage layout, the implementation contract must use unstructured storage patterns or inherit from specific base contracts (like those in OpenZeppelin's library) to avoid clashes between the proxy and implementation storage variables.

A Minimal Proxy (also known as an ERC-1167 proxy) is a smart contract pattern that deploys a tiny, fixed-bytecode contract whose sole function is to delegate all calls to a predetermined implementation contract. This creates a highly gas-efficient way to deploy multiple instances of similar logic, as each proxy requires only a fraction of the gas needed to deploy a full contract. The proxy contains just enough code to read its target implementation address from storage and forward any call via delegatecall, making it a cornerstone for scalable, low-cost contract factory systems.

The core mechanism relies on EIP-1167, which standardized a minimal bytecode sequence for these proxies. When a user interacts with a minimal proxy, the call is transparently routed to the master implementation contract using delegatecall. This means the proxy executes the logic in the context of its own storage, allowing each clone to maintain independent state—such as unique token balances or owner addresses—while sharing the same executable code. This separation of logic and storage is key to the pattern's efficiency and flexibility.

Common use cases include token drop campaigns, where thousands of unique reward contracts are needed, and proxy factories for DeFi pools or NFT collections. For example, a project might deploy a single sophisticated staking contract as the implementation, then use a factory to create thousands of minimal proxies, each representing a separate user's staking vault. This drastically reduces deployment costs compared to deploying the full contract bytecode for each user, making complex systems economically viable on-chain.

While extremely efficient, developers must consider important security implications. Since all proxies share the same logic, a bug or upgrade in the implementation contract affects every clone instantly. The pattern typically uses an immutable implementation address, meaning proxies are not upgradeable by design—a feature for simplicity and trust minimization. For upgradeable systems, more complex proxy patterns like Transparent or UUPS are used, which incorporate admin functions and storage slots for a mutable implementation address.

In practice, the minimal proxy bytecode is so compact (45 bytes) that it is often deployed using the CREATE2 opcode, which allows for the deterministic prediction of a proxy's address before it is deployed. This enables advanced patterns like counterfactual deployment, where systems can interact with or reference a contract address that may not yet exist on-chain, further optimizing gas usage and enabling novel application architectures.