Transparent Upgradeable Proxy

https://rareskills.io/post/transparent-upgradeable-proxy
Admin
A comprehensive guide explaining the Transparent Upgradeable Proxy design pattern for smart contract...
Tokens:2,657
Snippets:26
Trust Score:9.4
Update:4 months ago
Show doc for...
Tokens:
Raw
### Unsafe Proxy Contract Example

Source: https://rareskills.io/post/transparent-upgradeable-proxy

A trivial example demonstrating a potential function selector clash in a proxy contract.

```solidity
contract ProxyUnsafe {

    function changeImplementation(
            address newImplementation
    ) public {
        // some code...
    }

    fallback(bytes calldata data) external payable (bytes memory) {
        (bool ok, bytes memory data) = getImplementation().delegatecall(data);
        require(ok, "delegatecall failed");
        return data;
    }
}

contract Implementation {
    // an identical function is declared here -- they will clash
    function changeImplementation(
            address newImplementation
    ) public {

    }
    //...

}


```

--------------------------------

### upgradeToAndCall function from ERC1967Utils.sol

Source: https://rareskills.io/post/transparent-upgradeable-proxy

This function performs an implementation upgrade and optionally makes a setup call to the new implementation.

```Solidity
function upgradeToAndCall(address newImplementation, bytes memory data) internal {
    _setImplementation(newImplementation);
    emit IERC1967.Upgraded(newImplementation);
    if (data.length > 0) {
        Address.functionDelegateCall(newImplementation, data);
    } else {
        _checkNonPayable();
    }
}
```

--------------------------------

### Transparent Upgradeable Proxy Pattern - Basic Structure

Source: https://rareskills.io/post/transparent-upgradeable-proxy

Illustrates the core concept of the Transparent Upgradeable Proxy Pattern where the admin's calls are handled differently.

```solidity
contract Proxy is ERC1967 {
    address immutable admin;

    constructor(address admin_) {
        admin = admin_
    }

    fallback() external payable {
        if (msg.sender == admin) {
            // upgrade logic
        } else {
            // delegatecall to implementation
        }
    }
}


```

--------------------------------

### _setImplementation function from ERC1967Utils.sol

Source: https://rareskills.io/post/transparent-upgradeable-proxy

This internal helper function updates the storage slot holding the implementation address, ensuring the new implementation has bytecode.

```Solidity
function _setImplementation(address newImplementation) private {
    if (newImplementation.code.length == 0) {
        revert ERC1967InvalidImplementation(newImplementation);
    }
    StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
}
```

--------------------------------

### Proxy Contract Base

Source: https://rareskills.io/post/transparent-upgradeable-proxy

The base Proxy contract, which handles delegate calls to the implementation contract.

```solidity
abstract contract Proxy {
    function _delegate(address implementation) internal virtual {
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())

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

    function _implementation() internal view virtual returns (address);

    function _fallback() internal virtual {
        _delegate(_implementation());
    }

    fallback() external payable virtual {
        _fallback();
    }
}

```

--------------------------------

### ERC1967Proxy.sol

Source: https://rareskills.io/post/transparent-upgradeable-proxy

This contract inherits from Proxy.sol and adds the internal _implementation() function, which returns the implementation address stored at the slot specified by ERC-1967. The constructor stores the implementation in the storage slot specified by ERC-1967.

```solidity
pragma solidity ^0.8.20;

import {Proxy} from "../Proxy.sol";
import {ERC1967Utils} from "./ERC1967Utils.sol";

contract ERC1967Proxy is Proxy {

    constructor(address implementation, bytes memory _data) payable {
        ERC1967Utils.upgradeToAndCall(implementation, _data);
    }

    // reads from bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
    function _implementation() internal view virtual override returns (address) {
        return ERC1967Utils.getImplementation();
    }
}
```

--------------------------------

### TransparentUpgradeableProxy.sol

Source: https://rareskills.io/post/transparent-upgradeable-proxy

This contract inherits from ERC1967Proxy.sol. Its constructor deploys the ProxyAdmin and sets the immutable admin to its address. It also changes the admin for ERC-1967 compatibility.

```solidity
contract TransparentUpgradeableProxy is ERC1967Proxy {
    address private immutable _admin;

    error ProxyDeniedAdminAccess();

    constructor(address _logic, address initialOwner, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
        _admin = address(new ProxyAdmin(initialOwner));
        // Set the storage value and emit an event for ERC-1967 compatibility
        ERC1967Utils.changeAdmin(_proxyAdmin());
    }

    function _proxyAdmin() internal view virtual returns (address) {
        return _admin;
    }

    function _fallback() internal virtual override {
        if (msg.sender == _proxyAdmin()) {
            if (msg.sig != ITransparentUpgradeableProxy.upgradeToAndCall.selector) {
                revert ProxyDeniedAdminAccess();
            } else {
                _dispatchUpgradeToAndCall();
            }
        } else {
            super._fallback();
        }
    }

    function _dispatchUpgradeToAndCall() private {
        (address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes));
        ERC1967Utils.upgradeToAndCall(newImplementation, data);
    }
}
```

--------------------------------

### ProxyAdmin Contract

Source: https://rareskills.io/post/transparent-upgradeable-proxy

The ProxyAdmin contract, which is responsible for managing upgrades and calls to the TransparentUpgradeableProxy.

```solidity
pragma solidity ^0.8.20;

import {ITransparentUpgradeableProxy} from "./TransparentUpgradeableProxy.sol";
import {Ownable} from "../../access/Ownable.sol";

contract ProxyAdmin is Ownable {
    string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";

    constructor(address initialOwner) Ownable(initialOwner) {}

    function upgradeAndCall(
        ITransparentUpgradeableProxy proxy,
        address implementation,
        bytes memory data
    ) public payable virtual onlyOwner {
        proxy.upgradeToAndCall{value: msg.value}(implementation, data);
    }
}

```
Tokens:
Raw