Proxy pattern (upgradeable contracts) in Blockchain / Solidity - Mini Project: Build & Apply

Proxy Pattern for Upgradeable Contracts

📖 Scenario: You are building a simple blockchain smart contract system where you want to keep your contract upgradeable without changing its address. This is useful because users interact with the same contract address, but the logic can be updated later.

🎯 Goal: Build a proxy contract that delegates calls to a logic contract. You will create a simple logic contract with a counter, a proxy contract that forwards calls, and then show how to call the proxy to interact with the logic.

📋 What You'll Learn

Create a logic contract with a counter variable and functions to increment and get the counter

Create a proxy contract that stores the logic contract address and delegates calls to it

Add a function in the proxy to update the logic contract address

Demonstrate calling the proxy contract to increment and get the counter value

💡 Why This Matters

🌍 Real World

Upgradeable contracts let blockchain projects fix bugs or add features without changing the contract address users interact with.

💼 Career

Understanding proxy patterns is important for blockchain developers working on smart contract upgrades and maintaining decentralized applications.

1

Create the Logic Contract

Write a Solidity contract called LogicContract with a public uint256 variable called counter. Add a function increment() that increases counter by 1, and a function getCounter() that returns the current counter value.

Blockchain / Solidity

// Your code here

Hint

Think of counter as a box that holds a number. The increment() function adds 1 to that number. The getCounter() function lets you see the number.

2

Create the Proxy Contract with Logic Address

Write a Solidity contract called ProxyContract that has an address variable called logicContract. Add a constructor that sets logicContract to an address passed as a parameter. This will store the address of the logic contract.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract LogicContract {
    uint256 public counter;

    function increment() public {
        counter += 1;
    }

    function getCounter() public view returns (uint256) {
        return counter;
    }
}

contract ProxyContract {
    address public logicContract;

    // Your code here
}

Hint

The proxy needs to remember where the logic contract lives. The constructor sets this address when the proxy is created.

3

Add Delegatecall and Upgrade Function

In ProxyContract, add a function upgrade(address _newLogic) that updates logicContract to _newLogic. Also add a fallback() function that uses delegatecall to forward all calls to logicContract. This will let the proxy run the logic contract's code.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract LogicContract {
    uint256 public counter;

    function increment() public {
        counter += 1;
    }

    function getCounter() public view returns (uint256) {
        return counter;
    }
}

contract ProxyContract {
    address public logicContract;

    constructor(address _logicContract) {
        logicContract = _logicContract;
    }

    // Add upgrade function and fallback delegatecall here
}

Hint

The fallback() function catches all calls and forwards them to the logic contract using delegatecall. The upgrade() function lets you change the logic contract address later.

4

Interact with Proxy to Increment and Get Counter

Write a script or code snippet that calls increment() on the ProxyContract and then calls getCounter() on the ProxyContract. Print the returned counter value. This shows the proxy forwarding calls to the logic contract.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract LogicContract {
    uint256 public counter;

    function increment() public {
        counter += 1;
    }

    function getCounter() public view returns (uint256) {
        return counter;
    }
}

contract ProxyContract {
    address public logicContract;

    constructor(address _logicContract) {
        logicContract = _logicContract;
    }

    function upgrade(address _newLogic) public {
        logicContract = _newLogic;
    }

    fallback() external payable {
        address impl = logicContract;
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
            let size := returndatasize()
            returndatacopy(0, 0, size)

            switch result
            case 0 { revert(0, size) }
            default { return(0, size) }
        }
    }
}

// Call increment() and getCounter() on ProxyContract and print the result
// Your code here

Hint

This test contract creates the logic and proxy contracts, calls increment() through the proxy, then calls getCounter() through the proxy and returns the counter value. The expected output is 1.

Practice

1.

What is the main purpose of using the Proxy pattern in smart contracts?

easy

A. To upgrade contract logic without changing the contract address

B. To reduce gas fees by optimizing code

C. To create multiple copies of the same contract

