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: MIT
pragma solidity ^0.8.0;

import {IERC165} from "openzeppelin-contracts/utils/introspection/IERC165.sol";
import {IERC721} from "openzeppelin-contracts/token/ERC721/IERC721.sol";
import {IERC1271} from "openzeppelin-contracts/interfaces/IERC1271.sol";
import {SignatureChecker} from "openzeppelin-contracts/utils/cryptography/SignatureChecker.sol";
import {ERC1155Holder} from "openzeppelin-contracts/token/ERC1155/utils/ERC1155Holder.sol";

import {IERC6551Account} from "./interfaces/IERC6551Account.sol";
import {IERC6551Executable} from "./interfaces/IERC6551Executable.sol";
import {CallUtils} from "./lib/CallUtils.sol";
import {Errors} from "./lib/Errors.sol";

/**
 * @title NPC Acount
 * @author Mr DeadCe11
 * @notice This is a simple ERC6551 account implementation that can hold ERC1155 tokens
 */
contract CharacterAccount is IERC165, IERC1271, IERC6551Account, IERC6551Executable, ERC1155Holder {
    uint256 public state;

    event Executed();

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

    function execute(address to, uint256 value, bytes calldata data, uint256 operation)
        external
        payable
        returns (bytes memory result)
    {
        if (!_isValidSigner(msg.sender)) {
            revert Errors.InvalidSigner();
        }

        ++state;

        bool success;

        if (operation == 0) {
            // solhint-disable-next-line avoid-low-level-calls
            (success, result) = to.call{value: value}(data);
        } else if (operation == 1) {
            // solhint-disable-next-line avoid-low-level-calls
            (success, result) = to.delegatecall(data);
        } else {
            revert Errors.InvalidOperation();
        }

        if (!success) {
            CallUtils.revertFromReturnedData(result);
        }

        emit Executed();
    }

    function isValidSigner(address signer, bytes calldata) external view returns (bytes4) {
        if (_isValidSigner(signer)) {
            return IERC6551Account.isValidSigner.selector;
        }

        return bytes4(0);
    }

    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue) {
        bool isValid = SignatureChecker.isValidSignatureNow(owner(), hash, signature);

        if (isValid) {
            return IERC1271.isValidSignature.selector;
        }

        return "";
    }

    function token() public view returns (uint256, address, uint256) {
        bytes memory footer = new bytes(0x60);

        // solhint-disable-next-line no-inline-assembly
        assembly {
            extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)
        }

        return abi.decode(footer, (uint256, address, uint256));
    }

    function owner() public view returns (address) {
        (uint256 chainId, address tokenContract, uint256 tokenId) = token();
        if (chainId != block.chainid) return address(0);

        return IERC721(tokenContract).ownerOf(tokenId);
    }

    function supportsInterface(bytes4 interfaceId) public view override(IERC165, ERC1155Holder) returns (bool) {
        return (
            interfaceId == type(IERC165).interfaceId || interfaceId == type(IERC6551Account).interfaceId
                || interfaceId == type(IERC6551Executable).interfaceId || super.supportsInterface(interfaceId)
        );
    }

    function _isValidSigner(address signer) internal view returns (bool) {
        return signer == owner();
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Required interface of an ERC-721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

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

pragma solidity ^0.8.20;

import {ECDSA} from "./ECDSA.sol";
import {IERC1271} from "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like
 * Argent and Safe Wallet (previously Gnosis Safe).
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        if (signer.code.length == 0) {
            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);
            return err == ECDSA.RecoverError.NoError && recovered == signer;
        } else {
            return isValidERC1271SignatureNow(signer, hash, signature);
        }
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC-1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

// 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 ERC-1155 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
pragma solidity ^0.8.0;
//solhint-disable one-contract-per-file

interface IERC6551AccountProxy {
    function implementation() external view returns (address);
}

/// @dev the ERC-165 identifier for this interface is `0x6faff5f1`
interface IERC6551Account {
    /**
     * @dev Allows the account to receive Ether
     *
     * Accounts MUST implement a `receive` function.
     *
     * Accounts MAY perform arbitrary logic to restrict conditions
     * under which Ether can be received.
     */
    receive() external payable;

