Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "../verifiers/SgxVerifier.sol";
import "./LibRollupAddressCache.sol";

/// @title MainnetSgxVerifier
/// @dev This contract shall be deployed to replace its parent contract on Ethereum for Taiko
/// mainnet to reduce gas cost.
/// @notice See the documentation in {SgxVerifier}.
/// @custom:security-contact [email protected]
contract MainnetSgxVerifier is SgxVerifier {
    function _getAddress(uint64 _chainId, bytes32 _name) internal view override returns (address) {
        (bool found, address addr) = LibRollupAddressCache.getAddress(_chainId, _name);
        return found ? addr : super._getAddress(_chainId, _name);
    }

    function taikoChainId() internal pure override returns (uint64) {
        return LibNetwork.TAIKO_MAINNET;
    }
}

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

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../L1/ITaikoL1.sol";
import "../common/EssentialContract.sol";
import "../common/LibStrings.sol";
import "../automata-attestation/interfaces/IAttestation.sol";
import "../automata-attestation/lib/QuoteV3Auth/V3Struct.sol";
import "./libs/LibPublicInput.sol";
import "./IVerifier.sol";

/// @title SgxVerifier
/// @notice This contract is the implementation of verifying SGX signature proofs
/// onchain.
/// @dev Please see references below:
/// - Reference #1: https://ethresear.ch/t/2fa-zk-rollups-using-sgx/14462
/// - Reference #2: https://github.com/gramineproject/gramine/discussions/1579
/// @custom:security-contact [email protected]
contract SgxVerifier is EssentialContract, IVerifier {
    /// @dev Each public-private key pair (Ethereum address) is generated within
    /// the SGX program when it boots up. The off-chain remote attestation
    /// ensures the validity of the program hash and has the capability of
    /// bootstrapping the network with trustworthy instances.
    struct Instance {
        address addr;
        uint64 validSince;
    }

    /// @notice The expiry time for the SGX instance.
    uint64 public constant INSTANCE_EXPIRY = 365 days;

    /// @notice A security feature, a delay until an instance is enabled when using onchain RA
    /// verification
    uint64 public constant INSTANCE_VALIDITY_DELAY = 0;

    /// @dev For gas savings, we shall assign each SGX instance with an id that when we need to
    /// set a new pub key, just write storage once.
    /// Slot 1.
    uint256 public nextInstanceId;

    /// @dev One SGX instance is uniquely identified (on-chain) by it's ECDSA public key
    /// (or rather ethereum address). Once that address is used (by proof verification) it has to be
    /// overwritten by a new one (representing the same instance). This is due to side-channel
    /// protection. Also this public key shall expire after some time
    /// (for now it is a long enough 6 months setting).
    /// Slot 2.
    mapping(uint256 instanceId => Instance instance) public instances;

    /// @dev One address shall be registered (during attestation) only once, otherwise it could
    /// bypass this contract's expiry check by always registering with the same attestation and
    /// getting multiple valid instanceIds. While during proving, it is technically possible to
    /// register the old addresses, it is less of a problem, because the instanceId would be the
    /// same for those addresses and if deleted - the attestation cannot be reused anyways.
    /// Slot 3.
    mapping(address instanceAddress => bool alreadyAttested) public addressRegistered;

    uint256[47] private __gap;

    /// @notice Emitted when a new SGX instance is added to the registry, or replaced.
    /// @param id The ID of the SGX instance.
    /// @param instance The address of the SGX instance.
    /// @param replaced The address of the SGX instance that was replaced. If it is the first
    /// instance, this value is zero address.
    /// @param validSince The time since the instance is valid.
    event InstanceAdded(
        uint256 indexed id, address indexed instance, address indexed replaced, uint256 validSince
    );

    /// @notice Emitted when an SGX instance is deleted from the registry.
    /// @param id The ID of the SGX instance.
    /// @param instance The address of the SGX instance.
    event InstanceDeleted(uint256 indexed id, address indexed instance);

    error SGX_ALREADY_ATTESTED();
    error SGX_INVALID_ATTESTATION();
    error SGX_INVALID_INSTANCE();
    error SGX_INVALID_PROOF();
    error SGX_RA_NOT_SUPPORTED();

    /// @notice Initializes the contract.
    /// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
    /// @param _rollupAddressManager The address of the {AddressManager} contract.
    function init(address _owner, address _rollupAddressManager) external initializer {
        __Essential_init(_owner, _rollupAddressManager);
    }

    /// @notice Adds trusted SGX instances to the registry.
    /// @param _instances The address array of trusted SGX instances.
    /// @return The respective instanceId array per addresses.
    function addInstances(address[] calldata _instances)
        external
        onlyOwner
        returns (uint256[] memory)
    {
        return _addInstances(_instances, true);
    }

    /// @notice Deletes SGX instances from the registry.
    /// @param _ids The ids array of SGX instances.
    function deleteInstances(uint256[] calldata _ids)
        external
        onlyFromOwnerOrNamed(LibStrings.B_SGX_WATCHDOG)
    {
        for (uint256 i; i < _ids.length; ++i) {
            uint256 idx = _ids[i];

            if (instances[idx].addr == address(0)) revert SGX_INVALID_INSTANCE();

            emit InstanceDeleted(idx, instances[idx].addr);

            delete instances[idx];
        }
    }

    /// @notice Adds an SGX instance after the attestation is verified
    /// @param _attestation The parsed attestation quote.
    /// @return The respective instanceId
    function registerInstance(V3Struct.ParsedV3QuoteStruct calldata _attestation)
        external
        returns (uint256)
    {
        address automataDcapAttestation = resolve(LibStrings.B_AUTOMATA_DCAP_ATTESTATION, true);

        if (automataDcapAttestation == address(0)) {
            revert SGX_RA_NOT_SUPPORTED();
        }

        (bool verified,) = IAttestation(automataDcapAttestation).verifyParsedQuote(_attestation);

        if (!verified) revert SGX_INVALID_ATTESTATION();

        address[] memory _address = new address[](1);
        _address[0] = address(bytes20(_attestation.localEnclaveReport.reportData));

        return _addInstances(_address, false)[0];
    }

    /// @inheritdoc IVerifier
    function verifyProof(
        Context calldata _ctx,
        TaikoData.Transition calldata _tran,
        TaikoData.TierProof calldata _proof
    )
        external
        onlyFromNamed(LibStrings.B_TAIKO)
    {
        // Do not run proof verification to contest an existing proof
        if (_ctx.isContesting) return;

        // Size is: 89 bytes
        // 4 bytes + 20 bytes + 65 bytes (signature) = 89
        if (_proof.data.length != 89) revert SGX_INVALID_PROOF();

        uint32 id = uint32(bytes4(_proof.data[:4]));
        address newInstance = address(bytes20(_proof.data[4:24]));

        address oldInstance = ECDSA.recover(
            LibPublicInput.hashPublicInputs(
                _tran, address(this), newInstance, _ctx.prover, _ctx.metaHash, taikoChainId()
            ),
            _proof.data[24:]
        );

        if (!_isInstanceValid(id, oldInstance)) revert SGX_INVALID_INSTANCE();

        if (oldInstance != newInstance) {
            _replaceInstance(id, oldInstance, newInstance);
        }
    }

    function taikoChainId() internal view virtual returns (uint64) {
        return ITaikoL1(resolve(LibStrings.B_TAIKO, false)).getConfig().chainId;
    }

    function _addInstances(
        address[] memory _instances,
        bool instantValid
    )
        private
        returns (uint256[] memory ids)
    {
        ids = new uint256[](_instances.length);

        uint64 validSince = uint64(block.timestamp);

        if (!instantValid) {
            validSince += INSTANCE_VALIDITY_DELAY;
        }

        for (uint256 i; i < _instances.length; ++i) {
            if (addressRegistered[_instances[i]]) revert SGX_ALREADY_ATTESTED();

            addressRegistered[_instances[i]] = true;

            if (_instances[i] == address(0)) revert SGX_INVALID_INSTANCE();

            instances[nextInstanceId] = Instance(_instances[i], validSince);
            ids[i] = nextInstanceId;

            emit InstanceAdded(nextInstanceId, _instances[i], address(0), validSince);

            ++nextInstanceId;
        }
    }

    function _replaceInstance(uint256 id, address oldInstance, address newInstance) private {
        // Replacing an instance means, it went through a cooldown (if added by on-chain RA) so no
        // need to have a cooldown
        instances[id] = Instance(newInstance, uint64(block.timestamp));
        emit InstanceAdded(id, newInstance, oldInstance, block.timestamp);
    }

    function _isInstanceValid(uint256 id, address instance) private view returns (bool) {
        if (instance == address(0)) return false;
        if (instance != instances[id].addr) return false;
        return instances[id].validSince <= block.timestamp
            && block.timestamp <= instances[id].validSince + INSTANCE_EXPIRY;
    }
}

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

