Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import {
    ZoneParameters,
    Schema
} from "../../../../types/lib/ConsiderationStructs.sol";

import { ZoneInterface } from "../../../interfaces/ZoneInterface.sol";

import {
    SignedZoneEventsAndErrors
} from "../interfaces/SignedZoneEventsAndErrors.sol";

import { SIP5Interface } from "../../interfaces/SIP5Interface.sol";

import {
    SignedZoneControllerInterface
} from "../interfaces/SignedZoneControllerInterface.sol";

import {
    IAuthorizedTransferSecurityRegistry
} from "lib/erc721c-seaport/src/interfaces/IAuthorizedTransferSecurityRegistry.sol";

import "./lib/SignedZoneConstants.sol";

/**
 * @title  SignedZone
 * @author ryanio, BCLeFevre
 * @notice SignedZone is an implementation of SIP-7 that requires orders
 *         to be signed by an approved signer.
 *         https://github.com/ProjectOpenSea/SIPs/blob/main/SIPS/sip-7.md
 */
contract SignedZone is SignedZoneEventsAndErrors, ZoneInterface, SIP5Interface {
    /// @dev The zone's controller that is set during deployment.
    address private immutable _controller;

    /// @dev The authorized signers, and if they are active.
    mapping(address => bool) private _signers;

    /// @dev The EIP-712 digest parameters.
    bytes32 internal immutable _NAME_HASH;
    bytes32 internal immutable _VERSION_HASH = keccak256(bytes("2.0"));
    // prettier-ignore
    bytes32 internal immutable _EIP_712_DOMAIN_TYPEHASH = keccak256(
          abi.encodePacked(
            "EIP712Domain(",
                "string name,",
                "string version,",
                "uint256 chainId,",
                "address verifyingContract",
            ")"
          )
        );
    // prettier-ignore
    bytes32 internal immutable _SIGNED_ORDER_TYPEHASH = keccak256(
          abi.encodePacked(
            "SignedOrder(",
                "address fulfiller,",
                "uint64 expiration,",
                "bytes32 orderHash,",
                "bytes context",
            ")"
          )
        );
    uint256 internal immutable _CHAIN_ID = block.chainid;
    bytes32 internal immutable _DOMAIN_SEPARATOR;
    address private immutable SEAPORT =
        0x0000000000000068F116a894984e2DB1123eB395;

    /**
     * @notice Constructor to deploy the contract.
     *
     * @param zoneName The name for the zone used in the domain separator
     *                 derivation.
     */
    constructor(string memory zoneName) {
        // Set the deployer as the controller.
        _controller = msg.sender;

        // Set the name hash.
        _NAME_HASH = keccak256(bytes(zoneName));

        // Derive and set the domain separator.
        _DOMAIN_SEPARATOR = _deriveDomainSeparator();

        // Emit an event to signal a SIP-5 contract has been deployed.
        emit SeaportCompatibleContractDeployed();
    }

    /**
     * @notice The fallback function is used as a dispatcher for the
     *         `updateSigner`, `isActiveSigner`, `getActiveSigners` and
     *         `supportsInterface` functions.
     */
    // prettier-ignore
    fallback(bytes calldata) external returns (bytes memory output) {
        // Get the function selector.
        bytes4 selector = msg.sig;

        if (selector == UPDATE_SIGNER_SELECTOR) {
            // abi.encodeWithSignature("updateSigner(address,bool)", signer,
            // active)
          
            // Get the signer, and active status.
            address signer = abi.decode(msg.data[4:], (address));
            bool active = abi.decode(msg.data[36:], (bool));

            // Call to update the signer.
            _updateSigner(signer, active);
        } else if (selector == GET_ACTIVE_SIGNERS_SELECTOR) {
            // abi.encodeWithSignature("getActiveSigners()")
        
            // Call the internal function to get the active signers.
            return abi.encode(_getActiveSigners());
        } else if (selector == IS_ACTIVE_SIGNER_SELECTOR) {
            // abi.encodeWithSignature("isActiveSigner(address)", signer)

            // Get the signer.
            address signer = abi.decode(msg.data[4:], (address));

            // Call the internal function to determine if the signer is active.
            return abi.encode(_isActiveSigner(signer));
        }
        else {
             // Revert if the function selector is not supported.
            assembly {
                // Store left-padded selector with push4 (reduces bytecode),
                // mem[28:32] = selector
                mstore(0, UnsupportedFunctionSelector_error_selector)
                // revert(abi.encodeWithSignature(
                //  "UnsupportedFunctionSelector()"
                // ))
                revert(0x1c, UnsupportedFunctionSelector_error_length)
            }
        }
    }

    /**
     * @notice Check if a given order including extraData is currently valid.
     *
     * @dev This function is called by Seaport whenever any extraData is
     *      provided by the caller.
     *
     * @return authorizedOrderMagicValue A magic value indicating if the order
     *                                   is currently valid.
     */
    function authorizeOrder(
        ZoneParameters calldata zoneParameters
    ) external override returns (bytes4 authorizedOrderMagicValue) {
        if (msg.sender != SEAPORT) {
            // Revert if the caller is not Seaport.
            revert CallerNotSeaport();
        }

        // Check Zone Parameters validity.
        _assertValidZoneParameters();

        // Put the extraData and orderHash on the stack for cheaper access.
        bytes calldata extraData = zoneParameters.extraData;
        bytes32 orderHash = zoneParameters.orderHash;

        // Declare a variable to hold the expiration.
        uint64 expiration;

        // Declare a variable to hold the substandard version byte.
        uint256 subStandardVersionByte;

        // Validate the extraData.
        assembly {
            // Get the length of the extraData.
            let extraDataPtr := add(0x24, calldataload(Zone_extraData_cdPtr))
            let extraDataLength := calldataload(extraDataPtr)

            // Validate the extra data length.
            if lt(
                extraDataLength,
                InvalidExtraDataLength_expected_length_substandard_1
            ) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidExtraDataLength_error_selector)
                mstore(InvalidExtraDataLength_error_orderHash_ptr, orderHash)
                // revert(abi.encodeWithSignature(
                //   "InvalidExtraDataLength(bytes32)", orderHash)
                // )
                revert(0x1c, InvalidExtraDataLength_error_length)
            }

            // extraData bytes 0-1: SIP-6 version byte (MUST be 0x00)
            let versionByte := shr(248, calldataload(add(extraDataPtr, 0x20)))

            // Validate the SIP6 Version byte.
            if iszero(eq(versionByte, 0x00)) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidSIP6Version_error_selector)
                mstore(InvalidSIP6Version_error_orderHash_ptr, orderHash)
                // revert(abi.encodeWithSignature(
                //   "InvalidSIP6Version(bytes32)", orderHash)
                // )
                revert(0x1c, InvalidSIP6Version_error_length)
            }

            // extraData bytes 93-94: Substandard #1
            // (MUST be 0x00, 0x01, 0x07, 0x08, or 0x09)
            subStandardVersionByte := shr(
                248,
                calldataload(
                    add(extraDataPtr, ExtraData_substandard_version_byte_offset)
                )
            )

            // Validate the substandard version byte.
            if or(
                gt(subStandardVersionByte, 0x09),
                and(
                    gt(subStandardVersionByte, 0x01),
                    lt(subStandardVersionByte, 0x07)
                )
            ) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidSubstandardVersion_error_selector)
                mstore(InvalidSubstandardVersion_error_orderHash_ptr, orderHash)
                // revert(abi.encodeWithSignature(
                //   "InvalidSubstandardVersion(bytes32)", orderHash)
                // )
                revert(0x1c, InvalidSubstandardVersion_error_length)
            }

            // extraData bytes 21-29: expiration timestamp (uint64)
            expiration := shr(
                192,
                calldataload(add(extraDataPtr, ExtraData_expiration_offset))
            )

            // Revert if expired.
            if lt(expiration, timestamp()) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, SignatureExpired_error_selector)
                mstore(SignatureExpired_error_expiration_ptr, expiration)
                mstore(SignatureExpired_error_orderHash_ptr, orderHash)
                // revert(abi.encodeWithSignature(
                //   "SignatureExpired(uint256,bytes32)", expiration, orderHash)
                // )
                revert(0x1c, SignatureExpired_error_length)
            }

            // Get the length of the consideration array.
            let considerationLength := calldataload(
                add(0x24, calldataload(Zone_consideration_head_cdPtr))
            )

            // Revert if the order does not have any consideration items due to
            // the Substandard #1 requirement.
            if iszero(considerationLength) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidSubstandardSupport_error_selector)
                mstore(InvalidSubstandardSupport_error_reason_offset_ptr, 0x60)
                mstore(
                    InvalidSubstandardSupport_error_substandard_version_ptr,
                    1
                )
                mstore(InvalidSubstandardSupport_error_orderHash_ptr, orderHash)
                mstore(InvalidSubstandardSupport_error_reason_length_ptr, 0x2a)
                mstore(
                    InvalidSubstandardSupport_error_reason_ptr,
                    "Consideration must have at least"
                )
                mstore(
                    InvalidSubstandardSupport_error_reason_2_ptr,
                    " one item."
                )
                // revert(abi.encodeWithSignature(
                //     "InvalidSubstandardSupport(string,uint256,bytes32)",
                //     reason,
                //     substandardVersion,
                //     orderHash
                // ))
                revert(0x1c, InvalidSubstandardSupport_error_length)
            }
        }

        // Check the validity of the Substandard #1 extraData and get the
        // expected fulfiller address.
        address expectedFulfiller = (
            _assertValidSubstandardAndGetExpectedFulfiller(orderHash)
        );

        // extraData bytes 29-93: signature
        // (strictly requires 64 byte compact sig, EIP-2098)
        bytes calldata signature = extraData[29:93];

        // extraData bytes 93-126: context (fixed length, 32 bytes + 1 byte)
        bytes calldata context;

        if (subStandardVersionByte < 2) {
            context = extraData[93:126];
        } else if (subStandardVersionByte == 7) {
            if (extraData.length < 166) {
                assembly {
                    // Store left-padded selector with push4, mem[28:32] = selector
                    mstore(0, InvalidExtraDataLength_error_selector)
                    mstore(
                        InvalidExtraDataLength_error_orderHash_ptr,
                        orderHash
                    )
                    // revert(abi.encodeWithSignature(
                    //   "InvalidExtraDataLength(bytes32)", orderHash)
                    // )
                    revert(0x1c, InvalidExtraDataLength_error_length)
                }
            }
            context = extraData[93:166];
        } else {
            if (extraData.length < 146) {
                assembly {
                    // Store left-padded selector with push4, mem[28:32] = selector
                    mstore(0, InvalidExtraDataLength_error_selector)
                    mstore(
                        InvalidExtraDataLength_error_orderHash_ptr,
                        orderHash
                    )
                    // revert(abi.encodeWithSignature(
                    //   "InvalidExtraDataLength(bytes32)", orderHash)
                    // )
                    revert(0x1c, InvalidExtraDataLength_error_length)
                }
            }
            context = extraData[93:146];
        }

        // Derive the signedOrder hash.
        bytes32 signedOrderHash = _deriveSignedOrderHash(
            expectedFulfiller,
            expiration,
            orderHash,
            context
        );

        // Derive the EIP-712 digest using the domain separator and signedOrder
        // hash.
        bytes32 digest = _deriveEIP712Digest(
            _domainSeparator(),
            signedOrderHash
        );

        // Recover the signer address from the digest and signature.
        address recoveredSigner = _recoverSigner(digest, signature);

        // Revert if the signer is not active.
        if (!_signers[recoveredSigner]) {
            revert SignerNotActive(recoveredSigner, orderHash);
        }

        // Set the transfer status of the tokens to true.
        _setTransferStatus(zoneParameters, true);

        // Return the selector of authorizeOrder as the magic value.
        authorizedOrderMagicValue = ZoneInterface.authorizeOrder.selector;
    }

    /**
     * @notice Check if a given order including extraData is currently valid.
     *
     * @dev This function is called by Seaport whenever any extraData is
     *      provided by the caller.
     *
     * @return validOrderMagicValue A magic value indicating if the order is
     *                              currently valid.
     */
    function validateOrder(
        ZoneParameters calldata zoneParameters
    ) external override returns (bytes4 validOrderMagicValue) {
        if (msg.sender != SEAPORT) {
            // Revert if the caller is not Seaport.
            revert CallerNotSeaport();
        }

        // Set the transfer status of the tokens to false.
        _setTransferStatus(zoneParameters, false);

        // Return the selector of validateOrder as the magic value.
        validOrderMagicValue = ZoneInterface.validateOrder.selector;
    }

    /**
     * @dev Returns Seaport metadata for this contract, returning the
     *      contract name and supported schemas.
     *
     * @return name     The contract name
     * @return schemas  The supported SIPs
     */
    function getSeaportMetadata()
        external
        view
        override(SIP5Interface, ZoneInterface)
        returns (string memory name, Schema[] memory schemas)
    {
        // Return the supported SIPs.
        schemas = new Schema[](1);
        schemas[0].id = 7;

        // Get the SIP-7 information.
        (
            bytes32 domainSeparator,
            string memory zoneName,
            string memory apiEndpoint,
            uint256[] memory substandards,
            string memory documentationURI
        ) = _sip7Information();

        // Return the zone name.
        name = zoneName;

        // Encode the SIP-7 information.
        schemas[0].metadata = abi.encode(
            domainSeparator,
            apiEndpoint,
            substandards,
            documentationURI
        );
    }

    /**
     * @dev Returns if the zone supports the interfaceId.
     *
     * @param interfaceId The interface identifier, as specified in ERC-165.
     *
     * @return supportsInterface True if the zone supports interfaceId, false
     */
    function supportsInterface(
        bytes4 interfaceId
    ) external view override returns (bool) {
        // Call the internal function to determine if the interface is supported.
        return _supportsInterface(interfaceId);
    }

    /**
     * @dev Sets the transfer status of the token based on the consideration
     *      items or offer items.
     *
     * @param zoneParameters The zone parameters.
     * @param active The transfer status of the token.
     */
    function _setTransferStatus(
        ZoneParameters calldata zoneParameters,
        bool active
    ) internal {
        uint8 subStandardVersionByte = uint8(
            bytes1(zoneParameters.extraData[93])
        );

        if (subStandardVersionByte < 2) {
            return;
        }

        address registry = address(bytes20(zoneParameters.extraData[126:146]));

        address token;
        uint256 identifier;
        uint256 amount;

        if (uint256(zoneParameters.consideration[0].itemType) > 1) {
            // Call on first consideration
            token = zoneParameters.consideration[0].token;
            identifier = zoneParameters.consideration[0].identifier;
            amount = zoneParameters.consideration[0].amount;
        } else {
            // Call on first offer
            token = zoneParameters.offer[0].token;
            identifier = zoneParameters.offer[0].identifier;
            amount = zoneParameters.offer[0].amount;
        }

        if (subStandardVersionByte == 7) {
            address operator = address(
                bytes20(zoneParameters.extraData[146:166])
            );
            if (active) {
                IAuthorizedTransferSecurityRegistry(registry)
                    .beforeAuthorizedTransfer(operator, token);
            } else {
                IAuthorizedTransferSecurityRegistry(registry)
                    .afterAuthorizedTransfer(token);
            }
        } else if (subStandardVersionByte == 8) {
            if (active) {
                IAuthorizedTransferSecurityRegistry(registry)
                    .beforeAuthorizedTransfer(token, identifier);
            } else {
                IAuthorizedTransferSecurityRegistry(registry)
                    .afterAuthorizedTransfer(token, identifier);
            }
        }
        /* subStandardVersionByte == 9 */
        else {
            if (active) {
                IAuthorizedTransferSecurityRegistry(registry)
                    .beforeAuthorizedTransferWithAmount(
                        token,
                        identifier,
                        amount
                    );
            } else {
                IAuthorizedTransferSecurityRegistry(registry)
                    .afterAuthorizedTransferWithAmount(token, identifier);
            }
        }
    }

    /**
     * @notice Add or remove a signer to the zone.
     *         Only the controller can call this function.
     *
     * @param signer The signer address to add or remove.
     */
    function _updateSigner(address signer, bool active) internal {
        // Only the controller can call this function.
        _assertCallerIsController();
        // Add or remove the signer.
        active ? _addSigner(signer) : _removeSigner(signer);
    }

    /**
     * @notice Add a new signer to the zone.
     *         Only the controller or an active signer can call this function.
     *
     * @param signer The new signer address to add.
     */
    function _addSigner(address signer) internal {
        // Set the signer's active status to true.
        _signers[signer] = true;

        // Emit an event that the signer was added.
        emit SignerAdded(signer);
    }

    /**
     * @notice Remove an active signer from the zone.
     *         Only the controller or an active signer can call this function.
     *
     * @param signer The signer address to remove.
     */
    function _removeSigner(address signer) internal {
        // Set the signer's active status to false.
        _signers[signer] = false;

        // Emit an event that the signer was removed.
        emit SignerRemoved(signer);
    }

    /**
     * @notice Returns the active signers for the zone. Note that the array of
     *         active signers could grow to a size that this function could not
     *         return, the array of active signers is  expected to be small,
     *         and is managed by the controller.
     *
     * @return signers The active signers.
     */
    function _getActiveSigners()
        internal
        view
        returns (address[] memory signers)
    {
        // Return the active signers for the zone by calling the controller.
        signers = SignedZoneControllerInterface(_controller).getActiveSigners(
            address(this)
        );
    }

    /**
     * @notice Returns if the given address is an active signer for the zone.
     *
     * @param signer The address to check if it is an active signer.
     *
     * @return The address is an active signer, false otherwise.
     */
    function _isActiveSigner(address signer) internal view returns (bool) {
        // Return the active status of the caller.
        return _signers[signer];
    }

    /**
     * @notice Returns whether the interface is supported.
     *
     * @param interfaceId The interface id to check against.
     */
    function _supportsInterface(
        bytes4 interfaceId
    ) internal pure returns (bool) {
        // Determine if the interface is supported.
        return (interfaceId == type(SIP5Interface).interfaceId || // SIP-5
            interfaceId == type(ZoneInterface).interfaceId || // ZoneInterface
            interfaceId == 0x01ffc9a7); // ERC-165
    }

    /**
     * @notice Internal call to return the signing information, substandards,
     *         and documentation about the zone.
     *
     * @return domainSeparator  The domain separator used for signing.
     * @return zoneName         The zone name.
     * @return apiEndpoint      The API endpoint for the zone.
     * @return substandards     The substandards supported by the zone.
     * @return documentationURI The documentation URI for the zone.
     */
    function _sip7Information()
        internal
        view
        returns (
            bytes32 domainSeparator,
            string memory zoneName,
            string memory apiEndpoint,
            uint256[] memory substandards,
            string memory documentationURI
        )
    {
        // Return the SIP-7 information.
        domainSeparator = _domainSeparator();

        // Get the SIP-7 information from the controller.
        (
            ,
            zoneName,
            apiEndpoint,
            substandards,
            documentationURI
        ) = SignedZoneControllerInterface(_controller)
            .getAdditionalZoneInformation(address(this));
    }

    /**
     * @dev Derive the signedOrder hash from the orderHash and expiration.
     *
     * @param fulfiller  The expected fulfiller address.
     * @param expiration The signature expiration timestamp.
     * @param orderHash  The order hash.
     * @param context    The optional variable-length context.
     *
     * @return signedOrderHash The signedOrder hash.
     *
     */
    function _deriveSignedOrderHash(
        address fulfiller,
        uint64 expiration,
        bytes32 orderHash,
        bytes calldata context
    ) internal view returns (bytes32 signedOrderHash) {
        // Derive the signed order hash.
        signedOrderHash = keccak256(
            abi.encode(
                _SIGNED_ORDER_TYPEHASH,
                fulfiller,
                expiration,
                orderHash,
                keccak256(context)
            )
        );
    }

    /**
     * @dev Internal view function to return the signer of a signature.
     *
     * @param digest    The digest to verify the signature against.
     * @param signature A signature from the signer indicating that the order
     *                  has been approved.
     *
     * @return recoveredSigner The recovered signer.
     */
    function _recoverSigner(
        bytes32 digest,
        bytes memory signature
    ) internal view returns (address recoveredSigner) {
        // Utilize assembly to perform optimized signature verification check.
        assembly {
            // Ensure that first word of scratch space is empty.
            mstore(0, 0)

            // Declare value for v signature parameter.
            let v

            // Get the length of the signature.
            let signatureLength := mload(signature)

            // Get the pointer to the value preceding the signature length.
            // This will be used for temporary memory overrides - either the
            // signature head for isValidSignature or the digest for ecrecover.
            let wordBeforeSignaturePtr := sub(signature, OneWord)

            // Cache the current value behind the signature to restore it later.
            let cachedWordBeforeSignature := mload(wordBeforeSignaturePtr)

            // Declare lenDiff + recoveredSigner scope to manage stack pressure.
            {
                // Take the difference between the max ECDSA signature length
                // and the actual signature length. Overflow desired for any
                // values > 65. If the diff is not 0 or 1, it is not a valid
                // ECDSA signature - move on to EIP1271 check.
                let lenDiff := sub(ECDSA_MaxLength, signatureLength)

                // If diff is 0 or 1, it may be an ECDSA signature.
                // Try to recover signer.
                if iszero(gt(lenDiff, 1)) {
                    // Read the signature `s` value.
                    let originalSignatureS := mload(
                        add(signature, ECDSA_signature_s_offset)
                    )

                    // Read the first byte of the word after `s`. If the
                    // signature is 65 bytes, this will be the real `v` value.
                    // If not, it will need to be modified - doing it this way
                    // saves an extra condition.
                    v := byte(
                        0,
                        mload(add(signature, ECDSA_signature_v_offset))
                    )

                    // If lenDiff is 1, parse 64-byte signature as ECDSA.
                    if lenDiff {
                        // Extract yParity from highest bit of vs and add 27 to
                        // get v.
                        v := add(
                            shr(MaxUint8, originalSignatureS),
                            Signature_lower_v
                        )

                        // Extract canonical s from vs, all but the highest bit.
                        // Temporarily overwrite the original `s` value in the
                        // signature.
                        mstore(
                            add(signature, ECDSA_signature_s_offset),
                            and(
                                originalSignatureS,
                                EIP2098_allButHighestBitMask
                            )
                        )
                    }
                    // Temporarily overwrite the signature length with `v` to
                    // conform to the expected input for ecrecover.
                    mstore(signature, v)

                    // Temporarily overwrite the word before the length with
                    // `digest` to conform to the expected input for ecrecover.
                    mstore(wordBeforeSignaturePtr, digest)

                    // Attempt to recover the signer for the given signature. Do
                    // not check the call status as ecrecover will return a null
                    // address if the signature is invalid.
                    pop(
                        staticcall(
                            gas(),
                            Ecrecover_precompile, // Call ecrecover precompile.
                            wordBeforeSignaturePtr, // Use data memory location.
                            Ecrecover_args_size, // Size of digest, v, r, and s.
                            0, // Write result to scratch space.
                            OneWord // Provide size of returned result.
                        )
                    )

                    // Restore cached word before signature.
                    mstore(wordBeforeSignaturePtr, cachedWordBeforeSignature)

                    // Restore cached signature length.
                    mstore(signature, signatureLength)

                    // Restore cached signature `s` value.
                    mstore(
                        add(signature, ECDSA_signature_s_offset),
                        originalSignatureS
                    )

                    // Read the recovered signer from the buffer given as return
                    // space for ecrecover.
                    recoveredSigner := mload(0)
                }
            }

            // Restore the cached values overwritten by selector, digest and
            // signature head.
            mstore(wordBeforeSignaturePtr, cachedWordBeforeSignature)
        }
    }

    /**
     * @dev Internal view function to get the EIP-712 domain separator. If the
     *      chainId matches the chainId set on deployment, the cached domain
     *      separator will be returned; otherwise, it will be derived from
     *      scratch.
     *
     * @return The domain separator.
     */
    function _domainSeparator() internal view returns (bytes32) {
        // prettier-ignore
        return block.chainid == _CHAIN_ID
            ? _DOMAIN_SEPARATOR
            : _deriveDomainSeparator();
    }

    /**
     * @dev Internal view function to derive the EIP-712 domain separator.
     *
     * @return domainSeparator The derived domain separator.
     */
    function _deriveDomainSeparator()
        internal
        view
        returns (bytes32 domainSeparator)
    {
        bytes32 typehash = _EIP_712_DOMAIN_TYPEHASH;
        bytes32 nameHash = _NAME_HASH;
        bytes32 versionHash = _VERSION_HASH;

        // Leverage scratch space and other memory to perform an efficient hash.
        assembly {
            // Retrieve the free memory pointer; it will be replaced afterwards.
            let freeMemoryPointer := mload(FreeMemoryPointerSlot)

            // Retrieve value at 0x80; it will also be replaced afterwards.
            let slot0x80 := mload(Slot0x80)

            // Place typehash, name hash, and version hash at start of memory.
            mstore(0, typehash)
            mstore(OneWord, nameHash)
            mstore(TwoWords, versionHash)

            // Place chainId in the next memory location.
            mstore(ThreeWords, chainid())

            // Place the address of this contract in the next memory location.
            mstore(FourWords, address())

            // Hash relevant region of memory to derive the domain separator.
            domainSeparator := keccak256(0, FiveWords)

            // Restore the free memory pointer.
            mstore(FreeMemoryPointerSlot, freeMemoryPointer)

            // Restore the zero slot to zero.
            mstore(ZeroSlot, 0)

            // Restore the value at 0x80.
            mstore(Slot0x80, slot0x80)
        }
    }

    /**
     * @dev Internal pure function to efficiently derive an digest to sign for
     *      an order in accordance with EIP-712.
     *
     * @param domainSeparator The domain separator.
     * @param signedOrderHash The signedOrder hash.
     *
     * @return digest The digest hash.
     */
    function _deriveEIP712Digest(
        bytes32 domainSeparator,
        bytes32 signedOrderHash
    ) internal pure returns (bytes32 digest) {
        // Leverage scratch space to perform an efficient hash.
        assembly {
            // Place the EIP-712 prefix at the start of scratch space.
            mstore(0, EIP_712_PREFIX)

            // Place the domain separator in the next region of scratch space.
            mstore(EIP712_DomainSeparator_offset, domainSeparator)

            // Place the signed order hash in scratch space, spilling into the
            // first two bytes of the free memory pointer — this should never be
            // set as memory cannot be expanded to that size, and will be
            // zeroed out after the hash is performed.
            mstore(EIP712_SignedOrderHash_offset, signedOrderHash)

            // Hash the relevant region
            digest := keccak256(0, EIP712_DigestPayload_size)

            // Clear out the dirtied bits in the memory pointer.
            mstore(EIP712_SignedOrderHash_offset, 0)
        }
    }

    /**
     * @dev Internal view function to revert if the caller is not the
     *      controller.
     */
    function _assertCallerIsController() internal view {
        // Get the controller address to use in the assembly block.
        address controller = _controller;

        assembly {
            // Revert if the caller is not the controller.
            if iszero(eq(caller(), controller)) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidController_error_selector)
                // revert(abi.encodeWithSignature(
                //   "InvalidController()")
                // )
                revert(0x1c, InvalidController_error_length)
            }
        }
    }

    /**
     * @dev Internal pure function to validate calldata offsets for the
     *      dyanamic type in ZoneParameters. This ensures that functions using
     *      the calldata object normally will be using the same data as the
     *      assembly functions and that values that are bound to a given range
     *      are within that range.
     */
    function _assertValidZoneParameters() internal pure {
        // Utilize assembly in order to read offset data directly from calldata.
        assembly {
            /*
             * Checks:
             * 1. Zone parameters struct offset == 0x20
             */

            // Zone parameters at calldata 0x04 must have offset of 0x20.
            if iszero(
                eq(calldataload(Zone_parameters_cdPtr), Zone_parameters_ptr)
            ) {
                // Store left-padded selector with push4 (reduces bytecode),
                // mem[28:32] = selector
                mstore(0, InvalidZoneParameterEncoding_error_selector)
                // revert(abi.encodeWithSignature(
                //  "InvalidZoneParameterEncoding()"
                // ))
                revert(0x1c, InvalidZoneParameterEncoding_error_length)
            }
        }
    }

    /**
     * @dev Internal pure function to ensure that the context argument for the
     *      supplied extra data follows the substandard #1 format. Returns the
     *      expected fulfiller of the order for deriving the signed order hash.
     *
     * @param orderHash The order hash.
     *
     * @return expectedFulfiller The expected fulfiller of the order.
     */
    function _assertValidSubstandardAndGetExpectedFulfiller(
        bytes32 orderHash
    ) internal pure returns (address expectedFulfiller) {
        // Revert if the expected fulfiller is not the zero address and does
        // not match the actual fulfiller or if the expected received
        // identifier does not match the actual received identifier.
        assembly {
            // Get the actual fulfiller.
            let actualFulfiller := calldataload(Zone_parameters_fulfiller_cdPtr)
            let extraDataPtr := calldataload(Zone_extraData_cdPtr)
            let considerationPtr := calldataload(Zone_consideration_head_cdPtr)

            // Get the expected fulfiller.
            expectedFulfiller := shr(
                96,
                calldataload(add(expectedFulfiller_offset, extraDataPtr))
            )

            // Get the actual received identifier.
            let actualReceivedIdentifier := calldataload(
                add(actualReceivedIdentifier_offset, considerationPtr)
            )

            // Get the expected received identifier.
            let expectedReceivedIdentifier := calldataload(
                add(expectedReceivedIdentifier_offset, extraDataPtr)
            )

            // Revert if expected fulfiller is not the zero address and does
            // not match the actual fulfiller.
            if and(
                iszero(iszero(expectedFulfiller)),
                iszero(eq(expectedFulfiller, actualFulfiller))
            ) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidFulfiller_error_selector)
                mstore(
                    InvalidFulfiller_error_expectedFulfiller_ptr,
                    expectedFulfiller
                )
                mstore(
                    InvalidFulfiller_error_actualFulfiller_ptr,
                    actualFulfiller
                )
                mstore(InvalidFulfiller_error_orderHash_ptr, orderHash)
                // revert(abi.encodeWithSignature(
                //     "InvalidFulfiller(address,address,bytes32)",
                //     expectedFulfiller,
                //     actualFulfiller,
                //     orderHash
                // ))
                revert(0x1c, InvalidFulfiller_error_length)
            }

            // Revert if expected received item does not match the actual
            // received item.
            if iszero(
                eq(expectedReceivedIdentifier, actualReceivedIdentifier)
            ) {
                // Store left-padded selector with push4, mem[28:32] = selector
                mstore(0, InvalidReceivedItem_error_selector)
                mstore(
                    InvalidReceivedItem_error_expectedReceivedItem_ptr,
                    expectedReceivedIdentifier
                )
                mstore(
                    InvalidReceivedItem_error_actualReceivedItem_ptr,
                    actualReceivedIdentifier
                )
                mstore(InvalidReceivedItem_error_orderHash_ptr, orderHash)
                // revert(abi.encodeWithSignature(
                //     "InvalidReceivedItem(uint256,uint256,bytes32)",
                //     expectedReceivedIdentifier,
                //     actualReceievedIdentifier,
                //     orderHash
                // ))
                revert(0x1c, InvalidReceivedItem_error_length)
            }
        }
    }
}

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

