# EIP-1967: Proxy Storage Slots

Source: https://www.eipsfordesigners.com/standards/EIP-1967
Agent brief: https://www.eipsfordesigners.com/standards/EIP-1967/agent.md
Machine-readable JSON: https://www.eipsfordesigners.com/api/standards/EIP-1967
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-1967 |
| Discussion search | https://ethereum-magicians.org/search?q=EIP-1967 |

## UX Impact

Proxy contracts have standardized slots revealing implementation address and admin — enables reliable upgrade detection. Design implications: show 'Upgradeable' badges on proxy contracts, display both proxy and implementation addresses in contract details, alert users when implementation changes, show admin address for governance transparency. Design decisions: how prominently to warn about upgradeability risks vs. normalizing the pattern; whether to show upgrade history timeline.

## Summary

EIP-1967 standardizes where proxy contracts store their implementation address. This lets block explorers like Etherscan show "Read as Proxy" so users see actual functions instead of confusing wrapper code. Essential for making upgradeable contracts usable.

## For Designers

- You can design UI that delivers explorer detects proxy, shows implementation interface.
- You can standard slot, anyone can verify implementation address.
- You can standard slots: all tools work universally.

## Applicability

### When to Use

- Your product addresses: block explorers show proxy bytecode, not real functions.
- Your product must handle: can't verify what code proxy is running.
- The flow should deliver: explorer detects proxy, shows implementation interface.
- You are designing a block explorer proxy view experience with visible states and recovery paths.

### When to Avoid

- Detect proxy, show implementation source.
- Prominently show admin and their permissions.
- Notify users when implementation changes.
- Protocol plumbing is invisible and never surfaces in user-facing UI.

## Problems It Solves

### Block explorers show proxy bytecode, not real functions

Impact: critical

Old way: User sees confusing proxy code, can't interact

New way: Explorer detects proxy, shows implementation interface

### Can't verify what code proxy is running

Impact: critical

Old way: Trust that proxy points to claimed implementation

New way: Standard slot, anyone can verify implementation address

### Different proxies store implementation differently

Impact: high

Old way: Each proxy pattern needs custom detection

New way: Standard slots: all tools work universally

### Admin address hidden or unpredictable

Impact: high

Old way: Who can upgrade this? Check code manually

New way: Standard admin slot reveals upgrade authority

## Anti-Patterns

### Showing proxy bytecode as "contract source"

Severity: critical

Users can't understand or verify what code runs

Instead: Detect proxy, show implementation source

### Hiding admin address

Severity: critical

Users don't know who can change the contract

Instead: Prominently show admin and their permissions

### No upgrade notifications

Severity: high

Users surprised by changed behavior

Instead: Notify users when implementation changes

### Single EOA as admin

Severity: high

One compromised key = protocol compromised

Instead: Show warning when admin is single address

### Not linking to implementation on explorer

Severity: medium

User can't verify the actual code

Instead: Always provide clickable link to implementation

## UI Components

### ProxyBanner

Banner indicating contract is a proxy
States: proxy-detected, not-proxy, unknown
Props: implementationAddress, adminAddress, proxyType

### ImplementationViewer

Shows what implementation proxy points to
States: loading, verified, unverified, error
Props: proxyAddress, implementationAddress, isVerified

### AdminAnalyzer

Analyzes who controls proxy upgrades
States: eoa, multisig, timelock, renounced
Props: adminAddress, adminType, signers[], timelockDuration

### UpgradeNotification

Alert showing contract was upgraded
States: pending, executed, cancelled
Props: oldImplementation, newImplementation, changelog

### ProxyReadWrite

Interface for interacting via proxy
States: loading, ready, submitting
Props: proxyAddress, abiFromImplementation, onCall

## On Monad

### Upgrade Speed

Ethereum: Upgrade tx takes a block

Monad: Sub-second upgrade finality

Design implication: Emergency upgrades can be truly instant

### Slot Reading

Ethereum: Reading storage slots is cheap but requires RPC

Monad: Fast parallel reads for proxy detection

Design implication: Can check many contracts for proxy status quickly

### Timelock Precision

Ethereum: Timelocks based on block numbers

Monad: Precise second-level timelocks possible

Design implication: More accurate upgrade scheduling

### Proxy Overhead

Ethereum: Delegatecall adds small gas overhead

Monad: Optimized execution reduces proxy cost

Design implication: Proxy pattern even more efficient

## Key Takeaways

- EIP-1967 = standardized storage for proxy info
- Enables "Read as Proxy" on block explorers
- Always show implementation AND admin addresses
- Warn users about admin trust assumptions
- Notify on upgrades so users aren't surprised

## UX Patterns

### Block Explorer Proxy View

Etherscan "Read as Proxy" interface

User flow:

- User visits proxy contract on explorer
- Sees "This is a Proxy Contract" banner
- Views implementation address
- Sees admin who can upgrade
- Clicks "Read as Proxy" for real functions
- Interacts with actual interface

Mockup registry key: `generic/token-approval` (React UI on the live standard page).

### Contract Upgrade Notice

Inform users about proxy upgrade

User flow:

- Protocol upgrades implementation
- Users notified of change
- See what changed (new features/fixes)
- Understand their assets are safe
- Can verify upgrade transaction

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

### Proxy Trust Verification

Help users verify proxy safety

User flow:

- User pastes contract address
- System detects EIP-1967 proxy
- Fetches implementation from standard slot
- Checks verification and audit status
- Analyzes admin permissions
- Shows overall risk assessment

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

### Upgrade Governance

Admin interface for proposing upgrades

User flow:

- Admin enters new implementation address
- System runs verification checks
- Warns about missing requirements
- Admin proposes upgrade
- Other signers approve
- Timelock countdown begins
- Upgrade executes after delay

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

## Technical Notes

EIP-1967 defines three storage slots: implementation (0x360894...), admin (0xb531...), and beacon (0xa3f0...). These specific slots are chosen to avoid collisions with normal storage. Block explorers read these slots to detect proxies and show the correct interface. UUPS and Transparent proxies both use these slots.