D. To prevent any changes to the contract after deployment

Solution

1. Step 1: Understand the Proxy pattern role

   The Proxy pattern allows a contract to forward calls to another contract, enabling upgrades.

2. Step 2: Identify the main benefit

   This forwarding lets you change the logic contract without changing the proxy's address.

3. Final Answer:

   To upgrade contract logic without changing the contract address -> Option A

4. Quick Check:

   Proxy pattern = Upgrade logic without address change [OK]

Hint: Proxy pattern upgrades logic, keeps address same [OK]

Common Mistakes:

• Thinking proxy reduces gas fees
• Believing proxy creates contract copies
• Assuming proxy prevents all changes

2.

Which Solidity keyword is used inside a proxy contract to forward calls to the implementation contract?

easy

A. delegatecall

B. call

C. transfer

D. send

Solution

1. Step 1: Recall Solidity call types

   Solidity has several low-level calls: call, delegatecall, send, transfer.

2. Step 2: Identify forwarding call for proxy

   Proxy contracts use delegatecall to run implementation code in proxy's context.

3. Final Answer:

   delegatecall -> Option A

4. Quick Check:

   Proxy forwarding uses delegatecall [OK]

Hint: Proxy uses delegatecall to keep storage context [OK]

Common Mistakes:

• Confusing call with delegatecall
• Using transfer or send which are for Ether
• Not knowing delegatecall preserves storage

3.

Consider this simplified proxy contract snippet in Solidity:

contract Proxy {
    address implementation;
    
    fallback() external payable {
        (bool success, ) = implementation.delegatecall(msg.data);
        require(success);
    }
}

What happens if implementation address is zero?

medium

A. The contract will self-destruct

B. The call will succeed but do nothing

C. The fallback function will be ignored

D. The call will fail and revert the transaction

Solution

1. Step 1: Understand delegatecall to zero address

   Calling delegatecall on address zero means no code to execute.

2. Step 2: Effect of delegatecall failure

   delegatecall returns false on failure; require(success) then reverts transaction.

3. Final Answer:

   The call will fail and revert the transaction -> Option D

4. Quick Check:

   delegatecall to zero address = revert [OK]

Hint: delegatecall to zero address always fails [OK]

Common Mistakes:

• Assuming call succeeds silently
• Thinking fallback is skipped
• Believing contract self-destructs

4.

Identify the bug in this proxy upgrade function:

function upgradeTo(address newImplementation) public {
    implementation = newImplementation;
}

What is the main issue?

medium

A. Implementation address is not validated

B. Missing event emission after upgrade

C. No access control, anyone can upgrade implementation

D. Function should be external, not public

Solution

1. Step 1: Check function access control

   The function is public, so anyone can call it and change implementation.

2. Step 2: Understand security risk

   Without restricting access, attackers can hijack the contract logic.

3. Final Answer:

   No access control, anyone can upgrade implementation -> Option C

4. Quick Check:

   Upgrade function needs access control [OK]

Hint: Always restrict upgrade function access [OK]

Common Mistakes:

• Ignoring access control importance
• Focusing only on event emission
• Thinking public vs external affects security

5.

You want to upgrade a proxy contract to a new implementation that adds a new state variable. What must you ensure to avoid breaking storage layout?

hard

A. Rearrange all variables in the new implementation for optimization

B. Add new variables only at the end of existing storage variables

C. Remove unused variables from the old implementation

D. Change variable types to reduce storage size

Solution

1. Step 1: Understand storage layout importance

   Proxy pattern requires storage layout consistency between implementations.

2. Step 2: Correct way to add variables

   New variables must be appended to avoid overwriting existing storage slots.

3. Final Answer:

   Add new variables only at the end of existing storage variables -> Option B

4. Quick Check:

   Storage layout consistency = append variables [OK]

Hint: Append new variables to preserve storage layout [OK]

Common Mistakes:

• Rearranging variables breaks storage
• Removing old variables causes data loss
• Changing types shifts storage slots