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

import {MintContext, MINT_CONTEXT} from "./Types.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import {Controllable} from "../controllers/Controllable.sol";
import {IMulticallable} from "@ensdomains/ens-contracts/contracts/resolvers/Multicallable.sol";
import {INameWrapper, CANNOT_UNWRAP} from "../ens/INameWrapper.sol";

contract MintController is Controllable, EIP712, ERC1155Holder {
    mapping(address => bool) private verifiers;
    mapping(bytes32 => bool) private fuseBurned;
    address private treasury;
    address private wrapperProxy;
    address private nameWrapper;
    address private publicResolver;
    uint64 private TTL = 0;

    event SubnameMinted(
        bytes32 parentNode,
        string label,
        uint256 price,
        uint256 fee,
        address paymentReceiver,
        address owner,
        bytes extraData
    );

    constructor(
        address _verifier,
        address _treasury,
        address _wrapperProxy,
        address _nameWrapper,
        address _publicResolver
    ) EIP712("namespace", "1") {
        verifiers[_verifier] = true;
        treasury = _treasury;
        wrapperProxy = _wrapperProxy;
        nameWrapper = _nameWrapper;
        publicResolver = _publicResolver;
    }

    function mint(
        MintContext calldata ctx,
        bytes calldata sig,
        bytes[] calldata resolverData,
        bytes calldata extraData
    ) public payable {
        verifySignature(ctx, sig);
        ensureCannotUnwrapFuseBurned(ctx.parentNode);

        if (resolverData.length > 0) {
            mintWithData(ctx, resolverData);
        } else {
            mintSimple(ctx);
        }

        transferFunds(ctx.paymentReceiver, ctx.price, ctx.fee);

        emit SubnameMinted(
            ctx.parentNode,
            ctx.label,
            ctx.price,
            ctx.fee,
            ctx.paymentReceiver,
            ctx.owner,
            extraData
        );
    }

    function mintWithData(
        MintContext calldata context,
        bytes[] calldata resolverData
    ) internal {
        bytes32 subnameNode = INameWrapper(wrapperProxy).setSubnodeRecord(
            context.parentNode,
            context.label,
            address(this),
            publicResolver,
            TTL,
            context.fuses,
            context.expiry
        );

        _setRecords(publicResolver, subnameNode, resolverData);

        INameWrapper(nameWrapper).safeTransferFrom(
            address(this),
            context.owner,
            uint256(subnameNode),
            1,
            bytes("")
        );
    }

    function mintSimple(MintContext calldata context) internal {
        INameWrapper(wrapperProxy).setSubnodeRecord(
            context.parentNode,
            context.label,
            context.owner,
            publicResolver,
            TTL,
            context.fuses,
            context.expiry
        );
    }

    function verifySignature(
        MintContext calldata context,
        bytes calldata signature
    ) internal view {
        require(context.signatureExpiry > block.timestamp, "Signature expired");

        require(context.verifiedMinter == msg.sender, "Not verified minter");

        bytes32 signatureDigest = _createSignatureDigest(context);
        address extractedSigner = ECDSA.recover(signatureDigest, signature);

        require(verifiers[extractedSigner], "Invalid signature");
    }

    function transferFunds(
        address paymentReceiver,
        uint256 price,
        uint256 fees
    ) internal {
        uint256 totalPrice = price + fees;
        uint256 ethAmmount = msg.value;
        require(ethAmmount >= totalPrice, "Insufficient balance");

        if (price > 0) {
            (bool sentToPaymentReceiver, ) = payable(paymentReceiver).call{
                value: price
            }("");
            require(
                sentToPaymentReceiver,
                "Could not transfer ETH to payment receiver"
            );
        }

        if (fees > 0) {
            (bool sentToTreasury, ) = payable(treasury).call{value: fees}("");
            require(sentToTreasury, "Could not transfer ETH to treasury");
        }

        uint256 remainder = ethAmmount - totalPrice;
        if (remainder > 0) {
            (bool remainderSent, ) = payable(msg.sender).call{value: remainder}(
                ""
            );
            require(remainderSent, "Could not transfer ETH to msg.sender");
        }
    }

    function _createSignatureDigest(
        MintContext calldata context
    ) internal view returns (bytes32) {
        return
            _hashTypedDataV4(
                keccak256(
                    abi.encode(
                        MINT_CONTEXT,
                        keccak256(abi.encodePacked(context.label)),
                        context.parentNode,
                        context.owner,
                        context.price,
                        context.fee,
                        context.paymentReceiver,
                        context.expiry,
                        context.signatureExpiry,
                        context.verifiedMinter,
                        context.fuses
                    )
                )
            );
    }

    function ensureCannotUnwrapFuseBurned(bytes32 name) internal {
        if (fuseBurned[name]) {
            return;
        }

        if (!INameWrapper(nameWrapper).allFusesBurned(name, CANNOT_UNWRAP)) {
            INameWrapper(wrapperProxy).setFuses(name, uint16(CANNOT_UNWRAP));
        }

        fuseBurned[name] = true;
    }

    function _setRecords(
        address resolverAddress,
        bytes32 subnameNode,
        bytes[] calldata data
    ) internal {
        IMulticallable(resolverAddress).multicallWithNodeCheck(
            subnameNode,
            data
        );
    }

    function setVerifier(address verifier) external onlyOwner {
        verifiers[verifier] = true;
    }

    function removeVerifier(address verifier) external onlyOwner {
        verifiers[verifier] = false;
    }

    function setDefaultResolver(address resolver) external onlyOwner {
        publicResolver = resolver;
    }

    function setTreasury(address _treasury) external onlyOwner {
        treasury = _treasury;
    }
}

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

