Minimal proxy (clone) pattern in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Minimal proxy (clone) pattern

Deploy Implementation Contract

↓

Deploy Minimal Proxy Contract

↓

Proxy forwards calls

↓

Delegatecall to Implementation

↓

Return result to caller

↓

End

The minimal proxy pattern deploys a small proxy contract that forwards calls to a shared implementation contract using delegatecall.

Execution Sample

Blockchain / Solidity

contract Implementation {
    uint public value;
    function setValue(uint _value) external {
        value = _value;
    }
}

// Minimal Proxy forwards calls to Implementation

This code shows a simple implementation contract with a setter, and a minimal proxy that forwards calls to it.

Execution Table

Step	Action	Contract	Call Data	Delegatecall Target	State Change	Output
1	Deploy Implementation	Implementation	-	-	Implementation code stored	-
2	Deploy Minimal Proxy	Proxy	-	Implementation address	Proxy code stored with target address	-
3	Call setValue(42)	Proxy	setValue(42)	Delegatecall to Implementation	Proxy storage value set to 42	-
4	Read value	Proxy	value()	Delegatecall to Implementation	No state change	42
5	Call unknown function	Proxy	unknown()	Delegatecall to Implementation	No state change	Fallback or error
6	End	-	-	-	-	Execution complete

💡 Execution stops after calls are forwarded and results returned by delegatecall.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
value (in Proxy storage)	0	42	42	42
Implementation code	Deployed	Deployed	Deployed	Deployed
Proxy code	Deployed	Deployed	Deployed	Deployed

Key Moments - 3 Insights

Why does the proxy's storage change even though the code runs in the implementation?

Because delegatecall runs the implementation code in the proxy's context, so storage changes affect the proxy contract (see Step 3 in execution_table).

What happens if the proxy receives a call to a function not in the implementation?

The call is forwarded via delegatecall; if the implementation has no matching function, it triggers fallback or error (see Step 5).

Why deploy a minimal proxy instead of multiple full contracts?

Minimal proxies save gas by sharing one implementation contract and only storing a small forwarding code (see Steps 1 and 2).

Visual Quiz - 3 Questions

Look at the execution_table, what value does the proxy's storage variable 'value' have after Step 3?

A 42

B 0

C Undefined

D Implementation's value

💡 Hint

Check the 'State Change' column in Step 3 and variable_tracker for 'value'.

At which step does the proxy forward a call to the implementation contract?

A Step 1

B Step 2

C Step 3

D Step 6

💡 Hint

Look for 'Delegatecall to Implementation' in the 'Delegatecall Target' column.

If the implementation contract is upgraded, how does it affect the proxy's behavior?

A Proxy forwards calls to new implementation address

B Proxy still forwards calls to old implementation address

C Proxy code changes automatically

D Proxy stops working

💡 Hint

Minimal proxies store the implementation address at deployment (see Step 2), so changing implementation requires deploying new proxies.

Concept Snapshot

Minimal proxy pattern deploys a small proxy contract that forwards calls via delegatecall to a shared implementation.
Proxy storage is used, but code runs in implementation.
Saves gas by reusing code.
Calls unknown to proxy are forwarded.
State changes affect proxy storage.
Implementation upgrades require new proxies.

Full Transcript

The minimal proxy pattern involves deploying one implementation contract with full logic. Then, small proxy contracts are deployed that forward calls to this implementation using delegatecall. Delegatecall runs the implementation code but uses the proxy's storage, so state changes affect the proxy contract. This saves gas because proxies are minimal and share one implementation. When a call is made to the proxy, it forwards the call data to the implementation. If the function exists, it executes and updates proxy storage. If not, fallback or error occurs. Upgrading the implementation requires deploying new proxies pointing to the new implementation address.