Proxy pattern (upgradeable contracts) in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Proxy pattern (upgradeable contracts)

Client calls Proxy Contract

↓

Proxy forwards call to Logic Contract

↓

Logic Contract executes code

↓

Logic Contract returns result

↓

Proxy returns result to Client

↓

Upgrade? Replace Logic Contract address in Proxy

↓

Next calls use new Logic Contract

The proxy contract receives calls and forwards them to a logic contract. Upgrades happen by changing the logic contract address in the proxy.

Execution Sample

Blockchain / Solidity

contract Proxy {
  address logic;
  function call(bytes calldata data) external returns (bytes memory) {
    (bool success, bytes memory result) = logic.delegatecall(data);
    require(success, "Delegatecall failed");
    return result;
  }
  function upgrade(address newLogic) external {
    logic = newLogic;
  }
}

A proxy contract forwards calls to a logic contract and can upgrade by changing the logic address.

Execution Table

Step	Action	Proxy logic address	Call data	Delegatecall target	Result
1	Deploy Proxy with logic = LogicV1	LogicV1	-	-	-
2	Client calls Proxy.call with data for function foo()	LogicV1	foo()	LogicV1	foo() result from LogicV1
3	Upgrade Proxy logic to LogicV2	LogicV2	-	-	-
4	Client calls Proxy.call with data for function foo()	LogicV2	foo()	LogicV2	foo() result from LogicV2
5	Client calls Proxy.call with data for function bar()	LogicV2	bar()	LogicV2	bar() result from LogicV2
6	No more upgrades, calls continue to LogicV2	LogicV2	foo()	LogicV2	foo() result from LogicV2

💡 Execution stops when no more calls or upgrades happen.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
logic	null	LogicV1	LogicV2	LogicV2
call data	-	foo()	foo()	foo() or bar()
result	-	foo() result from LogicV1	foo() result from LogicV2	foo() or bar() result from LogicV2

Key Moments - 3 Insights

Why does the proxy not contain the logic code itself?

Because the proxy only forwards calls to the logic contract using delegatecall, so the logic code stays in the logic contract and can be upgraded by changing its address (see execution_table steps 2 and 4).

How does upgrading the logic contract affect existing state?

The proxy holds the state, and delegatecall runs logic in the proxy's context, so upgrading logic changes behavior but keeps the same state (see variable 'logic' changes in variable_tracker).

What happens if the logic contract address is not updated?

Calls keep forwarding to the old logic contract, so no new features or fixes apply (see execution_table step 6).

Visual Quiz - 3 Questions

Look at the execution_table, what is the logic address after step 3?

A LogicV1

B LogicV2

C null

D Proxy itself

💡 Hint

Check the 'Proxy logic address' column at step 3 in execution_table.

At which step does the proxy start forwarding calls to LogicV2?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Delegatecall target' column in execution_table for when it changes to LogicV2.

If the upgrade function is never called, what happens to the calls?

A They forward to LogicV1

B They fail with error

C They forward to LogicV2

D They execute in Proxy contract

💡 Hint

See variable_tracker 'logic' variable if it never changes from LogicV1.

Concept Snapshot

Proxy pattern lets a contract forward calls to a logic contract.
The proxy holds state; logic contract holds code.
Upgrade by changing logic contract address in proxy.
Calls use delegatecall to run logic in proxy context.
This enables upgradeable contracts without losing state.

Full Transcript

The proxy pattern in upgradeable contracts works by having a proxy contract that receives calls from clients. Instead of executing logic itself, the proxy forwards these calls to a separate logic contract using delegatecall. This means the logic contract's code runs in the proxy's storage context, so the proxy holds the state. When an upgrade is needed, the proxy's stored logic contract address is changed to a new logic contract with updated code. Calls then forward to the new logic contract, enabling upgrades without losing stored data. The execution table shows deploying the proxy with LogicV1, calling functions forwarded to LogicV1, upgrading to LogicV2, and subsequent calls forwarding to LogicV2. Variables like 'logic' track the current logic contract address. Key moments clarify why the proxy doesn't hold logic code, how state is preserved, and what happens if no upgrade occurs. The visual quiz tests understanding of when upgrades happen and how calls are forwarded. This pattern is essential for blockchain contracts that need to evolve after deployment.