interface IMulticallable {
    function multicall(
        bytes[] calldata data
    ) external returns (bytes[] memory results);

    function multicallWithNodeCheck(
        bytes32,
        bytes[] calldata data
    ) external returns (bytes[] memory results);
}

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

import "./IMulticallable.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";

abstract contract Multicallable is IMulticallable, ERC165 {
    function _multicall(
        bytes32 nodehash,
        bytes[] calldata data
    ) internal returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i = 0; i < data.length; i++) {
            if (nodehash != bytes32(0)) {
                bytes32 txNamehash = bytes32(data[i][4:36]);
                require(
                    txNamehash == nodehash,
                    "multicall: All records must have a matching namehash"
                );
            }
            (bool success, bytes memory result) = address(this).delegatecall(
                data[i]
            );
            require(success);
            results[i] = result;
        }
        return results;
    }

    // This function provides an extra security check when called
    // from priviledged contracts (such as EthRegistrarController)
    // that can set records on behalf of the node owners
    function multicallWithNodeCheck(
        bytes32 nodehash,
        bytes[] calldata data
    ) external returns (bytes[] memory results) {
        return _multicall(nodehash, data);
    }

    function multicall(
        bytes[] calldata data
    ) public override returns (bytes[] memory results) {
        return _multicall(bytes32(0), data);
    }

    function supportsInterface(
        bytes4 interfaceID
    ) public view virtual override returns (bool) {
        return
            interfaceID == type(IMulticallable).interfaceId ||
            super.supportsInterface(interfaceID);
    }
}

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

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the value of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

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

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
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 v5.0.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.20;

import {IERC165, ERC165} from "../../../utils/introspection/ERC165.sol";
import {IERC1155Receiver} from "../IERC1155Receiver.sol";

/**
 * @dev Simple implementation of `IERC1155Receiver` 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.
 */
abstract contract ERC1155Holder 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);
    }

    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 (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

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

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

pragma solidity ^0.8.20;

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

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile 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 {MessageHashUtils-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]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        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, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile 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 {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        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]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            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.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // 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, s);
        }

        // 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, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @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, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.20;

import {MessageHashUtils} from "./MessageHashUtils.sol";
import {ShortStrings, ShortString} from "../ShortStrings.sol";
import {IERC5267} from "../../interfaces/IERC5267.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its 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 order to
 * produce the hash of their typed data 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].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // 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 _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @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) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, 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 MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _name which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Name() internal view returns (string memory) {
        return _name.toStringWithFallback(_nameFallback);
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _version which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Version() internal view returns (string memory) {
        return _version.toStringWithFallback(_versionFallback);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;

import {Strings} from "../Strings.sol";

/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

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

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ShortStrings.sol)

pragma solidity ^0.8.20;

import {StorageSlot} from "./StorageSlot.sol";

// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |
// | length  | 0x                                                              BB |
type ShortString is bytes32;

/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 *
 * Strings of arbitrary length can be optimized using this library if
 * they are short enough (up to 31 bytes) by packing them with their
 * length (1 byte) in a single EVM word (32 bytes). Additionally, a
 * fallback mechanism can be used for every other case.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
