Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "@thirdweb-dev/contracts/prebuilts/account/utils/BaseAccountFactory.sol";
import "./YeetAccount.sol";

contract YeetAccountFactory is BaseAccountFactory  {

  event Registered(string email, address account);
  mapping(string => address) public accountOfEmail;

  constructor(
    IEntryPoint _entrypoint
  )
    BaseAccountFactory(
      address(new YeetAccount(_entrypoint, address(this))), address(_entrypoint)
    )
  {}

  function _initializeAccount(
    address _account,
    address _admin,
    bytes calldata _data
  ) internal override {
    YeetAccount(payable(_account)).initialize(_admin, _data);
  }


  function onRegistered(string calldata email) external {
    address account = msg.sender;
    require(this.isRegistered(account), "YeetAccountFactory: not an account.");
    require(accountOfEmail[email] == address(0), "YeetAccountFactory: email already registered");
    accountOfEmail[email] = account;
    emit Registered(email, account);
  }
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.0;

abstract contract ERC1271 {
    // bytes4(keccak256("isValidSignature(bytes32,bytes)")
    bytes4 internal constant MAGICVALUE = 0x1626ba7e;

    /**
     * @dev Should return whether the signature provided is valid for the provided hash
     * @param _hash      Hash of the data to be signed
     * @param _signature Signature byte array associated with _hash
     *
     * MUST return the bytes4 magic value 0x1626ba7e when function passes.
     * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
     * MUST allow external calls
     */
    function isValidSignature(bytes32 _hash, bytes memory _signature) public view virtual returns (bytes4 magicValue);
}

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

pragma solidity ^0.8.0;

import "./interface/IERC165.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 ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// 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
 * [EIP](https://eips.ethereum.org/EIPS/eip-165).
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * 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);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @author thirdweb

interface IAccountPermissions {
    /*///////////////////////////////////////////////////////////////
                                Types
    //////////////////////////////////////////////////////////////*/

    /**
     *  @notice The payload that must be signed by an authorized wallet to set permissions for a signer to use the smart wallet.
     *
     *  @param signer The addres of the signer to give permissions.
     *  @param approvedTargets The list of approved targets that a role holder can call using the smart wallet.
     *  @param nativeTokenLimitPerTransaction The maximum value that can be transferred by a role holder in a single transaction.
     *  @param permissionStartTimestamp The UNIX timestamp at and after which a signer has permission to use the smart wallet.
     *  @param permissionEndTimestamp The UNIX timestamp at and after which a signer no longer has permission to use the smart wallet.
     *  @param reqValidityStartTimestamp The UNIX timestamp at and after which a signature is valid.
     *  @param reqValidityEndTimestamp The UNIX timestamp at and after which a signature is invalid/expired.
     *  @param uid A unique non-repeatable ID for the payload.
     *  @param isAdmin Whether the signer should be an admin.
     */
    struct SignerPermissionRequest {
        address signer;
        uint8 isAdmin;
        address[] approvedTargets;
        uint256 nativeTokenLimitPerTransaction;
        uint128 permissionStartTimestamp;
        uint128 permissionEndTimestamp;
        uint128 reqValidityStartTimestamp;
        uint128 reqValidityEndTimestamp;
        bytes32 uid;
    }

    /**
     *  @notice The permissions that a signer has to use the smart wallet.
     *
     *  @param signer The address of the signer.
     *  @param approvedTargets The list of approved targets that a role holder can call using the smart wallet.
     *  @param nativeTokenLimitPerTransaction The maximum value that can be transferred by a role holder in a single transaction.
     *  @param startTimestamp The UNIX timestamp at and after which a signer has permission to use the smart wallet.
     *  @param endTimestamp The UNIX timestamp at and after which a signer no longer has permission to use the smart wallet.
     */
    struct SignerPermissions {
        address signer;
        address[] approvedTargets;
        uint256 nativeTokenLimitPerTransaction;
        uint128 startTimestamp;
        uint128 endTimestamp;
    }

    /**
     *  @notice Internal struct for storing permissions for a signer (without approved targets).
     *
     *  @param nativeTokenLimitPerTransaction The maximum value that can be transferred by a role holder in a single transaction.
     *  @param startTimestamp The UNIX timestamp at and after which a signer has permission to use the smart wallet.
     *  @param endTimestamp The UNIX timestamp at and after which a signer no longer has permission to use the smart wallet.
     */
    struct SignerPermissionsStatic {
        uint256 nativeTokenLimitPerTransaction;
        uint128 startTimestamp;
        uint128 endTimestamp;
    }

    /*///////////////////////////////////////////////////////////////
                                Events
    //////////////////////////////////////////////////////////////*/

    /// @notice Emitted when permissions for a signer are updated.
    event SignerPermissionsUpdated(
        address indexed authorizingSigner,
        address indexed targetSigner,
        SignerPermissionRequest permissions
    );

    /// @notice Emitted when an admin is set or removed.
    event AdminUpdated(address indexed signer, bool isAdmin);

    /*///////////////////////////////////////////////////////////////
                            View functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns whether the given account is an admin.
    function isAdmin(address signer) external view returns (bool);

    /// @notice Returns whether the given account is an active signer on the account.
    function isActiveSigner(address signer) external view returns (bool);

    /// @notice Returns the restrictions under which a signer can use the smart wallet.
    function getPermissionsForSigner(address signer) external view returns (SignerPermissions memory permissions);

    /// @notice Returns all active and inactive signers of the account.
    function getAllSigners() external view returns (SignerPermissions[] memory signers);

    /// @notice Returns all signers with active permissions to use the account.
    function getAllActiveSigners() external view returns (SignerPermissions[] memory signers);

    /// @notice Returns all admins of the account.
    function getAllAdmins() external view returns (address[] memory admins);

    /// @dev Verifies that a request is signed by an authorized account.
    function verifySignerPermissionRequest(
        SignerPermissionRequest calldata req,
        bytes calldata signature
    ) external view returns (bool success, address signer);

    /*///////////////////////////////////////////////////////////////
                            External functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Sets the permissions for a given signer.
    function setPermissionsForSigner(SignerPermissionRequest calldata req, bytes calldata signature) external;
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @author thirdweb

/**
 *  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
 *  for you contract.
 *
 *  Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
 */

interface IContractMetadata {
    /// @dev Returns the metadata URI of the contract.
    function contractURI() external view returns (string memory);

    /**
     *  @dev Sets contract URI for the storefront-level metadata of the contract.
     *       Only module admin can call this function.
     */
    function setContractURI(string calldata _uri) external;

    /// @dev Emitted when the contract URI is updated.
    event ContractURIUpdated(string prevURI, string newURI);
}

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

/// @author thirdweb

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 *
 * _Available since v4.1._
 */
interface IMulticall {
    /**
     * @dev Receives and executes a batch of function calls on this contract.
     */
    function multicall(bytes[] calldata data) external returns (bytes[] memory results);
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.0;

/// @author thirdweb

import "../lib/Address.sol";
import "./interface/IMulticall.sol";

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 *
 * _Available since v4.1._
 */
contract Multicall is IMulticall {
    /**
     *  @notice Receives and executes a batch of function calls on this contract.
     *  @dev Receives and executes a batch of function calls on this contract.
     *
     *  @param data The bytes data that makes up the batch of function calls to execute.
     *  @return results The bytes data that makes up the result of the batch of function calls executed.
     */
    function multicall(bytes[] calldata data) external returns (bytes[] memory results) {
        results = new bytes[](data.length);
        address sender = _msgSender();
        bool isForwarder = msg.sender != sender;
        for (uint256 i = 0; i < data.length; i++) {
            if (isForwarder) {
                results[i] = Address.functionDelegateCall(address(this), abi.encodePacked(data[i], sender));
            } else {
                results[i] = Address.functionDelegateCall(address(this), data[i]);
            }
        }
        return results;
    }

    /// @notice Returns the sender in the given execution context.
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @author thirdweb

import "../interface/IAccountPermissions.sol";
import "../../external-deps/openzeppelin/utils/cryptography/EIP712.sol";
import "../../external-deps/openzeppelin/utils/structs/EnumerableSet.sol";

library AccountPermissionsStorage {
    /// @custom:storage-location erc7201:account.permissions.storage
    /// @dev keccak256(abi.encode(uint256(keccak256("account.permissions.storage")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 public constant ACCOUNT_PERMISSIONS_STORAGE_POSITION =
        0x3181e78fc1b109bc611fd2406150bf06e33faa75f71cba12c3e1fd670f2def00;

    struct Data {
        /// @dev The set of all admins of the wallet.
        EnumerableSet.AddressSet allAdmins;
        /// @dev The set of all signers with permission to use the account.
        EnumerableSet.AddressSet allSigners;
        /// @dev Map from address => whether the address is an admin.
        mapping(address => bool) isAdmin;
        /// @dev Map from signer address => active restrictions for that signer.
        mapping(address => IAccountPermissions.SignerPermissionsStatic) signerPermissions;
        /// @dev Map from signer address => approved target the signer can call using the account contract.
        mapping(address => EnumerableSet.AddressSet) approvedTargets;
        /// @dev Mapping from a signed request UID => whether the request is processed.
        mapping(bytes32 => bool) executed;
    }

    function data() internal pure returns (Data storage data_) {
        bytes32 position = ACCOUNT_PERMISSIONS_STORAGE_POSITION;
        assembly {
            data_.slot := position
        }
    }
}

abstract contract AccountPermissions is IAccountPermissions, EIP712 {
    using ECDSA for bytes32;
    using EnumerableSet for EnumerableSet.AddressSet;

    bytes32 private constant TYPEHASH =
        keccak256(
            "SignerPermissionRequest(address signer,uint8 isAdmin,address[] approvedTargets,uint256 nativeTokenLimitPerTransaction,uint128 permissionStartTimestamp,uint128 permissionEndTimestamp,uint128 reqValidityStartTimestamp,uint128 reqValidityEndTimestamp,bytes32 uid)"
        );

    function _onlyAdmin() internal virtual {
        require(isAdmin(msg.sender), "!admin");
    }

    /*///////////////////////////////////////////////////////////////
                            External functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Sets the permissions for a given signer.
    function setPermissionsForSigner(SignerPermissionRequest calldata _req, bytes calldata _signature) external {
        address targetSigner = _req.signer;

        require(
            _req.reqValidityStartTimestamp <= block.timestamp && block.timestamp < _req.reqValidityEndTimestamp,
            "!period"
        );

        (bool success, address signer) = verifySignerPermissionRequest(_req, _signature);
        require(success, "!sig");

        _accountPermissionsStorage().executed[_req.uid] = true;

        //isAdmin > 0, set admin or remove admin
        if (_req.isAdmin > 0) {
            //isAdmin = 1, set admin
            //isAdmin > 1, remove admin
            bool _isAdmin = _req.isAdmin == 1;

            _setAdmin(targetSigner, _isAdmin);
            return;
        }

        require(!isAdmin(targetSigner), "admin");

        _accountPermissionsStorage().allSigners.add(targetSigner);

        _accountPermissionsStorage().signerPermissions[targetSigner] = SignerPermissionsStatic(
            _req.nativeTokenLimitPerTransaction,
            _req.permissionStartTimestamp,
            _req.permissionEndTimestamp
        );

        address[] memory currentTargets = _accountPermissionsStorage().approvedTargets[targetSigner].values();
        uint256 len = currentTargets.length;

        for (uint256 i = 0; i < len; i += 1) {
            _accountPermissionsStorage().approvedTargets[targetSigner].remove(currentTargets[i]);
        }

        len = _req.approvedTargets.length;
        for (uint256 i = 0; i < len; i += 1) {
            _accountPermissionsStorage().approvedTargets[targetSigner].add(_req.approvedTargets[i]);
        }

        _afterSignerPermissionsUpdate(_req);

        emit SignerPermissionsUpdated(signer, targetSigner, _req);
    }

    /*///////////////////////////////////////////////////////////////
                            View functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns whether the given account is an admin.
    function isAdmin(address _account) public view virtual returns (bool) {
        return _accountPermissionsStorage().isAdmin[_account];
    }

    /// @notice Returns whether the given account is an active signer on the account.
    function isActiveSigner(address signer) public view returns (bool) {
        SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];

        return
            permissions.startTimestamp <= block.timestamp &&
            block.timestamp < permissions.endTimestamp &&
            _accountPermissionsStorage().approvedTargets[signer].length() > 0;
    }

    /// @notice Returns the restrictions under which a signer can use the smart wallet.
    function getPermissionsForSigner(address signer) external view returns (SignerPermissions memory) {
        SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];

        return
            SignerPermissions(
                signer,
                _accountPermissionsStorage().approvedTargets[signer].values(),
                permissions.nativeTokenLimitPerTransaction,
                permissions.startTimestamp,
                permissions.endTimestamp
            );
    }

    /// @dev Verifies that a request is signed by an authorized account.
    function verifySignerPermissionRequest(
        SignerPermissionRequest calldata req,
        bytes calldata signature
    ) public view virtual returns (bool success, address signer) {
        signer = _recoverAddress(_encodeRequest(req), signature);
        success = !_accountPermissionsStorage().executed[req.uid] && isAdmin(signer);
    }

    /// @notice Returns all active and inactive signers of the account.
    function getAllSigners() external view returns (SignerPermissions[] memory signers) {
        address[] memory allSigners = _accountPermissionsStorage().allSigners.values();

        uint256 len = allSigners.length;
        signers = new SignerPermissions[](len);
        for (uint256 i = 0; i < len; i += 1) {
            address signer = allSigners[i];
            SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];

            signers[i] = SignerPermissions(
                signer,
                _accountPermissionsStorage().approvedTargets[signer].values(),
                permissions.nativeTokenLimitPerTransaction,
                permissions.startTimestamp,
                permissions.endTimestamp
            );
        }
    }

    /// @notice Returns all signers with active permissions to use the account.
    function getAllActiveSigners() external view returns (SignerPermissions[] memory signers) {
        address[] memory allSigners = _accountPermissionsStorage().allSigners.values();

        uint256 len = allSigners.length;
        uint256 numOfActiveSigners = 0;

        for (uint256 i = 0; i < len; i += 1) {
            if (isActiveSigner(allSigners[i])) {
                numOfActiveSigners++;
            } else {
                allSigners[i] = address(0);
            }
        }

        signers = new SignerPermissions[](numOfActiveSigners);
        uint256 index = 0;
        for (uint256 i = 0; i < len; i += 1) {
            if (allSigners[i] != address(0)) {
                address signer = allSigners[i];
                SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];

                signers[index++] = SignerPermissions(
                    signer,
                    _accountPermissionsStorage().approvedTargets[signer].values(),
                    permissions.nativeTokenLimitPerTransaction,
                    permissions.startTimestamp,
                    permissions.endTimestamp
                );
            }
        }
    }

    /// @notice Returns all admins of the account.
    function getAllAdmins() external view returns (address[] memory) {
        return _accountPermissionsStorage().allAdmins.values();
    }

    /*///////////////////////////////////////////////////////////////
                        Internal functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Runs after every `changeRole` run.
    function _afterSignerPermissionsUpdate(SignerPermissionRequest calldata _req) internal virtual;

    /// @notice Makes the given account an admin.
    function _setAdmin(address _account, bool _isAdmin) internal virtual {
        _accountPermissionsStorage().isAdmin[_account] = _isAdmin;

        if (_isAdmin) {
            _accountPermissionsStorage().allAdmins.add(_account);
        } else {
            _accountPermissionsStorage().allAdmins.remove(_account);
        }

        emit AdminUpdated(_account, _isAdmin);
    }

    /// @dev Returns the address of the signer of the request.
    function _recoverAddress(bytes memory _encoded, bytes calldata _signature) internal view virtual returns (address) {
        return _hashTypedDataV4(keccak256(_encoded)).recover(_signature);
    }

    /// @dev Encodes a request for recovery of the signer in `recoverAddress`.
    function _encodeRequest(SignerPermissionRequest calldata _req) internal pure virtual returns (bytes memory) {
        return
            abi.encode(
                TYPEHASH,
                _req.signer,
                _req.isAdmin,
                keccak256(abi.encodePacked(_req.approvedTargets)),
                _req.nativeTokenLimitPerTransaction,
                _req.permissionStartTimestamp,
                _req.permissionEndTimestamp,
                _req.reqValidityStartTimestamp,
                _req.reqValidityEndTimestamp,
                _req.uid
            );
    }

    /// @dev Returns the AccountPermissions storage.
    function _accountPermissionsStorage() internal pure returns (AccountPermissionsStorage.Data storage data) {
        data = AccountPermissionsStorage.data();
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @author thirdweb

import "../interface/IContractMetadata.sol";

/**
 *  @author  thirdweb.com
 *
 *  @title   Contract Metadata
 *  @notice  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
 *           for you contract.
 *           Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
 */

library ContractMetadataStorage {
    /// @custom:storage-location erc7201:contract.metadata.storage
    /// @dev keccak256(abi.encode(uint256(keccak256("contract.metadata.storage")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 public constant CONTRACT_METADATA_STORAGE_POSITION =
        0x4bc804ba64359c0e35e5ed5d90ee596ecaa49a3a930ddcb1470ea0dd625da900;

    struct Data {
        /// @notice Returns the contract metadata URI.
        string contractURI;
    }

    function data() internal pure returns (Data storage data_) {
        bytes32 position = CONTRACT_METADATA_STORAGE_POSITION;
        assembly {
            data_.slot := position
        }
    }
}

abstract contract ContractMetadata is IContractMetadata {
    /**
     *  @notice         Lets a contract admin set the URI for contract-level metadata.
     *  @dev            Caller should be authorized to setup contractURI, e.g. contract admin.
     *                  See {_canSetContractURI}.
     *                  Emits {ContractURIUpdated Event}.
     *
     *  @param _uri     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
     */
    function setContractURI(string memory _uri) external override {
        if (!_canSetContractURI()) {
            revert("Not authorized");
        }

        _setupContractURI(_uri);
    }

    /// @dev Lets a contract admin set the URI for contract-level metadata.
    function _setupContractURI(string memory _uri) internal {
        string memory prevURI = _contractMetadataStorage().contractURI;
        _contractMetadataStorage().contractURI = _uri;

        emit ContractURIUpdated(prevURI, _uri);
    }

    /// @notice Returns the contract metadata URI.
    function contractURI() public view virtual override returns (string memory) {
        return _contractMetadataStorage().contractURI;
    }

    /// @dev Returns the AccountPermissions storage.
    function _contractMetadataStorage() internal pure returns (ContractMetadataStorage.Data storage data) {
        data = ContractMetadataStorage.data();
    }

    /// @dev Returns whether contract metadata can be set in the given execution context.
    function _canSetContractURI() internal view virtual returns (bool);
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.0;

import "../../lib/Address.sol";

library InitStorage {
    /// @custom:storage-location erc7201:init.storage
    /// @dev keccak256(abi.encode(uint256(keccak256("init.storage")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 constant INIT_STORAGE_POSITION = 0x322cf19c484104d3b1a9c2982ebae869ede3fa5f6c4703ca41b9a48c76ee0300;

    /// @dev Layout of the entrypoint contract's storage.
    struct Data {
        uint8 initialized;
        bool initializing;
    }

    /// @dev Returns the entrypoint contract's data at the relevant storage location.
    function data() internal pure returns (Data storage data_) {
        bytes32 position = INIT_STORAGE_POSITION;
        assembly {
            data_.slot := position
        }
    }
}

abstract contract Initializable {
    /**
     * @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. Equivalent to `reinitializer(1)`.
     */
    modifier initializer() {
        uint8 _initialized = _initStorage().initialized;
        bool _initializing = _initStorage().initializing;

        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initStorage().initialized = 1;
        if (isTopLevelCall) {
            _initStorage().initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initStorage().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.
     *
     * `initializer` is equivalent to `reinitializer(1)`, so 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.
     *
     * 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.
     */
    modifier reinitializer(uint8 version) {
        uint8 _initialized = _initStorage().initialized;
        bool _initializing = _initStorage().initializing;

        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initStorage().initialized = version;
        _initStorage().initializing = true;
        _;
        _initStorage().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(_initStorage().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.
     */
    function _disableInitializers() internal virtual {
        uint8 _initialized = _initStorage().initialized;
        bool _initializing = _initStorage().initializing;

        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized < type(uint8).max) {
            _initStorage().initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /// @dev Returns the InitStorage storage.
    function _initStorage() internal pure returns (InitStorage.Data storage data) {
        data = InitStorage.data();
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(0, 0x09, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(0, 0x09, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := keccak256(add(ptr, 0x43), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../../../eip/interface/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

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

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../../../eip/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

pragma solidity ^0.8.0;

import "../IERC721Receiver.sol";

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

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

pragma solidity ^0.8.0;

import "../../../../lib/Strings.sol";

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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
 *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 *  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;

/// @author thirdweb, OpenZeppelin Contracts (v4.9.0)

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @author thirdweb
/// Credits: https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol

library BytesLib {
    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @author thirdweb

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte,
    /// and the alphabets are capitalized conditionally according to
    /// https://eips.ethereum.org/EIPS/eip-55
    function toHexStringChecksummed(address value) internal pure returns (string memory str) {
        str = toHexString(value);
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
            let o := add(str, 0x22)
            let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `
            let t := shl(240, 136) // `0b10001000 << 240`
            for {
                let i := 0
            } 1 {

            } {
                mstore(add(i, i), mul(t, byte(i, hashed)))
                i := add(i, 1)
                if eq(i, 20) {
                    break
                }
            }
            mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
            o := add(o, 0x20)
            mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    function toHexString(address value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(address value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            str := mload(0x40)

            // Allocate the memory.
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x28 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.
            mstore(0x40, add(str, 0x80))

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            str := add(str, 2)
            mstore(str, 40)

            let o := add(str, 0x20)
            mstore(add(o, 40), 0)

            value := shl(96, value)

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for {
                let i := 0
            } 1 {

            } {
                let p := add(o, add(i, i))
                let temp := byte(i, value)
                mstore8(add(p, 1), mload(and(temp, 15)))
                mstore8(p, mload(shr(4, temp)))
                i := add(i, 1)
                if eq(i, 20) {
                    break
                }
            }
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexString(bytes memory raw) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(raw);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(raw)
            str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
            mstore(str, add(length, length)) // Store the length of the output.

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let o := add(str, 0x20)
            let end := add(raw, length)

            for {

            } iszero(eq(raw, end)) {

            } {
                raw := add(raw, 1)
                mstore8(add(o, 1), mload(and(mload(raw), 15)))
                mstore8(o, mload(and(shr(4, mload(raw)), 15)))
                o := add(o, 2)
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate the memory.
        }
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import "../utils/UserOperation.sol";

interface IAccount {
    /**
     * Validate user's signature and nonce
     * the entryPoint will make the call to the recipient only if this validation call returns successfully.
     * signature failure should be reported by returning SIG_VALIDATION_FAILED (1).
     * This allows making a "simulation call" without a valid signature
     * Other failures (e.g. nonce mismatch, or invalid signature format) should still revert to signal failure.
     *
     * @dev Must validate caller is the entryPoint.
     *      Must validate the signature and nonce
     * @param userOp the operation that is about to be executed.
     * @param userOpHash hash of the user's request data. can be used as the basis for signature.
     * @param missingAccountFunds missing funds on the account's deposit in the entrypoint.
     *      This is the minimum amount to transfer to the sender(entryPoint) to be able to make the call.
     *      The excess is left as a deposit in the entrypoint, for future calls.
     *      can be withdrawn anytime using "entryPoint.withdrawTo()"
     *      In case there is a paymaster in the request (or the current deposit is high enough), this value will be zero.
     * @return validationData packaged ValidationData structure. use `_packValidationData` and `_unpackValidationData` to encode and decode
     *      <20-byte> sigAuthorizer - 0 for valid signature, 1 to mark signature failure,
     *         otherwise, an address of an "authorizer" contract.
     *      <6-byte> validUntil - last timestamp this operation is valid. 0 for "indefinite"
     *      <6-byte> validAfter - first timestamp this operation is valid
     *      If an account doesn't use time-range, it is enough to return SIG_VALIDATION_FAILED value (1) for signature failure.
     *      Note that the validation code cannot use block.timestamp (or block.number) directly.
     */
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external returns (uint256 validationData);
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;

import "./IAccount.sol";
import "../../../extension/interface/IAccountPermissions.sol";
import "../../../extension/interface/IMulticall.sol";

interface IAccountCore is IAccount, IAccountPermissions, IMulticall {
    /// @dev Returns the address of the factory from which the account was created.
    function factory() external view returns (address);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import "./IAccountFactoryCore.sol";

interface IAccountFactory is IAccountFactoryCore {
    /*///////////////////////////////////////////////////////////////
                        Callback Functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Callback function for an Account to register its signers.
    function onSignerAdded(address signer, bytes32 salt) external;

    /// @notice Callback function for an Account to un-register its signers.
    function onSignerRemoved(address signer, bytes32 salt) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

interface IAccountFactoryCore {
    /*///////////////////////////////////////////////////////////////
                                Events
    //////////////////////////////////////////////////////////////*/

    /// @notice Emitted when a new Account is created.
    event AccountCreated(address indexed account, address indexed accountAdmin);

    /// @notice Emitted when a new signer is added to an Account.
    event SignerAdded(address indexed account, address indexed signer);

    /// @notice Emitted when a new signer is added to an Account.
    event SignerRemoved(address indexed account, address indexed signer);

    /*///////////////////////////////////////////////////////////////
                        Extension Functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Deploys a new Account for admin.
    function createAccount(address admin, bytes calldata _data) external returns (address account);

    /*///////////////////////////////////////////////////////////////
                            View Functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns the address of the Account implementation.
    function accountImplementation() external view returns (address);

    /// @notice Returns all accounts created on the factory.
    function getAllAccounts() external view returns (address[] memory);

    /// @notice Returns the address of an Account that would be deployed with the given admin signer.
    function getAddress(address adminSigner, bytes calldata data) external view returns (address);

    /// @notice Returns all accounts on which a signer has (active or inactive) permissions.
    function getAccountsOfSigner(address signer) external view returns (address[] memory accounts);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import "../utils/UserOperation.sol";

/**
 * Aggregated Signatures validator.
 */
interface IAggregator {
    /**
     * validate aggregated signature.
     * revert if the aggregated signature does not match the given list of operations.
     */
    function validateSignatures(UserOperation[] calldata userOps, bytes calldata signature) external view;

    /**
     * validate signature of a single userOp
     * This method is should be called by bundler after EntryPoint.simulateValidation() returns (reverts) with ValidationResultWithAggregation
     * First it validates the signature over the userOp. Then it returns data to be used when creating the handleOps.
     * @param userOp the userOperation received from the user.
     * @return sigForUserOp the value to put into the signature field of the userOp when calling handleOps.
     *    (usually empty, unless account and aggregator support some kind of "multisig"
     */
    function validateUserOpSignature(UserOperation calldata userOp) external view returns (bytes memory sigForUserOp);

    /**
     * aggregate multiple signatures into a single value.
     * This method is called off-chain to calculate the signature to pass with handleOps()
     * bundler MAY use optimized custom code perform this aggregation
     * @param userOps array of UserOperations to collect the signatures from.
     * @return aggregatedSignature the aggregated signature
     */
    function aggregateSignatures(
        UserOperation[] calldata userOps
    ) external view returns (bytes memory aggregatedSignature);
}

/**
 ** Account-Abstraction (EIP-4337) singleton EntryPoint implementation.
 ** Only one instance required on each chain.
 **/
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable reason-string */

import "../utils/UserOperation.sol";
import "./IStakeManager.sol";
import "./IAggregator.sol";
import "./INonceManager.sol";

interface IEntryPoint is IStakeManager, INonceManager {
    /***
     * An event emitted after each successful request
     * @param userOpHash - unique identifier for the request (hash its entire content, except signature).
     * @param sender - the account that generates this request.
     * @param paymaster - if non-null, the paymaster that pays for this request.
     * @param nonce - the nonce value from the request.
     * @param success - true if the sender transaction succeeded, false if reverted.
     * @param actualGasCost - actual amount paid (by account or paymaster) for this UserOperation.
     * @param actualGasUsed - total gas used by this UserOperation (including preVerification, creation, validation and execution).
     */
    event UserOperationEvent(
        bytes32 indexed userOpHash,
        address indexed sender,
        address indexed paymaster,
        uint256 nonce,
        bool success,
        uint256 actualGasCost,
        uint256 actualGasUsed
    );

    /**
     * account "sender" was deployed.
     * @param userOpHash the userOp that deployed this account. UserOperationEvent will follow.
     * @param sender the account that is deployed
     * @param factory the factory used to deploy this account (in the initCode)
     * @param paymaster the paymaster used by this UserOp
     */
    event AccountDeployed(bytes32 indexed userOpHash, address indexed sender, address factory, address paymaster);

    /**
     * An event emitted if the UserOperation "callData" reverted with non-zero length
     * @param userOpHash the request unique identifier.
     * @param sender the sender of this request
     * @param nonce the nonce used in the request
     * @param revertReason - the return bytes from the (reverted) call to "callData".
     */
    event UserOperationRevertReason(
        bytes32 indexed userOpHash,
        address indexed sender,
        uint256 nonce,
        bytes revertReason
    );

    /**
     * an event emitted by handleOps(), before starting the execution loop.
     * any event emitted before this event, is part of the validation.
     */
    event BeforeExecution();

    /**
     * signature aggregator used by the following UserOperationEvents within this bundle.
     */
    event SignatureAggregatorChanged(address indexed aggregator);

    /**
     * a custom revert error of handleOps, to identify the offending op.
     *  NOTE: if simulateValidation passes successfully, there should be no reason for handleOps to fail on it.
     *  @param opIndex - index into the array of ops to the failed one (in simulateValidation, this is always zero)
     *  @param reason - revert reason
     *      The string starts with a unique code "AAmn", where "m" is "1" for factory, "2" for account and "3" for paymaster issues,
     *      so a failure can be attributed to the correct entity.
     *   Should be caught in off-chain handleOps simulation and not happen on-chain.
     *   Useful for mitigating DoS attempts against batchers or for troubleshooting of factory/account/paymaster reverts.
     */
    error FailedOp(uint256 opIndex, string reason);

    /**
     * error case when a signature aggregator fails to verify the aggregated signature it had created.
     */
    error SignatureValidationFailed(address aggregator);

    /**
     * Successful result from simulateValidation.
     * @param returnInfo gas and time-range returned values
     * @param senderInfo stake information about the sender
     * @param factoryInfo stake information about the factory (if any)
     * @param paymasterInfo stake information about the paymaster (if any)
     */
    error ValidationResult(ReturnInfo returnInfo, StakeInfo senderInfo, StakeInfo factoryInfo, StakeInfo paymasterInfo);

    /**
     * Successful result from simulateValidation, if the account returns a signature aggregator
     * @param returnInfo gas and time-range returned values
     * @param senderInfo stake information about the sender
     * @param factoryInfo stake information about the factory (if any)
     * @param paymasterInfo stake information about the paymaster (if any)
     * @param aggregatorInfo signature aggregation info (if the account requires signature aggregator)
     *      bundler MUST use it to verify the signature, or reject the UserOperation
     */
    error ValidationResultWithAggregation(
        ReturnInfo returnInfo,
        StakeInfo senderInfo,
        StakeInfo factoryInfo,
        StakeInfo paymasterInfo,
        AggregatorStakeInfo aggregatorInfo
    );

    /**
     * return value of getSenderAddress
     */
    error SenderAddressResult(address sender);

    /**
     * return value of simulateHandleOp
     */
    error ExecutionResult(
        uint256 preOpGas,
        uint256 paid,
        uint48 validAfter,
        uint48 validUntil,
        bool targetSuccess,
        bytes targetResult
    );

    //UserOps handled, per aggregator
    struct UserOpsPerAggregator {
        UserOperation[] userOps;
        // aggregator address
        IAggregator aggregator;
        // aggregated signature
        bytes signature;
    }

    /**
     * Execute a batch of UserOperation.
     * no signature aggregator is used.
     * if any account requires an aggregator (that is, it returned an aggregator when
     * performing simulateValidation), then handleAggregatedOps() must be used instead.
     * @param ops the operations to execute
     * @param beneficiary the address to receive the fees
     */
    function handleOps(UserOperation[] calldata ops, address payable beneficiary) external;

    /**
     * Execute a batch of UserOperation with Aggregators
     * @param opsPerAggregator the operations to execute, grouped by aggregator (or address(0) for no-aggregator accounts)
     * @param beneficiary the address to receive the fees
     */
    function handleAggregatedOps(
        UserOpsPerAggregator[] calldata opsPerAggregator,
        address payable beneficiary
    ) external;

    /**
     * generate a request Id - unique identifier for this request.
     * the request ID is a hash over the content of the userOp (except the signature), the entrypoint and the chainid.
     */
    function getUserOpHash(UserOperation calldata userOp) external view returns (bytes32);

    /**
     * Simulate a call to account.validateUserOp and paymaster.validatePaymasterUserOp.
     * @dev this method always revert. Successful result is ValidationResult error. other errors are failures.
     * @dev The node must also verify it doesn't use banned opcodes, and that it doesn't reference storage outside the account's data.
     * @param userOp the user operation to validate.
     */
    function simulateValidation(UserOperation calldata userOp) external;

    /**
     * gas and return values during simulation
     * @param preOpGas the gas used for validation (including preValidationGas)
     * @param prefund the required prefund for this operation
     * @param sigFailed validateUserOp's (or paymaster's) signature check failed
     * @param validAfter - first timestamp this UserOp is valid (merging account and paymaster time-range)
     * @param validUntil - last timestamp this UserOp is valid (merging account and paymaster time-range)
     * @param paymasterContext returned by validatePaymasterUserOp (to be passed into postOp)
     */
    struct ReturnInfo {
        uint256 preOpGas;
        uint256 prefund;
        bool sigFailed;
        uint48 validAfter;
        uint48 validUntil;
        bytes paymasterContext;
    }

    /**
     * returned aggregated signature info.
     * the aggregator returned by the account, and its current stake.
     */
    struct AggregatorStakeInfo {
        address aggregator;
        StakeInfo stakeInfo;
    }

    /**
     * Get counterfactual sender address.
     *  Calculate the sender contract address that will be generated by the initCode and salt in the UserOperation.
     * this method always revert, and returns the address in SenderAddressResult error
     * @param initCode the constructor code to be passed into the UserOperation.
     */
    function getSenderAddress(bytes memory initCode) external;

    /**
     * simulate full execution of a UserOperation (including both validation and target execution)
     * this method will always revert with "ExecutionResult".
     * it performs full validation of the UserOperation, but ignores signature error.
     * an optional target address is called after the userop succeeds, and its value is returned
     * (before the entire call is reverted)
     * Note that in order to collect the success/failure of the target call, it must be executed
     * with trace enabled to track the emitted events.
     * @param op the UserOperation to simulate
     * @param target if nonzero, a target address to call after userop simulation. If called, the targetSuccess and targetResult
     *        are set to the return from that call.
     * @param targetCallData callData to pass to target address
     */
    function simulateHandleOp(UserOperation calldata op, address target, bytes calldata targetCallData) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

interface INonceManager {
    /**
     * Return the next nonce for this sender.
     * Within a given key, the nonce values are sequenced (starting with zero, and incremented by one on each userop)
     * But UserOp with different keys can come with arbitrary order.
     *
     * @param sender the account address
     * @param key the high 192 bit of the nonce
     * @return nonce a full nonce to pass for next UserOp with this sender.
     */
    function getNonce(address sender, uint192 key) external view returns (uint256 nonce);

    /**
     * Manually increment the nonce of the sender.
     * This method is exposed just for completeness..
     * Account does NOT need to call it, neither during validation, nor elsewhere,
     * as the EntryPoint will update the nonce regardless.
     * Possible use-case is call it with various keys to "initialize" their nonces to one, so that future
     * UserOperations will not pay extra for the first transaction with a given key.
     */
    function incrementNonce(uint192 key) external;
}

// SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.12;

/**
 * manage deposits and stakes.
 * deposit is just a balance used to pay for UserOperations (either by a paymaster or an account)
 * stake is value locked for at least "unstakeDelay" by the staked entity.
 */
interface IStakeManager {
    event Deposited(address indexed account, uint256 totalDeposit);

    event Withdrawn(address indexed account, address withdrawAddress, uint256 amount);

    /// Emitted when stake or unstake delay are modified
    event StakeLocked(address indexed account, uint256 totalStaked, uint256 unstakeDelaySec);

    /// Emitted once a stake is scheduled for withdrawal
    event StakeUnlocked(address indexed account, uint256 withdrawTime);

    event StakeWithdrawn(address indexed account, address withdrawAddress, uint256 amount);

    /**
     * @param deposit the entity's deposit
     * @param staked true if this entity is staked.
     * @param stake actual amount of ether staked for this entity.
     * @param unstakeDelaySec minimum delay to withdraw the stake.
     * @param withdrawTime - first block timestamp where 'withdrawStake' will be callable, or zero if already locked
     * @dev sizes were chosen so that (deposit,staked, stake) fit into one cell (used during handleOps)
     *    and the rest fit into a 2nd cell.
     *    112 bit allows for 10^15 eth
     *    48 bit for full timestamp
     *    32 bit allows 150 years for unstake delay
     */
    struct DepositInfo {
        uint112 deposit;
        bool staked;
        uint112 stake;
        uint32 unstakeDelaySec;
        uint48 withdrawTime;
    }

    //API struct used by getStakeInfo and simulateValidation
    struct StakeInfo {
        uint256 stake;
        uint256 unstakeDelaySec;
    }

    /// @return info - full deposit information of given account
    function getDepositInfo(address account) external view returns (DepositInfo memory info);

    /// @return the deposit (for gas payment) of the account
    function balanceOf(address account) external view returns (uint256);

    /**
     * add to the deposit of the given account
     */
    function depositTo(address account) external payable;

    /**
     * add to the account's stake - amount and delay
     * any pending unstake is first cancelled.
     * @param _unstakeDelaySec the new lock duration before the deposit can be withdrawn.
     */
    function addStake(uint32 _unstakeDelaySec) external payable;

    /**
     * attempt to unlock the stake.
     * the value can be withdrawn (using withdrawStake) after the unstake delay.
     */
    function unlockStake() external;

    /**
     * withdraw from the (unlocked) stake.
     * must first call unlockStake and wait for the unstakeDelay to pass
     * @param withdrawAddress the address to send withdrawn value.
     */
    function withdrawStake(address payable withdrawAddress) external;

    /**
     * withdraw from the deposit.
     * @param withdrawAddress the address to send withdrawn value.
     * @param withdrawAmount the amount to withdraw.
     */
    function withdrawTo(address payable withdrawAddress, uint256 withdrawAmount) external;
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.11;

/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable reason-string */

// Base
import "../utils/BaseAccount.sol";

// Extensions
import "../utils/AccountCore.sol";
import "../../../extension/upgradeable/ContractMetadata.sol";
import "../../../external-deps/openzeppelin/token/ERC721/utils/ERC721Holder.sol";
import "../../../external-deps/openzeppelin/token/ERC1155/utils/ERC1155Holder.sol";

// Utils
import "../../../eip/ERC1271.sol";
import "../utils/Helpers.sol";
import "../../../external-deps/openzeppelin/utils/cryptography/ECDSA.sol";
import "../utils/BaseAccountFactory.sol";

//   $$\     $$\       $$\                 $$\                         $$\
//   $$ |    $$ |      \__|                $$ |                        $$ |
// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/

contract Account is AccountCore, ContractMetadata, ERC1271, ERC721Holder, ERC1155Holder {
    using ECDSA for bytes32;
    using EnumerableSet for EnumerableSet.AddressSet;

    bytes32 private constant MSG_TYPEHASH = keccak256("AccountMessage(bytes message)");

    /*///////////////////////////////////////////////////////////////
                    Constructor, Initializer, Modifiers
    //////////////////////////////////////////////////////////////*/

    constructor(IEntryPoint _entrypoint, address _factory) AccountCore(_entrypoint, _factory) {}

    /// @notice Checks whether the caller is the EntryPoint contract or the admin.
    modifier onlyAdminOrEntrypoint() virtual {
        require(msg.sender == address(entryPoint()) || isAdmin(msg.sender), "Account: not admin or EntryPoint.");
        _;
    }

    /// @notice Lets the account receive native tokens.
    receive() external payable {}

    /*///////////////////////////////////////////////////////////////
                            View functions
    //////////////////////////////////////////////////////////////*/

    /// @notice See {IERC165-supportsInterface}.
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155Receiver) returns (bool) {
        return
            interfaceId == type(IERC1155Receiver).interfaceId ||
            interfaceId == type(IERC721Receiver).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     *  @notice See EIP-1271
     *
     *  @param _hash The original message hash of the data to sign (before mixing this contract's domain separator)
     *  @param _signature The signature produced on signing the typed data hash (result of `getMessageHash(abi.encode(rawData))`)
     */
    function isValidSignature(
        bytes32 _hash,
        bytes memory _signature
    ) public view virtual override returns (bytes4 magicValue) {
        bytes32 targetDigest = getMessageHash(_hash);
        address signer = targetDigest.recover(_signature);

        if (isAdmin(signer)) {
            return MAGICVALUE;
        }

        address caller = msg.sender;
        EnumerableSet.AddressSet storage approvedTargets = _accountPermissionsStorage().approvedTargets[signer];

        require(
            approvedTargets.contains(caller) || (approvedTargets.length() == 1 && approvedTargets.at(0) == address(0)),
            "Account: caller not approved target."
        );

        if (isActiveSigner(signer)) {
            magicValue = MAGICVALUE;
        }
    }

    /**
     * @notice Returns the hash of message that should be signed for EIP1271 verification.
     * @param _hash The message hash to sign for the EIP-1271 origin verifying contract.
     * @return messageHash The digest to sign for EIP-1271 verification.
     */
    function getMessageHash(bytes32 _hash) public view returns (bytes32) {
        bytes32 messageHash = keccak256(abi.encode(_hash));
        bytes32 typedDataHash = keccak256(abi.encode(MSG_TYPEHASH, messageHash));
        return keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(), typedDataHash));
    }

    /*///////////////////////////////////////////////////////////////
                            External functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Executes a transaction (called directly from an admin, or by entryPoint)
    function execute(address _target, uint256 _value, bytes calldata _calldata) external virtual onlyAdminOrEntrypoint {
        _registerOnFactory();
        _call(_target, _value, _calldata);
    }

    /// @notice Executes a sequence transaction (called directly from an admin, or by entryPoint)
    function executeBatch(
        address[] calldata _target,
        uint256[] calldata _value,
        bytes[] calldata _calldata
    ) external virtual onlyAdminOrEntrypoint {
        _registerOnFactory();

        require(_target.length == _calldata.length && _target.length == _value.length, "Account: wrong array lengths.");
        for (uint256 i = 0; i < _target.length; i++) {
            _call(_target[i], _value[i], _calldata[i]);
        }
    }

    /// @notice Deposit funds for this account in Entrypoint.
    function addDeposit() public payable {
        entryPoint().depositTo{ value: msg.value }(address(this));
    }

    /// @notice Withdraw funds for this account from Entrypoint.
    function withdrawDepositTo(address payable withdrawAddress, uint256 amount) public {
        _onlyAdmin();
        entryPoint().withdrawTo(withdrawAddress, amount);
    }

    /*///////////////////////////////////////////////////////////////
                        Internal functions
    //////////////////////////////////////////////////////////////*/

    /// @dev Registers the account on the factory if it hasn't been registered yet.
    function _registerOnFactory() internal virtual {
        BaseAccountFactory factoryContract = BaseAccountFactory(factory);
        if (!factoryContract.isRegistered(address(this))) {
            factoryContract.onRegister(AccountCoreStorage.data().creationSalt);
        }
    }

    /// @dev Calls a target contract and reverts if it fails.
    function _call(
        address _target,
        uint256 value,
        bytes memory _calldata
    ) internal virtual returns (bytes memory result) {
        bool success;
        (success, result) = _target.call{ value: value }(_calldata);
        if (!success) {
            assembly {
                revert(add(result, 32), mload(result))
            }
        }
    }

    /// @dev Returns whether contract metadata can be set in the given execution context.
    function _canSetContractURI() internal view virtual override returns (bool) {
        return isAdmin(msg.sender) || msg.sender == address(this);
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.11;

/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable reason-string */

// Base
import "./../utils/BaseAccount.sol";

// Fixed Extensions
import "../../../extension/Multicall.sol";
import "../../../extension/upgradeable/Initializable.sol";
import "../../../extension/upgradeable/AccountPermissions.sol";

// Utils
import "./Helpers.sol";
import "./AccountCoreStorage.sol";
import "./BaseAccountFactory.sol";
import { AccountExtension } from "./AccountExtension.sol";
import "../../../external-deps/openzeppelin/utils/cryptography/ECDSA.sol";

import "../interface/IAccountCore.sol";

//   $$\     $$\       $$\                 $$\                         $$\
//   $$ |    $$ |      \__|                $$ |                        $$ |
// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/

contract AccountCore is IAccountCore, Initializable, Multicall, BaseAccount, AccountPermissions {
    using ECDSA for bytes32;
    using EnumerableSet for EnumerableSet.AddressSet;

    /*///////////////////////////////////////////////////////////////
                                State
    //////////////////////////////////////////////////////////////*/

    /// @notice EIP 4337 factory for this contract.
    address public immutable factory;

    /// @notice EIP 4337 Entrypoint contract.
    IEntryPoint private immutable entrypointContract;

    /*///////////////////////////////////////////////////////////////
                    Constructor, Initializer, Modifiers
    //////////////////////////////////////////////////////////////*/

    constructor(IEntryPoint _entrypoint, address _factory) EIP712("Account", "1") {
        _disableInitializers();
        factory = _factory;
        entrypointContract = _entrypoint;
    }

    /// @notice Initializes the smart contract wallet.
    function initialize(address _defaultAdmin, bytes calldata _data) public virtual initializer {
        // This is passed as data in the `_registerOnFactory()` call in `AccountExtension` / `Account`.
        AccountCoreStorage.data().creationSalt = _generateSalt(_defaultAdmin, _data);
        _setAdmin(_defaultAdmin, true);
    }

    /*///////////////////////////////////////////////////////////////
                            View functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns the EIP 4337 entrypoint contract.
    function entryPoint() public view virtual override returns (IEntryPoint) {
        address entrypointOverride = AccountCoreStorage.data().entrypointOverride;
        if (address(entrypointOverride) != address(0)) {
            return IEntryPoint(entrypointOverride);
        }
        return entrypointContract;
    }

    /** 
    @notice Returns whether a signer is authorized to perform transactions using the account.
            Validity of the signature is based upon signer permission start/end timestamps, txn target, and txn value.
            Account admins will always return true, and signers with address(0) as the only approved target will skip target checks.

    @param _signer The signer to check.
    @param _userOp The user operation to check.

    @return Whether the signer is authorized to perform the transaction.
    */

    /* solhint-disable*/
    function isValidSigner(address _signer, UserOperation calldata _userOp) public view virtual returns (bool) {
        // First, check if the signer is an admin.
        if (_accountPermissionsStorage().isAdmin[_signer]) {
            return true;
        }

        SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[_signer];
        EnumerableSet.AddressSet storage approvedTargets = _accountPermissionsStorage().approvedTargets[_signer];

        // If not an admin, check if the signer is active.
        if (
            permissions.startTimestamp > block.timestamp ||
            block.timestamp >= permissions.endTimestamp ||
            approvedTargets.length() == 0
        ) {
            // Account: no active permissions.
            return false;
        }

        // Extract the function signature from the userOp calldata and check whether the signer is attempting to call `execute` or `executeBatch`.
        bytes4 sig = getFunctionSignature(_userOp.callData);

        // if address(0) is the only approved target, set isWildCard to true (wildcard approved).
        bool isWildCard = approvedTargets.length() == 1 && approvedTargets.at(0) == address(0);

        // checking target and value for `execute`
        if (sig == AccountExtension.execute.selector) {
            // Extract the `target` and `value` arguments from the calldata for `execute`.
            (address target, uint256 value) = decodeExecuteCalldata(_userOp.callData);

            // if wildcard target is not approved, check that the target is in the approvedTargets set.
            if (!isWildCard) {
                // Check if the target is approved.
                if (!approvedTargets.contains(target)) {
                    // Account: target not approved.
                    return false;
                }
            }

            // Check if the value is within the allowed range.
            if (permissions.nativeTokenLimitPerTransaction < value) {
                // Account: value too high OR Account: target not approved.
                return false;
            }
        }
        // checking target and value for `executeBatch`
        else if (sig == AccountExtension.executeBatch.selector) {
            // Extract the `target` and `value` array arguments from the calldata for `executeBatch`.
            (address[] memory targets, uint256[] memory values, ) = decodeExecuteBatchCalldata(_userOp.callData);

            // if wildcard target is not approved, check that the targets are in the approvedTargets set.
            if (!isWildCard) {
                for (uint256 i = 0; i < targets.length; i++) {
                    if (!approvedTargets.contains(targets[i])) {
                        // If any target is not approved, break the loop.
                        return false;
                    }
                }
            }

            // For each target+value pair, check if the value is within the allowed range.
            for (uint256 i = 0; i < targets.length; i++) {
                if (permissions.nativeTokenLimitPerTransaction < values[i]) {
                    // Account: value too high OR Account: target not approved.
                    return false;
                }
            }
        } else {
            // Account: calling invalid fn.
            return false;
        }

        return true;
    }

    /* solhint-enable */

    /*///////////////////////////////////////////////////////////////
                            External functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Overrides the Entrypoint contract being used.
    function setEntrypointOverride(IEntryPoint _entrypointOverride) public virtual {
        _onlyAdmin();
        AccountCoreStorage.data().entrypointOverride = address(_entrypointOverride);
    }

    /*///////////////////////////////////////////////////////////////
                        Internal functions
    //////////////////////////////////////////////////////////////*/

    /// @dev Returns the salt used when deploying an Account.
    function _generateSalt(address _admin, bytes memory _data) internal view virtual returns (bytes32) {
        return keccak256(abi.encode(_admin, _data));
    }

    function getFunctionSignature(bytes calldata data) internal pure returns (bytes4 functionSelector) {
        require(data.length >= 4, "!Data");
        return bytes4(data[:4]);
    }

    function decodeExecuteCalldata(bytes calldata data) internal pure returns (address _target, uint256 _value) {
        require(data.length >= 4 + 32 + 32, "!Data");

        // Decode the address, which is bytes 4 to 35
        _target = abi.decode(data[4:36], (address));

        // Decode the value, which is bytes 36 to 68
        _value = abi.decode(data[36:68], (uint256));
    }

    function decodeExecuteBatchCalldata(
        bytes calldata data
    ) internal pure returns (address[] memory _targets, uint256[] memory _values, bytes[] memory _callData) {
        require(data.length >= 4 + 32 + 32 + 32, "!Data");

        (_targets, _values, _callData) = abi.decode(data[4:], (address[], uint256[], bytes[]));
    }

    /// @notice Validates the signature of a user operation.
    function _validateSignature(
        UserOperation calldata userOp,
        bytes32 userOpHash
    ) internal virtual override returns (uint256 validationData) {
        bytes32 hash = userOpHash.toEthSignedMessageHash();
        address signer = hash.recover(userOp.signature);

        if (!isValidSigner(signer, userOp)) return SIG_VALIDATION_FAILED;

        SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];

        uint48 validAfter = uint48(permissions.startTimestamp);
        uint48 validUntil = uint48(permissions.endTimestamp);

        return _packValidationData(ValidationData(address(0), validAfter, validUntil));
    }

    /// @notice Makes the given account an admin.
    function _setAdmin(address _account, bool _isAdmin) internal virtual override {
        super._setAdmin(_account, _isAdmin);
        if (factory.code.length > 0) {
            if (_isAdmin) {
                BaseAccountFactory(factory).onSignerAdded(_account, AccountCoreStorage.data().creationSalt);
            } else {
                BaseAccountFactory(factory).onSignerRemoved(_account, AccountCoreStorage.data().creationSalt);
            }
        }
    }

    /// @notice Runs after every `changeRole` run.
    function _afterSignerPermissionsUpdate(SignerPermissionRequest calldata _req) internal virtual override {
        if (factory.code.length > 0) {
            BaseAccountFactory(factory).onSignerAdded(_req.signer, AccountCoreStorage.data().creationSalt);
        }
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.11;

library AccountCoreStorage {
    /// @custom:storage-location erc7201:account.core.storage
    /// @dev keccak256(abi.encode(uint256(keccak256("account.core.storage")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 public constant ACCOUNT_CORE_STORAGE_POSITION =
        0x036f52c1827dab135f7fd44ca0bddde297e2f659c710e0ec53e975f22b548300;

    struct Data {
        address entrypointOverride;
        bytes32 creationSalt;
    }

    function data() internal pure returns (Data storage acountCoreData) {
        bytes32 position = ACCOUNT_CORE_STORAGE_POSITION;
        assembly {
            acountCoreData.slot := position
        }
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.11;

/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable reason-string */

// Extensions
import "../../../extension/upgradeable/AccountPermissions.sol";
import "../../../extension/upgradeable/ContractMetadata.sol";
import "../../../external-deps/openzeppelin/token/ERC721/utils/ERC721Holder.sol";
import "../../../external-deps/openzeppelin/token/ERC1155/utils/ERC1155Holder.sol";

// Utils
import "../../../eip/ERC1271.sol";
import "../../../external-deps/openzeppelin/utils/cryptography/ECDSA.sol";
import "../../../external-deps/openzeppelin/utils/structs/EnumerableSet.sol";
import "./BaseAccountFactory.sol";
import "./AccountCore.sol";
import "./AccountCoreStorage.sol";

//   $$\     $$\       $$\                 $$\                         $$\
//   $$ |    $$ |      \__|                $$ |                        $$ |
// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/

contract AccountExtension is ContractMetadata, ERC1271, AccountPermissions, ERC721Holder, ERC1155Holder {
    using ECDSA for bytes32;
    using EnumerableSet for EnumerableSet.AddressSet;

    bytes32 private constant MSG_TYPEHASH = keccak256("AccountMessage(bytes message)");

    /*///////////////////////////////////////////////////////////////
                    Constructor, Initializer, Modifiers
    //////////////////////////////////////////////////////////////*/

    /// @notice Checks whether the caller is the EntryPoint contract or the admin.
    modifier onlyAdminOrEntrypoint() virtual {
        require(
            msg.sender == address(AccountCore(payable(address(this))).entryPoint()) || isAdmin(msg.sender),
            "Account: not admin or EntryPoint."
        );
        _;
    }

    // solhint-disable-next-line no-empty-blocks
    receive() external payable virtual {}

    constructor() EIP712("Account", "1") {}

    /*///////////////////////////////////////////////////////////////
                            View functions
    //////////////////////////////////////////////////////////////*/

    /// @notice See {IERC165-supportsInterface}.
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155Receiver) returns (bool) {
        return
            interfaceId == type(IERC1155Receiver).interfaceId ||
            interfaceId == type(IERC721Receiver).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     *  @notice See EIP-1271
     *
     *  @param _hash The original message hash of the data to sign (before mixing this contract's domain separator)
     *  @param _signature The signature produced on signing the typed data hash (result of `getMessageHash(abi.encode(rawData))`)
     */
    function isValidSignature(
        bytes32 _hash,
        bytes memory _signature
    ) public view virtual override returns (bytes4 magicValue) {
        bytes32 targetDigest = getMessageHash(_hash);
        address signer = targetDigest.recover(_signature);

        if (isAdmin(signer)) {
            return MAGICVALUE;
        }

        address caller = msg.sender;
        EnumerableSet.AddressSet storage approvedTargets = _accountPermissionsStorage().approvedTargets[signer];

        require(
            approvedTargets.contains(caller) || (approvedTargets.length() == 1 && approvedTargets.at(0) == address(0)),
            "Account: caller not approved target."
        );

        if (isActiveSigner(signer)) {
            magicValue = MAGICVALUE;
        }
    }

    /**
     * @notice Returns the hash of message that should be signed for EIP1271 verification.
     * @param _hash The message hash to sign for the EIP-1271 origin verifying contract.
     * @return messageHash The digest to sign for EIP-1271 verification.
     */
    function getMessageHash(bytes32 _hash) public view returns (bytes32) {
        bytes32 messageHash = keccak256(abi.encode(_hash));
        bytes32 typedDataHash = keccak256(abi.encode(MSG_TYPEHASH, messageHash));
        return keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(), typedDataHash));
    }

    /*///////////////////////////////////////////////////////////////
                            External functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Executes a transaction (called directly from an admin, or by entryPoint)
    function execute(address _target, uint256 _value, bytes calldata _calldata) external virtual onlyAdminOrEntrypoint {
        _registerOnFactory();
        _call(_target, _value, _calldata);
    }

    /// @notice Executes a sequence transaction (called directly from an admin, or by entryPoint)
    function executeBatch(
        address[] calldata _target,
        uint256[] calldata _value,
        bytes[] calldata _calldata
    ) external virtual onlyAdminOrEntrypoint {
        _registerOnFactory();
        require(_target.length == _calldata.length && _target.length == _value.length, "Account: wrong array lengths.");
        for (uint256 i = 0; i < _target.length; i++) {
            _call(_target[i], _value[i], _calldata[i]);
        }
    }

    /// @notice Deposit funds for this account in Entrypoint.
    function addDeposit() public payable {
        AccountCore(payable(address(this))).entryPoint().depositTo{ value: msg.value }(address(this));
    }

    /// @notice Withdraw funds for this account from Entrypoint.
    function withdrawDepositTo(address payable withdrawAddress, uint256 amount) public {
        _onlyAdmin();
        AccountCore(payable(address(this))).entryPoint().withdrawTo(withdrawAddress, amount);
    }

    /*///////////////////////////////////////////////////////////////
                        Internal functions
    //////////////////////////////////////////////////////////////*/

    /// @dev Registers the account on the factory if it hasn't been registered yet.
    function _registerOnFactory() internal virtual {
        address factory = AccountCore(payable(address(this))).factory();
        BaseAccountFactory factoryContract = BaseAccountFactory(factory);
        if (!factoryContract.isRegistered(address(this))) {
            factoryContract.onRegister(AccountCoreStorage.data().creationSalt);
        }
    }

    /// @dev Calls a target contract and reverts if it fails.
    function _call(address _target, uint256 value, bytes memory _calldata) internal returns (bytes memory result) {
        bool success;
        (success, result) = _target.call{ value: value }(_calldata);
        if (!success) {
            assembly {
                revert(add(result, 32), mload(result))
            }
        }
    }

    /// @dev Returns whether contract metadata can be set in the given execution context.
    function _canSetContractURI() internal view virtual override returns (bool) {
        return isAdmin(msg.sender) || msg.sender == address(this);
    }

    function _afterSignerPermissionsUpdate(SignerPermissionRequest calldata _req) internal virtual override {}
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-empty-blocks */

import "../interface/IAccount.sol";
import "../interface/IEntrypoint.sol";
import "./Helpers.sol";

/**
 * Basic account implementation.
 * this contract provides the basic logic for implementing the IAccount interface  - validateUserOp
 * specific account implementation should inherit it and provide the account-specific logic
 */
abstract contract BaseAccount is IAccount {
    using UserOperationLib for UserOperation;

    //return value in case of signature failure, with no time-range.
    // equivalent to _packValidationData(true,0,0);
    uint256 internal constant SIG_VALIDATION_FAILED = 1;

    /**
     * Return the account nonce.
     * This method returns the next sequential nonce.
     * For a nonce of a specific key, use `entrypoint.getNonce(account, key)`
     */
    function getNonce() public view virtual returns (uint256) {
        return entryPoint().getNonce(address(this), 0);
    }

    /**
     * return the entryPoint used by this account.
     * subclass should return the current entryPoint used by this account.
     */
    function entryPoint() public view virtual returns (IEntryPoint);

    /**
     * Validate user's signature and nonce.
     * subclass doesn't need to override this method. Instead, it should override the specific internal validation methods.
     */
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external virtual override returns (uint256 validationData) {
        _requireFromEntryPoint();
        validationData = _validateSignature(userOp, userOpHash);
        _validateNonce(userOp.nonce);
        _payPrefund(missingAccountFunds);
    }

    /**
     * ensure the request comes from the known entrypoint.
     */
    function _requireFromEntryPoint() internal view virtual {
        require(msg.sender == address(entryPoint()), "account: not from EntryPoint");
    }

    /**
     * validate the signature is valid for this message.
     * @param userOp validate the userOp.signature field
     * @param userOpHash convenient field: the hash of the request, to check the signature against
     *          (also hashes the entrypoint and chain id)
     * @return validationData signature and time-range of this operation
     *      <20-byte> sigAuthorizer - 0 for valid signature, 1 to mark signature failure,
     *         otherwise, an address of an "authorizer" contract.
     *      <6-byte> validUntil - last timestamp this operation is valid. 0 for "indefinite"
     *      <6-byte> validAfter - first timestamp this operation is valid
     *      If the account doesn't use time-range, it is enough to return SIG_VALIDATION_FAILED value (1) for signature failure.
     *      Note that the validation code cannot use block.timestamp (or block.number) directly.
     */
    function _validateSignature(
        UserOperation calldata userOp,
        bytes32 userOpHash
    ) internal virtual returns (uint256 validationData);

    /**
     * Validate the nonce of the UserOperation.
     * This method may validate the nonce requirement of this account.
     * e.g.
     * To limit the nonce to use sequenced UserOps only (no "out of order" UserOps):
     *      `require(nonce < type(uint64).max)`
     * For a hypothetical account that *requires* the nonce to be out-of-order:
     *      `require(nonce & type(uint64).max == 0)`
     *
     * The actual nonce uniqueness is managed by the EntryPoint, and thus no other
     * action is needed by the account itself.
     *
     * @param nonce to validate
     *
     * solhint-disable-next-line no-empty-blocks
     */
    function _validateNonce(uint256 nonce) internal view virtual {}

    /**
     * sends to the entrypoint (msg.sender) the missing funds for this transaction.
     * subclass MAY override this method for better funds management
     * (e.g. send to the entryPoint more than the minimum required, so that in future transactions
     * it will not be required to send again)
     * @param missingAccountFunds the minimum value this method should send the entrypoint.
     *  this value MAY be zero, in case there is enough deposit, or the userOp has a paymaster.
     */
    function _payPrefund(uint256 missingAccountFunds) internal virtual {
        if (missingAccountFunds != 0) {
            (bool success, ) = payable(msg.sender).call{ value: missingAccountFunds, gas: type(uint256).max }("");
            (success);
            //ignore failure (its EntryPoint's job to verify, not account.)
        }
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

// Utils
import "../../../extension/Multicall.sol";
import "../../../external-deps/openzeppelin/proxy/Clones.sol";
import "../../../external-deps/openzeppelin/utils/structs/EnumerableSet.sol";
import "../utils/BaseAccount.sol";
import "../../../extension/interface/IAccountPermissions.sol";
import "../../../lib/BytesLib.sol";

// Interface
import "../interface/IEntrypoint.sol";
import "../interface/IAccountFactory.sol";

//   $$\     $$\       $$\                 $$\                         $$\
//   $$ |    $$ |      \__|                $$ |                        $$ |
// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/

abstract contract BaseAccountFactory is IAccountFactory, Multicall {
    using EnumerableSet for EnumerableSet.AddressSet;

    /*///////////////////////////////////////////////////////////////
                                State
    //////////////////////////////////////////////////////////////*/

    address public immutable accountImplementation;
    address public immutable entrypoint;

    EnumerableSet.AddressSet private allAccounts;
    mapping(address => EnumerableSet.AddressSet) internal accountsOfSigner;

    /*///////////////////////////////////////////////////////////////
                            Constructor
    //////////////////////////////////////////////////////////////*/

    constructor(address _accountImpl, address _entrypoint) {
        accountImplementation = _accountImpl;
        entrypoint = _entrypoint;
    }

    /*///////////////////////////////////////////////////////////////
                        External functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Deploys a new Account for admin.
    function createAccount(address _admin, bytes calldata _data) external virtual override returns (address) {
        address impl = accountImplementation;
        bytes32 salt = _generateSalt(_admin, _data);
        address account = Clones.predictDeterministicAddress(impl, salt);

        if (account.code.length > 0) {
            return account;
        }

        account = Clones.cloneDeterministic(impl, salt);

        if (msg.sender != entrypoint) {
            require(allAccounts.add(account), "AccountFactory: account already registered");
        }

        _initializeAccount(account, _admin, _data);

        emit AccountCreated(account, _admin);

        return account;
    }

    /// @notice Callback function for an Account to register itself on the factory.
    function onRegister(bytes32 _salt) external {
        address account = msg.sender;
        require(_isAccountOfFactory(account, _salt), "AccountFactory: not an account.");

        require(allAccounts.add(account), "AccountFactory: account already registered");
    }

    function onSignerAdded(address _signer, bytes32 _salt) external {
        address account = msg.sender;
        require(_isAccountOfFactory(account, _salt), "AccountFactory: not an account.");

        bool isNewSigner = accountsOfSigner[_signer].add(account);

        if (isNewSigner) {
            emit SignerAdded(account, _signer);
        }
    }

    /// @notice Callback function for an Account to un-register its signers.
    function onSignerRemoved(address _signer, bytes32 _salt) external {
        address account = msg.sender;
        require(_isAccountOfFactory(account, _salt), "AccountFactory: not an account.");

        bool isAccount = accountsOfSigner[_signer].remove(account);

        if (isAccount) {
            emit SignerRemoved(account, _signer);
        }
    }

    /*///////////////////////////////////////////////////////////////
                            View functions
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns whether an account is registered on this factory.
    function isRegistered(address _account) external view returns (bool) {
        return allAccounts.contains(_account);
    }

    /// @notice Returns the total number of accounts.
    function totalAccounts() external view returns (uint256) {
        return allAccounts.length();
    }

    /// @notice Returns all accounts between the given indices.
    function getAccounts(uint256 _start, uint256 _end) external view returns (address[] memory accounts) {
        require(_start < _end && _end <= allAccounts.length(), "BaseAccountFactory: invalid indices");

        uint256 len = _end - _start;
        accounts = new address[](_end - _start);

        for (uint256 i = 0; i < len; i += 1) {
            accounts[i] = allAccounts.at(i + _start);
        }
    }

    /// @notice Returns all accounts created on the factory.
    function getAllAccounts() external view returns (address[] memory) {
        return allAccounts.values();
    }

    /// @notice Returns the address of an Account that would be deployed with the given admin signer.
    function getAddress(address _adminSigner, bytes calldata _data) public view returns (address) {
        bytes32 salt = _generateSalt(_adminSigner, _data);
        return Clones.predictDeterministicAddress(accountImplementation, salt);
    }

    /// @notice Returns all accounts that the given address is a signer of.
    function getAccountsOfSigner(address signer) external view returns (address[] memory accounts) {
        return accountsOfSigner[signer].values();
    }

    /*///////////////////////////////////////////////////////////////
                            Internal functions
    //////////////////////////////////////////////////////////////*/

    /// @dev Returns whether the caller is an account deployed by this factory.
    function _isAccountOfFactory(address _account, bytes32 _salt) internal view virtual returns (bool) {
        address predicted = Clones.predictDeterministicAddress(accountImplementation, _salt);
        return _account == predicted;
    }

    function _getImplementation(address cloneAddress) internal view returns (address) {
        bytes memory code = cloneAddress.code;
        return BytesLib.toAddress(code, 10);
    }

    /// @dev Returns the salt used when deploying an Account.
    function _generateSalt(address _admin, bytes memory _data) internal view virtual returns (bytes32) {
        return keccak256(abi.encode(_admin, _data));
    }

    /// @dev Called in `createAccount`. Initializes the account contract created in `createAccount`.
    function _initializeAccount(address _account, address _admin, bytes calldata _data) internal virtual;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

/* solhint-disable no-inline-assembly */
/* solhint-disable func-visibility */

/**
 * returned data from validateUserOp.
 * validateUserOp returns a uint256, with is created by `_packedValidationData` and parsed by `_parseValidationData`
 * @param aggregator - address(0) - the account validated the signature by itself.
 *              address(1) - the account failed to validate the signature.
 *              otherwise - this is an address of a signature aggregator that must be used to validate the signature.
 * @param validAfter - this UserOp is valid only after this timestamp.
 * @param validaUntil - this UserOp is valid only up to this timestamp.
 */
struct ValidationData {
    address aggregator;
    uint48 validAfter;
    uint48 validUntil;
}

//extract sigFailed, validAfter, validUntil.
// also convert zero validUntil to type(uint48).max
function _parseValidationData(uint256 validationData) pure returns (ValidationData memory data) {
    address aggregator = address(uint160(validationData));
    uint48 validUntil = uint48(validationData >> 160);
    if (validUntil == 0) {
        validUntil = type(uint48).max;
    }
    uint48 validAfter = uint48(validationData >> (48 + 160));
    return ValidationData(aggregator, validAfter, validUntil);
}

// intersect account and paymaster ranges.
function _intersectTimeRange(
    uint256 validationData,
    uint256 paymasterValidationData
) pure returns (ValidationData memory) {
    ValidationData memory accountValidationData = _parseValidationData(validationData);
    ValidationData memory pmValidationData = _parseValidationData(paymasterValidationData);
    address aggregator = accountValidationData.aggregator;
    if (aggregator == address(0)) {
        aggregator = pmValidationData.aggregator;
    }
    uint48 validAfter = accountValidationData.validAfter;
    uint48 validUntil = accountValidationData.validUntil;
    uint48 pmValidAfter = pmValidationData.validAfter;
    uint48 pmValidUntil = pmValidationData.validUntil;

    if (validAfter < pmValidAfter) validAfter = pmValidAfter;
    if (validUntil > pmValidUntil) validUntil = pmValidUntil;
    return ValidationData(aggregator, validAfter, validUntil);
}

/**
 * helper to pack the return value for validateUserOp
 * @param data - the ValidationData to pack
 */
function _packValidationData(ValidationData memory data) pure returns (uint256) {
    return uint160(data.aggregator) | (uint256(data.validUntil) << 160) | (uint256(data.validAfter) << (160 + 48));
}

/**
 * helper to pack the return value for validateUserOp, when not using an aggregator
 * @param sigFailed - true for signature failure, false for success
 * @param validUntil last timestamp this UserOperation is valid (or zero for infinite)
 * @param validAfter first timestamp this UserOperation is valid
 */
function _packValidationData(bool sigFailed, uint48 validUntil, uint48 validAfter) pure returns (uint256) {
    return (sigFailed ? 1 : 0) | (uint256(validUntil) << 160) | (uint256(validAfter) << (160 + 48));
}

/**
 * keccak function over calldata.
 * @dev copy calldata into memory, do keccak and drop allocated memory. Strangely, this is more efficient than letting solidity do it.
 */
function calldataKeccak(bytes calldata data) pure returns (bytes32 ret) {
    assembly {
        let mem := mload(0x40)
        let len := data.length
        calldatacopy(mem, data.offset, len)
        ret := keccak256(mem, len)
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

/* solhint-disable no-inline-assembly */

import { calldataKeccak } from "./Helpers.sol";

/**
 * User Operation struct
 * @param sender the sender account of this request.
 * @param nonce unique value the sender uses to verify it is not a replay.
 * @param initCode if set, the account contract will be created by this constructor/
 * @param callData the method call to execute on this account.
 * @param callGasLimit the gas limit passed to the callData method call.
 * @param verificationGasLimit gas used for validateUserOp and validatePaymasterUserOp.
 * @param preVerificationGas gas not calculated by the handleOps method, but added to the gas paid. Covers batch overhead.
 * @param maxFeePerGas same as EIP-1559 gas parameter.
 * @param maxPriorityFeePerGas same as EIP-1559 gas parameter.
 * @param paymasterAndData if set, this field holds the paymaster address and paymaster-specific data. the paymaster will pay for the transaction instead of the sender.
 * @param signature sender-verified signature over the entire request, the EntryPoint address and the chain ID.
 */
struct UserOperation {
    address sender;
    uint256 nonce;
    bytes initCode;
    bytes callData;
    uint256 callGasLimit;
    uint256 verificationGasLimit;
    uint256 preVerificationGas;
    uint256 maxFeePerGas;
    uint256 maxPriorityFeePerGas;
    bytes paymasterAndData;
    bytes signature;
}

/**
 * Utility functions helpful when working with UserOperation structs.
 */
library UserOperationLib {
    function getSender(UserOperation calldata userOp) internal pure returns (address) {
        address data;
        //read sender from userOp, which is first userOp member (saves 800 gas...)
        assembly {
            data := calldataload(userOp)
        }
        return address(uint160(data));
    }

    //relayer/block builder might submit the TX with higher priorityFee, but the user should not
    // pay above what he signed for.
    function gasPrice(UserOperation calldata userOp) internal view returns (uint256) {
        unchecked {
            uint256 maxFeePerGas = userOp.maxFeePerGas;
            uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
            if (maxFeePerGas == maxPriorityFeePerGas) {
                //legacy mode (for networks that don't support basefee opcode)
                return maxFeePerGas;
            }
            return min(maxFeePerGas, maxPriorityFeePerGas + block.basefee);
        }
    }

    function pack(UserOperation calldata userOp) internal pure returns (bytes memory ret) {
        address sender = getSender(userOp);
        uint256 nonce = userOp.nonce;
        bytes32 hashInitCode = calldataKeccak(userOp.initCode);
        bytes32 hashCallData = calldataKeccak(userOp.callData);
        uint256 callGasLimit = userOp.callGasLimit;
        uint256 verificationGasLimit = userOp.verificationGasLimit;
        uint256 preVerificationGas = userOp.preVerificationGas;
        uint256 maxFeePerGas = userOp.maxFeePerGas;
        uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
        bytes32 hashPaymasterAndData = calldataKeccak(userOp.paymasterAndData);

        return
            abi.encode(
                sender,
                nonce,
                hashInitCode,
                hashCallData,
                callGasLimit,
                verificationGasLimit,
                preVerificationGas,
                maxFeePerGas,
                maxPriorityFeePerGas,
                hashPaymasterAndData
            );
    }

    function hash(UserOperation calldata userOp) internal pure returns (bytes32) {
        return keccak256(pack(userOp));
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "./YeetAccountFactory.sol";
import "@thirdweb-dev/contracts/prebuilts/account/non-upgradeable/Account.sol";

contract YeetAccount is Account {

  constructor(
    IEntryPoint _entrypoint,
    address _factory
  ) Account(_entrypoint, _factory) {
    _disableInitializers();
  }

  function register(
    string calldata email,
    string calldata metadataURI
  ) external {
    require(msg.sender == address(this), "YeetAccount: only account itself can register");
    YeetAccountFactory(factory).onRegistered(email);
    _setupContractURI(metadataURI);
  }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IEntryPoint","name":"_entrypoint","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"accountAdmin","type":"address"}],"name":"AccountCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"email","type":"string"},{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Registered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"signer","type":"address"}],"name":"SignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"signer","type":"address"}],"name":"SignerRemoved","type":"event"},{"inputs":[],"name":"accountImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"accountOfEmail","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"createAccount","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"entrypoint","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_start","type":"uint256"},{"internalType":"uint256","name":"_end","type":"uint256"}],"name":"getAccounts","outputs":[{"internalType":"address[]","name":"accounts","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"getAccountsOfSigner","outputs":[{"internalType":"address[]","name":"accounts","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_adminSigner","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"getAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllAccounts","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isRegistered","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_salt","type":"bytes32"}],"name":"onRegister","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"email","type":"string"}],"name":"onRegistered","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"}],"name":"onSignerAdded","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"}],"name":"onSignerRemoved","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAccounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000bc4f1464710480799e482f63e7fd1ddc1aa2d338

-----Decoded View---------------
Arg [0] : _entrypoint (address): 0xbc4f1464710480799e482f63E7fD1ddC1Aa2D338

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000bc4f1464710480799e482f63e7fd1ddc1aa2d338