You saved the contract address. It still matches. That is useful, but for an upgradeable smart contract it does not settle which code your next interaction will execute.
This explainer covers common proxy patterns on Ethereum and compatible EVM networks. It is for readers checking a token, DeFi application or account, not a deployment tutorial or an audit of any live contract.
How upgradeable smart contracts keep the same address
A proxy is a contract that delegates execution to another contract, called its implementation. In an upgradeable design, an authorized action can change that implementation reference. The proxy remains at its existing address.
This does not edit the old implementation's deployed bytecode. A new implementation is deployed separately and the proxy starts using it. Ethereum's upgrade overview distinguishes this arrangement from migrating users to an entirely new contract address.
Under delegatecall, implementation code executes in the proxy's context. Application storage, such as the records used for balances, belongs to the proxy in this design. It is not copied into the new implementation simply because the reference changes. OpenZeppelin's proxy explanation describes this separation between code and state.
Think of a fixed service counter with a replaceable rulebook. The counter's number stays on the wall; the instructions behind it change. The analogy stops there: new code can also change stored records, and a bad upgrade can misinterpret them.
Follow the proxy, implementation and authority separately
ERC-1967 defines standard storage locations for implementation, beacon and optional admin information. This lets tools inspect supported proxies rather than guess from the token name.
| Item | What to establish | What it does not settle |
|---|---|---|
| Network and proxy address | Which deployment the application uses | Which code it will use after a future upgrade |
| Implementation | Which logic the proxy currently delegates to | Who can replace it or whether it is safe |
| Upgrade authority | Which account or contract can authorize the change | Whether every relevant path has a delay |
| Proxy storage | Where the application's persistent records are kept in this pattern | Whether new code preserves their meaning |
The standard's implementation slot is a location inside proxy storage, not an address to send funds to. A beacon-based design needs another step: find the beacon, then its implementation. An empty implementation slot alone therefore does not prove that a contract is non-upgradeable.
For a historical transaction, today's implementation may be the wrong version to inspect. Record the relevant block or execution point. ERC-1967 recommends upgrade events, but an event list alone is not a complete proof of every control path or custom design.
First establish the exact network and contract address. A matching ticker remains a separate, weaker clue.
UUPS, transparent and beacon are different designs
The names describe where routing and upgrade control live. They are not security ratings. In OpenZeppelin Contracts 5.x, the distinctions are:
- A transparent proxy has an upgrade interface in the proxy and an associated
ProxyAdmin. Follow that contract's owner to understand who controls upgrades; do not stop at an admin label. - A UUPS design puts upgrade functionality in the implementation. Its authorization logic matters. OpenZeppelin requires
_authorizeUpgradeto be overridden with appropriate access restrictions. - A beacon proxy gets its implementation from a beacon. Changing that beacon's implementation can affect several proxies that follow it.
Not every proxy is upgradeable. OpenZeppelin explicitly describes ERC1967Proxy as not upgradeable by itself; a UUPS implementation supplies the upgrade mechanism. Its minimal-clone utilities also include non-upgradeable proxies. Conversely, a different contract system may use a custom mechanism outside these patterns.
The useful question is: which code path can change this deployment's behavior, and who can call it?
A fictional upgrade without a token migration
Suppose a fictional application uses proxy P, delegates to implementation V1, and stores a user's record in P. Its authorized controller changes the reference to V2. Assume this example changes only the reference and performs no migration or other state writes.
The user still interacts with P. The stored record has not automatically moved to V2, and no replacement token was automatically delivered. Future delegated calls use V2's logic.
Keeping the record's raw bytes is not enough. If V2 interprets storage incorrectly, the application can behave incorrectly even though its address is unchanged. OpenZeppelin's upgradeable-contract guide explains storage-layout compatibility and initializer rules. Those are engineering requirements, not checks a reader can replace with a green badge.
The cover illustrates this simplified reference change. Brokzi is inspecting the route, not certifying V2 or operating a real upgrade. Real upgrades can include initialization and other state changes, so the example is not a promise that balances or permissions stay unchanged.
What a timelock and a verified badge actually tell you
A multisignature controller can require several approvals. A timelock can enforce a delay before an operation executes. They answer different questions: whose authorization is needed, and when execution is permitted. Neither is automatically present because a project calls itself decentralized.
OpenZeppelin's access-control documentation describes owner, role and timelock arrangements. Check the actual controller, configured delay and alternative privileged routes. A delay is not a guarantee that you can withdraw in time; liquidity, withdrawal rules and other dependencies may still prevent that.
Source-code verification concerns the relationship between published source and deployed bytecode. It is distinct from proving that the program behaves correctly. For a proxy, inspect the implementation as well as the wrapper. An audit of V1 is not automatically an audit of V2, its initialization or its current control configuration.
A read-only contract-upgrade checklist
- Confirm the chain and full application or token address through independently checked official documentation.
- Establish whether the deployment uses a proxy and which pattern. Treat an unrecognized design as unresolved, not immutable.
- Identify its current implementation, following a beacon when applicable. Record the observation time or block.
- Trace the upgrade authority and any enforced delay. Separate the application owner, proxy administration and ordinary user permissions.
- Compare the named version and configuration with any published audit scope. Check documented upgrades rather than assuming an old report covers today's code.
Public documentation and explorer lookups do not require recovery words or a wallet signature. Stop if a supposed inspection asks you to approve an unsolicited transaction.
Your token allowance and a protocol's upgrade authority are different permissions. Revoking an allowance does not remove somebody else's administrative powers. For account-specific recovery and delegation, see smart contract wallets; a successful transaction record also does not certify future contract behavior.
Can a contract address stay the same after an upgrade?
Yes, in an upgradeable proxy design. The proxy address remains while its implementation reference changes. This is different from a migration to another application address. Whether a particular deployment supports upgrades, and who can authorize them, needs evidence from that deployment rather than its name or ticker.
Does verified source code mean a contract cannot change?
No. Source-code verification and upgradeability are separate properties. A verified proxy can delegate to a different implementation after an authorized upgrade. Verification also does not prove safety. Read the current implementation and control arrangement, and establish which version any security review actually examined.
Brokzi's take
Upgradeable smart contracts give developers a way to fix bugs and add features, along with authority that readers need to understand. Keep checking the address, but add the current implementation and its controller to the record. If either is unclear, the honest result is unknown, not a safety verdict.
Sources
Primary documentation checked 18 October 2026 (UTC). This is an explanation of proxy mechanisms, not a new protocol announcement, deployed-contract test, endorsement, investment recommendation or security audit. OpenZeppelin is cited as the implementation-documentation source, not as a sponsor or reviewer of Brokzi.
- Ethereum.org: Upgrading smart contracts — proxy upgrades versus migration, delegated execution and trust assumptions.
- OpenZeppelin: Proxy upgrade pattern — code/state separation and storage collisions.
- ERC-1967: Proxy storage slots — implementation, beacon, optional admin slots and event recommendations.
- OpenZeppelin Contracts 5.x: Proxy API — transparent, UUPS, beacon and non-upgradeable proxy distinctions.
- OpenZeppelin: Writing upgradeable contracts — initialization and storage-layout constraints.
- OpenZeppelin Contracts 5.x: Access control — ownership, roles and timelocks.
- Ethereum.org: Verifying smart contracts — source/bytecode matching versus correctness verification.
See something wrong? Brokzi logs material changes. Prepare a correction note.