import {
    BasicOrderType, ItemType, OrderType, Side
} from "./ConsiderationEnums.sol";

import { CalldataPointer, MemoryPointer } from "../helpers/PointerLibraries.sol";

/**
 * @dev An order contains eleven components: an offerer, a zone (or account that
 *      can cancel the order or restrict who can fulfill the order depending on
 *      the type), the order type (specifying partial fill support as well as
 *      restricted order status), the start and end time, a hash that will be
 *      provided to the zone when validating restricted orders, a salt, a key
 *      corresponding to a given conduit, a counter, and an arbitrary number of
 *      offer items that can be spent along with consideration items that must
 *      be received by their respective recipient.
 */
struct OrderComponents {
    address offerer;
    address zone;
    OfferItem[] offer;
    ConsiderationItem[] consideration;
    OrderType orderType;
    uint256 startTime;
    uint256 endTime;
    bytes32 zoneHash;
    uint256 salt;
    bytes32 conduitKey;
    uint256 counter;
}

/**
 * @dev An offer item has five components: an item type (ETH or other native
 *      tokens, ERC20, ERC721, and ERC1155, as well as criteria-based ERC721 and
 *      ERC1155), a token address, a dual-purpose "identifierOrCriteria"
 *      component that will either represent a tokenId or a merkle root
 *      depending on the item type, and a start and end amount that support
 *      increasing or decreasing amounts over the duration of the respective
 *      order.
 */
struct OfferItem {
    ItemType itemType;
    address token;
    uint256 identifierOrCriteria;
    uint256 startAmount;
    uint256 endAmount;
}

