Secure Design Patterns for Smart Contracts (Proxy Patterns, Upgradeability Patterns)

As a blockchain developer, it is essential to understand and implement secure design patterns in your smart contracts. These patterns can help prevent vulnerabilities and ensure the integrity of your contract’s functionality.

There are several design patterns that are commonly used in smart contract development, including proxy patterns and upgradeability patterns. In this article, we will discuss these patterns in detail and provide examples of their implementation.

Proxy Patterns

Proxy patterns involve the use of a “proxy contract” that acts as an intermediary between the contract owner and the contract’s functionality. The proxy contract is the only contract that is visible to the outside world, and it forwards function calls to the actual contract.

There are several benefits to using proxy patterns in your smart contracts. First, they allow for contract upgradeability without requiring the deployment of a new contract. This can save time and resources, as well as reduce the risk of contract vulnerabilities.

In addition, proxy patterns can be used to implement access control and restrict certain functions to only be called by certain users or addresses. This can help prevent unauthorized access to sensitive contract functionality.

Here is an example of a simple proxy pattern implemented in Solidity:

pragma solidity ^0.6.0;

contract Proxy {
    address public owner;
    address private contractAddr;

    constructor(address _contractAddr) public {
        owner = msg.sender;
        contractAddr = _contractAddr;
    }

    function forward(bytes memory _data) public {
        require(msg.sender == owner, "Only the owner can forward calls to the contract.");
        contractAddr.call(_data);
    }
}

In this example, the Proxy contract has a constructor that accepts the address of the actual contract as an argument. The forward function allows the contract owner to forward function calls to the actual contract by passing in the data as a byte array.

Upgradeability Patterns

Upgradeability patterns refer to the ability to modify or update the functionality of a smart contract after it has been deployed. There are several approaches to implementing upgradeability in smart contracts, including proxy patterns, delegatecall patterns, and library patterns.

Proxy patterns, as discussed above, allow for the implementation of upgradeability by forwarding function calls to a new contract address. Delegatecall patterns involve the use of the delegatecall opcode to execute code from a different contract within the context of the current contract.

Library patterns involve the use of a separate library contract that contains the updated code. The library contract is then linked to the main contract using the library keyword in Solidity.

It is important to carefully consider the approach to upgradeability in your smart contracts, as it can introduce additional security risks if not implemented properly.

Here is an example to demonstrate upgradeability patterns:

pragma solidity ^0.6.0;

contract MyUpgradeableContract {
    function doSomething(uint _value) public {
        // contract logic
    }
}

contract MyProxy {
    address private _currentVersion;

    constructor(address _address) public {
        _currentVersion = _address;
    }

    function doSomething(uint _value) public {
        MyUpgradeableContract(_currentVersion).doSomething(_value);
    }

    function upgrade(address _newVersion) public {
        _currentVersion = _newVersion;
    }
}

Conclusion

Proxy patterns and upgradeability patterns are essential tools for blockchain developers to ensure the security and integrity of their smart contracts. By understanding and implementing these patterns in your contracts, you can prevent vulnerabilities and protect against unauthorized access.

Exercises

To review these concepts, we will go through a series of exercises designed to test your understanding and apply what you have learned.

pragma solidity ^0.6.0;

contract Target {
    function add(uint x, uint y) public view returns (uint z) {
        z = x + y;
    }
}

contract Proxy {
    Target target;

    constructor(address targetAddress) public {
        target = Target(targetAddress);
    }

    function call(bytes memory data) public {
        target.call(data);
    }
}

pragma solidity ^0.6.0;

contract Target {
    function add(uint x, uint y) public view returns (uint z) {
        z = x + y;
    }
}

contract Proxy {
    Target target;

    constructor(address targetAddress) public {
        target = Target(targetAddress);
    }

    function call(bytes memory data) public {
        require(data[0] == 0x40, "Invalid function call"); // 0x40 is the function selector for the `add` function
        target.call(data);
    }
}

pragma solidity ^0.6.0;

contract Upgradable {
    address owner;
    address public logic;

    constructor() public {
        owner = msg.sender;
        logic = address(this);
    }

    function upgrade(address newLogic) public {
        require(msg.sender == owner, "Only the owner can upgrade the contract");
        logic = newLogic;
    }

    function add(uint x, uint y) public view returns (uint z) {
        return UpgradableLogic(logic).add(x, y);
    }
}

contract UpgradableLogic {
    function add(uint x, uint y) public view returns (uint z);
}

pragma solidity ^0.6.0;

contract Upgradable {
    address owner;
    address public logic;

    constructor() public {
        owner = msg.sender;
        logic = address(this);
    }

    function upgrade(address newLogic) public {
        require(msg.sender == owner, "Only the owner can upgrade the contract");
        logic = newLogic;
    }

    function add(uint x, uint y) public view returns (uint z) {
        return UpgradableLogic(logic).add(x, y);
    }
}

contract UpgradableLogic {
    function add(uint x, uint y) public view returns (uint z);
}

pragma solidity ^0.6.0;

contract ProxyContract {
    function doSomething(string memory _input) public view returns (string memory) {
        return _input;
    }

    function getProxy() public view returns (Proxy memory) {
        return new Proxy();
    }

    Proxy public proxy;

    constructor() public {
        proxy = new Proxy();
    }
}

contract Proxy is ProxyContract {
    function doSomething(string memory _input) public view returns (string memory) override {
        return _input + " done";
    }
}