Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import {ISP1Vector} from "./interfaces/ISP1Vector.sol";
import {TimelockedUpgradeable} from "@succinctx/upgrades/TimelockedUpgradeable.sol";
import {ISP1Verifier} from "@sp1-contracts/ISP1Verifier.sol";

/// @notice SP1Vector is a light client for Avail's consensus.
/// @dev The light client tracks both the state of Avail's Grandpa consensus and Vector, Avail's
///     data commitment solution.
/// @dev Ensure that all new storage variables are placed after existing storage variables to avoid
/// storage corruption during upgrades.
contract SP1Vector is ISP1Vector, TimelockedUpgradeable {
    /// @notice Indicator of if the contract is frozen.
    bool public frozen;

    /// @notice The address of the gateway contract.
    /// @dev DEPRECATED: Do not use. Compatibility for upgrades from VectorX.
    address public gateway_deprecated;

    /// @notice The latest block that has been committed.
    uint32 public latestBlock;

    /// @notice The latest authority set id used in commitHeaderRange.
    uint64 public latestAuthoritySetId;

    /// @notice The function for requesting a header range.
    /// @dev DEPRECATED: Do not use. Compatibility for upgrades from VectorX.
    bytes32 public headerRangeFunctionId_deprecated;

    /// @notice The function for requesting a rotate.
    /// @dev DEPRECATED: Do not use. Compatibility for upgrades from VectorX.
    bytes32 public rotateFunctionId_deprecated;

    /// @notice Maps block height to the header hash of the block.
    mapping(uint32 => bytes32) public blockHeightToHeaderHash;

    /// @notice Maps authority set id to the authority set hash.
    mapping(uint64 => bytes32) public authoritySetIdToHash;

    /// @notice Maps block ranges to data commitments. Block ranges are stored as
    ///     keccak256(abi.encode(startBlock, endBlock)).
    mapping(bytes32 => bytes32) public dataRootCommitments;

    /// @notice Maps block ranges to state commitments. Block ranges are stored as
    ///     keccak256(abi.encode(startBlock, endBlock)).
    mapping(bytes32 => bytes32) public stateRootCommitments;

    /// @notice Maps range hashes to the start block of the range. This allows us
    ///     to know the block height of an attestation.
    mapping(bytes32 => uint32) public rangeStartBlocks;

    /// @notice The commitment tree size for the header range.
    uint32 public headerRangeCommitmentTreeSize;

    /// @notice The verification key for the SP1Vector program.
    bytes32 public vectorXProgramVkey;

    /// @notice The deployed SP1 verifier contract.
    ISP1Verifier public verifier;

    /// @notice Approved relayers for the contract.
    mapping(address => bool) public approvedRelayers;

    /// @notice Check the relayer is approved.
    bool public checkRelayer;

    /// @notice The type of proof that is being verified.
    enum ProofType {
        HeaderRangeProof,
        RotateProof
    }

    struct InitParameters {
        address guardian;
        uint32 height;
        bytes32 header;
        uint64 authoritySetId;
        bytes32 authoritySetHash;
        uint32 headerRangeCommitmentTreeSize;
        bytes32 vectorProgramVkey;
        address verifier;
    }

    struct HeaderRangeOutputs {
        uint32 trusted_block;
        bytes32 trusted_header_hash;
        uint64 authority_set_id;
        bytes32 authority_set_hash;
        uint32 target_block;
        bytes32 target_header_hash;
        bytes32 state_root_commitment;
        bytes32 data_root_commitment;
        uint32 merkle_tree_size;
    }

    struct RotateOutputs {
        uint64 current_authority_set_id;
        bytes32 current_authority_set_hash;
        bytes32 new_authority_set_hash;
    }

    struct ProofOutputs {
        ProofType proofType;
        bytes headerRangeOutputs;
        bytes rotateOutputs;
    }

    /// @notice If the relayer check is enabled, only approved relayers can call the function.
    modifier onlyApprovedRelayer() {
        if (checkRelayer && !approvedRelayers[msg.sender]) {
            revert RelayerNotApproved();
        }
        _;
    }

    function VERSION() external pure override returns (string memory) {
        return "2.0.0";
    }

    /// @dev Initializes the contract.
    /// @param _params The initialization parameters for the contract.
    function initialize(InitParameters calldata _params) external initializer {
        blockHeightToHeaderHash[_params.height] = _params.header;
        authoritySetIdToHash[_params.authoritySetId] = _params.authoritySetHash;
        latestAuthoritySetId = _params.authoritySetId;
        latestBlock = _params.height;
        vectorXProgramVkey = _params.vectorProgramVkey;
        verifier = ISP1Verifier(_params.verifier);
        headerRangeCommitmentTreeSize = _params.headerRangeCommitmentTreeSize;

        __TimelockedUpgradeable_init(_params.guardian, _params.guardian);
    }

    /// @notice Update the SP1 verifier.
    function updateVerifier(address _verifier) external onlyGuardian {
        verifier = ISP1Verifier(_verifier);
    }

    /// @notice Update the SP1Vector program verification key.
    function updateVectorXProgramVkey(bytes32 _vectorXProgramVkey) external onlyGuardian {
        vectorXProgramVkey = _vectorXProgramVkey;
    }

    /// @notice Update the freeze parameter.
    function updateFreeze(bool _freeze) external onlyGuardian {
        frozen = _freeze;
    }

    /// @notice Update the commitment tree size for the header range function.
    function updateCommitmentTreeSize(uint32 _headerRangeCommitmentTreeSize) external onlyGuardian {
        headerRangeCommitmentTreeSize = _headerRangeCommitmentTreeSize;
    }

    /// @notice Update the genesis state of the light client.
    function updateGenesisState(uint32 _height, bytes32 _header, uint64 _authoritySetId, bytes32 _authoritySetHash)
        external
        onlyGuardian
    {
        blockHeightToHeaderHash[_height] = _header;
        latestBlock = _height;

        authoritySetIdToHash[_authoritySetId] = _authoritySetHash;
        latestAuthoritySetId = _authoritySetId;
    }

    /// @notice Force update the data & state commitments for a range of blocks.
    function updateBlockRangeData(
        uint32[] calldata _startBlocks,
        uint32[] calldata _endBlocks,
        bytes32[] calldata _headerHashes,
        bytes32[] calldata _dataRootCommitments,
        bytes32[] calldata _stateRootCommitments,
        uint64 _endAuthoritySetId,
        bytes32 _endAuthoritySetHash
    ) external onlyGuardian {
        assert(
            _startBlocks.length > 0 && _startBlocks.length == _endBlocks.length
                && _endBlocks.length == _headerHashes.length && _headerHashes.length == _dataRootCommitments.length
                && _dataRootCommitments.length == _stateRootCommitments.length
        );
        require(_startBlocks[0] == latestBlock);
        for (uint256 i = 0; i < _startBlocks.length; i++) {
            if (i < _startBlocks.length - 1) {
                require(_endBlocks[i] == _startBlocks[i + 1]);
            }
            bytes32 key = keccak256(abi.encode(_startBlocks[i], _endBlocks[i]));
            dataRootCommitments[key] = _dataRootCommitments[i];
            stateRootCommitments[key] = _stateRootCommitments[i];
            rangeStartBlocks[key] = _startBlocks[i];

            blockHeightToHeaderHash[_endBlocks[i]] = _headerHashes[i];

            emit HeadUpdate(_endBlocks[i], _headerHashes[i]);

            emit HeaderRangeCommitmentStored(
                _startBlocks[i],
                _endBlocks[i],
                _dataRootCommitments[i],
                _stateRootCommitments[i],
                headerRangeCommitmentTreeSize
            );
        }
        latestBlock = _endBlocks[_endBlocks.length - 1];

        authoritySetIdToHash[_endAuthoritySetId] = _endAuthoritySetHash;
        latestAuthoritySetId = _endAuthoritySetId;
    }

    /// @notice Set a relayer's approval status.
    function setRelayerApproval(address _relayer, bool _approved) external onlyGuardian {
        approvedRelayers[_relayer] = _approved;
    }

    /// @notice Set a check relayer status.
    function setCheckRelayer(bool _checkRelayer) external onlyGuardian {
        checkRelayer = _checkRelayer;
    }

    /// @notice Add target header hash, and data + state commitments for (latestBlock, targetBlock].
    /// @param proof The proof bytes for the SP1 proof.
    /// @param publicValues The public commitments from the SP1 proof.
    /// @dev The trusted block and requested block must have the same authority set id. If the target
    /// block is greater than the max batch size of the circuit, the proof will fail to generate.
    function commitHeaderRange(bytes calldata proof, bytes calldata publicValues) external onlyApprovedRelayer {
        if (frozen) {
            revert ContractFrozen();
        }

        // Parse the outputs from the committed public values associated with the proof.
        ProofOutputs memory proofOutputs = abi.decode(publicValues, (ProofOutputs));

        // Assert this is a header range proof. Sanity check to prevent accidental submission of a
        // rotate proof.
        if (proofOutputs.proofType != ProofType.HeaderRangeProof) {
            revert InvalidProofType();
        }

        // Decode the header range outputs from the proof outputs.
        HeaderRangeOutputs memory hro = abi.decode(proofOutputs.headerRangeOutputs, (HeaderRangeOutputs));

        // Verify the merkle tree size in the proof matches the expected size.
        if (hro.merkle_tree_size != headerRangeCommitmentTreeSize) {
            revert InvalidMerkleTreeSize();
        }

        // Verify the trusted header matches the stored trusted header and latestBlock.
        bytes32 storedTrustedHeader = blockHeightToHeaderHash[latestBlock];
        if (storedTrustedHeader == bytes32(0)) {
            revert TrustedHeaderNotFound();
        }
        if (hro.trusted_header_hash != storedTrustedHeader && hro.trusted_block != latestBlock) {
            revert TrustedHeaderMismatch();
        }

        // Verify the authority set hash matches the stored authority set hash.
        bytes32 authoritySetHashStored = authoritySetIdToHash[hro.authority_set_id];
        if (authoritySetHashStored == bytes32(0)) {
            revert AuthoritySetNotFound();
        }
        if (hro.authority_set_hash != authoritySetHashStored) {
            revert AuthoritySetMismatch();
        }

        // Verify the target block is greater than the latest block.
        if (hro.target_block <= latestBlock) {
            revert InvalidTargetBlock();
        }

        // If the authority set id is less than the latest authority set id proven in the contract,
        // the proof is invalid.
        if (hro.authority_set_id < latestAuthoritySetId) {
            revert OldAuthoritySetId();
        }

        // Verify the proof with the associated public values. This will revert if proof invalid.
        verifier.verifyProof(vectorXProgramVkey, publicValues, proof);

        emit HeadUpdate(hro.target_block, hro.target_header_hash);
        emit HeaderRangeCommitmentStored(
            hro.trusted_block,
            hro.target_block,
            hro.data_root_commitment,
            hro.state_root_commitment,
            headerRangeCommitmentTreeSize
        );

        // Update the latest authority set id if the authority set id is greater than the latest
        // authority set id.
        if (hro.authority_set_id > latestAuthoritySetId) {
            latestAuthoritySetId = hro.authority_set_id;
        }

        // Store the data and state commitments for the range (latestBlock, targetBlock].
        bytes32 key = keccak256(abi.encode(latestBlock, hro.target_block));
        dataRootCommitments[key] = hro.data_root_commitment;
        stateRootCommitments[key] = hro.state_root_commitment;
        rangeStartBlocks[key] = latestBlock;

        // Add the target header hash to the contract.
        blockHeightToHeaderHash[hro.target_block] = hro.target_header_hash;

        // Update latest block.
        latestBlock = hro.target_block;
    }

    /// @notice Adds the authority set hash for the next authority set id.
    /// @param proof The proof bytes for the SP1 proof.
    /// @param publicValues The public commitments from the SP1 proof.
    function rotate(bytes calldata proof, bytes calldata publicValues) external onlyApprovedRelayer {
        if (frozen) {
            revert ContractFrozen();
        }

        // Parse the outputs from the committed public values associated with the proof.
        ProofOutputs memory proofOutputs = abi.decode(publicValues, (ProofOutputs));

        // Assert this is a rotate proof.
        if (proofOutputs.proofType != ProofType.RotateProof) {
            revert InvalidProofType();
        }

        // Decode the rotate outputs from the proof.
        RotateOutputs memory ro = abi.decode(proofOutputs.rotateOutputs, (RotateOutputs));

        // Verify the current authority set hash has already been proven in the contract.
        bytes32 currentAuthoritySetHashStored = authoritySetIdToHash[ro.current_authority_set_id];
        if (currentAuthoritySetHashStored == bytes32(0)) {
            revert AuthoritySetNotFound();
        }
        if (ro.current_authority_set_hash != currentAuthoritySetHashStored) {
            revert AuthoritySetMismatch();
        }

        // Verify the next authority set hash does not exist yet.
        bytes32 nextAuthoritySetHash = authoritySetIdToHash[ro.current_authority_set_id + 1];
        if (nextAuthoritySetHash != bytes32(0)) {
            revert NextAuthoritySetExists();
        }

        // Verify the proof with the associated public values.
        verifier.verifyProof(vectorXProgramVkey, publicValues, proof);

        emit AuthoritySetStored(ro.current_authority_set_id + 1, ro.new_authority_set_hash);

        // Store the authority set hash for the next authority set id.
        authoritySetIdToHash[ro.current_authority_set_id + 1] = ro.new_authority_set_hash;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface ISP1Vector {
    /// @notice Emits event with the inputs of a header range request.
    /// @param trustedBlock The block height of the trusted block.
    /// @param trustedHeader The header hash of the trusted block.
    /// @param authoritySetId The authority set id of trusted block + 1.
    /// @param authoritySetHash The authority set hash of trusted block + 1.
    /// @param targetBlock The block height of the target block.
    event HeaderRangeRequested(
        uint32 trustedBlock, bytes32 trustedHeader, uint64 authoritySetId, bytes32 authoritySetHash, uint32 targetBlock
    );

    /// @notice Emits event with the inputs of a rotate request.
    /// @param currentAuthoritySetId The authority set id of the current authority set.
    /// @param currentAuthoritySetHash The authority set hash of the current authority set.
    event RotateRequested(uint64 currentAuthoritySetId, bytes32 currentAuthoritySetHash);

    /// @notice Emitted when the light client's head is updated.
    event HeadUpdate(uint32 blockNumber, bytes32 headerHash);

    /// @notice Emitted when data + state commitment for range (startBlock, endBlock] are stored.
    /// @param headerRangeCommitmentTreeSize The commitment tree size for the header range.
    event HeaderRangeCommitmentStored(
        uint32 startBlock,
        uint32 endBlock,
        bytes32 dataCommitment,
        bytes32 stateCommitment,
        uint32 headerRangeCommitmentTreeSize
    );

    /// @notice Emitted when a new authority set is stored.
    event AuthoritySetStored(uint64 authoritySetId, bytes32 authoritySetHash);

    /// @notice If the next authority set already exists.
    error NextAuthoritySetExists();

    /// @notice Contract is frozen.
    error ContractFrozen();

    /// @notice Trusted header not found.
    error TrustedHeaderNotFound();

    /// @notice Stored trusted header does not match proof trusted header.
    error TrustedHeaderMismatch();

    /// @notice Authority set not found.
    error AuthoritySetNotFound();

    /// @notice Stored authority set does not match proof authority set.
    error AuthoritySetMismatch();

    /// @notice The authority set id is older than the authority set id of the latest commitHeaderRange.
    error OldAuthoritySetId();

    /// @notice The proof type is not HeaderRangeProof or RotateProof.
    error InvalidProofType();

    /// @notice The merkle tree size does not match the expected size.
    error InvalidMerkleTreeSize();

    /// @notice The trusted block inside the proof does not match the trusted block of the contract.
    error BlockHeightMismatch();

    /// @notice Target block is not greater than the latest block.
    error InvalidTargetBlock();

    /// @notice Relayer not approved.
    error RelayerNotApproved();
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;

import {Versioned} from "./Versioned.sol";
import {Initializable} from "@openzeppelin-upgradeable/contracts/proxy/utils/Initializable.sol";
import {UUPSUpgradeable} from "@openzeppelin-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
import {AccessControlUpgradeable} from
    "@openzeppelin-upgradeable/contracts/access/AccessControlUpgradeable.sol";

/// @title TimelockedUpgradeable
/// @notice A base contract that has modifiers to specify that certain functions are only callable
///         by a sender with a timelock or guardian role.
abstract contract TimelockedUpgradeable is
    Versioned,
    Initializable,
    UUPSUpgradeable,
    AccessControlUpgradeable
{
    /// @notice A random constant used to identify addresses with the permission of a 'timelock'.
    /// @dev Should be set to a 'timelock' contract, which may only execute calls after being
    ///      for a certain amount of time.
    bytes32 public constant TIMELOCK_ROLE = keccak256("TIMELOCK_ROLE");
    /// @notice A random constant used to identify addresses with the permission of a 'guardian'.
    /// @dev Can be set to any address, which may execute calls immediately.
    bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");

    error OnlyTimelock(address sender);
    error OnlyGuardian(address sender);

    modifier onlyTimelock() {
        if (!hasRole(TIMELOCK_ROLE, msg.sender)) {
            revert OnlyTimelock(msg.sender);
        }
        _;
    }

    modifier onlyGuardian() {
        if (!hasRole(GUARDIAN_ROLE, msg.sender)) {
            revert OnlyGuardian(msg.sender);
        }
        _;
    }

    /// @notice Prevents the implementation contract from being initialized outside of an
    ///         upgradeable proxy.
    constructor() {
        _disableInitializers();
    }

    /// @notice Initializes the contract.
    /// @dev The DEFAULT_ADMIN_ROLE needs to be set but should be unused.
    function __TimelockedUpgradeable_init(address _timelock, address _guardian)
        internal
        onlyInitializing
    {
        __AccessControl_init();
        __UUPSUpgradeable_init();
        _grantRole(DEFAULT_ADMIN_ROLE, _timelock);
        _grantRole(TIMELOCK_ROLE, _timelock);
        _grantRole(GUARDIAN_ROLE, _guardian);
    }

    /// @notice Authorizes an upgrade for the implementation contract.
    function _authorizeUpgrade(address newImplementation) internal virtual override onlyTimelock {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @title SP1 Verifier Interface
/// @author Succinct Labs
/// @notice This contract is the interface for the SP1 Verifier.
interface ISP1Verifier {
    /// @notice Verifies a proof with given public values and vkey.
    /// @dev It is expected that the first 4 bytes of proofBytes must match the first 4 bytes of
    /// target verifier's VERIFIER_HASH.
    /// @param programVKey The verification key for the RISC-V program.
    /// @param publicValues The public values encoded as bytes.
    /// @param proofBytes The proof of the program execution the SP1 zkVM encoded as bytes.
    function verifyProof(
        bytes32 programVKey,
        bytes calldata publicValues,
        bytes calldata proofBytes
    ) external view;
}

interface ISP1VerifierWithHash is ISP1Verifier {
    /// @notice Returns the hash of the verifier.
    function VERIFIER_HASH() external pure returns (bytes32);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;

/// @title Versioned
/// @notice Contract that provides a VERSION to inheritors.
/// @dev This is used for easier management and version compatibility checking between contracts.
abstract contract Versioned {
    /// @dev This should be overridden by inheriting contracts.
    function VERSION() external pure virtual returns (string memory) {
        return "1.0.0";
    }
}

// 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
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import "./Initializable.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 Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /// @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;

    /**
     * @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) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
    function __AccessControl_init() internal onlyInitializing {
    }

    function __AccessControl_init_unchained() internal onlyInitializing {
    }
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        StringsUpgradeable.toHexString(account),
                        " is missing role ",
                        StringsUpgradeable.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }

    /**
     * @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) (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);
        }
    }
}

// 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 IERC1822ProxiableUpgradeable {
    /**
     * @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/IBeaconUpgradeable.sol";
import "../../interfaces/IERC1967Upgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import "../utils/Initializable.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 ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
    function __ERC1967Upgrade_init() internal onlyInitializing {
    }

    function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
    }
    // 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 StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlotUpgradeable.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) {
            AddressUpgradeable.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 (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822ProxiableUpgradeable(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 StorageSlotUpgradeable.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");
        StorageSlotUpgradeable.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 StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlotUpgradeable.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) {
            AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
        }
    }

    /**
     * @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 v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControlUpgradeable {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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

pragma solidity ^0.8.0;
import "../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;
    }

    /**
     * @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/Strings.sol)

pragma solidity ^0.8.0;

import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    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 = MathUpgradeable.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(SignedMathUpgradeable.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, MathUpgradeable.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
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal onlyInitializing {
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }

    /**
     * @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 v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeaconUpgradeable {
    /**
     * @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 IERC1967Upgradeable {
    /**
     * @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/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 StorageSlotUpgradeable {
    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.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library MathUpgradeable {
    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 SignedMathUpgradeable {
    /**
     * @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 v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165Upgradeable {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "@sp1-contracts/=lib/sp1-contracts/contracts/src/",
    "@succinctx/=lib/succinctx/contracts/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "@openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "ds-test/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "safe-contracts/=lib/succinctx/contracts/lib/safe-contracts/",
    "sp1-contracts/=lib/sp1-contracts/contracts/",
    "succinctx/=lib/succinctx/contracts/"
  ],
  "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": {}
}

[{"inputs":[],"name":"AuthoritySetMismatch","type":"error"},{"inputs":[],"name":"AuthoritySetNotFound","type":"error"},{"inputs":[],"name":"BlockHeightMismatch","type":"error"},{"inputs":[],"name":"ContractFrozen","type":"error"},{"inputs":[],"name":"InvalidMerkleTreeSize","type":"error"},{"inputs":[],"name":"InvalidProofType","type":"error"},{"inputs":[],"name":"InvalidTargetBlock","type":"error"},{"inputs":[],"name":"NextAuthoritySetExists","type":"error"},{"inputs":[],"name":"OldAuthoritySetId","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"OnlyGuardian","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"OnlyTimelock","type":"error"},{"inputs":[],"name":"RelayerNotApproved","type":"error"},{"inputs":[],"name":"TrustedHeaderMismatch","type":"error"},{"inputs":[],"name":"TrustedHeaderNotFound","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":false,"internalType":"uint64","name":"authoritySetId","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"authoritySetHash","type":"bytes32"}],"name":"AuthoritySetStored","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"blockNumber","type":"uint32"},{"indexed":false,"internalType":"bytes32","name":"headerHash","type":"bytes32"}],"name":"HeadUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"startBlock","type":"uint32"},{"indexed":false,"internalType":"uint32","name":"endBlock","type":"uint32"},{"indexed":false,"internalType":"bytes32","name":"dataCommitment","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"stateCommitment","type":"bytes32"},{"indexed":false,"internalType":"uint32","name":"headerRangeCommitmentTreeSize","type":"uint32"}],"name":"HeaderRangeCommitmentStored","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"trustedBlock","type":"uint32"},{"indexed":false,"internalType":"bytes32","name":"trustedHeader","type":"bytes32"},{"indexed":false,"internalType":"uint64","name":"authoritySetId","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"authoritySetHash","type":"bytes32"},{"indexed":false,"internalType":"uint32","name":"targetBlock","type":"uint32"}],"name":"HeaderRangeRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"currentAuthoritySetId","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"currentAuthoritySetHash","type":"bytes32"}],"name":"RotateRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GUARDIAN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TIMELOCK_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"approvedRelayers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"authoritySetIdToHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"","type":"uint32"}],"name":"blockHeightToHeaderHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"checkRelayer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"proof","type":"bytes"},{"internalType":"bytes","name":"publicValues","type":"bytes"}],"name":"commitHeaderRange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"dataRootCommitments","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"frozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gateway_deprecated","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"headerRangeCommitmentTreeSize","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"headerRangeFunctionId_deprecated","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"guardian","type":"address"},{"internalType":"uint32","name":"height","type":"uint32"},{"internalType":"bytes32","name":"header","type":"bytes32"},{"internalType":"uint64","name":"authoritySetId","type":"uint64"},{"internalType":"bytes32","name":"authoritySetHash","type":"bytes32"},{"internalType":"uint32","name":"headerRangeCommitmentTreeSize","type":"uint32"},{"internalType":"bytes32","name":"vectorProgramVkey","type":"bytes32"},{"internalType":"address","name":"verifier","type":"address"}],"internalType":"struct SP1Vector.InitParameters","name":"_params","type":"tuple"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"latestAuthoritySetId","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestBlock","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"rangeStartBlocks","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"proof","type":"bytes"},{"internalType":"bytes","name":"publicValues","type":"bytes"}],"name":"rotate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rotateFunctionId_deprecated","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_checkRelayer","type":"bool"}],"name":"setCheckRelayer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_relayer","type":"address"},{"internalType":"bool","name":"_approved","type":"bool"}],"name":"setRelayerApproval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"stateRootCommitments","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32[]","name":"_startBlocks","type":"uint32[]"},{"internalType":"uint32[]","name":"_endBlocks","type":"uint32[]"},{"internalType":"bytes32[]","name":"_headerHashes","type":"bytes32[]"},{"internalType":"bytes32[]","name":"_dataRootCommitments","type":"bytes32[]"},{"internalType":"bytes32[]","name":"_stateRootCommitments","type":"bytes32[]"},{"internalType":"uint64","name":"_endAuthoritySetId","type":"uint64"},{"internalType":"bytes32","name":"_endAuthoritySetHash","type":"bytes32"}],"name":"updateBlockRangeData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_headerRangeCommitmentTreeSize","type":"uint32"}],"name":"updateCommitmentTreeSize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_freeze","type":"bool"}],"name":"updateFreeze","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_height","type":"uint32"},{"internalType":"bytes32","name":"_header","type":"bytes32"},{"internalType":"uint64","name":"_authoritySetId","type":"uint64"},{"internalType":"bytes32","name":"_authoritySetHash","type":"bytes32"}],"name":"updateGenesisState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_vectorXProgramVkey","type":"bytes32"}],"name":"updateVectorXProgramVkey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_verifier","type":"address"}],"name":"updateVerifier","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":[],"name":"vectorXProgramVkey","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"verifier","outputs":[{"internalType":"contract ISP1Verifier","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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