S Price: $0.712827 (-2.03%)
    /

    Contract Diff Checker

    Contract Name:
    Proxy

    Contract Source Code:

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.23;
    
    import "../base/UpgradeableProxy.sol";
    import "../../interfaces/IControllable.sol";
    import "../../interfaces/IProxy.sol";
    
    /// @title Proxy for Stability Platform core contracts.
    /// @dev ERC-1967: Proxy Storage Slots used.
    /// @author JodsMigel (https://github.com/JodsMigel)
    contract Proxy is UpgradeableProxy, IProxy {
        /// @inheritdoc IProxy
        function initProxy(address logic_) external override {
            _init(logic_);
        }
    
        /// @inheritdoc IProxy
        //slither-disable-next-line naming-convention
        function upgrade(address _newImplementation) external override {
            if (IControllable(address(this)).platform() != msg.sender) {
                revert IControllable.NotPlatform();
            }
            _upgradeTo(_newImplementation);
            // the new contract must have the same ABI and you must have the power to change it again
            if (IControllable(address(this)).platform() != msg.sender) {
                revert IControllable.NotPlatform();
            }
        }
    
        /// @inheritdoc IProxy
        function implementation() external view override returns (address) {
            return _implementation();
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.23;
    
    /// @title Simple ERC-1967 upgradeable proxy implementation
    abstract contract UpgradeableProxy {
        error ImplementationIsNotContract();
    
        /// @dev This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
        bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    
        /// @dev Emitted when the implementation is upgraded.
        event Upgraded(address indexed implementation);
    
        constructor() {
            assert(_IMPLEMENTATION_SLOT == bytes32(uint(keccak256("eip1967.proxy.implementation")) - 1));
        }
    
        /// @dev Post deploy initialisation for compatability with EIP-1167 factory
        function _init(address _logic) internal {
            // nosemgrep
            require(_implementation() == address(0), "Already inited");
            _setImplementation(_logic);
        }
    
        /// @dev Returns the current implementation address.
        function _implementation() internal view virtual returns (address impl) {
            bytes32 slot = _IMPLEMENTATION_SLOT;
            // solhint-disable-next-line no-inline-assembly
            //slither-disable-next-line assembly
            assembly {
                impl := sload(slot)
            }
        }
    
        /// @dev Upgrades the proxy to a new implementation.
        function _upgradeTo(address newImplementation) internal virtual {
            _setImplementation(newImplementation);
            emit Upgraded(newImplementation);
        }
    
        /// @dev Stores a new address in the EIP1967 implementation slot.
        function _setImplementation(address newImplementation) private {
            if (newImplementation.code.length == 0) revert ImplementationIsNotContract();
            bytes32 slot = _IMPLEMENTATION_SLOT;
            // solhint-disable-next-line no-inline-assembly
            //slither-disable-next-line assembly
            assembly {
                sstore(slot, newImplementation)
            }
        }
    
        /**
         * @dev Delegates the current call to `implementation`.
         *
         * This function does not return to its internal call site, it will return directly to the external caller.
         */
        function _delegate(address implementation) internal virtual {
            //slither-disable-next-line assembly
            assembly {
                // Copy msg.data. We take full control of memory in this inline assembly
                // block because it will not return to Solidity code. We overwrite the
                // Solidity scratch pad at memory position 0.
                calldatacopy(0, 0, calldatasize())
    
                // Call the implementation.
                // out and outsize are 0 because we don't know the size yet.
                let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
    
                // Copy the returned data.
                returndatacopy(0, 0, returndatasize())
    
                switch result
                // delegatecall returns 0 on error.
                case 0 { revert(0, returndatasize()) }
                default { return(0, returndatasize()) }
            }
        }
    
        /**
         * @dev Delegates the current call to the address returned by `_implementation()`.
         *
         * This function does not return to its internal call site, it will return directly to the external caller.
         */
        function _fallback() internal virtual {
            _delegate(_implementation());
        }
    
        /// @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
        /// function in the contract matches the call data.
        //slither-disable-next-line locked-ether
        fallback() external payable virtual {
            _fallback();
        }
    
        /// @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
        /// is empty.
        //slither-disable-next-line locked-ether
        receive() external payable virtual {
            _fallback();
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.23;
    
    /// @dev Base core interface implemented by most platform contracts.
    ///      Inherited contracts store an immutable Platform proxy address in the storage,
    ///      which provides authorization capabilities and infrastructure contract addresses.
    /// @author Alien Deployer (https://github.com/a17)
    /// @author JodsMigel (https://github.com/JodsMigel)
    interface IControllable {
        //region ----- Custom Errors -----
        error IncorrectZeroArgument();
        error IncorrectMsgSender();
        error NotGovernance();
        error NotMultisig();
        error NotGovernanceAndNotMultisig();
        error NotOperator();
        error NotFactory();
        error NotPlatform();
        error NotVault();
        error IncorrectArrayLength();
        error AlreadyExist();
        error NotExist();
        error NotTheOwner();
        error ETHTransferFailed();
        error IncorrectInitParams();
        //endregion -- Custom Errors -----
    
        event ContractInitialized(address platform, uint ts, uint block);
    
        /// @notice Stability Platform main contract address
        function platform() external view returns (address);
    
        /// @notice Version of contract implementation
        /// @dev SemVer scheme MAJOR.MINOR.PATCH
        //slither-disable-next-line naming-convention
        function VERSION() external view returns (string memory);
    
        /// @notice Block number when contract was initialized
        function createdBlock() external view returns (uint);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.23;
    
    /// @dev Proxy of core contract implementation
    interface IProxy {
        /// @dev Initialize proxy logic. Need to call after deploy new proxy.
        /// @param logic Address of core contract implementation
        function initProxy(address logic) external;
    
        /// @notice Upgrade proxy implementation (contract logic).
        /// @dev Upgrade execution allowed only for Platform contract.
        /// An upgrade of any core contract proxy is always part of a platform time locked upgrade,
        /// with a change in the platform version.
        /// @param newImplementation New implementation address
        function upgrade(address newImplementation) external;
    
        /// @notice Return current logic implementation
        /// @return Address of implementation contract
        function implementation() external view returns (address);
    }

    Please enter a contract address above to load the contract details and source code.

    Context size (optional):