Upgrade strategies in Blockchain / Solidity - Mini Project: Build & Apply

Upgrade Strategies in Blockchain Smart Contracts

📖 Scenario: You are working on a blockchain project where smart contracts need to be upgraded safely without losing data or breaking existing features. This is common in decentralized applications where improvements or bug fixes are required after deployment.

🎯 Goal: Build a simple smart contract upgrade system using a proxy pattern. You will create an initial contract, set up an upgrade mechanism, implement a new version of the contract, and finally show how to switch to the upgraded contract.

📋 What You'll Learn

Create an initial smart contract with a stored value and a function to get and set it.

Create a proxy contract that delegates calls to the implementation contract.

Create a new version of the implementation contract with an added function.

Demonstrate upgrading the proxy to point to the new implementation and verify the new function works.

💡 Why This Matters

🌍 Real World

Smart contract upgrades are essential in blockchain projects to fix bugs or add features without losing user data or requiring users to switch contracts manually.

💼 Career

Understanding upgrade patterns is important for blockchain developers working on decentralized applications, ensuring maintainability and security of smart contracts.

1

Create the initial implementation contract

Write a Solidity contract named ImplementationV1 with a uint256 state variable called value. Add a function setValue(uint256 newValue) to update value and a function getValue() that returns value.

Blockchain / Solidity

// Your code here

Need a hint?

Define a contract with a public uint256 variable and two functions to set and get its value.

2

Create the proxy contract

Write a Solidity contract named Proxy with an address variable called implementation. Add a constructor that sets implementation. Implement a fallback function that delegates all calls to the implementation address using delegatecall.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ImplementationV1 {
    uint256 public value;

    function setValue(uint256 newValue) public {
        value = newValue;
    }

    function getValue() public view returns (uint256) {
        return value;
    }
}

// Create Proxy contract below
// Your code here

Need a hint?

Use a fallback function with assembly to forward calls to the implementation contract.

3

Create the upgraded implementation contract

Write a Solidity contract named ImplementationV2 that inherits from ImplementationV1. Add a new function increment() that increases value by 1.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ImplementationV1 {
    uint256 public value;

    function setValue(uint256 newValue) public {
        value = newValue;
    }

    function getValue() public view returns (uint256) {
        return value;
    }
}

contract Proxy {
    address public implementation;

    constructor(address _implementation) {
        implementation = _implementation;
    }

    fallback() external payable {
        address impl = implementation;
        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) }
        }
    }
}

// Create ImplementationV2 contract below
// Your code here

Need a hint?

Extend the first contract and add a function to increase the stored value by one.

4

Upgrade the proxy to the new implementation and test

Add a function upgradeTo(address newImplementation) in the Proxy contract that updates the implementation address. Then, write a simple script or comment showing how to call upgradeTo to switch to ImplementationV2 and call increment() through the proxy.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ImplementationV1 {
    uint256 public value;

    function setValue(uint256 newValue) public {
        value = newValue;
    }

    function getValue() public view returns (uint256) {
        return value;
    }
}

contract Proxy {
    address public implementation;

    constructor(address _implementation) {
        implementation = _implementation;
    }

    fallback() external payable {
        address impl = implementation;
        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) }
        }
    }

    // Add upgradeTo function here
    // Your code here
}

contract ImplementationV2 is ImplementationV1 {
    function increment() public {
        value += 1;
    }
}

// Example usage:
// proxy.upgradeTo(addressOfImplementationV2);
// Call increment() through proxy

Need a hint?

Add a public function to change the implementation address and show how to call it.