import "../common/LibStrings.sol";
import "../libs/LibNetwork.sol";

/// @title LibRollupAddressCache
/// @custom:security-contact [email protected]
library LibRollupAddressCache {
    function getAddress(
        uint64 _chainId,
        bytes32 _name
    )
        internal
        pure
        returns (bool found, address addr)
    {
        if (_chainId == LibNetwork.ETHEREUM_MAINNET) {
            if (_name == LibStrings.B_TAIKO_TOKEN) {
                return (true, 0x10dea67478c5F8C5E2D90e5E9B26dBe60c54d800);
            }
            if (_name == LibStrings.B_SIGNAL_SERVICE) {
                return (true, 0x9e0a24964e5397B566c1ed39258e21aB5E35C77C);
            }
            if (_name == LibStrings.B_BRIDGE) {
                return (true, 0xd60247c6848B7Ca29eDdF63AA924E53dB6Ddd8EC);
            }
            if (_name == LibStrings.B_TAIKO) {
                return (true, 0x06a9Ab27c7e2255df1815E6CC0168d7755Feb19a);
            }
            if (_name == LibStrings.B_TIER_ROUTER) {
                return (true, 0x6E997f1F22C40ba37F633B08f3b07E10Ed43155a);
            }
            if (_name == LibStrings.B_TIER_SGX) {
                return (true, 0xb0f3186FC1963f774f52ff455DC86aEdD0b31F81);
            }
            if (_name == LibStrings.B_TIER_GUARDIAN_MINORITY) {
                return (true, 0x579A8d63a2Db646284CBFE31FE5082c9989E985c);
            }
            if (_name == LibStrings.B_TIER_GUARDIAN) {
                return (true, 0xE3D777143Ea25A6E031d1e921F396750885f43aC);
            }
            if (_name == LibStrings.B_AUTOMATA_DCAP_ATTESTATION) {
                return (true, 0x8d7C954960a36a7596d7eA4945dDf891967ca8A3);
            }
            if (_name == LibStrings.B_CHAIN_WATCHDOG) {
                return (true, address(0));
            }
        }
        return (false, address(0));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

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

import "./TaikoData.sol";

/// @title ITaikoL1
/// @custom:security-contact [email protected]
interface ITaikoL1 {
    /// @notice Proposes a Taiko L2 block.
    /// @param _params Block parameters, currently an encoded BlockParams object.
    /// @param _txList txList data if calldata is used for DA.
    /// @return meta_ The metadata of the proposed L2 block.
    /// @return deposits_ The Ether deposits processed.
    function proposeBlock(
        bytes calldata _params,
        bytes calldata _txList
    )
        external
        payable
        returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_);

    /// @notice Proves or contests a block transition.
    /// @param _blockId The index of the block to prove. This is also used to
    /// select the right implementation version.
    /// @param _input An abi-encoded (TaikoData.BlockMetadata, TaikoData.Transition,
    /// TaikoData.TierProof) tuple.
    function proveBlock(uint64 _blockId, bytes calldata _input) external;

    /// @notice Verifies up to a certain number of blocks.
    /// @param _maxBlocksToVerify Max number of blocks to verify.
    function verifyBlocks(uint64 _maxBlocksToVerify) external;

    /// @notice Pause block proving.
    /// @param _pause True if paused.
    function pauseProving(bool _pause) external;

    /// @notice Deposits Taiko token to be used as bonds.
    /// @param _amount The amount of Taiko token to deposit.
    function depositBond(uint256 _amount) external;

    /// @notice Withdraws Taiko token.
    /// @param _amount The amount of Taiko token to withdraw.
    function withdrawBond(uint256 _amount) external;

    /// @notice Gets the prover that actually proved a verified block.
    /// @param _blockId The index of the block.
    /// @return The prover's address. If the block is not verified yet, address(0) will be returned.
    function getVerifiedBlockProver(uint64 _blockId) external view returns (address);

    /// @notice Gets the configuration of the TaikoL1 contract.
    /// @return Config struct containing configuration parameters.
    function getConfig() external pure returns (TaikoData.Config memory);
}

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

import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "./AddressResolver.sol";
import "../libs/LibNetwork.sol";

/// @title EssentialContract
/// @custom:security-contact [email protected]
abstract contract EssentialContract is UUPSUpgradeable, Ownable2StepUpgradeable, AddressResolver {
    uint8 private constant _FALSE = 1;

    uint8 private constant _TRUE = 2;

    /// @dev The slot in transient storage of the reentry lock.
    /// This is the result of keccak256("ownerUUPS.reentry_slot") plus 1. The addition aims to
    /// prevent hash collisions with slots defined in EIP-1967, where slots are derived by
    /// keccak256("something") - 1, and with slots in SignalService, calculated directly with
    /// keccak256("something").
    bytes32 private constant _REENTRY_SLOT =
        0xa5054f728453d3dbe953bdc43e4d0cb97e662ea32d7958190f3dc2da31d9721b;

    /// @dev Slot 1.
    uint8 private __reentry;
    uint8 private __paused;
    uint64 public lastUnpausedAt;

    uint256[49] private __gap;

    /// @notice Emitted when the contract is paused.
    /// @param account The account that paused the contract.
    event Paused(address account);

    /// @notice Emitted when the contract is unpaused.
    /// @param account The account that unpaused the contract.
    event Unpaused(address account);

    error INVALID_PAUSE_STATUS();
    error FUNC_NOT_IMPLEMENTED();
    error REENTRANT_CALL();
    error ZERO_ADDRESS();
    error ZERO_VALUE();

    /// @dev Modifier that ensures the caller is the owner or resolved address of a given name.
    /// @param _name The name to check against.
    modifier onlyFromOwnerOrNamed(bytes32 _name) {
        if (msg.sender != owner() && msg.sender != resolve(_name, true)) revert RESOLVER_DENIED();
        _;
    }

    modifier notImplemented() {
        revert FUNC_NOT_IMPLEMENTED();
        _;
    }

    modifier nonReentrant() {
        if (_loadReentryLock() == _TRUE) revert REENTRANT_CALL();
        _storeReentryLock(_TRUE);
        _;
        _storeReentryLock(_FALSE);
    }

    modifier whenPaused() {
        if (!paused()) revert INVALID_PAUSE_STATUS();
        _;
    }

    modifier whenNotPaused() {
        if (paused()) revert INVALID_PAUSE_STATUS();
        _;
    }

    modifier nonZeroAddr(address _addr) {
        if (_addr == address(0)) revert ZERO_ADDRESS();
        _;
    }

    modifier nonZeroValue(bytes32 _value) {
        if (_value == 0) revert ZERO_VALUE();
        _;
    }

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    /// @notice Pauses the contract.
    function pause() public virtual {
        _pause();
        // We call the authorize function here to avoid:
        // Warning (5740): Unreachable code.
        _authorizePause(msg.sender, true);
    }

    /// @notice Unpauses the contract.
    function unpause() public virtual {
        _unpause();
        // We call the authorize function here to avoid:
        // Warning (5740): Unreachable code.
        _authorizePause(msg.sender, false);
    }

    function impl() public view returns (address) {
        return _getImplementation();
    }

    /// @notice Returns true if the contract is paused, and false otherwise.
    /// @return true if paused, false otherwise.
    function paused() public view returns (bool) {
        return __paused == _TRUE;
    }

    function inNonReentrant() public view returns (bool) {
        return _loadReentryLock() == _TRUE;
    }

    /// @notice Initializes the contract.
    /// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
    /// @param _addressManager The address of the {AddressManager} contract.
    function __Essential_init(
        address _owner,
        address _addressManager
    )
        internal
        nonZeroAddr(_addressManager)
    {
        __Essential_init(_owner);
        __AddressResolver_init(_addressManager);
    }

    function __Essential_init(address _owner) internal virtual onlyInitializing {
        __Context_init();
        _transferOwnership(_owner == address(0) ? msg.sender : _owner);
        __paused = _FALSE;
    }

    function _pause() internal whenNotPaused {
        __paused = _TRUE;
        emit Paused(msg.sender);
    }

    function _unpause() internal whenPaused {
        __paused = _FALSE;
        lastUnpausedAt = uint64(block.timestamp);
        emit Unpaused(msg.sender);
    }

    function _authorizeUpgrade(address) internal virtual override onlyOwner { }

    function _authorizePause(address, bool) internal virtual onlyOwner { }

    // Stores the reentry lock
    function _storeReentryLock(uint8 _reentry) internal virtual {
        if (LibNetwork.isDencunSupported(block.chainid)) {
            assembly {
                tstore(_REENTRY_SLOT, _reentry)
            }
        } else {
            __reentry = _reentry;
        }
    }

    // Loads the reentry lock
    function _loadReentryLock() internal view virtual returns (uint8 reentry_) {
        if (LibNetwork.isDencunSupported(block.chainid)) {
            assembly {
                reentry_ := tload(_REENTRY_SLOT)
            }
        } else {
            reentry_ = __reentry;
        }
    }
}

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

/// @title LibStrings
/// @custom:security-contact [email protected]
library LibStrings {
    bytes32 internal constant B_AUTOMATA_DCAP_ATTESTATION = bytes32("automata_dcap_attestation");
    bytes32 internal constant B_BRIDGE = bytes32("bridge");
    bytes32 internal constant B_BRIDGE_WATCHDOG = bytes32("bridge_watchdog");
    bytes32 internal constant B_BRIDGED_ERC1155 = bytes32("bridged_erc1155");
    bytes32 internal constant B_BRIDGED_ERC20 = bytes32("bridged_erc20");
    bytes32 internal constant B_BRIDGED_ERC721 = bytes32("bridged_erc721");
    bytes32 internal constant B_CHAIN_WATCHDOG = bytes32("chain_watchdog");
    bytes32 internal constant B_ERC1155_VAULT = bytes32("erc1155_vault");
    bytes32 internal constant B_ERC20_VAULT = bytes32("erc20_vault");
    bytes32 internal constant B_ERC721_VAULT = bytes32("erc721_vault");
    bytes32 internal constant B_PROVER_ASSIGNMENT = bytes32("PROVER_ASSIGNMENT");
    bytes32 internal constant B_PROVER_SET = bytes32("prover_set");
    bytes32 internal constant B_QUOTA_MANAGER = bytes32("quota_manager");
    bytes32 internal constant B_SGX_WATCHDOG = bytes32("sgx_watchdog");
    bytes32 internal constant B_SIGNAL_SERVICE = bytes32("signal_service");
    bytes32 internal constant B_TAIKO = bytes32("taiko");
    bytes32 internal constant B_TAIKO_TOKEN = bytes32("taiko_token");
    bytes32 internal constant B_TIER_GUARDIAN = bytes32("tier_guardian");
    bytes32 internal constant B_TIER_GUARDIAN_MINORITY = bytes32("tier_guardian_minority");
    bytes32 internal constant B_TIER_ROUTER = bytes32("tier_router");
    bytes32 internal constant B_TIER_SGX = bytes32("tier_sgx");
    bytes32 internal constant B_TIER_SGX_ZKVM = bytes32("tier_sgx_zkvm");
    bytes32 internal constant B_WITHDRAWER = bytes32("withdrawer");
    bytes32 internal constant H_RETURN_LIVENESS_BOND = keccak256("RETURN_LIVENESS_BOND");
    bytes32 internal constant H_SIGNAL_ROOT = keccak256("SIGNAL_ROOT");
    bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT");
}

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

import { V3Struct } from "../lib/QuoteV3Auth/V3Struct.sol";

/// @title IAttestation
/// @custom:security-contact [email protected]
interface IAttestation {
    function verifyAttestation(bytes calldata data) external returns (bool);
    function verifyParsedQuote(V3Struct.ParsedV3QuoteStruct calldata v3quote)
        external
        returns (bool success, bytes memory retData);
}

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

/// @title V3Struct
/// @custom:security-contact [email protected]
library V3Struct {
    struct Header {
        bytes2 version;
        bytes2 attestationKeyType;
        bytes4 teeType;
        bytes2 qeSvn;
        bytes2 pceSvn;
        bytes16 qeVendorId;
        bytes20 userData;
    }

    struct EnclaveReport {
        bytes16 cpuSvn;
        bytes4 miscSelect;
        bytes28 reserved1;
        bytes16 attributes;
        bytes32 mrEnclave;
        bytes32 reserved2;
        bytes32 mrSigner;
        bytes reserved3; // 96 bytes
        uint16 isvProdId;
        uint16 isvSvn;
        bytes reserved4; // 60 bytes
        bytes reportData; // 64 bytes - For QEReports, this contains the hash of the concatenation
            // of attestation key and QEAuthData
    }

    struct QEAuthData {
        uint16 parsedDataSize;
        bytes data;
    }

    struct CertificationData {
        uint16 certType;
        // todo! In encoded path, we need to calculate the size of certDataArray
        // certDataSize = len(join((BEGIN_CERT, certArray[i], END_CERT) for i in 0..3))
        // But for plain bytes path, we don't need that.
        uint32 certDataSize;
        bytes[3] decodedCertDataArray; // base64 decoded cert bytes array
    }

    struct ECDSAQuoteV3AuthData {
        bytes ecdsa256BitSignature; // 64 bytes
        bytes ecdsaAttestationKey; // 64 bytes
        EnclaveReport pckSignedQeReport; // 384 bytes
        bytes qeReportSignature; // 64 bytes
        QEAuthData qeAuthData;
        CertificationData certification;
    }

    struct ParsedV3QuoteStruct {
        Header header;
        EnclaveReport localEnclaveReport;
        ECDSAQuoteV3AuthData v3AuthData;
    }
}

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

import "../../L1/TaikoData.sol";

/// @title LibPublicInput
/// @notice A library for handling hashing the so-called public input hash, used by sgx and zk
/// proofs.
/// @custom:security-contact [email protected]
library LibPublicInput {
    /// @notice Hashes the public input for the proof verification.
    /// @param _tran The transition to verify.
    /// @param _verifierContract The contract address which as current verifier.
    /// @param _newInstance The new instance address. For SGX it is the new signer address, for ZK
    /// this variable is not used and must have value address(0).
    /// @param _prover The prover address.
    /// @param _metaHash The meta hash.
    /// @param _chainId The chain id.
    /// @return The public input hash.
    function hashPublicInputs(
        TaikoData.Transition memory _tran,
        address _verifierContract,
        address _newInstance,
        address _prover,
        bytes32 _metaHash,
        uint64 _chainId
    )
        internal
        pure
        returns (bytes32)
    {
        return keccak256(
            abi.encode(
                "VERIFY_PROOF", _chainId, _verifierContract, _tran, _newInstance, _prover, _metaHash
            )
        );
    }
}

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

import "../L1/TaikoData.sol";

/// @title IVerifier
/// @notice Defines the function that handles proof verification.
/// @custom:security-contact [email protected]
interface IVerifier {
    struct Context {
        bytes32 metaHash;
        bytes32 blobHash;
        address prover;
        uint64 blockId;
        bool isContesting;
        bool blobUsed;
        address msgSender;
    }

    /// @notice Verifies a proof.
    /// @param _ctx The context of the proof verification.
    /// @param _tran The transition to verify.
    /// @param _proof The proof to verify.
    function verifyProof(
        Context calldata _ctx,
        TaikoData.Transition calldata _tran,
        TaikoData.TierProof calldata _proof
    )
        external;
}

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

/// @title LibNetwork
library LibNetwork {
    uint256 internal constant ETHEREUM_MAINNET = 1;
    uint256 internal constant ETHEREUM_ROPSTEN = 2;
    uint256 internal constant ETHEREUM_RINKEBY = 4;
    uint256 internal constant ETHEREUM_GOERLI = 5;
    uint256 internal constant ETHEREUM_KOVAN = 42;
    uint256 internal constant ETHEREUM_HOLESKY = 17_000;
    uint256 internal constant ETHEREUM_SEPOLIA = 11_155_111;

    uint64 internal constant TAIKO_MAINNET = 167_000;
    uint64 internal constant TAIKO_HEKLA = 167_009;

    /// @dev Checks if the chain ID represents an Ethereum testnet.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents an Ethereum testnet, false otherwise.
    function isEthereumTestnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId == LibNetwork.ETHEREUM_ROPSTEN || _chainId == LibNetwork.ETHEREUM_RINKEBY
            || _chainId == LibNetwork.ETHEREUM_GOERLI || _chainId == LibNetwork.ETHEREUM_KOVAN
            || _chainId == LibNetwork.ETHEREUM_HOLESKY || _chainId == LibNetwork.ETHEREUM_SEPOLIA;
    }

    /// @dev Checks if the chain ID represents an Ethereum testnet or the Etheruem mainnet.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents an Ethereum testnet or the Etheruem mainnet, false
    /// otherwise.
    function isEthereumMainnetOrTestnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId == LibNetwork.ETHEREUM_MAINNET || isEthereumTestnet(_chainId);
    }

    /// @dev Checks if the chain ID represents the Taiko L2 mainnet.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents the Taiko L2 mainnet.
    function isTaikoMainnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId == TAIKO_MAINNET;
    }

    /// @dev Checks if the chain ID represents an internal Taiko devnet's base layer.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents an internal Taiko devnet's base layer, false
    /// otherwise.
    function isTaikoDevnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId >= 32_300 && _chainId <= 32_400;
    }

    /// @dev Checks if the chain supports Dencun hardfork. Note that this check doesn't need to be
    /// exhaustive.
    /// @param _chainId The chain ID.
    /// @return true if the chain supports Dencun hardfork, false otherwise.
    function isDencunSupported(uint256 _chainId) internal pure returns (bool) {
        return _chainId == LibNetwork.ETHEREUM_MAINNET || _chainId == LibNetwork.ETHEREUM_HOLESKY
            || _chainId == LibNetwork.ETHEREUM_SEPOLIA || isTaikoDevnet(_chainId);
    }
}

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

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

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