/**
 * @dev A consideration item has the same five components as an offer item and
 *      an additional sixth component designating the required recipient of the
 *      item.
 */
struct ConsiderationItem {
    ItemType itemType;
    address token;
    uint256 identifierOrCriteria;
    uint256 startAmount;
    uint256 endAmount;
    address payable recipient;
}

/**
 * @dev A spent item is translated from a utilized offer item and has four
 *      components: an item type (ETH or other native tokens, ERC20, ERC721, and
 *      ERC1155), a token address, a tokenId, and an amount.
 */
struct SpentItem {
    ItemType itemType;
    address token;
    uint256 identifier;
    uint256 amount;
}

/**
 * @dev A received item is translated from a utilized consideration item and has
 *      the same four components as a spent item, as well as an additional fifth
 *      component designating the required recipient of the item.
 */
struct ReceivedItem {
    ItemType itemType;
    address token;
    uint256 identifier;
    uint256 amount;
    address payable recipient;
}

/**
 * @dev For basic orders involving ETH / native / ERC20 <=> ERC721 / ERC1155
 *      matching, a group of six functions may be called that only requires a
 *      subset of the usual order arguments. Note the use of a "basicOrderType"
 *      enum; this represents both the usual order type as well as the "route"
 *      of the basic order (a simple derivation function for the basic order
 *      type is `basicOrderType = orderType + (4 * basicOrderRoute)`.)
 */
struct BasicOrderParameters {
    // calldata offset
    address considerationToken; // 0x24
    uint256 considerationIdentifier; // 0x44
    uint256 considerationAmount; // 0x64
    address payable offerer; // 0x84
    address zone; // 0xa4
    address offerToken; // 0xc4
    uint256 offerIdentifier; // 0xe4
    uint256 offerAmount; // 0x104
    BasicOrderType basicOrderType; // 0x124
    uint256 startTime; // 0x144
    uint256 endTime; // 0x164
    bytes32 zoneHash; // 0x184
    uint256 salt; // 0x1a4
    bytes32 offererConduitKey; // 0x1c4
    bytes32 fulfillerConduitKey; // 0x1e4
    uint256 totalOriginalAdditionalRecipients; // 0x204
    AdditionalRecipient[] additionalRecipients; // 0x224
    bytes signature; // 0x244
        // Total length, excluding dynamic array data: 0x264 (580)
}

/**
 * @dev Basic orders can supply any number of additional recipients, with the
 *      implied assumption that they are supplied from the offered ETH (or other
 *      native token) or ERC20 token for the order.
 */
struct AdditionalRecipient {
    uint256 amount;
    address payable recipient;
}

/**
 * @dev The full set of order components, with the exception of the counter,
 *      must be supplied when fulfilling more sophisticated orders or groups of
 *      orders. The total number of original consideration items must also be
 *      supplied, as the caller may specify additional consideration items.
 */
struct OrderParameters {
    address offerer; // 0x00
    address zone; // 0x20
    OfferItem[] offer; // 0x40
    ConsiderationItem[] consideration; // 0x60
    OrderType orderType; // 0x80
    uint256 startTime; // 0xa0
    uint256 endTime; // 0xc0
    bytes32 zoneHash; // 0xe0
    uint256 salt; // 0x100
    bytes32 conduitKey; // 0x120
    uint256 totalOriginalConsiderationItems; // 0x140
        // offer.length                          // 0x160
}

/**
 * @dev Orders require a signature in addition to the other order parameters.
 */
struct Order {
    OrderParameters parameters;
    bytes signature;
}

/**
 * @dev Advanced orders include a numerator (i.e. a fraction to attempt to fill)
 *      and a denominator (the total size of the order) in addition to the
 *      signature and other order parameters. It also supports an optional field
 *      for supplying extra data; this data will be provided to the zone if the
 *      order type is restricted and the zone is not the caller, or will be
 *      provided to the offerer as context for contract order types.
 */
struct AdvancedOrder {
    OrderParameters parameters;
    uint120 numerator;
    uint120 denominator;
    bytes signature;
    bytes extraData;
}

/**
 * @dev Orders can be validated (either explicitly via `validate`, or as a
 *      consequence of a full or partial fill), specifically cancelled (they can
 *      also be cancelled in bulk via incrementing a per-zone counter), and
 *      partially or fully filled (with the fraction filled represented by a
 *      numerator and denominator).
 */
struct OrderStatus {
    bool isValidated;
    bool isCancelled;
    uint120 numerator;
    uint120 denominator;
}

/**
 * @dev A criteria resolver specifies an order, side (offer vs. consideration),
 *      and item index. It then provides a chosen identifier (i.e. tokenId)
 *      alongside a merkle proof demonstrating the identifier meets the required
 *      criteria.
 */
struct CriteriaResolver {
    uint256 orderIndex;
    Side side;
    uint256 index;
    uint256 identifier;
    bytes32[] criteriaProof;
}

/**
 * @dev A fulfillment is applied to a group of orders. It decrements a series of
 *      offer and consideration items, then generates a single execution
 *      element. A given fulfillment can be applied to as many offer and
 *      consideration items as desired, but must contain at least one offer and
 *      at least one consideration that match. The fulfillment must also remain
 *      consistent on all key parameters across all offer items (same offerer,
 *      token, type, tokenId, and conduit preference) as well as across all
 *      consideration items (token, type, tokenId, and recipient).
 */
struct Fulfillment {
    FulfillmentComponent[] offerComponents;
    FulfillmentComponent[] considerationComponents;
}

/**
 * @dev Each fulfillment component contains one index referencing a specific
 *      order and another referencing a specific offer or consideration item.
 */
struct FulfillmentComponent {
    uint256 orderIndex;
    uint256 itemIndex;
}

/**
 * @dev An execution is triggered once all consideration items have been zeroed
 *      out. It sends the item in question from the offerer to the item's
 *      recipient, optionally sourcing approvals from either this contract
 *      directly or from the offerer's chosen conduit if one is specified. An
 *      execution is not provided as an argument, but rather is derived via
 *      orders, criteria resolvers, and fulfillments (where the total number of
 *      executions will be less than or equal to the total number of indicated
 *      fulfillments) and returned as part of `matchOrders`.
 */
struct Execution {
    ReceivedItem item;
    address offerer;
    bytes32 conduitKey;
}

/**
 * @dev Restricted orders are validated post-execution by calling validateOrder
 *      on the zone. This struct provides context about the order fulfillment
 *      and any supplied extraData, as well as all order hashes fulfilled in a
 *      call to a match or fulfillAvailable method.
 */
struct ZoneParameters {
    bytes32 orderHash;
    address fulfiller;
    address offerer;
    SpentItem[] offer;
    ReceivedItem[] consideration;
    bytes extraData;
    bytes32[] orderHashes;
    uint256 startTime;
    uint256 endTime;
    bytes32 zoneHash;
}

/**
 * @dev Zones and contract offerers can communicate which schemas they implement
 *      along with any associated metadata related to each schema.
 */
struct Schema {
    uint256 id;
    bytes metadata;
}

using StructPointers for OrderComponents global;
using StructPointers for OfferItem global;
using StructPointers for ConsiderationItem global;
using StructPointers for SpentItem global;
using StructPointers for ReceivedItem global;
using StructPointers for BasicOrderParameters global;
using StructPointers for AdditionalRecipient global;
using StructPointers for OrderParameters global;
using StructPointers for Order global;
using StructPointers for AdvancedOrder global;
using StructPointers for OrderStatus global;
using StructPointers for CriteriaResolver global;
using StructPointers for Fulfillment global;
using StructPointers for FulfillmentComponent global;
using StructPointers for Execution global;
using StructPointers for ZoneParameters global;

/**
 * @dev This library provides a set of functions for converting structs to
 *      pointers.
 */
library StructPointers {
    /**
     * @dev Get a MemoryPointer from OrderComponents.
     *
     * @param obj The OrderComponents object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(OrderComponents memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from OrderComponents.
     *
     * @param obj The OrderComponents object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(OrderComponents calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from OfferItem.
     *
     * @param obj The OfferItem object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(OfferItem memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from OfferItem.
     *
     * @param obj The OfferItem object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(OfferItem calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from ConsiderationItem.
     *
     * @param obj The ConsiderationItem object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(ConsiderationItem memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from ConsiderationItem.
     *
     * @param obj The ConsiderationItem object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(ConsiderationItem calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from SpentItem.
     *
     * @param obj The SpentItem object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(SpentItem memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from SpentItem.
     *
     * @param obj The SpentItem object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(SpentItem calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from ReceivedItem.
     *
     * @param obj The ReceivedItem object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(ReceivedItem memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from ReceivedItem.
     *
     * @param obj The ReceivedItem object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(ReceivedItem calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from BasicOrderParameters.
     *
     * @param obj The BasicOrderParameters object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(BasicOrderParameters memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from BasicOrderParameters.
     *
     * @param obj The BasicOrderParameters object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(BasicOrderParameters calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from AdditionalRecipient.
     *
     * @param obj The AdditionalRecipient object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(AdditionalRecipient memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from AdditionalRecipient.
     *
     * @param obj The AdditionalRecipient object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(AdditionalRecipient calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from OrderParameters.
     *
     * @param obj The OrderParameters object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(OrderParameters memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from OrderParameters.
     *
     * @param obj The OrderParameters object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(OrderParameters calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from Order.
     *
     * @param obj The Order object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(Order memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from Order.
     *
     * @param obj The Order object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(Order calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from AdvancedOrder.
     *
     * @param obj The AdvancedOrder object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(AdvancedOrder memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from AdvancedOrder.
     *
     * @param obj The AdvancedOrder object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(AdvancedOrder calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from OrderStatus.
     *
     * @param obj The OrderStatus object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(OrderStatus memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from OrderStatus.
     *
     * @param obj The OrderStatus object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(OrderStatus calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from CriteriaResolver.
     *
     * @param obj The CriteriaResolver object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(CriteriaResolver memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from CriteriaResolver.
     *
     * @param obj The CriteriaResolver object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(CriteriaResolver calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from Fulfillment.
     *
     * @param obj The Fulfillment object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(Fulfillment memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from Fulfillment.
     *
     * @param obj The Fulfillment object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(Fulfillment calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from FulfillmentComponent.
     *
     * @param obj The FulfillmentComponent object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(FulfillmentComponent memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from FulfillmentComponent.
     *
     * @param obj The FulfillmentComponent object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(FulfillmentComponent calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from Execution.
     *
     * @param obj The Execution object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(Execution memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from Execution.
     *
     * @param obj The Execution object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(Execution calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a MemoryPointer from ZoneParameters.
     *
     * @param obj The ZoneParameters object.
     *
     * @return ptr The MemoryPointer.
     */
    function toMemoryPointer(ZoneParameters memory obj)
        internal
        pure
        returns (MemoryPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }

    /**
     * @dev Get a CalldataPointer from ZoneParameters.
     *
     * @param obj The ZoneParameters object.
     *
     * @return ptr The CalldataPointer.
     */
    function toCalldataPointer(ZoneParameters calldata obj)
        internal
        pure
        returns (CalldataPointer ptr)
    {
        assembly {
            ptr := obj
        }
    }
}

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

import { ZoneInterface } from "seaport-types/src/interfaces/ZoneInterface.sol";

interface LocalZoneInterface is ZoneInterface { }

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

/**
 * @notice SignedZoneEventsAndErrors contains errors and events
 *         related to zone interaction.
 */
interface SignedZoneEventsAndErrors {
    /**
     * @dev Emit an event when a new signer is added.
     */
    event SignerAdded(address signer);

    /**
     * @dev Emit an event when a signer is removed.
     */
    event SignerRemoved(address signer);

    /**
     * @dev Revert with an error when the signature has expired.
     */
    error SignatureExpired(uint256 expiration, bytes32 orderHash);

    /**
     * @dev Revert with an error when the caller is not seaport.
     */
    error CallerNotSeaport();

    /**
     * @dev Revert with an error when attempting to update the signers of a
     *      the zone from a caller that is not the zone's controller.
     */
    error InvalidController();

    /**
     * @dev Revert with an error if supplied order extraData is an invalid
     *      length.
     */
    error InvalidExtraDataLength(bytes32 orderHash);

    /**
     * @dev Revert with an error if the supplied order extraData does not
     *      support the zone's SIP6 version.
     */
    error InvalidSIP6Version(bytes32 orderHash);

    /**
     * @dev Revert with an error if the supplied order extraData does not
     *      support the zone's substandard requirements.
     */
    error InvalidSubstandardSupport(
        string reason,
        uint256 substandardVersion,
        bytes32 orderHash
    );

    /**
     * @dev Revert with an error if the supplied order extraData does not
     *      support the zone's substandard version.
     */
    error InvalidSubstandardVersion(bytes32 orderHash);

    /**
     * @dev Revert with an error if the fulfiller does not match.
     */
    error InvalidFulfiller(
        address expectedFulfiller,
        address actualFulfiller,
        bytes32 orderHash
    );

    /**
     * @dev Revert with an error if the received item does not match.
     */
    error InvalidReceivedItem(
        uint256 expectedReceivedIdentifier,
        uint256 actualReceievedIdentifier,
        bytes32 orderHash
    );

    /**
     * @dev Revert with an error if the zone parameter encoding is invalid.
     */
    error InvalidZoneParameterEncoding();

    /**
     * @dev Revert with an error when an order is signed with a signer
     *      that is not active.
     */
    error SignerNotActive(address signer, bytes32 orderHash);

    /**
     * @dev Revert when an unsupported function selector is found.
     */
    error UnsupportedFunctionSelector();
}

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

import { Schema } from "../../../types/lib/ConsiderationStructs.sol";

/**
 * @dev SIP-5: Contract Metadata Interface for Seaport Contracts
 *      https://github.com/ProjectOpenSea/SIPs/blob/main/SIPS/sip-5.md
 */
interface SIP5Interface {
    /**
     * @dev An event that is emitted when a SIP-5 compatible contract is deployed.
     */
    event SeaportCompatibleContractDeployed();

    /**
     * @dev Returns Seaport metadata for this contract, returning the
     *      contract name and supported schemas.
     *
     * @return name    The contract name
     * @return schemas The supported SIPs
     */
    function getSeaportMetadata()
        external
        view
        returns (string memory name, Schema[] memory schemas);
}

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

/**
 * @title  SignedZoneControllerInterface
 * @author BCLeFevre
 * @notice SignedZoneControllerInterface enables the deploying of SignedZones.
 *         SignedZones are an implementation of SIP-7 that requires orders
 *         to be signed by an approved signer.
 *         https://github.com/ProjectOpenSea/SIPs/blob/main/SIPS/sip-7.md
 *
 */
interface SignedZoneControllerInterface {
    /**
     * @notice Returns the active signers for the zone.
     *
     * @param signedZone The signed zone to get the active signers for.
     *
     * @return signers The active signers.
     */
    function getActiveSigners(
        address signedZone
    ) external view returns (address[] memory signers);

    /**
     * @notice Returns additional information about the zone.
     *
     * @param zone The zone to get the additional information for.
     *
     * @return domainSeparator  The domain separator used for signing.
     * @return zoneName         The name of the zone.
     * @return apiEndpoint      The API endpoint for the zone.
     * @return substandards     The substandards supported by the zone.
     * @return documentationURI The documentation URI for the zone.
     */
    function getAdditionalZoneInformation(
        address zone
    )
        external
        view
        returns (
            bytes32 domainSeparator,
            string memory zoneName,
            string memory apiEndpoint,
            uint256[] memory substandards,
            string memory documentationURI
        );

    /**
     * @notice Update the API endpoint returned by the supplied zone.
     *         Only the owner or an active signer can call this function.
     *
     * @param signedZone     The signed zone to update the API endpoint for.
     * @param newApiEndpoint The new API endpoint.
     */
    function updateAPIEndpoint(
        address signedZone,
        string calldata newApiEndpoint
    ) external;

    /**
     * @notice Update the documentationURI returned by a zone.
     *         Only the owner or an active signer of the supplied zone can call
     *         this function.
     *
     * @param zone             The signed zone to update the API endpoint for.
     * @param documentationURI The new documentation URI.
     */
    function updateDocumentationURI(
        address zone,
        string calldata documentationURI
    ) external;

    /**
     * @notice Update the signer for a given signed zone.
     *
     * @param signedZone The signed zone to update the signer for.
     * @param signer     The signer to update.
     * @param active     If the signer should be active or not.
     */
    function updateSigner(
        address signedZone,
        address signer,
        bool active
    ) external;

