Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {IUpgradeGate} from "../interfaces/IUpgradeGate.sol";
import {Ownable2StepUpgradeable} from "../utils/ownable/Ownable2StepUpgradeable.sol";
import {UpgradeGateStorageV1} from "./UpgradeGateStorageV1.sol";

/// @title UpgradeGate
/// @notice Contract for managing upgrades and safe upgrade paths for 1155 contracts
contract UpgradeGate is IUpgradeGate, Ownable2StepUpgradeable, UpgradeGateStorageV1 {
    /// @notice Constructor for deployment pathway. This contract needs to be atomically initialized to be safe.
    constructor() {}

    /// @notice Default owner initializer. Allows for shared deterministic addresses.
    /// @param _initialOwner initial owner for the contract
    function initialize(address _initialOwner) external initializer {
        __Ownable_init(_initialOwner);
        emit UpgradeGateSetup();
    }

    /// @notice The URI of the upgrade grate contract
    function contractURI() external pure returns (string memory) {
        return "https://github.com/ourzora/zora-1155-contracts/";
    }

    /// @notice The name of the upgrade gate contract
    function contractName() external pure returns (string memory) {
        return "ZORA 1155 Upgrade Gate";
    }

    ///                                                          ///
    ///                   CREATOR TOKEN UPGRADES                 ///
    ///                                                          ///

    /// @notice If an implementation is registered as an optional upgrade
    /// @param baseImpl The base implementation address
    /// @param upgradeImpl The upgrade implementation address
    function isRegisteredUpgradePath(address baseImpl, address upgradeImpl) public view returns (bool) {
        return isAllowedUpgrade[baseImpl][upgradeImpl];
    }

    /// @notice Registers optional upgrades
    /// @param baseImpls The base implementation addresses
    /// @param upgradeImpl The upgrade implementation address
    function registerUpgradePath(address[] memory baseImpls, address upgradeImpl) public onlyOwner {
        unchecked {
            for (uint256 i = 0; i < baseImpls.length; ++i) {
                isAllowedUpgrade[baseImpls[i]][upgradeImpl] = true;
                emit UpgradeRegistered(baseImpls[i], upgradeImpl);
            }
        }
    }

    /// @notice Removes an upgrade
    /// @param baseImpl The base implementation address
    /// @param upgradeImpl The upgrade implementation address
    function removeUpgradePath(address baseImpl, address upgradeImpl) public onlyOwner {
        delete isAllowedUpgrade[baseImpl][upgradeImpl];

        emit UpgradeRemoved(baseImpl, upgradeImpl);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

/// @notice Factory Upgrade Gate Admin Factory Implementation – Allows specific contract upgrades as a safety measure
interface IUpgradeGate {
    /// @notice Event emitted when upgrade gate is emitted
    event UpgradeGateSetup();

    /// @notice If an implementation is registered by the Builder DAO as an optional upgrade
    /// @param baseImpl The base implementation address
    /// @param upgradeImpl The upgrade implementation address
    function isRegisteredUpgradePath(address baseImpl, address upgradeImpl) external view returns (bool);

    /// @notice Called by the Builder DAO to offer implementation upgrades for created DAOs
    /// @param baseImpls The base implementation addresses
    /// @param upgradeImpl The upgrade implementation address
    function registerUpgradePath(address[] memory baseImpls, address upgradeImpl) external;

    /// @notice Called by the Builder DAO to remove an upgrade
    /// @param baseImpl The base implementation address
    /// @param upgradeImpl The upgrade implementation address
    function removeUpgradePath(address baseImpl, address upgradeImpl) external;

    event UpgradeRegistered(address indexed baseImpl, address indexed upgradeImpl);
    event UpgradeRemoved(address indexed baseImpl, address indexed upgradeImpl);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {IOwnable2StepUpgradeable} from "./IOwnable2StepUpgradeable.sol";
import {IOwnable2StepStorageV1} from "./IOwnable2StepStorageV1.sol";
import {Initializable} from "@zoralabs/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol";

/// @title Ownable
/// @author Rohan Kulkarni / Iain Nash
/// @notice Modified from OpenZeppelin Contracts v4.7.3 (access/OwnableUpgradeable.sol)
/// - Uses custom errors declared in IOwnable
/// - Adds optional two-step ownership transfer (`safeTransferOwnership` + `acceptOwnership`)
abstract contract Ownable2StepUpgradeable is IOwnable2StepUpgradeable, IOwnable2StepStorageV1, Initializable {
    ///                                                          ///
    ///                            STORAGE                       ///
    ///                                                          ///

    /// @dev Modifier to check if the address argument is the zero/burn address
    modifier notZeroAddress(address check) {
        if (check == address(0)) {
            revert OWNER_CANNOT_BE_ZERO_ADDRESS();
        }
        _;
    }

    ///                                                          ///
    ///                           MODIFIERS                      ///
    ///                                                          ///

    /// @dev Ensures the caller is the owner
    modifier onlyOwner() {
        if (msg.sender != _owner) {
            revert ONLY_OWNER();
        }
        _;
    }

    /// @dev Ensures the caller is the pending owner
    modifier onlyPendingOwner() {
        if (msg.sender != _pendingOwner) {
            revert ONLY_PENDING_OWNER();
        }
        _;
    }

    ///                                                          ///
    ///                           FUNCTIONS                      ///
    ///                                                          ///

    /// @dev Initializes contract ownership
    /// @param _initialOwner The initial owner address
    function __Ownable_init(address _initialOwner) internal notZeroAddress(_initialOwner) onlyInitializing {
        _owner = _initialOwner;

        emit OwnerUpdated(address(0), _initialOwner);
    }

    /// @notice The address of the owner
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /// @notice The address of the pending owner
    function pendingOwner() public view returns (address) {
        return _pendingOwner;
    }

    /// @notice Forces an ownership transfer from the last owner
    /// @param _newOwner The new owner address
    function transferOwnership(address _newOwner) public notZeroAddress(_newOwner) onlyOwner {
        _transferOwnership(_newOwner);
    }

    /// @notice Forces an ownership transfer from any sender
    /// @param _newOwner New owner to transfer contract to
    /// @dev Ensure is called only from trusted internal code, no access control checks.
    function _transferOwnership(address _newOwner) internal {
        emit OwnerUpdated(_owner, _newOwner);

        _owner = _newOwner;

        if (_pendingOwner != address(0)) {
            delete _pendingOwner;
        }
    }

    /// @notice Initiates a two-step ownership transfer
    /// @param _newOwner The new owner address
    function safeTransferOwnership(address _newOwner) public notZeroAddress(_newOwner) onlyOwner {
        _pendingOwner = _newOwner;

        emit OwnerPending(_owner, _newOwner);
    }

    /// @notice Resign ownership of contract
    /// @dev only callably by the owner, dangerous call.
    function resignOwnership() public onlyOwner {
        _transferOwnership(address(0));
    }

    /// @notice Accepts an ownership transfer
    function acceptOwnership() public onlyPendingOwner {
        emit OwnerUpdated(_owner, msg.sender);

        _transferOwnership(msg.sender);
    }

    /// @notice Cancels a pending ownership transfer
    function cancelOwnershipTransfer() public onlyOwner {
        emit OwnerCanceled(_owner, _pendingOwner);

        delete _pendingOwner;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

abstract contract UpgradeGateStorageV1 {
    mapping(address => mapping(address => bool)) public isAllowedUpgrade;

    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

/// @title IOwnable2StepUpgradeable
/// @author Rohan Kulkarni
/// @notice The external Ownable events, errors, and functions
interface IOwnable2StepUpgradeable {
    ///                                                          ///
    ///                            EVENTS                        ///
    ///                                                          ///

    /// @notice Emitted when ownership has been updated
    /// @param prevOwner The previous owner address
    /// @param newOwner The new owner address
    event OwnerUpdated(address indexed prevOwner, address indexed newOwner);

    /// @notice Emitted when an ownership transfer is pending
    /// @param owner The current owner address
    /// @param pendingOwner The pending new owner address
    event OwnerPending(address indexed owner, address indexed pendingOwner);

    /// @notice Emitted when a pending ownership transfer has been canceled
    /// @param owner The current owner address
    /// @param canceledOwner The canceled owner address
    event OwnerCanceled(address indexed owner, address indexed canceledOwner);

    ///                                                          ///
    ///                            ERRORS                        ///
    ///                                                          ///

    /// @dev Reverts if an unauthorized user calls an owner function
    error ONLY_OWNER();

    /// @dev Reverts if an unauthorized user calls a pending owner function
    error ONLY_PENDING_OWNER();

    /// @dev Owner cannot be the zero/burn address
    error OWNER_CANNOT_BE_ZERO_ADDRESS();

    ///                                                          ///
    ///                           FUNCTIONS                      ///
    ///                                                          ///

    /// @notice The address of the owner
    function owner() external view returns (address);

    /// @notice The address of the pending owner
    function pendingOwner() external view returns (address);

    /// @notice Forces an ownership transfer
    /// @param newOwner The new owner address
    function transferOwnership(address newOwner) external;

    /// @notice Initiates a two-step ownership transfer
    /// @param newOwner The new owner address
    function safeTransferOwnership(address newOwner) external;

    /// @notice Accepts an ownership transfer
    function acceptOwnership() external;

    /// @notice Cancels a pending ownership transfer
    function cancelOwnershipTransfer() external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

abstract contract IOwnable2StepStorageV1 {
    /// @dev The address of the owner
    address internal _owner;

    /// @dev The address of the pending owner
    address internal _pendingOwner;

    /// @dev storage gap
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

error INITIALIZABLE_CONTRACT_ALREADY_INITIALIZED();
error INITIALIZABLE_CONTRACT_IS_NOT_INITIALIZING();
error INITIALIZABLE_CONTRACT_IS_INITIALIZING();

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        if ((!isTopLevelCall || _initialized != 0) && (AddressUpgradeable.isContract(address(this)) || _initialized != 1)) {
            revert INITIALIZABLE_CONTRACT_ALREADY_INITIALIZED();
        }
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        if (_initializing || _initialized >= version) {
            revert INITIALIZABLE_CONTRACT_ALREADY_INITIALIZED();
        }
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        if (!_initializing) {
            revert INITIALIZABLE_CONTRACT_IS_NOT_INITIALIZING();
        }
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        if (_initializing) {
            revert INITIALIZABLE_CONTRACT_IS_INITIALIZING();
        }
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;


error ADDRESS_INSUFFICIENT_BALANCE();
error ADDRESS_UNABLE_TO_SEND_VALUE();
error ADDRESS_LOW_LEVEL_CALL_FAILED();
error ADDRESS_LOW_LEVEL_CALL_WITH_VALUE_FAILED();
error ADDRESS_INSUFFICIENT_BALANCE_FOR_CALL();
error ADDRESS_LOW_LEVEL_STATIC_CALL_FAILED();
error ADDRESS_CALL_TO_NON_CONTRACT();

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance > amount) {
            revert ADDRESS_INSUFFICIENT_BALANCE();
        }
        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert ADDRESS_UNABLE_TO_SEND_VALUE();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert ADDRESS_INSUFFICIENT_BALANCE();
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                if (!isContract(target)) {
                    revert ADDRESS_CALL_TO_NON_CONTRACT();
                }
            }
            return returndata;
        } else {
            _revert(returndata);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata);
        }
    }

    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert ADDRESS_LOW_LEVEL_CALL_FAILED();
        }
    }
}