    /**
     * @dev Returns the identifier of the non-fungible token which owns the account
     *
     * The return value of this function MUST be constant - it MUST NOT change
     * over time
     *
     * @return chainId       The EIP-155 ID of the chain the token exists on
     * @return tokenContract The contract address of the token
     * @return tokenId       The ID of the token
     */
    function token() external view returns (uint256 chainId, address tokenContract, uint256 tokenId);

    /**
     * @dev Returns a value that SHOULD be modified each time the account changes state
     *
     * @return The current account state
     */
    function state() external view returns (uint256);

    /**
     * @dev Returns a magic value indicating whether a given signer is authorized to act on behalf of the account
     *
     * MUST return the bytes4 magic value 0x523e3260 if the given signer is valid
     *
     * By default, the holder of the non-fungible token the account is bound to MUST be considered a valid
     * signer
     *
     * Accounts MAY implement additional authorization logic which invalidates the holder as a
     * signer or grants signing permissions to other non-holder accounts
     *
     * @param  signer     The address to check signing authorization for
     * @param  context    Additional data used to determine whether the signer is valid
     * @return magicValue Magic value indicating whether the signer is valid
     */
    function isValidSigner(address signer, bytes calldata context) external view returns (bytes4 magicValue);
}

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

/// @dev the ERC-165 identifier for this interface is `0x74420f4c`
interface IERC6551Executable {
    /**
     * @dev Executes a low-level operation if the caller is a valid signer on the account
     *
     * Reverts and bubbles up error if operation fails
     *
     * @param to        The target address of the operation
     * @param value     The Ether value to be sent to the target
     * @param data      The encoded operation calldata
     * @param operation A value indicating the type of operation to perform
     *
     * Accounts implementing this interface MUST accept the following operation parameter values:
     * - 0 = CALL
     * - 1 = DELEGATECALL
     * - 2 = CREATE
     * - 3 = CREATE2
     *
     * Accounts implementing this interface MAY support additional operations or restrict a signer's
     * ability to execute certain operations
     *
     * @return The result of the operation
     */
    function execute(address to, uint256 value, bytes calldata data, uint256 operation)
        external
        payable
        returns (bytes memory);
}

/* solhint-disable */

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

/**
 * @title Call utilities library that is absent from the OpenZeppelin
 * @author Superfluid
 * @dev This library is copied from the Superfluid repo
 * @dev at the url: https://github.com/superfluid-finance/protocol-monorepo/blob/dev/packages/ethereum-contracts/contracts/libs/CallUtils.sol
 */
library CallUtils {
    /// @dev Bubble up the revert from the returnedData (supports Panic, Error & Custom Errors)
    /// @notice This is needed in order to provide some human-readable revert message from a call
    /// @param returnedData Response of the call
    function revertFromReturnedData(bytes memory returnedData) internal pure {
        if (returnedData.length < 4) {
            // case 1: catch all
            revert("CallUtils: target revert()");
        } else {
            bytes4 errorSelector;
            assembly {
                errorSelector := mload(add(returnedData, 0x20))
            }
            if (errorSelector == bytes4(0x4e487b71) /* $ seth sig "Panic(uint256)" */ ) {
                // case 2: Panic(uint256) (Defined since 0.8.0)
                // solhint-disable-next-line max-line-length
                // ref: https://docs.soliditylang.org/en/v0.8.0/control-structures.html#panic-via-assert-and-error-via-require)
                string memory reason = "CallUtils: target panicked: 0x__";
                uint256 errorCode;
                assembly {
                    errorCode := mload(add(returnedData, 0x24))
                    let reasonWord := mload(add(reason, 0x20))
                    // [0..9] is converted to ['0'..'9']
                    // [0xa..0xf] is not correctly converted to ['a'..'f']
                    // but since panic code doesn't have those cases, we will ignore them for now!
                    let e1 := add(and(errorCode, 0xf), 0x30)
                    let e2 := shl(8, add(shr(4, and(errorCode, 0xf0)), 0x30))
                    reasonWord :=
                        or(and(reasonWord, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000), or(e2, e1))
                    mstore(add(reason, 0x20), reasonWord)
                }
                revert(reason);
            } else {
                // - case 3: Error(string) (Defined at least since 0.7.0)
                //   - "The require function either creates an error without any data or an error of type Error(string).
                //     It should be used to ensure valid conditions that cannot be detected until execution time."
                //   - $ cast sig 'Error(string)' # 0x08c379a0
                // - case 4: Custom errors (Defined since 0.8.0)
                // - In all these cases, we bubble up the error directly.
                uint256 len = returnedData.length;
                assembly {
                    revert(add(returnedData, 0x20), len)
                }
            }
        }
    }

    /**
     * @dev Helper method to parse data and extract the method signature (selector).
     *
     * Copied from: https://github.com/argentlabs/argent-contracts/
     * blob/master/contracts/modules/common/Utils.sol#L54-L60
     */
    function parseSelector(bytes memory callData) internal pure returns (bytes4 selector) {
        require(callData.length >= 4, "CallUtils: invalid callData");
        // solhint-disable-next-line no-inline-assembly
        assembly {
            selector := mload(add(callData, 0x20))
        }
    }

    /**
     * @dev Pad length to 32 bytes word boundary
     */
    function padLength32(uint256 len) internal pure returns (uint256 paddedLen) {
        return ((len / 32) + (((len & 31) > 0) /* rounding? */ ? 1 : 0)) * 32;
    }

    /**
     * @dev Validate if the data is encoded correctly with abi.encode(bytesData)
     *
     * Expected ABI Encode Layout:
     * | word 1      | word 2           | word 3           | the rest...
     * | data length | bytesData offset | bytesData length | bytesData + padLength32 zeros |
     */
    function isValidAbiEncodedBytes(bytes memory data) internal pure returns (bool) {
        if (data.length < 64) return false;
        uint256 bytesOffset;
        uint256 bytesLen;
        // bytes offset is always expected to be 32
        assembly {
            bytesOffset := mload(add(data, 32))
        }
        if (bytesOffset != 32) return false;
        assembly {
            bytesLen := mload(add(data, 64))
        }
        // the data length should be bytesData.length + 64 + padded bytes length
        return data.length == 64 + padLength32(bytesLen);
    }
}

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