    /**
     * @notice Initiate zone ownership transfer by assigning a new potential
     *         owner for the given zone. Once set, the new potential owner
     *         may call `acceptOwnership` to claim ownership of the zone.
     *         Only the owner of the zone in question may call this function.
     *
     * @param zone              The zone for which to initiate ownership
     *                          transfer.
     * @param newPotentialOwner The new potential owner of the zone.
     */
    function transferOwnership(
        address zone,
        address newPotentialOwner
    ) external;

    /**
     * @notice Clear the currently set potential owner, if any, from a zone.
     *         Only the owner of the zone in question may call this function.
     *
     * @param zone The zone for which to cancel ownership transfer.
     */
    function cancelOwnershipTransfer(address zone) external;

    /**
     * @notice Accept ownership of a supplied zone. Only accounts that the
     *         current owner has set as the new potential owner may call this
     *         function.
     *
     * @param zone The zone for which to accept ownership.
     */
    function acceptOwnership(address zone) external;

    /**
     * @notice Retrieve the current owner of a deployed zone.
     *
     * @param zone The zone for which to retrieve the associated owner.
     *
     * @return owner The owner of the supplied zone.
     */
    function ownerOf(address zone) external view returns (address owner);

    /**
     * @notice Retrieve the potential owner, if any, for a given zone. The
     *         current owner may set a new potential owner via
     *         `transferOwnership` and that owner may then accept ownership of
     *         the zone in question via `acceptOwnership`.
     *
     * @param zone The zone for which to retrieve the potential owner.
     *
     * @return potentialOwner The potential owner, if any, for the zone.
     */
    function getPotentialOwner(
        address zone
    ) external view returns (address potentialOwner);

    /**
     * @notice Returns whether or not the supplied address is an active signer
     *         for the supplied zone.
     *
     * @param zone   The zone to check if the supplied address is an active
     *               signer for.
     * @param signer The address to check if it is an active signer for
     *
     * @return active If the supplied address is an active signer for the
     *                supplied zone.
     */
    function isActiveSigner(
        address zone,
        address signer
    ) external view returns (bool);
}

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

enum ListTypes {
    AuthorizerList,
    OperatorList
}

/// @title IAuthorizedTransferSecurityRegistry
/// @dev Interface for the Authorized Transfer Security Registry, a simplified version of the Transfer
///      Security Registry that only supports authorizers and whitelisted operators, and assumes a
///      security level of OperatorWhitelistEnableOTC + authorizers for all collections that use it.
///      Note that a number of view functions on collections that add this validator will not work.
interface IAuthorizedTransferSecurityRegistry {
    event CreatedList(uint256 indexed id, string name);
    event AppliedListToCollection(address indexed collection, uint120 indexed id);
    event ReassignedListOwnership(uint256 indexed id, address indexed newOwner);
    event AddedAccountToList(ListTypes indexed kind, uint256 indexed id, address indexed account);
    event RemovedAccountFromList(ListTypes indexed kind, uint256 indexed id, address indexed account);

    error AuthorizedTransferSecurityRegistry__ListDoesNotExist();
    error AuthorizedTransferSecurityRegistry__CallerDoesNotOwnList();
    error AuthorizedTransferSecurityRegistry__ArrayLengthCannotBeZero();
    error AuthorizedTransferSecurityRegistry__CallerMustHaveElevatedPermissionsForSpecifiedNFT();
    error AuthorizedTransferSecurityRegistry__ListOwnershipCannotBeTransferredToZeroAddress();
    error AuthorizedTransferSecurityRegistry__ZeroAddressNotAllowed();
    error AuthorizedTransferSecurityRegistry__UnauthorizedTransfer();
    error AuthorizedTransferSecurityRegistry__CallerIsNotValidAuthorizer();

    /// Manage lists of authorizers & operators that can be applied to collections
    function createList(string calldata name) external returns (uint120);
    function createListCopy(string calldata name, uint120 sourceListId) external returns (uint120);
    function reassignOwnershipOfList(uint120 id, address newOwner) external;
    function renounceOwnershipOfList(uint120 id) external;
    function applyListToCollection(address collection, uint120 id) external;
    function listOwners(uint120 id) external view returns (address);

    /// Manage and query for authorizers on lists
    function addAuthorizers(uint120 id, address[] calldata accounts) external;
    function removeAuthorizers(uint120 id, address[] calldata accounts) external;
    function getAuthorizers(uint120 id) external view returns (address[] memory);
    function isAuthorizer(uint120 id, address account) external view returns (bool);
    function getAuthorizersByCollection(address collection) external view returns (address[] memory);
    function isAuthorizerByCollection(address collection, address account) external view returns (bool);

    /// Manage and query for operators on lists
    function addOperators(uint120 id, address[] calldata accounts) external;
    function removeOperators(uint120 id, address[] calldata accounts) external;
    function getOperators(uint120 id) external view returns (address[] memory);
    function isOperator(uint120 id, address account) external view returns (bool);
    function getOperatorsByCollection(address collection) external view returns (address[] memory);
    function isOperatorByCollection(address collection, address account) external view returns (bool);

    /// Ensure that a specific operator has been authorized to transfer tokens
    function validateTransfer(address caller, address from, address to) external view;

    /// Ensure that a transfer has been authorized for a specific tokenId
    function validateTransfer(address caller, address from, address to, uint256 tokenId) external view;

    /// Ensure that a transfer has been authorized for a specific amount of a specific tokenId, and
    /// reduce the transferable amount remaining
    function validateTransfer(address caller, address from, address to, uint256 tokenId, uint256 amount) external;

    /// Legacy alias for validateTransfer (address caller, address from, address to)
    function applyCollectionTransferPolicy(address caller, address from, address to) external view;

    /// Temporarily assign a specific allowed operator for a given collection
    function beforeAuthorizedTransfer(address operator, address token) external;

    /// Clear assignment of a specific allowed operator for a given collection
    function afterAuthorizedTransfer(address token) external;

    /// Temporarily allow a specific tokenId from a given collection to be transferred
    function beforeAuthorizedTransfer(address token, uint256 tokenId) external;

    /// Clear assignment of an specific tokenId's transfer allowance
    function afterAuthorizedTransfer(address token, uint256 tokenId) external;

    /// Temporarily allow a specific amount of a specific tokenId from a given collection to be transferred
    function beforeAuthorizedTransferWithAmount(address token, uint256 tokenId, uint256 amount) external;

    /// Clear assignment of a tokenId's transfer allowance for a specific amount
    function afterAuthorizedTransferWithAmount(address token, uint256 tokenId) external;
}

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

/// @dev ECDSA signature offsets.
uint256 constant ECDSA_MaxLength = 65;
uint256 constant ECDSA_signature_s_offset = 0x40;
uint256 constant ECDSA_signature_v_offset = 0x60;

/// @dev Helpers for memory offsets.
uint256 constant OneWord = 0x20;
uint256 constant TwoWords = 0x40;
uint256 constant ThreeWords = 0x60;
uint256 constant FourWords = 0x80;
uint256 constant FiveWords = 0xa0;
uint256 constant Signature_lower_v = 27;
uint256 constant MaxUint8 = 0xff;
bytes32 constant EIP2098_allButHighestBitMask = (
    0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
);
uint256 constant Ecrecover_precompile = 1;
uint256 constant Ecrecover_args_size = 0x80;
uint256 constant FreeMemoryPointerSlot = 0x40;
uint256 constant ZeroSlot = 0x60;
uint256 constant Slot0x80 = 0x80;

/// @dev The EIP-712 digest offsets.
uint256 constant EIP712_DomainSeparator_offset = 0x02;
uint256 constant EIP712_SignedOrderHash_offset = 0x22;
uint256 constant EIP712_DigestPayload_size = 0x42;
uint256 constant EIP_712_PREFIX = (
    0x1901000000000000000000000000000000000000000000000000000000000000
);

// @dev Function selectors used in the fallback function..
bytes4 constant UPDATE_SIGNER_SELECTOR = 0xf460590b;
bytes4 constant GET_ACTIVE_SIGNERS_SELECTOR = 0xa784b80c;
bytes4 constant IS_ACTIVE_SIGNER_SELECTOR = 0x7dff5a79;
bytes4 constant SUPPORTS_INTERFACE_SELECTOR = 0x01ffc9a7;

/*
 *  error InvalidController()
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 * Revert buffer is memory[0x1c:0x20]
 */
uint256 constant InvalidController_error_selector = 0x6d5769be;
uint256 constant InvalidController_error_length = 0x04;

/*
 *  error InvalidFulfiller(address expectedFulfiller, address actualFulfiller, bytes32 orderHash)
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 *    - 0x20: expectedFulfiller
 *    - 0x40: actualFullfiller
 *    - 0x60: orderHash
 * Revert buffer is memory[0x1c:0x80]
 */
uint256 constant InvalidFulfiller_error_selector = 0x1bcf9bb7;
uint256 constant InvalidFulfiller_error_expectedFulfiller_ptr = 0x20;
uint256 constant InvalidFulfiller_error_actualFulfiller_ptr = 0x40;
uint256 constant InvalidFulfiller_error_orderHash_ptr = 0x60;
uint256 constant InvalidFulfiller_error_length = 0x64;

/*
 *  error InvalidReceivedItem(uint256 expectedReceivedIdentifier, uint256 actualReceievedIdentifier, bytes32 orderHash)
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 *    - 0x20: expectedReceivedIdentifier
 *    - 0x40: actualReceievedIdentifier
 *    - 0x60: orderHash
 * Revert buffer is memory[0x1c:0x80]
 */
uint256 constant InvalidReceivedItem_error_selector = 0xb36c03e8;
uint256 constant InvalidReceivedItem_error_expectedReceivedItem_ptr = 0x20;
uint256 constant InvalidReceivedItem_error_actualReceivedItem_ptr = 0x40;
uint256 constant InvalidReceivedItem_error_orderHash_ptr = 0x60;
uint256 constant InvalidReceivedItem_error_length = 0x64;

/*
 *  error InvalidZoneParameterEncoding()
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 * Revert buffer is memory[0x1c:0x20]
 */
uint256 constant InvalidZoneParameterEncoding_error_selector = 0x46d5d895;
uint256 constant InvalidZoneParameterEncoding_error_length = 0x04;

/*
 * error InvalidExtraDataLength()
 *   - Defined in SignedZoneEventsAndErrors.sol
 * Memory layout:
 *   - 0x00: Left-padded selector (data begins at 0x1c)
 *   - 0x20: orderHash
 * Revert buffer is memory[0x1c:0x40]
 */
uint256 constant InvalidExtraDataLength_error_selector = 0xd232fd2c;
uint256 constant InvalidExtraDataLength_error_orderHash_ptr = 0x20;
uint256 constant InvalidExtraDataLength_error_length = 0x24;
uint256 constant InvalidExtraDataLength_expected_length_substandard_1 = 0x7e; // 126
uint256 constant InvalidExtraDataLength_expected_length_substandard_7 = 0xa6; // 166
uint256 constant InvalidExtraDataLength_expected_length_substandard_8_or_9 = 0x92; // 146

uint256 constant ExtraData_expiration_offset = 0x35;
uint256 constant ExtraData_substandard_version_byte_offset = 0x7d;
/*
 *  error InvalidSIP6Version()
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 *    - 0x20: orderHash
 * Revert buffer is memory[0x1c:0x40]
 */
uint256 constant InvalidSIP6Version_error_selector = 0x64115774;
uint256 constant InvalidSIP6Version_error_orderHash_ptr = 0x20;
uint256 constant InvalidSIP6Version_error_length = 0x24;

/*
 *  error InvalidSubstandardVersion()
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 *    - 0x20: orderHash
 * Revert buffer is memory[0x1c:0x40]
 */
uint256 constant InvalidSubstandardVersion_error_selector = 0x26787999;
uint256 constant InvalidSubstandardVersion_error_orderHash_ptr = 0x20;
uint256 constant InvalidSubstandardVersion_error_length = 0x24;

/*
 *  error InvalidSubstandardSupport()
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 *    - 0x20: reason
 *    - 0x40: substandardVersion
 *    - 0x60: orderHash
 * Revert buffer is memory[0x1c:0xe0]
 */
uint256 constant InvalidSubstandardSupport_error_selector = 0x2be76224;
uint256 constant InvalidSubstandardSupport_error_reason_offset_ptr = 0x20;
uint256 constant InvalidSubstandardSupport_error_substandard_version_ptr = 0x40;
uint256 constant InvalidSubstandardSupport_error_orderHash_ptr = 0x60;
uint256 constant InvalidSubstandardSupport_error_reason_length_ptr = 0x80;
uint256 constant InvalidSubstandardSupport_error_reason_ptr = 0xa0;
uint256 constant InvalidSubstandardSupport_error_reason_2_ptr = 0xc0;
uint256 constant InvalidSubstandardSupport_error_length = 0xc4;

/*
 * error SignatureExpired()
 *   - Defined in SignedZoneEventsAndErrors.sol
 * Memory layout:
 *   - 0x00: Left-padded selector (data begins at 0x1c)
 *   - 0x20: expiration
 *   - 0x40: orderHash
 * Revert buffer is memory[0x1c:0x60]
 */
uint256 constant SignatureExpired_error_selector = 0x16546071;
uint256 constant SignatureExpired_error_expiration_ptr = 0x20;
uint256 constant SignatureExpired_error_orderHash_ptr = 0x40;
uint256 constant SignatureExpired_error_length = 0x44;

/*
 *  error UnsupportedFunctionSelector()
 *    - Defined in SignedZoneEventsAndErrors.sol
 *  Memory layout:
 *    - 0x00: Left-padded selector (data begins at 0x1c)
 * Revert buffer is memory[0x1c:0x20]
 */
uint256 constant UnsupportedFunctionSelector_error_selector = 0x54c91b87;
uint256 constant UnsupportedFunctionSelector_error_length = 0x04;

// Zone parameter calldata pointers
uint256 constant Zone_parameters_cdPtr = 0x04;
uint256 constant Zone_parameters_fulfiller_cdPtr = 0x44;
uint256 constant Zone_consideration_head_cdPtr = 0xa4;
uint256 constant Zone_extraData_cdPtr = 0xc4;

// Zone parameter memory pointers
uint256 constant Zone_parameters_ptr = 0x20;

// Zone parameter offsets
uint256 constant Zone_parameters_offset = 0x24;
uint256 constant expectedFulfiller_offset = 0x45;
uint256 constant actualReceivedIdentifier_offset = 0x84;
uint256 constant expectedReceivedIdentifier_offset = 0xa2;

// Spent Item Size
uint256 constant SpentItem_size = 0x80;

// Received Item Size
uint256 constant ReceivedItem_size = 0xa0;

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

enum OrderType
// 0: no partial fills, anyone can execute
{
    FULL_OPEN,
    // 1: partial fills supported, anyone can execute
    PARTIAL_OPEN,
    // 2: no partial fills, only offerer or zone can execute
    FULL_RESTRICTED,
    // 3: partial fills supported, only offerer or zone can execute
    PARTIAL_RESTRICTED,
    // 4: contract order type
    CONTRACT
}