{
  "remappings": [
    "ds-test/=node_modules/ds-test/src/",
    "forge-std/=node_modules/forge-std/src/",
    "@zoralabs/openzeppelin-contracts-upgradeable/=node_modules/@zoralabs/openzeppelin-contracts-upgradeable/",
    "@zoralabs/protocol-rewards/src/=node_modules/@zoralabs/protocol-rewards/src/",
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "_imagine/=_imagine/",
    "solemate/=/node_modules/solemate/src/",
    "solady/=node_modules/solady/src/",
    "mint/=_imagine/mint/",
    "solmate/=node_modules/solmate/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 50
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"INITIALIZABLE_CONTRACT_ALREADY_INITIALIZED","type":"error"},{"inputs":[],"name":"INITIALIZABLE_CONTRACT_IS_NOT_INITIALIZING","type":"error"},{"inputs":[],"name":"ONLY_OWNER","type":"error"},{"inputs":[],"name":"ONLY_PENDING_OWNER","type":"error"},{"inputs":[],"name":"OWNER_CANNOT_BE_ZERO_ADDRESS","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"canceledOwner","type":"address"}],"name":"OwnerCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnerPending","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"prevOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"UpgradeGateSetup","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"baseImpl","type":"address"},{"indexed":true,"internalType":"address","name":"upgradeImpl","type":"address"}],"name":"UpgradeRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"baseImpl","type":"address"},{"indexed":true,"internalType":"address","name":"upgradeImpl","type":"address"}],"name":"UpgradeRemoved","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelOwnershipTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_initialOwner","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isAllowedUpgrade","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseImpl","type":"address"},{"internalType":"address","name":"upgradeImpl","type":"address"}],"name":"isRegisteredUpgradePath","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"baseImpls","type":"address[]"},{"internalType":"address","name":"upgradeImpl","type":"address"}],"name":"registerUpgradePath","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"baseImpl","type":"address"},{"internalType":"address","name":"upgradeImpl","type":"address"}],"name":"removeUpgradePath","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resignOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"safeTransferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