/// @title TaikoData
/// @notice This library defines various data structures used in the Taiko
/// protocol.
/// @custom:security-contact [email protected]
library TaikoData {
    /// @dev Struct holding Taiko configuration parameters. See {TaikoConfig}.
    struct Config {
        // ---------------------------------------------------------------------
        // Group 1: General configs
        // ---------------------------------------------------------------------
        // The chain ID of the network where Taiko contracts are deployed.
        uint64 chainId;
        // ---------------------------------------------------------------------
        // Group 2: Block level configs
        // ---------------------------------------------------------------------
        // The maximum number of proposals allowed in a single block.
        uint64 blockMaxProposals;
        // Size of the block ring buffer, allowing extra space for proposals.
        uint64 blockRingBufferSize;
        // The maximum number of verifications allowed when a block is proposed
        // or proved.
        uint64 maxBlocksToVerify;
        // The maximum gas limit allowed for a block.
        uint32 blockMaxGasLimit;
        // ---------------------------------------------------------------------
        // Group 3: Proof related configs
        // ---------------------------------------------------------------------
        // The amount of Taiko token as a prover liveness bond
        uint96 livenessBond;
        // ---------------------------------------------------------------------
        // Group 4: Cross-chain sync
        // ---------------------------------------------------------------------
        // The number of L2 blocks between each L2-to-L1 state root sync.
        uint8 stateRootSyncInternal;
        bool checkEOAForCalldataDA;
    }

    /// @dev A proof and the tier of proof it belongs to
    struct TierProof {
        uint16 tier;
        bytes data;
    }

    /// @dev Hook and it's data (currently used only during proposeBlock)
    struct HookCall {
        address hook;
        bytes data;
    }

    /// @dev Represents proposeBlock's _data input parameter
    struct BlockParams {
        address assignedProver; // DEPRECATED, value ignored.
        address coinbase;
        bytes32 extraData;
        bytes32 parentMetaHash;
        HookCall[] hookCalls; // DEPRECATED, value ignored.
        bytes signature;
    }

    /// @dev Struct containing data only required for proving a block
    /// Note: On L2, `block.difficulty` is the pseudo name of
    /// `block.prevrandao`, which returns a random number provided by the layer
    /// 1 chain.
    struct BlockMetadata {
        bytes32 l1Hash;
        bytes32 difficulty;
        bytes32 blobHash; //or txListHash (if Blob not yet supported)
        bytes32 extraData;
        bytes32 depositsHash;
        address coinbase; // L2 coinbase,
        uint64 id;
        uint32 gasLimit;
        uint64 timestamp;
        uint64 l1Height;
        uint16 minTier;
        bool blobUsed;
        bytes32 parentMetaHash;
        address sender; // a.k.a proposer
    }

    /// @dev Struct representing transition to be proven.
    struct Transition {
        bytes32 parentHash;
        bytes32 blockHash;
        bytes32 stateRoot;
        bytes32 graffiti; // Arbitrary data that the prover can use for various purposes.
    }

    /// @dev Struct representing state transition data.
    /// 6 slots used.
    struct TransitionState {
        bytes32 key; // slot 1, only written/read for the 1st state transition.
        bytes32 blockHash; // slot 2
        bytes32 stateRoot; // slot 3
        address prover; // slot 4
        uint96 validityBond;
        address contester; // slot 5
        uint96 contestBond;
        uint64 timestamp; // slot 6 (90 bits)
        uint16 tier;
        uint8 __reserved1;
    }

    /// @dev Struct containing data required for verifying a block.
    /// 3 slots used.
    struct Block {
        bytes32 metaHash; // slot 1
        address assignedProver; // slot 2
        uint96 livenessBond;
        uint64 blockId; // slot 3
        uint64 proposedAt; // timestamp
        uint64 proposedIn; // L1 block number, required/used by node/client.
        uint32 nextTransitionId;
        // The ID of the transaction that is used to verify this block. However, if
        // this block is not verified as the last block in a batch, verifiedTransitionId
        // will remain zero.
        uint32 verifiedTransitionId;
    }

    /// @dev Struct representing an Ethereum deposit.
    /// 2 slot used. Currently removed from protocol, but to be backwards compatible, the struct and
    /// return values stayed for now.
    struct EthDeposit {
        address recipient;
        uint96 amount;
        uint64 id;
    }

    /// @dev Forge is only able to run coverage in case the contracts by default
    /// capable of compiling without any optimization (neither optimizer runs,
    /// no compiling --via-ir flag).
    /// In order to resolve stack too deep without optimizations, we needed to
    /// introduce outsourcing vars into structs below.
    struct SlotA {
        uint64 genesisHeight;
        uint64 genesisTimestamp;
        uint64 lastSyncedBlockId;
        uint64 lastSynecdAt; // typo!
    }

    struct SlotB {
        uint64 numBlocks;
        uint64 lastVerifiedBlockId;
        bool provingPaused;
        uint8 __reservedB1;
        uint16 __reservedB2;
        uint32 __reservedB3;
        uint64 lastUnpausedAt;
    }

    /// @dev Struct holding the state variables for the {TaikoL1} contract.
    struct State {
        // Ring buffer for proposed blocks and a some recent verified blocks.
        mapping(uint64 blockId_mod_blockRingBufferSize => Block blk) blocks;
        // Indexing to transition ids (ring buffer not possible)
        mapping(uint64 blockId => mapping(bytes32 parentHash => uint32 transitionId)) transitionIds;
        // Ring buffer for transitions
        mapping(
            uint64 blockId_mod_blockRingBufferSize
                => mapping(uint32 transitionId => TransitionState ts)
        ) transitions;
        // Ring buffer for Ether deposits
        bytes32 __reserve1;
        SlotA slotA; // slot 5
        SlotB slotB; // slot 6
        mapping(address account => uint256 bond) bondBalance;
        uint256[43] __gap;
    }
}

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

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822.sol";
import "../ERC1967/ERC1967Upgrade.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 *
 * _Available since v4.1._
 */
abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
    address private immutable __self = address(this);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        require(_getImplementation() == __self, "Function must be called through active proxy");
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
        _;
    }

    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
        return _IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeTo(address newImplementation) public virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeTo} and {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal override onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "./OwnableUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
    address private _pendingOwner;

    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);

    function __Ownable2Step_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable2Step_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

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

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "./IAddressManager.sol";
import "./IAddressResolver.sol";

/// @title AddressResolver
/// @notice See the documentation in {IAddressResolver}.
/// @custom:security-contact [email protected]
abstract contract AddressResolver is IAddressResolver, Initializable {
    /// @notice Address of the AddressManager.
    address public addressManager;
    uint256[49] private __gap;

    error RESOLVER_DENIED();
    error RESOLVER_INVALID_MANAGER();
    error RESOLVER_UNEXPECTED_CHAINID();
    error RESOLVER_ZERO_ADDR(uint64 chainId, bytes32 name);

    /// @dev Modifier that ensures the caller is the resolved address of a given
    /// name.
    /// @param _name The name to check against.
    modifier onlyFromNamed(bytes32 _name) {
        if (msg.sender != resolve(_name, true)) revert RESOLVER_DENIED();
        _;
    }

    /// @dev Modifier that ensures the caller is a resolved address to either _name1 or _name2
    /// name.
    /// @param _name1 The first name to check against.
    /// @param _name2 The second name to check against.
    modifier onlyFromNamedEither(bytes32 _name1, bytes32 _name2) {
        if (msg.sender != resolve(_name1, true) && msg.sender != resolve(_name2, true)) {
            revert RESOLVER_DENIED();
        }
        _;
    }

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    /// @inheritdoc IAddressResolver
    function resolve(bytes32 _name, bool _allowZeroAddress) public view virtual returns (address) {
        return _resolve(uint64(block.chainid), _name, _allowZeroAddress);
    }

    /// @inheritdoc IAddressResolver
    function resolve(
        uint64 _chainId,
        bytes32 _name,
        bool _allowZeroAddress
    )
        public
        view
        virtual
        returns (address)
    {
        return _resolve(_chainId, _name, _allowZeroAddress);
    }

    /// @dev Initialization method for setting up AddressManager reference.
    /// @param _addressManager Address of the AddressManager.
    function __AddressResolver_init(address _addressManager) internal virtual onlyInitializing {
        if (block.chainid > type(uint64).max) {
            revert RESOLVER_UNEXPECTED_CHAINID();
        }
        addressManager = _addressManager;
    }

    /// @dev Helper method to resolve name-to-address.
    /// @param _chainId The chainId of interest.
    /// @param _name Name whose address is to be resolved.
    /// @param _allowZeroAddress If set to true, does not throw if the resolved
    /// address is `address(0)`.
    /// @return addr_ Address associated with the given name on the specified
    /// chain.
    function _resolve(
        uint64 _chainId,
        bytes32 _name,
        bool _allowZeroAddress
    )
        internal
        view
        returns (address addr_)
    {
        addr_ = _getAddress(_chainId, _name);

        if (!_allowZeroAddress && addr_ == address(0)) {
            revert RESOLVER_ZERO_ADDR(_chainId, _name);
        }
    }

    function _getAddress(uint64 _chainId, bytes32 _name) internal view virtual returns (address) {
        address _addressManager = addressManager;
        if (_addressManager == address(0)) revert RESOLVER_INVALID_MANAGER();

        return IAddressManager(_addressManager).getAddress(_chainId, _name);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 */
abstract contract ERC1967Upgrade is IERC1967 {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

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

pragma solidity ^0.8.2;

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

/**
 * @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;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is 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) {
        require(!_initializing && _initialized < version, "Initializable: contract is 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() {
        require(_initializing, "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 {
        require(!_initializing, "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
pragma solidity 0.8.24;

/// @title IAddressManager
/// @notice Manages a mapping of (chainId, name) pairs to Ethereum addresses.
/// @custom:security-contact [email protected]
interface IAddressManager {
    /// @notice Gets the address mapped to a specific chainId-name pair.
    /// @dev Note that in production, this method shall be a pure function
    /// without any storage access.
    /// @param _chainId The chainId for which the address needs to be fetched.
    /// @param _name The name for which the address needs to be fetched.
    /// @return Address associated with the chainId-name pair.
    function getAddress(uint64 _chainId, bytes32 _name) external view returns (address);
}

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

/// @title IAddressResolver
/// @notice This contract acts as a bridge for name-to-address resolution.
/// It delegates the resolution to the AddressManager. By separating the logic,
/// we can maintain flexibility in address management without affecting the
/// resolving process.
/// @dev Note that the address manager should be changed using upgradability, there
/// is no setAddressManager() function to guarantee atomicity across all
/// contracts that are resolvers.
/// @custom:security-contact [email protected]
interface IAddressResolver {
    /// @notice Resolves a name to its address deployed on this chain.
    /// @param _name Name whose address is to be resolved.
    /// @param _allowZeroAddress If set to true, does not throw if the resolved
    /// address is `address(0)`.
    /// @return Address associated with the given name.
    function resolve(bytes32 _name, bool _allowZeroAddress) external view returns (address);

    /// @notice Resolves a name to its address deployed on a specified chain.
    /// @param _chainId The chainId of interest.
    /// @param _name Name whose address is to be resolved.
    /// @param _allowZeroAddress If set to true, does not throw if the resolved
    /// address is `address(0)`.
    /// @return Address associated with the given name on the specified
    /// chain.
    function resolve(
        uint64 _chainId,
        bytes32 _name,
        bool _allowZeroAddress
    )
        external
        view
        returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @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) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @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,
        string memory errorMessage
    ) 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
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @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,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

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

pragma solidity ^0.8.1;

/**
 * @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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @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) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @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,
        string memory errorMessage
    ) 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
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @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,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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(errorMessage);
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/",
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "solady/=node_modules/solady/",
    "forge-std/=node_modules/forge-std/",
    "ds-test/=node_modules/ds-test/src/",
    "p256-verifier/=node_modules/p256-verifier/",
    "forge-safe/=node_modules/forge-safe/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"FUNC_NOT_IMPLEMENTED","type":"error"},{"inputs":[],"name":"INVALID_PAUSE_STATUS","type":"error"},{"inputs":[],"name":"REENTRANT_CALL","type":"error"},{"inputs":[],"name":"RESOLVER_DENIED","type":"error"},{"inputs":[],"name":"RESOLVER_INVALID_MANAGER","type":"error"},{"inputs":[],"name":"RESOLVER_UNEXPECTED_CHAINID","type":"error"},{"inputs":[{"internalType":"uint64","name":"chainId","type":"uint64"},{"internalType":"bytes32","name":"name","type":"bytes32"}],"name":"RESOLVER_ZERO_ADDR","type":"error"},{"inputs":[],"name":"SGX_ALREADY_ATTESTED","type":"error"},{"inputs":[],"name":"SGX_INVALID_ATTESTATION","type":"error"},{"inputs":[],"name":"SGX_INVALID_INSTANCE","type":"error"},{"inputs":[],"name":"SGX_INVALID_PROOF","type":"error"},{"inputs":[],"name":"SGX_RA_NOT_SUPPORTED","type":"error"},{"inputs":[],"name":"ZERO_ADDRESS","type":"error"},{"inputs":[],"name":"ZERO_VALUE","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"instance","type":"address"},{"indexed":true,"internalType":"address","name":"replaced","type":"address"},{"indexed":false,"internalType":"uint256","name":"validSince","type":"uint256"}],"name":"InstanceAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"instance","type":"address"}],"name":"InstanceDeleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"INSTANCE_EXPIRY","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INSTANCE_VALIDITY_DELAY","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_instances","type":"address[]"}],"name":"addInstances","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"addressManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"instanceAddress","type":"address"}],"name":"addressRegistered","outputs":[{"internalType":"bool","name":"alreadyAttested","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"deleteInstances","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"impl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inNonReentrant","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_rollupAddressManager","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"instanceId","type":"uint256"}],"name":"instances","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"validSince","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUnpausedAt","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextInstanceId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"bytes2","name":"version","type":"bytes2"},{"internalType":"bytes2","name":"attestationKeyType","type":"bytes2"},{"internalType":"bytes4","name":"teeType","type":"bytes4"},{"internalType":"bytes2","name":"qeSvn","type":"bytes2"},{"internalType":"bytes2","name":"pceSvn","type":"bytes2"},{"internalType":"bytes16","name":"qeVendorId","type":"bytes16"},{"internalType":"bytes20","name":"userData","type":"bytes20"}],"internalType":"struct V3Struct.Header","name":"header","type":"tuple"},{"components":[{"internalType":"bytes16","name":"cpuSvn","type":"bytes16"},{"internalType":"bytes4","name":"miscSelect","type":"bytes4"},{"internalType":"bytes28","name":"reserved1","type":"bytes28"},{"internalType":"bytes16","name":"attributes","type":"bytes16"},{"internalType":"bytes32","name":"mrEnclave","type":"bytes32"},{"internalType":"bytes32","name":"reserved2","type":"bytes32"},{"internalType":"bytes32","name":"mrSigner","type":"bytes32"},{"internalType":"bytes","name":"reserved3","type":"bytes"},{"internalType":"uint16","name":"isvProdId","type":"uint16"},{"internalType":"uint16","name":"isvSvn","type":"uint16"},{"internalType":"bytes","name":"reserved4","type":"bytes"},{"internalType":"bytes","name":"reportData","type":"bytes"}],"internalType":"struct V3Struct.EnclaveReport","name":"localEnclaveReport","type":"tuple"},{"components":[{"internalType":"bytes","name":"ecdsa256BitSignature","type":"bytes"},{"internalType":"bytes","name":"ecdsaAttestationKey","type":"bytes"},{"components":[{"internalType":"bytes16","name":"cpuSvn","type":"bytes16"},{"internalType":"bytes4","name":"miscSelect","type":"bytes4"},{"internalType":"bytes28","name":"reserved1","type":"bytes28"},{"internalType":"bytes16","name":"attributes","type":"bytes16"},{"internalType":"bytes32","name":"mrEnclave","type":"bytes32"},{"internalType":"bytes32","name":"reserved2","type":"bytes32"},{"internalType":"bytes32","name":"mrSigner","type":"bytes32"},{"internalType":"bytes","name":"reserved3","type":"bytes"},{"internalType":"uint16","name":"isvProdId","type":"uint16"},{"internalType":"uint16","name":"isvSvn","type":"uint16"},{"internalType":"bytes","name":"reserved4","type":"bytes"},{"internalType":"bytes","name":"reportData","type":"bytes"}],"internalType":"struct V3Struct.EnclaveReport","name":"pckSignedQeReport","type":"tuple"},{"internalType":"bytes","name":"qeReportSignature","type":"bytes"},{"components":[{"internalType":"uint16","name":"parsedDataSize","type":"uint16"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct V3Struct.QEAuthData","name":"qeAuthData","type":"tuple"},{"components":[{"internalType":"uint16","name":"certType","type":"uint16"},{"internalType":"uint32","name":"certDataSize","type":"uint32"},{"internalType":"bytes[3]","name":"decodedCertDataArray","type":"bytes[3]"}],"internalType":"struct V3Struct.CertificationData","name":"certification","type":"tuple"}],"internalType":"struct V3Struct.ECDSAQuoteV3AuthData","name":"v3AuthData","type":"tuple"}],"internalType":"struct V3Struct.ParsedV3QuoteStruct","name":"_attestation","type":"tuple"}],"name":"registerInstance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_chainId","type":"uint64"},{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"bool","name":"_allowZeroAddress","type":"bool"}],"name":"resolve","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"bool","name":"_allowZeroAddress","type":"bool"}],"name":"resolve","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"metaHash","type":"bytes32"},{"internalType":"bytes32","name":"blobHash","type":"bytes32"},{"internalType":"address","name":"prover","type":"address"},{"internalType":"uint64","name":"blockId","type":"uint64"},{"internalType":"bool","name":"isContesting","type":"bool"},{"internalType":"bool","name":"blobUsed","type":"bool"},{"internalType":"address","name":"msgSender","type":"address"}],"internalType":"struct IVerifier.Context","name":"_ctx","type":"tuple"},{"components":[{"internalType":"bytes32","name":"parentHash","type":"bytes32"},{"internalType":"bytes32","name":"blockHash","type":"bytes32"},{"internalType":"bytes32","name":"stateRoot","type":"bytes32"},{"internalType":"bytes32","name":"graffiti","type":"bytes32"}],"internalType":"struct TaikoData.Transition","name":"_tran","type":"tuple"},{"components":[{"internalType":"uint16","name":"tier","type":"uint16"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct TaikoData.TierProof","name":"_proof","type":"tuple"}],"name":"verifyProof","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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