library ShortStrings {
    // Used as an identifier for strings longer than 31 bytes.
    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;

    error StringTooLong(string str);
    error InvalidShortString();

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = byteLength(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function byteLength(ShortString sstr) internal pure returns (uint256) {
        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
        if (result > 31) {
            revert InvalidShortString();
        }
        return result;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(FALLBACK_SENTINEL);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return toString(value);
        } else {
            return store;
        }
    }

    /**
     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using
     * {setWithFallback}.
     *
     * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
     */
    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return byteLength(value);
        } else {
            return bytes(store).length;
        }
    }
}

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

pragma solidity ^0.8.20;

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

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

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

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

import "@openzeppelin/contracts/access/Ownable.sol";

contract Controllable is Ownable {
    mapping(address => bool) public controllers;

    event ControllerChanged(address indexed controller, bool enabled);

    constructor() Ownable(msg.sender) {}

    modifier onlyController() {
        require(
            controllers[msg.sender],
            "Controllable: Caller is not a controller"
        );
        _;
    }

    function setController(address controller, bool enabled) public onlyOwner {
        controllers[controller] = enabled;
        emit ControllerChanged(controller, enabled);
    }
}

//SPDX-License-Identifier: MIT
pragma solidity ~0.8.20;
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
uint32 constant CANNOT_UNWRAP = 1;

interface INameWrapper is IERC1155 {
    error Unauthorised(bytes32 node, address addr);
    error IncompatibleParent();
    error IncorrectTokenType();
    error LabelMismatch(bytes32 labelHash, bytes32 expectedLabelhash);
    error LabelTooShort();
    error LabelTooLong(string label);
    error IncorrectTargetOwner(address owner);
    error CannotUpgrade();
    error OperationProhibited(bytes32 node);
    error NameIsNotWrapped();
    error NameIsStillExpired();

    function ownerOf(uint256 id) external view returns (address owner);

    function setSubnodeRecord(
        bytes32 node,
        string calldata label,
        address owner,
        address resolver,
        uint64 ttl,
        uint32 fuses,
        uint64 expiry
    ) external returns (bytes32);

    function setFuses(
        bytes32 node,
        uint16 ownerControlledFuses
    ) external returns (uint32 newFuses);

    function allFusesBurned(
        bytes32 node,
        uint32 fuseMask
    ) external view returns (bool);
}

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

bytes32 constant MINT_CONTEXT = keccak256(
    "MintContext(string label,bytes32 parentNode,address owner,uint256 price,uint256 fee,address paymentReceiver,uint256 expiry,uint256 signatureExpiry,address verifiedMinter,uint32 fuses)"
);

struct MintContext {
    address owner;
    string label;
    bytes32 parentNode;
    uint256 price;
    uint256 fee;
    address paymentReceiver;
    uint64 expiry;
    uint256 signatureExpiry;
    address verifiedMinter;
    uint32 fuses;
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_verifier","type":"address"},{"internalType":"address","name":"_treasury","type":"address"},{"internalType":"address","name":"_wrapperProxy","type":"address"},{"internalType":"address","name":"_nameWrapper","type":"address"},{"internalType":"address","name":"_publicResolver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"},{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"ControllerChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"parentNode","type":"bytes32"},{"indexed":false,"internalType":"string","name":"label","type":"string"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"address","name":"paymentReceiver","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bytes","name":"extraData","type":"bytes"}],"name":"SubnameMinted","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"controllers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"string","name":"label","type":"string"},{"internalType":"bytes32","name":"parentNode","type":"bytes32"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"fee","type":"uint256"},{"internalType":"address","name":"paymentReceiver","type":"address"},{"internalType":"uint64","name":"expiry","type":"uint64"},{"internalType":"uint256","name":"signatureExpiry","type":"uint256"},{"internalType":"address","name":"verifiedMinter","type":"address"},{"internalType":"uint32","name":"fuses","type":"uint32"}],"internalType":"struct MintContext","name":"ctx","type":"tuple"},{"internalType":"bytes","name":"sig","type":"bytes"},{"internalType":"bytes[]","name":"resolverData","type":"bytes[]"},{"internalType":"bytes","name":"extraData","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"verifier","type":"address"}],"name":"removeVerifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"},{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"resolver","type":"address"}],"name":"setDefaultResolver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"verifier","type":"address"}],"name":"setVerifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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