6080806040523461001657610948908161001c8239f35b600080fdfe6080604081815260048036101561001557600080fd5b600092833560e01c90816321f74347146107b95750806323452b9c14610753578063395db2cd146106d15780634dc5b7c71461068357806375d0c0dc1461062157806379ba5097146105cc5780638da5cb5b146105a457806392b60a4c1461042e578063c4d66de8146102d6578063e30c3978146102ad578063e8a3d48514610211578063ed0c7091146101ac578063f0fad9911461011c5763f2fde38b146100bd57600080fd5b34610118576020366003190112610118576100d6610805565b916001600160a01b038084161561010a5784541633036100fd57836100fa846108a9565b80f35b5163d238ed5960e01b8152fd5b5051631627621f60e11b8152fd5b8280fd5b5034610118578160031936011261011857610135610805565b9161013e610820565b845490936001600160a01b039390918416330361019e57508216918285526035602052818520931692838552602052832060ff1981541690557f0ebd98f6f75e38ba2f0751378f5c86205cafca83e206cb62795f45fcea7283338380a380f35b825163d238ed5960e01b8152fd5b50346101185782600319360112610118578254916001600160a01b039182841691338390036100fd57505083906000805160206108f38339815191528280a36001600160a01b03199182168355600154908116610207578280f35b1660015538808280f35b509190346102a957816003193601126102a957805191606083019083821067ffffffffffffffff831117610296575061029293508152602f82527f68747470733a2f2f6769746875622e636f6d2f6f75727a6f72612f7a6f72612d60208301526e313135352d636f6e7472616374732f60881b818301525191829182610836565b0390f35b634e487b7160e01b815260418552602490fd5b5080fd5b5050346102a957816003193601126102a95760015490516001600160a01b039091168152602090f35b5034610118576020366003190112610118576102f0610805565b6034549060ff8260081c16159182801590610422575b8061040a575b6103fa5760ff198116600117603455826103e8575b506001600160a01b03169283156103d9576034549260ff8460081c16156103cc575084546001600160a01b031916841785555192846000805160206108f38339815191528180a37f0c52cc367a132cac0ea9f3a1e1f75873b17977858812b85c89a9654486e444388480a1610394578280f35b61ff001916603455600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249890602090a138808280f35b90516296bfb160e81b8152fd5b51631627621f60e11b81529050fd5b61ffff19166101011760345538610321565b8451633d5c224160e11b81528490fd5b50303b15158061030c5750600160ff8216141561030c565b5060ff81161515610306565b503461011857816003193601126101185780359067ffffffffffffffff8083116105a057366023840112156105a057828201359281841161058d578360051b93855192601f19603f8701168401908482109082111761057a57865282526020936024858401918301019136831161057657602401905b828210610553575050506104b6610820565b855490946001600160a01b039390918416330361054557509293821692855b82518110156105415780846104ec6001938661087f565b51168852603587528288208689528752828820805460ff1916831790558585610515838761087f565b51167fab6a7dc54721d6a1a284ca865830f8981d6f12fbddb3618d1774b71c003680598a80a3016104d5565b8680f35b905163d238ed5960e01b8152fd5b81356001600160a01b03811681036105725781529085019085016104a4565b8880fd5b8780fd5b634e487b7160e01b885260418552602488fd5b634e487b7160e01b865260418352602486fd5b8480fd5b5050346102a957816003193601126102a957905490516001600160a01b039091168152602090f35b50346101185782600319360112610118576001546001600160a01b0392908316330361061457505033908254166000805160206108f38339815191528380a36100fa336108a9565b5163065cd53160e01b8152fd5b509190346102a957816003193601126102a9578051918183019083821067ffffffffffffffff83111761029657506102929350815260168252755a4f524120313135352055706772616465204761746560501b60208301525191829182610836565b5050346102a957806003193601126102a95760ff816020936106a3610805565b6106ab610820565b6001600160a01b0391821683526035875283832091168252855220549151911615158152f35b509034610118576020366003190112610118576001600160a01b0391826106f6610805565b1692831561074457845416918233036100fd575050600180546001600160a01b031916831790557f4f2638f5949b9614ef8d5e268cb51348ad7f434a34812bf64b6e95014fbd357e8380a380f35b509051631627621f60e11b8152fd5b50903461011857826003193601126101185782546001600160a01b039290831691338390036100fd575050600154918216907f682679deecef4dcd49674845cc1e3a075fea9073680aa445a8207d5a4bdea3da8480a36001600160a01b03191660015580f35b8490843461011857806003193601126101185760ff906020936107da610805565b6107e2610820565b6001600160a01b0391821683526035875283832091168252855220541615158152f35b600435906001600160a01b038216820361081b57565b600080fd5b602435906001600160a01b038216820361081b57565b6020808252825181830181905290939260005b82811061086b57505060409293506000838284010152601f8019910116010190565b818101860151848201604001528501610849565b80518210156108935760209160051b010190565b634e487b7160e01b600052603260045260246000fd5b6000549060018060a01b03809116808284166000805160206108f3833981519152600080a36001600160a01b0319928316176000556001549081166108ec575050565b1660015556fe8292fce18fa69edf4db7b94ea2e58241df0ae57f97e0a6c9b29067028bf92d76a2646970667358221220e0ec2ae1dad17b5200e7a0834d04c84b0ea9b2a833f519d7ea3e59906f17844d64736f6c63430008110033

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