# EIP-1167: Minimal Proxy Contract

Source: https://www.eipsfordesigners.com/standards/EIP-1167
Agent brief: https://www.eipsfordesigners.com/standards/EIP-1167/agent.md
Machine-readable JSON: https://www.eipsfordesigners.com/api/standards/EIP-1167
Last reviewed: 2026-04-05
Last updated: 2026-04-05

| Field | Value |
| --- | --- |
| Status | Final |
| Chain | both |
| Category | Infrastructure |
| Journey stages | Infrastructure |
| Detailed guide | Yes |
| Official specification | https://eips.ethereum.org/EIPS/eip-1167 |
| Discussion search | https://ethereum-magicians.org/search?q=EIP-1167 |

## UX Impact

Many contracts share identical code via lightweight clones — same interface, different addresses. Design implications: when displaying contract info, detect clones and show the 'master' contract's verified source/audit status, group clone contracts in portfolio views, indicate 'Clone of [verified contract]' badges. Design decisions: whether to surface clone relationships prominently (transparency) or hide complexity (simplicity); how to handle trust signals when master contract upgrades.

## Summary

EIP-1167 defines minimal proxy contracts (clones) that delegate all calls to an implementation contract. This lets you deploy many contracts cheaply by creating tiny proxies pointing to shared code—why creating an NFT collection or DAO doesn't cost $500 in gas.

## For Designers

- You can design UI that delivers tiny 45-byte proxy cloned for ~$5-10.
- You can design UI that delivers clone factory creates instances cheaply.
- You can each user gets their own contract cheaply in the interface.

## Applicability

### When to Use

- Your product addresses: deploying contracts is expensive.
- Your product addresses: factory patterns cost too much.
- The flow should deliver: tiny 45-byte proxy cloned for ~$5-10.
- You are designing a one-click contract creation experience with visible states and recovery paths.

### When to Avoid

- Show "Powered by [Implementation]" with link.
- Always link to implementation on block explorer.
- Clearly label "Your contract" vs "Implementation".
- Protocol plumbing is invisible and never surfaces in user-facing UI.

## Problems It Solves

### Deploying contracts is expensive

Impact: critical

Old way: Full contract bytecode deployed each time (~$200-500)

New way: Tiny 45-byte proxy cloned for ~$5-10

### Factory patterns cost too much

Impact: critical

Old way: Each user's vault/collection is full deployment

New way: Clone factory creates instances cheaply

### Can't afford per-user contracts

Impact: high

Old way: Share one contract, complex accounting

New way: Each user gets their own contract cheaply

### Code duplication on chain

Impact: medium

Old way: Same bytecode stored thousands of times

New way: One implementation, many proxies

## Anti-Patterns

### Hiding that contract is a proxy

Severity: high

Users deserve to know how their contract works

Instead: Show "Powered by [Implementation]" with link

### Not linking to verified implementation

Severity: high

User can't verify the code their proxy uses

Instead: Always link to implementation on block explorer

### Confusing proxy address with implementation

Severity: medium

User looks up wrong address, sees weird bytecode

Instead: Clearly label "Your contract" vs "Implementation"

### Not explaining gas savings

Severity: medium

User doesn't understand the value they're getting

Instead: Show "Saved ~$150 using clone pattern"

### Using clones for upgradeable contracts

Severity: medium

EIP-1167 clones are immutable, confuses with upgradeable

Instead: Clarify: "Your clone points to fixed implementation"

## UI Components

### CloneDeployer

Form for creating new clone instance
States: configuring, deploying, deployed, error
Props: factoryAddress, initParams, onDeploy

### GasSavingsIndicator

Shows savings from using clone vs full deploy
States: calculating, ready
Props: fullDeployCost, cloneCost, savings

### ProxyVerificationBadge

Badge showing proxy points to verified impl
States: verified, unverified, loading
Props: proxyAddress, implementationAddress, isVerified

### FactoryCloneList

List of all clones from a factory
States: loading, loaded, empty
Props: clones[], onCloneClick

### CloneExplainerTooltip

Explains how minimal proxy works
States: collapsed, expanded
Props: showDiagram

## On Monad

### Clone Deployment

Ethereum: Clone deploy still costs ~$5-10

Monad: Near-zero cost clone creation

Design implication: Can create per-transaction contracts if needed

### Factory Throughput

Ethereum: Factory limited by block gas limits

Monad: Parallel execution enables high clone throughput

Design implication: Bulk clone creation for airdrops/onboarding viable

### User Contract Pattern

Ethereum: Still consider shared contracts for cost

Monad: Per-user contracts always affordable

Design implication: Every user can have isolated contract by default

### Delegate Call Speed

Ethereum: Delegate call adds small overhead

Monad: Optimized execution minimizes proxy overhead

Design implication: Proxy pattern has negligible performance cost

## Key Takeaways

- EIP-1167 = tiny proxy pointing to shared implementation
- Creates contracts cheaply (95%+ savings)
- Always link to the verified implementation
- Explain to users their clone uses audited code
- Clones are immutable—not upgradeable proxies

## UX Patterns

### One-Click Contract Creation

User creates their own contract instantly

User flow:

- User fills in contract parameters
- Sees cost comparison (clone vs full)
- Clicks create
- Clone deployed in seconds
- Gets their own contract address

Mockup registry key: `concept/nft-gallery` (React UI on the live standard page).

### Factory Dashboard

View all clones created from a factory

User flow:

- Admin views factory dashboard
- Sees all clones created
- Monitors adoption and gas savings
- Links to implementation for verification

Mockup registry key: `concept/nft-gallery` (React UI on the live standard page).

### Clone Verification

Show user their clone points to verified code

User flow:

- User checks their contract
- Sees it's a proxy (not full code)
- Views implementation it delegates to
- Confirms implementation is verified/audited
- Trusts their clone is safe

Mockup registry key: `concept/proxy-pattern` (React UI on the live standard page).

### Personal Vault Creation

User gets their own vault contract

User flow:

- User selects vault type
- Sees low deployment cost
- Can learn why it's cheap (clone pattern)
- Creates vault
- Gets personal contract address

Mockup registry key: `concept/proxy-pattern` (React UI on the live standard page).

## Technical Notes

EIP-1167 minimal proxy is exactly 45 bytes of bytecode that delegatecalls to a hardcoded implementation address. All storage lives in the proxy, logic in the implementation. The proxy cannot be upgraded—it permanently points to one implementation. This is different from upgradeable proxies (EIP-1967) where the implementation can change.