enum BasicOrderType
// 0: no partial fills, anyone can execute
{
    ETH_TO_ERC721_FULL_OPEN,
    // 1: partial fills supported, anyone can execute
    ETH_TO_ERC721_PARTIAL_OPEN,
    // 2: no partial fills, only offerer or zone can execute
    ETH_TO_ERC721_FULL_RESTRICTED,
    // 3: partial fills supported, only offerer or zone can execute
    ETH_TO_ERC721_PARTIAL_RESTRICTED,
    // 4: no partial fills, anyone can execute
    ETH_TO_ERC1155_FULL_OPEN,
    // 5: partial fills supported, anyone can execute
    ETH_TO_ERC1155_PARTIAL_OPEN,
    // 6: no partial fills, only offerer or zone can execute
    ETH_TO_ERC1155_FULL_RESTRICTED,
    // 7: partial fills supported, only offerer or zone can execute
    ETH_TO_ERC1155_PARTIAL_RESTRICTED,
    // 8: no partial fills, anyone can execute
    ERC20_TO_ERC721_FULL_OPEN,
    // 9: partial fills supported, anyone can execute
    ERC20_TO_ERC721_PARTIAL_OPEN,
    // 10: no partial fills, only offerer or zone can execute
    ERC20_TO_ERC721_FULL_RESTRICTED,
    // 11: partial fills supported, only offerer or zone can execute
    ERC20_TO_ERC721_PARTIAL_RESTRICTED,
    // 12: no partial fills, anyone can execute
    ERC20_TO_ERC1155_FULL_OPEN,
    // 13: partial fills supported, anyone can execute
    ERC20_TO_ERC1155_PARTIAL_OPEN,
    // 14: no partial fills, only offerer or zone can execute
    ERC20_TO_ERC1155_FULL_RESTRICTED,
    // 15: partial fills supported, only offerer or zone can execute
    ERC20_TO_ERC1155_PARTIAL_RESTRICTED,
    // 16: no partial fills, anyone can execute
    ERC721_TO_ERC20_FULL_OPEN,
    // 17: partial fills supported, anyone can execute
    ERC721_TO_ERC20_PARTIAL_OPEN,
    // 18: no partial fills, only offerer or zone can execute
    ERC721_TO_ERC20_FULL_RESTRICTED,
    // 19: partial fills supported, only offerer or zone can execute
    ERC721_TO_ERC20_PARTIAL_RESTRICTED,
    // 20: no partial fills, anyone can execute
    ERC1155_TO_ERC20_FULL_OPEN,
    // 21: partial fills supported, anyone can execute
    ERC1155_TO_ERC20_PARTIAL_OPEN,
    // 22: no partial fills, only offerer or zone can execute
    ERC1155_TO_ERC20_FULL_RESTRICTED,
    // 23: partial fills supported, only offerer or zone can execute
    ERC1155_TO_ERC20_PARTIAL_RESTRICTED
}

enum BasicOrderRouteType
// 0: provide Ether (or other native token) to receive offered ERC721 item.
{
    ETH_TO_ERC721,
    // 1: provide Ether (or other native token) to receive offered ERC1155 item.
    ETH_TO_ERC1155,
    // 2: provide ERC20 item to receive offered ERC721 item.
    ERC20_TO_ERC721,
    // 3: provide ERC20 item to receive offered ERC1155 item.
    ERC20_TO_ERC1155,
    // 4: provide ERC721 item to receive offered ERC20 item.
    ERC721_TO_ERC20,
    // 5: provide ERC1155 item to receive offered ERC20 item.
    ERC1155_TO_ERC20
}

enum ItemType
// 0: ETH on mainnet, MATIC on polygon, etc.
{
    NATIVE,
    // 1: ERC20 items (ERC777 and ERC20 analogues could also technically work)
    ERC20,
    // 2: ERC721 items
    ERC721,
    // 3: ERC1155 items
    ERC1155,
    // 4: ERC721 items where a number of tokenIds are supported
    ERC721_WITH_CRITERIA,
    // 5: ERC1155 items where a number of ids are supported
    ERC1155_WITH_CRITERIA
}

enum Side
// 0: Items that can be spent
{
    OFFER,
    // 1: Items that must be received
    CONSIDERATION
}

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

type CalldataPointer is uint256;

type ReturndataPointer is uint256;

type MemoryPointer is uint256;

using CalldataPointerLib for CalldataPointer global;
using MemoryPointerLib for MemoryPointer global;
using ReturndataPointerLib for ReturndataPointer global;

using CalldataReaders for CalldataPointer global;
using ReturndataReaders for ReturndataPointer global;
using MemoryReaders for MemoryPointer global;
using MemoryWriters for MemoryPointer global;

CalldataPointer constant CalldataStart = CalldataPointer.wrap(0x04);
MemoryPointer constant FreeMemoryPPtr = MemoryPointer.wrap(0x40);
MemoryPointer constant ZeroSlotPtr = MemoryPointer.wrap(0x60);
uint256 constant IdentityPrecompileAddress = 0x4;
uint256 constant OffsetOrLengthMask = 0xffffffff;
uint256 constant _OneWord = 0x20;
uint256 constant _FreeMemoryPointerSlot = 0x40;

/// @dev Allocates `size` bytes in memory by increasing the free memory pointer
///    and returns the memory pointer to the first byte of the allocated region.
// (Free functions cannot have visibility.)
// solhint-disable-next-line func-visibility
function malloc(uint256 size) pure returns (MemoryPointer mPtr) {
    assembly {
        mPtr := mload(_FreeMemoryPointerSlot)
        mstore(_FreeMemoryPointerSlot, add(mPtr, size))
    }
}

// (Free functions cannot have visibility.)
// solhint-disable-next-line func-visibility
function getFreeMemoryPointer() pure returns (MemoryPointer mPtr) {
    mPtr = FreeMemoryPPtr.readMemoryPointer();
}

// (Free functions cannot have visibility.)
// solhint-disable-next-line func-visibility
function setFreeMemoryPointer(MemoryPointer mPtr) pure {
    FreeMemoryPPtr.write(mPtr);
}

library CalldataPointerLib {
    function lt(CalldataPointer a, CalldataPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := lt(a, b)
        }
    }

    function gt(CalldataPointer a, CalldataPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := gt(a, b)
        }
    }

    function eq(CalldataPointer a, CalldataPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := eq(a, b)
        }
    }

    function isNull(CalldataPointer a) internal pure returns (bool b) {
        assembly {
            b := iszero(a)
        }
    }

    /// @dev Resolves an offset stored at `cdPtr + headOffset` to a calldata.
    ///      pointer `cdPtr` must point to some parent object with a dynamic
    ///      type's head stored at `cdPtr + headOffset`.
    function pptrOffset(CalldataPointer cdPtr, uint256 headOffset)
        internal
        pure
        returns (CalldataPointer cdPtrChild)
    {
        cdPtrChild = cdPtr.offset(
            cdPtr.offset(headOffset).readUint256() & OffsetOrLengthMask
        );
    }

    /// @dev Resolves an offset stored at `cdPtr` to a calldata pointer.
    ///      `cdPtr` must point to some parent object with a dynamic type as its
    ///      first member, e.g. `struct { bytes data; }`
    function pptr(CalldataPointer cdPtr)
        internal
        pure
        returns (CalldataPointer cdPtrChild)
    {
        cdPtrChild = cdPtr.offset(cdPtr.readUint256() & OffsetOrLengthMask);
    }

    /// @dev Returns the calldata pointer one word after `cdPtr`.
    function next(CalldataPointer cdPtr)
        internal
        pure
        returns (CalldataPointer cdPtrNext)
    {
        assembly {
            cdPtrNext := add(cdPtr, _OneWord)
        }
    }

    /// @dev Returns the calldata pointer `_offset` bytes after `cdPtr`.
    function offset(CalldataPointer cdPtr, uint256 _offset)
        internal
        pure
        returns (CalldataPointer cdPtrNext)
    {
        assembly {
            cdPtrNext := add(cdPtr, _offset)
        }
    }

    /// @dev Copies `size` bytes from calldata starting at `src` to memory at
    ///      `dst`.
    function copy(CalldataPointer src, MemoryPointer dst, uint256 size)
        internal
        pure
    {
        assembly {
            calldatacopy(dst, src, size)
        }
    }
}

library ReturndataPointerLib {
    function lt(ReturndataPointer a, ReturndataPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := lt(a, b)
        }
    }

    function gt(ReturndataPointer a, ReturndataPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := gt(a, b)
        }
    }

    function eq(ReturndataPointer a, ReturndataPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := eq(a, b)
        }
    }

    function isNull(ReturndataPointer a) internal pure returns (bool b) {
        assembly {
            b := iszero(a)
        }
    }

    /// @dev Resolves an offset stored at `rdPtr + headOffset` to a returndata
    ///      pointer. `rdPtr` must point to some parent object with a dynamic
    ///      type's head stored at `rdPtr + headOffset`.
    function pptrOffset(ReturndataPointer rdPtr, uint256 headOffset)
        internal
        pure
        returns (ReturndataPointer rdPtrChild)
    {
        rdPtrChild = rdPtr.offset(
            rdPtr.offset(headOffset).readUint256() & OffsetOrLengthMask
        );
    }

    /// @dev Resolves an offset stored at `rdPtr` to a returndata pointer.
    ///    `rdPtr` must point to some parent object with a dynamic type as its
    ///    first member, e.g. `struct { bytes data; }`
    function pptr(ReturndataPointer rdPtr)
        internal
        pure
        returns (ReturndataPointer rdPtrChild)
    {
        rdPtrChild = rdPtr.offset(rdPtr.readUint256() & OffsetOrLengthMask);
    }

    /// @dev Returns the returndata pointer one word after `cdPtr`.
    function next(ReturndataPointer rdPtr)
        internal
        pure
        returns (ReturndataPointer rdPtrNext)
    {
        assembly {
            rdPtrNext := add(rdPtr, _OneWord)
        }
    }

    /// @dev Returns the returndata pointer `_offset` bytes after `cdPtr`.
    function offset(ReturndataPointer rdPtr, uint256 _offset)
        internal
        pure
        returns (ReturndataPointer rdPtrNext)
    {
        assembly {
            rdPtrNext := add(rdPtr, _offset)
        }
    }

    /// @dev Copies `size` bytes from returndata starting at `src` to memory at
    /// `dst`.
    function copy(ReturndataPointer src, MemoryPointer dst, uint256 size)
        internal
        pure
    {
        assembly {
            returndatacopy(dst, src, size)
        }
    }
}

library MemoryPointerLib {
    function copy(MemoryPointer src, MemoryPointer dst, uint256 size)
        internal
        view
    {
        assembly {
            let success :=
                staticcall(gas(), IdentityPrecompileAddress, src, size, dst, size)
            if or(iszero(returndatasize()), iszero(success)) { revert(0, 0) }
        }
    }

    function lt(MemoryPointer a, MemoryPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := lt(a, b)
        }
    }

    function gt(MemoryPointer a, MemoryPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := gt(a, b)
        }
    }

    function eq(MemoryPointer a, MemoryPointer b)
        internal
        pure
        returns (bool c)
    {
        assembly {
            c := eq(a, b)
        }
    }

    function isNull(MemoryPointer a) internal pure returns (bool b) {
        assembly {
            b := iszero(a)
        }
    }

    function hash(MemoryPointer ptr, uint256 length)
        internal
        pure
        returns (bytes32 _hash)
    {
        assembly {
            _hash := keccak256(ptr, length)
        }
    }

    /// @dev Returns the memory pointer one word after `mPtr`.
    function next(MemoryPointer mPtr)
        internal
        pure
        returns (MemoryPointer mPtrNext)
    {
        assembly {
            mPtrNext := add(mPtr, _OneWord)
        }
    }

    /// @dev Returns the memory pointer `_offset` bytes after `mPtr`.
    function offset(MemoryPointer mPtr, uint256 _offset)
        internal
        pure
        returns (MemoryPointer mPtrNext)
    {
        assembly {
            mPtrNext := add(mPtr, _offset)
        }
    }

    /// @dev Resolves a pointer at `mPtr + headOffset` to a memory
    ///    pointer. `mPtr` must point to some parent object with a dynamic
    ///    type's pointer stored at `mPtr + headOffset`.
    function pptrOffset(MemoryPointer mPtr, uint256 headOffset)
        internal
        pure
        returns (MemoryPointer mPtrChild)
    {
        mPtrChild = mPtr.offset(headOffset).readMemoryPointer();
    }

    /// @dev Resolves a pointer stored at `mPtr` to a memory pointer.
    ///    `mPtr` must point to some parent object with a dynamic type as its
    ///    first member, e.g. `struct { bytes data; }`
    function pptr(MemoryPointer mPtr)
        internal
        pure
        returns (MemoryPointer mPtrChild)
    {
        mPtrChild = mPtr.readMemoryPointer();
    }
}