abstract contract Errors {
    error VariableNotSet();
    error TokenBalanceError();
    error EligibilityError();
    error CharacterError();
    error PlayerError();
    error InventoryError();
    error OwnershipError();
    error InvalidToken();
    error ClaimableError();
    error CraftableError();
    error TransferError();
    error DuplicateError();
    error GameMasterOnly();
    error PlayerOnly();
    error AdminOnly();
    error CharacterOnly();
    error ClassError();
    error RequirementError();
    error ItemError();
    error LengthMismatch();
    error PlayerOrGameMasterOnly();

    error CraftItemsError();
    error CraftItemError();
    error ItemEquipped();

    error Jailed();
    error InsufficientBalance();
    error CallerNotApproved();
    error SoulboundToken();
    error RequirementNotMet();

    error ExceedsDistribution();

    //merkle proof erros
    error InvalidProof();

    // CharacterAccount.sol
    error InvalidSigner();
    error InvalidOperation();

    error DeletedItem();

    // Common
    error NotInitialized();

    // ClassLevel
    error InvalidClassLevel();

    // Factory
    error UnsupportedInterface();

    error MustRefundFullReceiptAmount(uint256 amountRequired);

    // Requirement Tree
    error InvalidOperator();
    error InvalidNilOperator();
    error InvalidAndOperator();
    error InvalidOrOperator();
    error InvalidNotOperator();
}

// 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[ERC-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/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 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) (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 ERC-1155 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 ERC-1155 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);
}

{
  "remappings": [
    "@openzeppelin-contracts/=lib/hats-module/lib/openzeppelin-contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ERC1155/=lib/hats-protocol/lib/ERC1155/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "hats-module/=lib/hats-module/src/",
    "hats-protocol/=lib/hats-protocol/src/",
    "murky/=lib/murky/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
    "openzeppelin/=lib/hats-module/lib/openzeppelin-contracts/contracts/",
    "solady/=lib/hats-protocol/lib/solady/src/",
    "solbase/=lib/hats-protocol/lib/solbase/src/",
    "utils/=lib/hats-protocol/lib/utils/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 20000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"InvalidOperation","type":"error"},{"inputs":[],"name":"InvalidSigner","type":"error"},{"anonymous":false,"inputs":[],"name":"Executed","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"operation","type":"uint256"}],"name":"execute","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"isValidSignature","outputs":[{"internalType":"bytes4","name":"magicValue","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"isValidSigner","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","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":[],"name":"state","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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