Proxy.sol

pragma solidity ^0.5.17;

/**
 * @title Base Proxy contract.
 * @notice The proxy performs delegated calls to the contract implementation
 * it is pointing to. This way upgradable contracts are possible on blockchain.
 *
 * Delegating proxy contracts are widely used for both upgradeability and gas
 * savings. These proxies rely on a logic contract (also known as implementation
 * contract or master copy) that is called using delegatecall. This allows
 * proxies to keep a persistent state (storage and balance) while the code is
 * delegated to the logic contract.
 *
 * Proxy contract is meant to be inherited and its internal functions
 * _setImplementation and _setProxyOwner to be called when upgrades become
 * neccessary.
 *
 * The loan token (iToken) contract as well as the protocol contract act as
 * proxies, delegating all calls to underlying contracts. Therefore, if you
 * want to interact with them using web3, you need to use the ABIs from the
 * contracts containing the actual logic or the interface contract.
 *   ABI for LoanToken contracts: LoanTokenLogicStandard
 *   ABI for Protocol contract: ISovryn
 *
 * @dev UpgradableProxy is the contract that inherits Proxy and wraps these
 * functions.
 * */
contract Proxy {
    bytes32 private constant KEY_IMPLEMENTATION = keccak256("key.implementation");
    bytes32 private constant KEY_OWNER = keccak256("key.proxy.owner");

    event OwnershipTransferred(address indexed _oldOwner, address indexed _newOwner);
    event ImplementationChanged(
        address indexed _oldImplementation,
        address indexed _newImplementation
    );

    /**
     * @notice Set sender as an owner.
     * */
    constructor() public {
        _setProxyOwner(msg.sender);
    }

    /**
     * @notice Throw error if called not by an owner.
     * */
    modifier onlyProxyOwner() {
        require(msg.sender == getProxyOwner(), "Proxy:: access denied");
        _;
    }

    /**
     * @notice Set address of the implementation.
     * @param _implementation Address of the implementation.
     * */
    function _setImplementation(address _implementation) internal {
        require(_implementation != address(0), "Proxy::setImplementation: invalid address");
        emit ImplementationChanged(getImplementation(), _implementation);

        bytes32 key = KEY_IMPLEMENTATION;
        assembly {
            sstore(key, _implementation)
        }
    }

    /**
     * @notice Return address of the implementation.
     * @return Address of the implementation.
     * */
    function getImplementation() public view returns (address _implementation) {
        bytes32 key = KEY_IMPLEMENTATION;
        assembly {
            _implementation := sload(key)
        }
    }

    /**
     * @notice Set address of the owner.
     * @param _owner Address of the owner.
     * */
    function _setProxyOwner(address _owner) internal {
        require(_owner != address(0), "Proxy::setProxyOwner: invalid address");
        emit OwnershipTransferred(getProxyOwner(), _owner);

        bytes32 key = KEY_OWNER;
        assembly {
            sstore(key, _owner)
        }
    }

    /**
     * @notice Return address of the owner.
     * @return Address of the owner.
     * */
    function getProxyOwner() public view returns (address _owner) {
        bytes32 key = KEY_OWNER;
        assembly {
            _owner := sload(key)
        }
    }

    /**
     * @notice Fallback function performs a delegate call
     * to the actual implementation address is pointing this proxy.
     * Returns whatever the implementation call returns.
     * */
    function() external payable {
        address implementation = getImplementation();
        require(implementation != address(0), "Proxy::(): implementation not found");

        assembly {
            let pointer := mload(0x40)
            calldatacopy(pointer, 0, calldatasize)
            let result := delegatecall(gas, implementation, pointer, calldatasize, 0, 0)
            let size := returndatasize
            returndatacopy(pointer, 0, size)

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