library CalldataReaders {
    /// @dev Reads the value at `cdPtr` and applies a mask to return only the
    ///    last 4 bytes.
    function readMaskedUint256(CalldataPointer cdPtr)
        internal
        pure
        returns (uint256 value)
    {
        value = cdPtr.readUint256() & OffsetOrLengthMask;
    }

    /// @dev Reads the bool at `cdPtr` in calldata.
    function readBool(CalldataPointer cdPtr)
        internal
        pure
        returns (bool value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the address at `cdPtr` in calldata.
    function readAddress(CalldataPointer cdPtr)
        internal
        pure
        returns (address value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes1 at `cdPtr` in calldata.
    function readBytes1(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes1 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes2 at `cdPtr` in calldata.
    function readBytes2(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes2 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes3 at `cdPtr` in calldata.
    function readBytes3(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes3 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes4 at `cdPtr` in calldata.
    function readBytes4(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes4 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes5 at `cdPtr` in calldata.
    function readBytes5(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes5 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes6 at `cdPtr` in calldata.
    function readBytes6(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes6 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes7 at `cdPtr` in calldata.
    function readBytes7(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes7 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes8 at `cdPtr` in calldata.
    function readBytes8(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes8 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes9 at `cdPtr` in calldata.
    function readBytes9(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes9 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes10 at `cdPtr` in calldata.
    function readBytes10(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes10 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes11 at `cdPtr` in calldata.
    function readBytes11(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes11 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes12 at `cdPtr` in calldata.
    function readBytes12(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes12 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes13 at `cdPtr` in calldata.
    function readBytes13(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes13 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes14 at `cdPtr` in calldata.
    function readBytes14(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes14 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes15 at `cdPtr` in calldata.
    function readBytes15(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes15 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes16 at `cdPtr` in calldata.
    function readBytes16(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes16 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes17 at `cdPtr` in calldata.
    function readBytes17(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes17 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes18 at `cdPtr` in calldata.
    function readBytes18(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes18 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes19 at `cdPtr` in calldata.
    function readBytes19(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes19 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes20 at `cdPtr` in calldata.
    function readBytes20(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes20 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes21 at `cdPtr` in calldata.
    function readBytes21(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes21 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes22 at `cdPtr` in calldata.
    function readBytes22(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes22 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes23 at `cdPtr` in calldata.
    function readBytes23(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes23 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes24 at `cdPtr` in calldata.
    function readBytes24(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes24 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes25 at `cdPtr` in calldata.
    function readBytes25(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes25 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes26 at `cdPtr` in calldata.
    function readBytes26(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes26 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes27 at `cdPtr` in calldata.
    function readBytes27(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes27 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes28 at `cdPtr` in calldata.
    function readBytes28(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes28 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes29 at `cdPtr` in calldata.
    function readBytes29(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes29 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes30 at `cdPtr` in calldata.
    function readBytes30(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes30 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes31 at `cdPtr` in calldata.
    function readBytes31(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes31 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the bytes32 at `cdPtr` in calldata.
    function readBytes32(CalldataPointer cdPtr)
        internal
        pure
        returns (bytes32 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint8 at `cdPtr` in calldata.
    function readUint8(CalldataPointer cdPtr)
        internal
        pure
        returns (uint8 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint16 at `cdPtr` in calldata.
    function readUint16(CalldataPointer cdPtr)
        internal
        pure
        returns (uint16 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint24 at `cdPtr` in calldata.
    function readUint24(CalldataPointer cdPtr)
        internal
        pure
        returns (uint24 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint32 at `cdPtr` in calldata.
    function readUint32(CalldataPointer cdPtr)
        internal
        pure
        returns (uint32 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint40 at `cdPtr` in calldata.
    function readUint40(CalldataPointer cdPtr)
        internal
        pure
        returns (uint40 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint48 at `cdPtr` in calldata.
    function readUint48(CalldataPointer cdPtr)
        internal
        pure
        returns (uint48 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint56 at `cdPtr` in calldata.
    function readUint56(CalldataPointer cdPtr)
        internal
        pure
        returns (uint56 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint64 at `cdPtr` in calldata.
    function readUint64(CalldataPointer cdPtr)
        internal
        pure
        returns (uint64 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint72 at `cdPtr` in calldata.
    function readUint72(CalldataPointer cdPtr)
        internal
        pure
        returns (uint72 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint80 at `cdPtr` in calldata.
    function readUint80(CalldataPointer cdPtr)
        internal
        pure
        returns (uint80 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint88 at `cdPtr` in calldata.
    function readUint88(CalldataPointer cdPtr)
        internal
        pure
        returns (uint88 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint96 at `cdPtr` in calldata.
    function readUint96(CalldataPointer cdPtr)
        internal
        pure
        returns (uint96 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint104 at `cdPtr` in calldata.
    function readUint104(CalldataPointer cdPtr)
        internal
        pure
        returns (uint104 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint112 at `cdPtr` in calldata.
    function readUint112(CalldataPointer cdPtr)
        internal
        pure
        returns (uint112 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint120 at `cdPtr` in calldata.
    function readUint120(CalldataPointer cdPtr)
        internal
        pure
        returns (uint120 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint128 at `cdPtr` in calldata.
    function readUint128(CalldataPointer cdPtr)
        internal
        pure
        returns (uint128 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint136 at `cdPtr` in calldata.
    function readUint136(CalldataPointer cdPtr)
        internal
        pure
        returns (uint136 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint144 at `cdPtr` in calldata.
    function readUint144(CalldataPointer cdPtr)
        internal
        pure
        returns (uint144 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint152 at `cdPtr` in calldata.
    function readUint152(CalldataPointer cdPtr)
        internal
        pure
        returns (uint152 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint160 at `cdPtr` in calldata.
    function readUint160(CalldataPointer cdPtr)
        internal
        pure
        returns (uint160 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint168 at `cdPtr` in calldata.
    function readUint168(CalldataPointer cdPtr)
        internal
        pure
        returns (uint168 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint176 at `cdPtr` in calldata.
    function readUint176(CalldataPointer cdPtr)
        internal
        pure
        returns (uint176 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint184 at `cdPtr` in calldata.
    function readUint184(CalldataPointer cdPtr)
        internal
        pure
        returns (uint184 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint192 at `cdPtr` in calldata.
    function readUint192(CalldataPointer cdPtr)
        internal
        pure
        returns (uint192 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint200 at `cdPtr` in calldata.
    function readUint200(CalldataPointer cdPtr)
        internal
        pure
        returns (uint200 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint208 at `cdPtr` in calldata.
    function readUint208(CalldataPointer cdPtr)
        internal
        pure
        returns (uint208 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint216 at `cdPtr` in calldata.
    function readUint216(CalldataPointer cdPtr)
        internal
        pure
        returns (uint216 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint224 at `cdPtr` in calldata.
    function readUint224(CalldataPointer cdPtr)
        internal
        pure
        returns (uint224 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint232 at `cdPtr` in calldata.
    function readUint232(CalldataPointer cdPtr)
        internal
        pure
        returns (uint232 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint240 at `cdPtr` in calldata.
    function readUint240(CalldataPointer cdPtr)
        internal
        pure
        returns (uint240 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint248 at `cdPtr` in calldata.
    function readUint248(CalldataPointer cdPtr)
        internal
        pure
        returns (uint248 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the uint256 at `cdPtr` in calldata.
    function readUint256(CalldataPointer cdPtr)
        internal
        pure
        returns (uint256 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int8 at `cdPtr` in calldata.
    function readInt8(CalldataPointer cdPtr)
        internal
        pure
        returns (int8 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int16 at `cdPtr` in calldata.
    function readInt16(CalldataPointer cdPtr)
        internal
        pure
        returns (int16 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int24 at `cdPtr` in calldata.
    function readInt24(CalldataPointer cdPtr)
        internal
        pure
        returns (int24 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int32 at `cdPtr` in calldata.
    function readInt32(CalldataPointer cdPtr)
        internal
        pure
        returns (int32 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int40 at `cdPtr` in calldata.
    function readInt40(CalldataPointer cdPtr)
        internal
        pure
        returns (int40 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int48 at `cdPtr` in calldata.
    function readInt48(CalldataPointer cdPtr)
        internal
        pure
        returns (int48 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int56 at `cdPtr` in calldata.
    function readInt56(CalldataPointer cdPtr)
        internal
        pure
        returns (int56 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int64 at `cdPtr` in calldata.
    function readInt64(CalldataPointer cdPtr)
        internal
        pure
        returns (int64 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int72 at `cdPtr` in calldata.
    function readInt72(CalldataPointer cdPtr)
        internal
        pure
        returns (int72 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int80 at `cdPtr` in calldata.
    function readInt80(CalldataPointer cdPtr)
        internal
        pure
        returns (int80 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int88 at `cdPtr` in calldata.
    function readInt88(CalldataPointer cdPtr)
        internal
        pure
        returns (int88 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int96 at `cdPtr` in calldata.
    function readInt96(CalldataPointer cdPtr)
        internal
        pure
        returns (int96 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int104 at `cdPtr` in calldata.
    function readInt104(CalldataPointer cdPtr)
        internal
        pure
        returns (int104 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int112 at `cdPtr` in calldata.
    function readInt112(CalldataPointer cdPtr)
        internal
        pure
        returns (int112 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int120 at `cdPtr` in calldata.
    function readInt120(CalldataPointer cdPtr)
        internal
        pure
        returns (int120 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int128 at `cdPtr` in calldata.
    function readInt128(CalldataPointer cdPtr)
        internal
        pure
        returns (int128 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int136 at `cdPtr` in calldata.
    function readInt136(CalldataPointer cdPtr)
        internal
        pure
        returns (int136 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int144 at `cdPtr` in calldata.
    function readInt144(CalldataPointer cdPtr)
        internal
        pure
        returns (int144 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int152 at `cdPtr` in calldata.
    function readInt152(CalldataPointer cdPtr)
        internal
        pure
        returns (int152 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int160 at `cdPtr` in calldata.
    function readInt160(CalldataPointer cdPtr)
        internal
        pure
        returns (int160 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int168 at `cdPtr` in calldata.
    function readInt168(CalldataPointer cdPtr)
        internal
        pure
        returns (int168 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int176 at `cdPtr` in calldata.
    function readInt176(CalldataPointer cdPtr)
        internal
        pure
        returns (int176 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int184 at `cdPtr` in calldata.
    function readInt184(CalldataPointer cdPtr)
        internal
        pure
        returns (int184 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int192 at `cdPtr` in calldata.
    function readInt192(CalldataPointer cdPtr)
        internal
        pure
        returns (int192 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int200 at `cdPtr` in calldata.
    function readInt200(CalldataPointer cdPtr)
        internal
        pure
        returns (int200 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int208 at `cdPtr` in calldata.
    function readInt208(CalldataPointer cdPtr)
        internal
        pure
        returns (int208 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int216 at `cdPtr` in calldata.
    function readInt216(CalldataPointer cdPtr)
        internal
        pure
        returns (int216 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int224 at `cdPtr` in calldata.
    function readInt224(CalldataPointer cdPtr)
        internal
        pure
        returns (int224 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int232 at `cdPtr` in calldata.
    function readInt232(CalldataPointer cdPtr)
        internal
        pure
        returns (int232 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int240 at `cdPtr` in calldata.
    function readInt240(CalldataPointer cdPtr)
        internal
        pure
        returns (int240 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int248 at `cdPtr` in calldata.
    function readInt248(CalldataPointer cdPtr)
        internal
        pure
        returns (int248 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }

    /// @dev Reads the int256 at `cdPtr` in calldata.
    function readInt256(CalldataPointer cdPtr)
        internal
        pure
        returns (int256 value)
    {
        assembly {
            value := calldataload(cdPtr)
        }
    }
}

library ReturndataReaders {
    /// @dev Reads value at `rdPtr` & applies a mask to return only last 4 bytes
    function readMaskedUint256(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint256 value)
    {
        value = rdPtr.readUint256() & OffsetOrLengthMask;
    }

    /// @dev Reads the bool at `rdPtr` in returndata.
    function readBool(ReturndataPointer rdPtr)
        internal
        pure
        returns (bool value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the address at `rdPtr` in returndata.
    function readAddress(ReturndataPointer rdPtr)
        internal
        pure
        returns (address value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes1 at `rdPtr` in returndata.
    function readBytes1(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes1 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes2 at `rdPtr` in returndata.
    function readBytes2(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes2 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes3 at `rdPtr` in returndata.
    function readBytes3(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes3 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes4 at `rdPtr` in returndata.
    function readBytes4(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes4 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes5 at `rdPtr` in returndata.
    function readBytes5(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes5 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes6 at `rdPtr` in returndata.
    function readBytes6(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes6 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes7 at `rdPtr` in returndata.
    function readBytes7(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes7 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes8 at `rdPtr` in returndata.
    function readBytes8(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes8 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes9 at `rdPtr` in returndata.
    function readBytes9(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes9 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes10 at `rdPtr` in returndata.
    function readBytes10(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes10 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes11 at `rdPtr` in returndata.
    function readBytes11(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes11 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes12 at `rdPtr` in returndata.
    function readBytes12(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes12 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes13 at `rdPtr` in returndata.
    function readBytes13(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes13 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes14 at `rdPtr` in returndata.
    function readBytes14(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes14 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes15 at `rdPtr` in returndata.
    function readBytes15(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes15 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes16 at `rdPtr` in returndata.
    function readBytes16(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes16 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes17 at `rdPtr` in returndata.
    function readBytes17(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes17 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes18 at `rdPtr` in returndata.
    function readBytes18(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes18 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes19 at `rdPtr` in returndata.
    function readBytes19(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes19 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes20 at `rdPtr` in returndata.
    function readBytes20(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes20 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes21 at `rdPtr` in returndata.
    function readBytes21(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes21 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes22 at `rdPtr` in returndata.
    function readBytes22(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes22 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes23 at `rdPtr` in returndata.
    function readBytes23(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes23 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes24 at `rdPtr` in returndata.
    function readBytes24(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes24 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes25 at `rdPtr` in returndata.
    function readBytes25(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes25 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes26 at `rdPtr` in returndata.
    function readBytes26(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes26 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes27 at `rdPtr` in returndata.
    function readBytes27(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes27 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes28 at `rdPtr` in returndata.
    function readBytes28(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes28 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes29 at `rdPtr` in returndata.
    function readBytes29(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes29 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes30 at `rdPtr` in returndata.
    function readBytes30(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes30 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes31 at `rdPtr` in returndata.
    function readBytes31(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes31 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the bytes32 at `rdPtr` in returndata.
    function readBytes32(ReturndataPointer rdPtr)
        internal
        pure
        returns (bytes32 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint8 at `rdPtr` in returndata.
    function readUint8(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint8 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint16 at `rdPtr` in returndata.
    function readUint16(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint16 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint24 at `rdPtr` in returndata.
    function readUint24(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint24 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint32 at `rdPtr` in returndata.
    function readUint32(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint32 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint40 at `rdPtr` in returndata.
    function readUint40(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint40 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint48 at `rdPtr` in returndata.
    function readUint48(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint48 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint56 at `rdPtr` in returndata.
    function readUint56(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint56 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint64 at `rdPtr` in returndata.
    function readUint64(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint64 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint72 at `rdPtr` in returndata.
    function readUint72(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint72 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint80 at `rdPtr` in returndata.
    function readUint80(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint80 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint88 at `rdPtr` in returndata.
    function readUint88(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint88 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint96 at `rdPtr` in returndata.
    function readUint96(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint96 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint104 at `rdPtr` in returndata.
    function readUint104(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint104 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint112 at `rdPtr` in returndata.
    function readUint112(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint112 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint120 at `rdPtr` in returndata.
    function readUint120(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint120 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint128 at `rdPtr` in returndata.
    function readUint128(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint128 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint136 at `rdPtr` in returndata.
    function readUint136(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint136 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint144 at `rdPtr` in returndata.
    function readUint144(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint144 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint152 at `rdPtr` in returndata.
    function readUint152(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint152 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint160 at `rdPtr` in returndata.
    function readUint160(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint160 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint168 at `rdPtr` in returndata.
    function readUint168(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint168 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint176 at `rdPtr` in returndata.
    function readUint176(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint176 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint184 at `rdPtr` in returndata.
    function readUint184(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint184 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint192 at `rdPtr` in returndata.
    function readUint192(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint192 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint200 at `rdPtr` in returndata.
    function readUint200(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint200 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint208 at `rdPtr` in returndata.
    function readUint208(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint208 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint216 at `rdPtr` in returndata.
    function readUint216(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint216 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint224 at `rdPtr` in returndata.
    function readUint224(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint224 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint232 at `rdPtr` in returndata.
    function readUint232(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint232 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint240 at `rdPtr` in returndata.
    function readUint240(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint240 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint248 at `rdPtr` in returndata.
    function readUint248(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint248 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the uint256 at `rdPtr` in returndata.
    function readUint256(ReturndataPointer rdPtr)
        internal
        pure
        returns (uint256 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int8 at `rdPtr` in returndata.
    function readInt8(ReturndataPointer rdPtr)
        internal
        pure
        returns (int8 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int16 at `rdPtr` in returndata.
    function readInt16(ReturndataPointer rdPtr)
        internal
        pure
        returns (int16 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int24 at `rdPtr` in returndata.
    function readInt24(ReturndataPointer rdPtr)
        internal
        pure
        returns (int24 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int32 at `rdPtr` in returndata.
    function readInt32(ReturndataPointer rdPtr)
        internal
        pure
        returns (int32 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int40 at `rdPtr` in returndata.
    function readInt40(ReturndataPointer rdPtr)
        internal
        pure
        returns (int40 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int48 at `rdPtr` in returndata.
    function readInt48(ReturndataPointer rdPtr)
        internal
        pure
        returns (int48 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int56 at `rdPtr` in returndata.
    function readInt56(ReturndataPointer rdPtr)
        internal
        pure
        returns (int56 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int64 at `rdPtr` in returndata.
    function readInt64(ReturndataPointer rdPtr)
        internal
        pure
        returns (int64 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int72 at `rdPtr` in returndata.
    function readInt72(ReturndataPointer rdPtr)
        internal
        pure
        returns (int72 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int80 at `rdPtr` in returndata.
    function readInt80(ReturndataPointer rdPtr)
        internal
        pure
        returns (int80 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int88 at `rdPtr` in returndata.
    function readInt88(ReturndataPointer rdPtr)
        internal
        pure
        returns (int88 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int96 at `rdPtr` in returndata.
    function readInt96(ReturndataPointer rdPtr)
        internal
        pure
        returns (int96 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int104 at `rdPtr` in returndata.
    function readInt104(ReturndataPointer rdPtr)
        internal
        pure
        returns (int104 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int112 at `rdPtr` in returndata.
    function readInt112(ReturndataPointer rdPtr)
        internal
        pure
        returns (int112 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int120 at `rdPtr` in returndata.
    function readInt120(ReturndataPointer rdPtr)
        internal
        pure
        returns (int120 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int128 at `rdPtr` in returndata.
    function readInt128(ReturndataPointer rdPtr)
        internal
        pure
        returns (int128 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int136 at `rdPtr` in returndata.
    function readInt136(ReturndataPointer rdPtr)
        internal
        pure
        returns (int136 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int144 at `rdPtr` in returndata.
    function readInt144(ReturndataPointer rdPtr)
        internal
        pure
        returns (int144 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int152 at `rdPtr` in returndata.
    function readInt152(ReturndataPointer rdPtr)
        internal
        pure
        returns (int152 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int160 at `rdPtr` in returndata.
    function readInt160(ReturndataPointer rdPtr)
        internal
        pure
        returns (int160 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int168 at `rdPtr` in returndata.
    function readInt168(ReturndataPointer rdPtr)
        internal
        pure
        returns (int168 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int176 at `rdPtr` in returndata.
    function readInt176(ReturndataPointer rdPtr)
        internal
        pure
        returns (int176 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int184 at `rdPtr` in returndata.
    function readInt184(ReturndataPointer rdPtr)
        internal
        pure
        returns (int184 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int192 at `rdPtr` in returndata.
    function readInt192(ReturndataPointer rdPtr)
        internal
        pure
        returns (int192 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int200 at `rdPtr` in returndata.
    function readInt200(ReturndataPointer rdPtr)
        internal
        pure
        returns (int200 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int208 at `rdPtr` in returndata.
    function readInt208(ReturndataPointer rdPtr)
        internal
        pure
        returns (int208 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int216 at `rdPtr` in returndata.
    function readInt216(ReturndataPointer rdPtr)
        internal
        pure
        returns (int216 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int224 at `rdPtr` in returndata.
    function readInt224(ReturndataPointer rdPtr)
        internal
        pure
        returns (int224 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int232 at `rdPtr` in returndata.
    function readInt232(ReturndataPointer rdPtr)
        internal
        pure
        returns (int232 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int240 at `rdPtr` in returndata.
    function readInt240(ReturndataPointer rdPtr)
        internal
        pure
        returns (int240 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int248 at `rdPtr` in returndata.
    function readInt248(ReturndataPointer rdPtr)
        internal
        pure
        returns (int248 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }

    /// @dev Reads the int256 at `rdPtr` in returndata.
    function readInt256(ReturndataPointer rdPtr)
        internal
        pure
        returns (int256 value)
    {
        assembly {
            returndatacopy(0, rdPtr, _OneWord)
            value := mload(0)
        }
    }
}

library MemoryReaders {
    /// @dev Reads the memory pointer at `mPtr` in memory.
    function readMemoryPointer(MemoryPointer mPtr)
        internal
        pure
        returns (MemoryPointer value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads value at `mPtr` & applies a mask to return only last 4 bytes
    function readMaskedUint256(MemoryPointer mPtr)
        internal
        pure
        returns (uint256 value)
    {
        value = mPtr.readUint256() & OffsetOrLengthMask;
    }

    /// @dev Reads the bool at `mPtr` in memory.
    function readBool(MemoryPointer mPtr) internal pure returns (bool value) {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the address at `mPtr` in memory.
    function readAddress(MemoryPointer mPtr)
        internal
        pure
        returns (address value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes1 at `mPtr` in memory.
    function readBytes1(MemoryPointer mPtr)
        internal
        pure
        returns (bytes1 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes2 at `mPtr` in memory.
    function readBytes2(MemoryPointer mPtr)
        internal
        pure
        returns (bytes2 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes3 at `mPtr` in memory.
    function readBytes3(MemoryPointer mPtr)
        internal
        pure
        returns (bytes3 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes4 at `mPtr` in memory.
    function readBytes4(MemoryPointer mPtr)
        internal
        pure
        returns (bytes4 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes5 at `mPtr` in memory.
    function readBytes5(MemoryPointer mPtr)
        internal
        pure
        returns (bytes5 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes6 at `mPtr` in memory.
    function readBytes6(MemoryPointer mPtr)
        internal
        pure
        returns (bytes6 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes7 at `mPtr` in memory.
    function readBytes7(MemoryPointer mPtr)
        internal
        pure
        returns (bytes7 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes8 at `mPtr` in memory.
    function readBytes8(MemoryPointer mPtr)
        internal
        pure
        returns (bytes8 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes9 at `mPtr` in memory.
    function readBytes9(MemoryPointer mPtr)
        internal
        pure
        returns (bytes9 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes10 at `mPtr` in memory.
    function readBytes10(MemoryPointer mPtr)
        internal
        pure
        returns (bytes10 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes11 at `mPtr` in memory.
    function readBytes11(MemoryPointer mPtr)
        internal
        pure
        returns (bytes11 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes12 at `mPtr` in memory.
    function readBytes12(MemoryPointer mPtr)
        internal
        pure
        returns (bytes12 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes13 at `mPtr` in memory.
    function readBytes13(MemoryPointer mPtr)
        internal
        pure
        returns (bytes13 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes14 at `mPtr` in memory.
    function readBytes14(MemoryPointer mPtr)
        internal
        pure
        returns (bytes14 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes15 at `mPtr` in memory.
    function readBytes15(MemoryPointer mPtr)
        internal
        pure
        returns (bytes15 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes16 at `mPtr` in memory.
    function readBytes16(MemoryPointer mPtr)
        internal
        pure
        returns (bytes16 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes17 at `mPtr` in memory.
    function readBytes17(MemoryPointer mPtr)
        internal
        pure
        returns (bytes17 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes18 at `mPtr` in memory.
    function readBytes18(MemoryPointer mPtr)
        internal
        pure
        returns (bytes18 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes19 at `mPtr` in memory.
    function readBytes19(MemoryPointer mPtr)
        internal
        pure
        returns (bytes19 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes20 at `mPtr` in memory.
    function readBytes20(MemoryPointer mPtr)
        internal
        pure
        returns (bytes20 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes21 at `mPtr` in memory.
    function readBytes21(MemoryPointer mPtr)
        internal
        pure
        returns (bytes21 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes22 at `mPtr` in memory.
    function readBytes22(MemoryPointer mPtr)
        internal
        pure
        returns (bytes22 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes23 at `mPtr` in memory.
    function readBytes23(MemoryPointer mPtr)
        internal
        pure
        returns (bytes23 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes24 at `mPtr` in memory.
    function readBytes24(MemoryPointer mPtr)
        internal
        pure
        returns (bytes24 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes25 at `mPtr` in memory.
    function readBytes25(MemoryPointer mPtr)
        internal
        pure
        returns (bytes25 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes26 at `mPtr` in memory.
    function readBytes26(MemoryPointer mPtr)
        internal
        pure
        returns (bytes26 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes27 at `mPtr` in memory.
    function readBytes27(MemoryPointer mPtr)
        internal
        pure
        returns (bytes27 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes28 at `mPtr` in memory.
    function readBytes28(MemoryPointer mPtr)
        internal
        pure
        returns (bytes28 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes29 at `mPtr` in memory.
    function readBytes29(MemoryPointer mPtr)
        internal
        pure
        returns (bytes29 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes30 at `mPtr` in memory.
    function readBytes30(MemoryPointer mPtr)
        internal
        pure
        returns (bytes30 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes31 at `mPtr` in memory.
    function readBytes31(MemoryPointer mPtr)
        internal
        pure
        returns (bytes31 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the bytes32 at `mPtr` in memory.
    function readBytes32(MemoryPointer mPtr)
        internal
        pure
        returns (bytes32 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint8 at `mPtr` in memory.
    function readUint8(MemoryPointer mPtr)
        internal
        pure
        returns (uint8 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint16 at `mPtr` in memory.
    function readUint16(MemoryPointer mPtr)
        internal
        pure
        returns (uint16 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint24 at `mPtr` in memory.
    function readUint24(MemoryPointer mPtr)
        internal
        pure
        returns (uint24 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint32 at `mPtr` in memory.
    function readUint32(MemoryPointer mPtr)
        internal
        pure
        returns (uint32 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint40 at `mPtr` in memory.
    function readUint40(MemoryPointer mPtr)
        internal
        pure
        returns (uint40 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint48 at `mPtr` in memory.
    function readUint48(MemoryPointer mPtr)
        internal
        pure
        returns (uint48 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint56 at `mPtr` in memory.
    function readUint56(MemoryPointer mPtr)
        internal
        pure
        returns (uint56 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint64 at `mPtr` in memory.
    function readUint64(MemoryPointer mPtr)
        internal
        pure
        returns (uint64 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint72 at `mPtr` in memory.
    function readUint72(MemoryPointer mPtr)
        internal
        pure
        returns (uint72 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint80 at `mPtr` in memory.
    function readUint80(MemoryPointer mPtr)
        internal
        pure
        returns (uint80 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint88 at `mPtr` in memory.
    function readUint88(MemoryPointer mPtr)
        internal
        pure
        returns (uint88 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint96 at `mPtr` in memory.
    function readUint96(MemoryPointer mPtr)
        internal
        pure
        returns (uint96 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint104 at `mPtr` in memory.
    function readUint104(MemoryPointer mPtr)
        internal
        pure
        returns (uint104 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint112 at `mPtr` in memory.
    function readUint112(MemoryPointer mPtr)
        internal
        pure
        returns (uint112 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint120 at `mPtr` in memory.
    function readUint120(MemoryPointer mPtr)
        internal
        pure
        returns (uint120 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint128 at `mPtr` in memory.
    function readUint128(MemoryPointer mPtr)
        internal
        pure
        returns (uint128 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint136 at `mPtr` in memory.
    function readUint136(MemoryPointer mPtr)
        internal
        pure
        returns (uint136 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint144 at `mPtr` in memory.
    function readUint144(MemoryPointer mPtr)
        internal
        pure
        returns (uint144 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint152 at `mPtr` in memory.
    function readUint152(MemoryPointer mPtr)
        internal
        pure
        returns (uint152 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint160 at `mPtr` in memory.
    function readUint160(MemoryPointer mPtr)
        internal
        pure
        returns (uint160 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint168 at `mPtr` in memory.
    function readUint168(MemoryPointer mPtr)
        internal
        pure
        returns (uint168 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint176 at `mPtr` in memory.
    function readUint176(MemoryPointer mPtr)
        internal
        pure
        returns (uint176 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint184 at `mPtr` in memory.
    function readUint184(MemoryPointer mPtr)
        internal
        pure
        returns (uint184 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint192 at `mPtr` in memory.
    function readUint192(MemoryPointer mPtr)
        internal
        pure
        returns (uint192 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint200 at `mPtr` in memory.
    function readUint200(MemoryPointer mPtr)
        internal
        pure
        returns (uint200 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint208 at `mPtr` in memory.
    function readUint208(MemoryPointer mPtr)
        internal
        pure
        returns (uint208 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint216 at `mPtr` in memory.
    function readUint216(MemoryPointer mPtr)
        internal
        pure
        returns (uint216 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint224 at `mPtr` in memory.
    function readUint224(MemoryPointer mPtr)
        internal
        pure
        returns (uint224 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint232 at `mPtr` in memory.
    function readUint232(MemoryPointer mPtr)
        internal
        pure
        returns (uint232 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint240 at `mPtr` in memory.
    function readUint240(MemoryPointer mPtr)
        internal
        pure
        returns (uint240 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint248 at `mPtr` in memory.
    function readUint248(MemoryPointer mPtr)
        internal
        pure
        returns (uint248 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the uint256 at `mPtr` in memory.
    function readUint256(MemoryPointer mPtr)
        internal
        pure
        returns (uint256 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int8 at `mPtr` in memory.
    function readInt8(MemoryPointer mPtr) internal pure returns (int8 value) {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int16 at `mPtr` in memory.
    function readInt16(MemoryPointer mPtr)
        internal
        pure
        returns (int16 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int24 at `mPtr` in memory.
    function readInt24(MemoryPointer mPtr)
        internal
        pure
        returns (int24 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int32 at `mPtr` in memory.
    function readInt32(MemoryPointer mPtr)
        internal
        pure
        returns (int32 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int40 at `mPtr` in memory.
    function readInt40(MemoryPointer mPtr)
        internal
        pure
        returns (int40 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int48 at `mPtr` in memory.
    function readInt48(MemoryPointer mPtr)
        internal
        pure
        returns (int48 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int56 at `mPtr` in memory.
    function readInt56(MemoryPointer mPtr)
        internal
        pure
        returns (int56 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int64 at `mPtr` in memory.
    function readInt64(MemoryPointer mPtr)
        internal
        pure
        returns (int64 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int72 at `mPtr` in memory.
    function readInt72(MemoryPointer mPtr)
        internal
        pure
        returns (int72 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int80 at `mPtr` in memory.
    function readInt80(MemoryPointer mPtr)
        internal
        pure
        returns (int80 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int88 at `mPtr` in memory.
    function readInt88(MemoryPointer mPtr)
        internal
        pure
        returns (int88 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int96 at `mPtr` in memory.
    function readInt96(MemoryPointer mPtr)
        internal
        pure
        returns (int96 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int104 at `mPtr` in memory.
    function readInt104(MemoryPointer mPtr)
        internal
        pure
        returns (int104 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int112 at `mPtr` in memory.
    function readInt112(MemoryPointer mPtr)
        internal
        pure
        returns (int112 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int120 at `mPtr` in memory.
    function readInt120(MemoryPointer mPtr)
        internal
        pure
        returns (int120 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int128 at `mPtr` in memory.
    function readInt128(MemoryPointer mPtr)
        internal
        pure
        returns (int128 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int136 at `mPtr` in memory.
    function readInt136(MemoryPointer mPtr)
        internal
        pure
        returns (int136 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int144 at `mPtr` in memory.
    function readInt144(MemoryPointer mPtr)
        internal
        pure
        returns (int144 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int152 at `mPtr` in memory.
    function readInt152(MemoryPointer mPtr)
        internal
        pure
        returns (int152 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int160 at `mPtr` in memory.
    function readInt160(MemoryPointer mPtr)
        internal
        pure
        returns (int160 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int168 at `mPtr` in memory.
    function readInt168(MemoryPointer mPtr)
        internal
        pure
        returns (int168 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int176 at `mPtr` in memory.
    function readInt176(MemoryPointer mPtr)
        internal
        pure
        returns (int176 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int184 at `mPtr` in memory.
    function readInt184(MemoryPointer mPtr)
        internal
        pure
        returns (int184 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int192 at `mPtr` in memory.
    function readInt192(MemoryPointer mPtr)
        internal
        pure
        returns (int192 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int200 at `mPtr` in memory.
    function readInt200(MemoryPointer mPtr)
        internal
        pure
        returns (int200 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int208 at `mPtr` in memory.
    function readInt208(MemoryPointer mPtr)
        internal
        pure
        returns (int208 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int216 at `mPtr` in memory.
    function readInt216(MemoryPointer mPtr)
        internal
        pure
        returns (int216 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int224 at `mPtr` in memory.
    function readInt224(MemoryPointer mPtr)
        internal
        pure
        returns (int224 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int232 at `mPtr` in memory.
    function readInt232(MemoryPointer mPtr)
        internal
        pure
        returns (int232 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int240 at `mPtr` in memory.
    function readInt240(MemoryPointer mPtr)
        internal
        pure
        returns (int240 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int248 at `mPtr` in memory.
    function readInt248(MemoryPointer mPtr)
        internal
        pure
        returns (int248 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }

    /// @dev Reads the int256 at `mPtr` in memory.
    function readInt256(MemoryPointer mPtr)
        internal
        pure
        returns (int256 value)
    {
        assembly {
            value := mload(mPtr)
        }
    }
}

library MemoryWriters {
    /// @dev Writes `valuePtr` to memory at `mPtr`.
    function write(MemoryPointer mPtr, MemoryPointer valuePtr) internal pure {
        assembly {
            mstore(mPtr, valuePtr)
        }
    }

    /// @dev Writes a boolean `value` to `mPtr` in memory.
    function write(MemoryPointer mPtr, bool value) internal pure {
        assembly {
            mstore(mPtr, value)
        }
    }

    /// @dev Writes an address `value` to `mPtr` in memory.
    function write(MemoryPointer mPtr, address value) internal pure {
        assembly {
            mstore(mPtr, value)
        }
    }

    /// @dev Writes a bytes32 `value` to `mPtr` in memory.
    /// Separate name to disambiguate literal write parameters.
    function writeBytes32(MemoryPointer mPtr, bytes32 value) internal pure {
        assembly {
            mstore(mPtr, value)
        }
    }

    /// @dev Writes a uint256 `value` to `mPtr` in memory.
    function write(MemoryPointer mPtr, uint256 value) internal pure {
        assembly {
            mstore(mPtr, value)
        }
    }

    /// @dev Writes an int256 `value` to `mPtr` in memory.
    /// Separate name to disambiguate literal write parameters.
    function writeInt(MemoryPointer mPtr, int256 value) internal pure {
        assembly {
            mstore(mPtr, value)
        }
    }
}

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

import { ZoneParameters, Schema } from "../lib/ConsiderationStructs.sol";

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

/**
 * @title  ZoneInterface
 * @notice Contains functions exposed by a zone.
 */
interface ZoneInterface is IERC165 {
    /**
     * @dev Authorizes an order before any token fulfillments from any order have been executed by Seaport.
     *
     * @param zoneParameters The context about the order fulfillment and any
     *                       supplied extraData.
     *
     * @return authorizedOrderMagicValue The magic value that indicates a valid
     *                              order.
     */
    function authorizeOrder(ZoneParameters calldata zoneParameters)
        external
        returns (bytes4 authorizedOrderMagicValue);

    /**
     * @dev Validates an order after all token fulfillments for all orders have been executed by Seaport.
     *
     * @param zoneParameters The context about the order fulfillment and any
     *                       supplied extraData.
     *
     * @return validOrderMagicValue The magic value that indicates a valid
     *                              order.
     */
    function validateOrder(ZoneParameters calldata zoneParameters)
        external
        returns (bytes4 validOrderMagicValue);

    /**
     * @dev Returns the metadata for this zone.
     *
     * @return name The name of the zone.
     * @return schemas The schemas that the zone implements.
     */
    function getSeaportMetadata()
        external
        view
        returns (string memory name, Schema[] memory schemas); // map to Seaport Improvement Proposal IDs

    /**
    * @dev Returns if the zone supports the interfaceId.
    *
    * @param interfaceId The interface identifier, as specified in ERC-165.
    *
    * @return supportsInterface True if the zone supports interfaceId, false
    */
    function supportsInterface(bytes4 interfaceId)
        external
        view
        override
        returns (bool supportsInterface);
}

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

pragma solidity ^0.8.7;

/**
 * @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`.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId)
        external
        view
        returns (bool);
}

{
  "remappings": [
    "@rari-capital/solmate/=lib/solmate/",
    "ds-test/=lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "murky/=lib/murky/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "solarray/=lib/solarray/src/",
    "solady/=lib/solady/",
    "seaport-sol/src/=src/sol/",
    "seaport-sol/=src/sol/",
    "seaport-types/src/=src/types/",
    "seaport-types/=src/types/",
    "seaport-core/src/=src/core/",
    "seaport-core/=src/core/",
    "seaport/=src/main/",
    "@limitbreak/creator-token-standards/=lib/erc721c-seaport/lib/creator-token-standards/src/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ERC721A/=lib/erc721c-seaport/lib/creator-token-standards/lib/ERC721A/contracts/",
    "creator-token-standards/=lib/erc721c-seaport/lib/creator-token-standards/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "erc721a/=lib/erc721c-seaport/lib/creator-token-standards/lib/ERC721A/",
    "erc721c-seaport/=lib/erc721c-seaport/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "seaport-deploy/=lib/erc721c-seaport/lib/seaport-deploy/",
    "solmate/=lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 9999999
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"zoneName","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CallerNotSeaport","type":"error"},{"inputs":[],"name":"InvalidController","type":"error"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"InvalidExtraDataLength","type":"error"},{"inputs":[{"internalType":"address","name":"expectedFulfiller","type":"address"},{"internalType":"address","name":"actualFulfiller","type":"address"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"InvalidFulfiller","type":"error"},{"inputs":[{"internalType":"uint256","name":"expectedReceivedIdentifier","type":"uint256"},{"internalType":"uint256","name":"actualReceievedIdentifier","type":"uint256"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"InvalidReceivedItem","type":"error"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"InvalidSIP6Version","type":"error"},{"inputs":[{"internalType":"string","name":"reason","type":"string"},{"internalType":"uint256","name":"substandardVersion","type":"uint256"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"InvalidSubstandardSupport","type":"error"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"InvalidSubstandardVersion","type":"error"},{"inputs":[],"name":"InvalidZoneParameterEncoding","type":"error"},{"inputs":[{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"SignatureExpired","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"SignerNotActive","type":"error"},{"inputs":[],"name":"UnsupportedFunctionSelector","type":"error"},{"anonymous":false,"inputs":[],"name":"SeaportCompatibleContractDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"signer","type":"address"}],"name":"SignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"signer","type":"address"}],"name":"SignerRemoved","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[{"components":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"internalType":"address","name":"fulfiller","type":"address"},{"internalType":"address","name":"offerer","type":"address"},{"components":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct SpentItem[]","name":"offer","type":"tuple[]"},{"components":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address payable","name":"recipient","type":"address"}],"internalType":"struct ReceivedItem[]","name":"consideration","type":"tuple[]"},{"internalType":"bytes","name":"extraData","type":"bytes"},{"internalType":"bytes32[]","name":"orderHashes","type":"bytes32[]"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"bytes32","name":"zoneHash","type":"bytes32"}],"internalType":"struct ZoneParameters","name":"zoneParameters","type":"tuple"}],"name":"authorizeOrder","outputs":[{"internalType":"bytes4","name":"authorizedOrderMagicValue","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getSeaportMetadata","outputs":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bytes","name":"metadata","type":"bytes"}],"internalType":"struct Schema[]","name":"schemas","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"internalType":"address","name":"fulfiller","type":"address"},{"internalType":"address","name":"offerer","type":"address"},{"components":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct SpentItem[]","name":"offer","type":"tuple[]"},{"components":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address payable","name":"recipient","type":"address"}],"internalType":"struct ReceivedItem[]","name":"consideration","type":"tuple[]"},{"internalType":"bytes","name":"extraData","type":"bytes"},{"internalType":"bytes32[]","name":"orderHashes","type":"bytes32[]"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"bytes32","name":"zoneHash","type":"bytes32"}],"internalType":"struct ZoneParameters","name":"zoneParameters","type":"tuple"}],"name":"validateOrder","outputs":[{"internalType":"bytes4","name":"validOrderMagicValue","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561000f575f80fd5b506004361061004a575f3560e01c806301e4d72a1461022f57806301ffc9a71461027857806317b1f9421461029b5780632e778efc146102ae575b5f3660607fffffffff000000000000000000000000000000000000000000000000000000008335167f0b9fa6f50000000000000000000000000000000000000000000000000000000081016100e4575f6100a7366004818461136b565b8101906100b491906113b3565b90505f6100c4366024818461136b565b8101906100d191906113d5565b90506100dd82826102c4565b5050610222565b7f587b47f4000000000000000000000000000000000000000000000000000000007fffffffff0000000000000000000000000000000000000000000000000000000082160161015c576101356102e7565b60405160200161014591906113f4565b604051602081830303815290604052915050610224565b7f8200a587000000000000000000000000000000000000000000000000000000007fffffffff00000000000000000000000000000000000000000000000000000000821601610215575f6101b3366004818461136b565b8101906101c091906113b3565b90506101f08173ffffffffffffffffffffffffffffffffffffffff165f9081526020819052604090205460ff1690565b6040805191151560208301520160405160208183030381529060405292505050610224565b6354c91b875f526004601cfd5b505b915050805190602001f35b61024261023d36600461144d565b6103bb565b6040517fffffffff0000000000000000000000000000000000000000000000000000000090911681526020015b60405180910390f35b61028b610286366004611485565b610751565b604051901515815260200161026f565b6102426102a936600461144d565b610761565b6102b6610802565b60405161026f92919061152f565b6102cc6108cf565b806102de576102da82610907565b5050565b6102da82610987565b6040517f66a2489f0000000000000000000000000000000000000000000000000000000081523060048201526060907f000000000000000000000000000000657e498d54000053b69bdaad008a001dbf73ffffffffffffffffffffffffffffffffffffffff16906366a2489f906024015f60405180830381865afa158015610371573d5f803e3d5ffd5b505050506040513d5f823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526103b6919081019061166f565b905090565b5f3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000068f116a894984e2db1123eb395161461042b576040517f979a7ba000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610433610a03565b365f61044260a0850185611709565b909250905083355f80602460c435018035607e81101561046d5763d232fd2c5f52846020526024601cfd5b50602081013560f81c801561048d5763641157745f52846020526024601cfd5b50607d81013560f81c91506007821060018311166009831117156104bc5763267879995f52836020526024601cfd5b6035013560c01c9150428210156104e25763165460715f5281602052826040526044601cfd5b60a435602401358061055657632be762245f526060602052600160405283606052602a6080527f436f6e73696465726174696f6e206d7573742068617665206174206c6561737460a0527f206f6e65206974656d2e0000000000000000000000000000000000000000000060c05260c4601cfd5b505f61056184610a1c565b9050365f610573605d601d898b61136b565b91509150365f600286101561059957610590607e605d8b8d61136b565b915091506105f6565b856007036105c95760a68910156105bb5763d232fd2c5f52876020526024601cfd5b61059060a6605d8b8d61136b565b60928910156105e35763d232fd2c5f52876020526024601cfd5b6105f16092605d8b8d61136b565b915091505b5f61060486898b8686610a85565b90505f61064c610612610b32565b7f19010000000000000000000000000000000000000000000000000000000000005f90815260029190915260228481526042822091905290565b90505f61068e8288888080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610c0f92505050565b73ffffffffffffffffffffffffffffffffffffffff81165f9081526020819052604090205490915060ff16610712576040517f17c3008900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff82166004820152602481018c905260440160405180910390fd5b61071d8f6001610c9b565b507f01e4d72a000000000000000000000000000000000000000000000000000000009e9d5050505050505050505050505050565b5f61075b8261119d565b92915050565b5f3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000068f116a894984e2db1123eb39516146107d1576040517f979a7ba000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6107db825f610c9b565b507f17b1f94200000000000000000000000000000000000000000000000000000000919050565b604080516001808252818301909252606091829190816020015b604080518082019091525f81526060602082015281526020019060019003908161081c5790505090506007815f8151811061085957610859611771565b6020908102919091010151525f8080808061087261127d565b9450945094509450945083965084838383604051602001610896949392919061179e565b604051602081830303815290604052865f815181106108b7576108b7611771565b60200260200101516020018190525050505050509091565b7f000000000000000000000000000000657e498d54000053b69bdaad008a001dbf33811461090457636d5769be5f526004601cfd5b50565b73ffffffffffffffffffffffffffffffffffffffff81165f818152602081815260409182902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905590519182527f3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b91015b60405180910390a150565b73ffffffffffffffffffffffffffffffffffffffff81165f818152602081815260409182902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905590519182527f47d1c22a25bb3a5d4e481b9b1e6944c2eade3181a0a20b495ed61d35b5323f24910161097c565b602060043514610a1a576346d5d8955f526004601cfd5b565b60c435604581013560601c906044359060a2013560a43560840135828414158415151615610a5d57631bcf9bb75f528360205282604052846060526064601cfd5b808214610a7d5763b36c03e85f528160205280604052846060526064601cfd5b505050919050565b5f7f58d1345cbd7d0ceb38b86441d42a4086bc412b7f1ed7d947a569ed7d68b1b7908686868686604051610aba92919061180c565b604051908190038120610b11959493929160200194855273ffffffffffffffffffffffffffffffffffffffff93909316602085015267ffffffffffffffff9190911660408401526060830152608082015260a00190565b60405160208183030381529060405280519060200120905095945050505050565b5f7f00000000000000000000000000000000000000000000000000000000000000014614610bea575060408051608080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f5f9081527f9d5b9438a9d7eeaa076af4212c6fe8fab33591a0bc22cc712826de09a81ab4476020527f88f72b566ae0c96f6fffac4bc8ac74909f61512ac0c06a8124d5ed420d306f90855246606090815230845260a08220949095529093529190915290565b507f8a806758477d159b24ea61747ac59cb52cfa39babd73268db8a19fc5d34953a790565b5f805f525f82516020840380518260410360018111610c8f57604087015160608801515f1a95508115610c6e57601b8160ff1c0195507f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811660408901525b85885288845260205f60808660015afa5082845284885260408801525f5195505b50905250909392505050565b5f610ca960a0840184611709565b605d818110610cba57610cba611771565b919091013560f81c9150506002811015610cd357505050565b5f610ce160a0850185611709565b610cf091609291607e9161136b565b610cf99161181b565b60601c90505f80806001610d106080890189611863565b5f818110610d2057610d20611771565b610d3692602060a09092020190810191506118c6565b6005811115610d4757610d476118e4565b1115610dde57610d5a6080880188611863565b5f818110610d6a57610d6a611771565b905060a002016020016020810190610d8291906113b3565b9250610d916080880188611863565b5f818110610da157610da1611771565b905060a00201604001359150868060800190610dbd9190611863565b5f818110610dcd57610dcd611771565b905060a00201606001359050610e6b565b610deb6060880188611911565b5f818110610dfb57610dfb611771565b9050608002016020016020810190610e1391906113b3565b9250610e226060880188611911565b5f818110610e3257610e32611771565b905060800201604001359150868060600190610e4e9190611911565b5f818110610e5e57610e5e611771565b9050608002016060013590505b8460ff16600703610fb3575f610e8460a0890189611709565b610e939160a69160929161136b565b610e9c9161181b565b60601c90508615610f30576040517f5079331500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff828116600483015285811660248301528616906350793315906044015f604051808303815f87803b158015610f15575f80fd5b505af1158015610f27573d5f803e3d5ffd5b50505050610fad565b6040517f0ad3889900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8581166004830152861690630ad38899906024015f604051808303815f87803b158015610f96575f80fd5b505af1158015610fa8573d5f803e3d5ffd5b505050505b50611194565b8460ff166008036110a857851561104d576040517f3a0e316000000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff848116600483015260248201849052851690633a0e3160906044015b5f604051808303815f87803b158015611032575f80fd5b505af1158015611044573d5f803e3d5ffd5b50505050611194565b6040517fb89c4b0d00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff84811660048301526024820184905285169063b89c4b0d9060440161101b565b8515611110576040517f28cc113100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff848116600483015260248201849052604482018390528516906328cc11319060640161101b565b6040517fb6e39ba100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff84811660048301526024820184905285169063b6e39ba1906044015f604051808303815f87803b15801561117d575f80fd5b505af115801561118f573d5f803e3d5ffd5b505050505b50505050505050565b5f7fffffffff0000000000000000000000000000000000000000000000000000000082167f2e778efc00000000000000000000000000000000000000000000000000000000148061122f57507fffffffff0000000000000000000000000000000000000000000000000000000082167f39dd693300000000000000000000000000000000000000000000000000000000145b8061075b5750507fffffffff00000000000000000000000000000000000000000000000000000000167f01ffc9a7000000000000000000000000000000000000000000000000000000001490565b5f60608060608061128c610b32565b6040517f04789c980000000000000000000000000000000000000000000000000000000081523060048201529095507f000000000000000000000000000000657e498d54000053b69bdaad008a001dbf73ffffffffffffffffffffffffffffffffffffffff16906304789c98906024015f60405180830381865afa158015611316573d5f803e3d5ffd5b505050506040513d5f823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820160405261135b91908101906119fc565b9899929891975095509350915050565b5f8085851115611379575f80fd5b83861115611385575f80fd5b5050820193919092039150565b73ffffffffffffffffffffffffffffffffffffffff81168114610904575f80fd5b5f602082840312156113c3575f80fd5b81356113ce81611392565b9392505050565b5f602082840312156113e5575f80fd5b813580151581146113ce575f80fd5b602080825282518282018190525f9190848201906040850190845b8181101561144157835173ffffffffffffffffffffffffffffffffffffffff168352928401929184019160010161140f565b50909695505050505050565b5f6020828403121561145d575f80fd5b813567ffffffffffffffff811115611473575f80fd5b820161014081850312156113ce575f80fd5b5f60208284031215611495575f80fd5b81357fffffffff00000000000000000000000000000000000000000000000000000000811681146113ce575f80fd5b5f5b838110156114de5781810151838201526020016114c6565b50505f910152565b5f81518084526114fd8160208601602086016114c4565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b5f604080835261154260408401866114e6565b6020848203818601528186518084528284019150828160051b8501018389015f5b838110156115c0578683037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe00185528151805184528601518684018990526115ad898501826114e6565b9587019593505090850190600101611563565b50909a9950505050505050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715611644576116446115d0565b604052919050565b5f67ffffffffffffffff821115611665576116656115d0565b5060051b60200190565b5f6020808385031215611680575f80fd5b825167ffffffffffffffff811115611696575f80fd5b8301601f810185136116a6575f80fd5b80516116b96116b48261164c565b6115fd565b81815260059190911b820183019083810190878311156116d7575f80fd5b928401925b828410156116fe5783516116ef81611392565b825292840192908401906116dc565b979650505050505050565b5f8083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe184360301811261173c575f80fd5b83018035915067ffffffffffffffff821115611756575f80fd5b60200191503681900382131561176a575f80fd5b9250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b8481525f6020608060208401526117b860808401876114e6565b8381036040850152855180825260208088019201905f5b818110156117eb578351835292840192918401916001016117cf565b505084810360608601526117ff81876114e6565b9998505050505050505050565b818382375f9101908152919050565b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000813581811691601485101561185b5780818660140360031b1b83161692505b505092915050565b5f8083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112611896575f80fd5b83018035915067ffffffffffffffff8211156118b0575f80fd5b602001915060a08102360382131561176a575f80fd5b5f602082840312156118d6575f80fd5b8135600681106113ce575f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffd5b5f8083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112611944575f80fd5b83018035915067ffffffffffffffff82111561195e575f80fd5b6020019150600781901b360382131561176a575f80fd5b5f82601f830112611984575f80fd5b815167ffffffffffffffff81111561199e5761199e6115d0565b6119cf60207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116016115fd565b8181528460208386010111156119e3575f80fd5b6119f48260208301602087016114c4565b949350505050565b5f805f805f60a08688031215611a10575f80fd5b8551945060208087015167ffffffffffffffff80821115611a2f575f80fd5b611a3b8a838b01611975565b96506040890151915080821115611a50575f80fd5b611a5c8a838b01611975565b95506060890151915080821115611a71575f80fd5b818901915089601f830112611a84575f80fd5b8151611a926116b48261164c565b81815260059190911b8301840190848101908c831115611ab0575f80fd5b938501935b82851015611ace57845182529385019390850190611ab5565b60808c01519097509450505080831115611ae6575f80fd5b5050611af488828901611975565b915050929550929590935056fea26469706673582212208cf0e76ef76b2bee85dd5f1436a047bf9c87ae5f888e0b194385b99aece78a8664736f6c63430008180033

000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000114f70656e5365615369676e65645a6f6e65000000000000000000000000000000

-----Decoded View---------------
Arg [0] : zoneName (string): OpenSeaSignedZone

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000011
Arg [2] : 4f70656e5365615369676e65645a6f6e65000000000000000000000000000000