Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• library Strings
•    - function toString(uint256 value)
•    - function toStringSigned(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library MessageHashUtils
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toDataWithIntendedValidatorH ...
•    - function toTypedDataHash(bytes32 doma ...
• interface IERC1271
•    - function isValidSignature(bytes32 has ...
• library ECDSA
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(
•    - function recover(bytes32 hash, uint8 ...
•    - function _throwError(RecoverError err ...
• library SignatureChecker
•    - function isValidSignatureNow(address ...
•    - function isValidERC1271SignatureNow(
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•  contract LLClaim is Ownable *
•    - function claim(address recipient, uin ...
•    - function hasClaimed(address recipient ...
•    - function setSigner(address signer)
•    - function setActivePhase(uint256 phase ...
•    - function setSalt(uint256 salt)
•    - function withdraw(address recipient, ...
•    - function _validateSignature(address r ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-04-14
*/

// File: lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

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

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

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

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

// File: lib/openzeppelin-contracts/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: lib/openzeppelin-contracts/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;



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

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

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

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

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

// File: lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;


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

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

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

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

// File: lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1271.sol)

pragma solidity ^0.8.20;

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

// File: lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

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

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

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

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

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

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

// File: lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.20;



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

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

// File: lib/openzeppelin-contracts/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

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

// File: lib/openzeppelin-contracts/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


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

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

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

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

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

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

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

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

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

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

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

// File: lib/openzeppelin-contracts/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

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

// File: lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// File: src/LLClaim.sol


pragma solidity ^0.8.23;






contract LLClaim is Ownable {
    using SafeERC20 for IERC20;

    event Claim(uint256 indexed phase, address indexed recipient, uint256 amount);

    IERC20 _token;
    address _signer;
    uint256 _salt;

    uint256 _activePhase;

    mapping(uint256 phase => mapping(address recipient => bool)) _claims;

    constructor(address token, address signer) Ownable(msg.sender) {
        _token = IERC20(token);
        _signer = signer;
    }

    function claim(address recipient, uint256 amount, uint256 phase, bytes memory signature) external {
        require(_validateSignature(recipient, amount, phase, signature), "Invalid signature");
        require(phase == _activePhase, "Phase not active");
        require(!_claims[phase][recipient], "Recipient already claimed");

        _claims[phase][recipient] = true;

        _token.safeTransfer(recipient, amount);

        emit Claim(phase, recipient, amount);
    }

    function hasClaimed(address recipient, uint256 phase) external view returns (bool) {
        return _claims[phase][recipient];
    }

    function setSigner(address signer) external onlyOwner {
        _signer = signer;
    }

    function setActivePhase(uint256 phase) external onlyOwner {
        _activePhase = phase;
    }

    function setSalt(uint256 salt) external onlyOwner {
        _salt = salt;
    }

    function withdraw(address recipient, uint256 amount) external onlyOwner {
        _token.safeTransfer(recipient, amount);
    }

    function _validateSignature(address recipient, uint256 amount, uint256 phase, bytes memory signature)
        internal
        view
        returns (bool)
    {
        bytes32 message = keccak256(abi.encodePacked(recipient, amount, phase, _salt));
        bytes32 messageHash = MessageHashUtils.toEthSignedMessageHash(message);

        return SignatureChecker.isValidSignatureNow(_signer, messageHash, signature);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"signer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"phase","type":"uint256"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"phase","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"phase","type":"uint256"}],"name":"hasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"phase","type":"uint256"}],"name":"setActivePhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"salt","type":"uint256"}],"name":"setSalt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000921799cb1d702148131024d18fcde022129dc730000000000000000000000003b39f89a9a28377f6ba11fe210744f8eb2dc1209

-----Decoded View---------------
Arg [0] : token (address): 0x0921799CB1d702148131024d18fCdE022129Dc73
Arg [1] : signer (address): 0x3B39f89A9A28377f6ba11fE210744f8Eb2DC1209

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000921799cb1d702148131024d18fcde022129dc73
Arg [1] : 0000000000000000000000003b39f89a9a28377f6ba11fe210744f8eb2dc1209

58283:1959:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58748:483;;;;;;:::i;:::-;;:::i;:::-;;59478:97;;;;;;:::i;:::-;;:::i;59583:81::-;;;;;;:::i;:::-;;:::i;59381:89::-;;;;;;:::i;:::-;;:::i;38276:103::-;;;:::i;37601:87::-;37647:7;37674:6;37601:87;;37674:6;;;;2122:74:1;;2110:2;2095:18;37601:87:0;;;;;;;;59239:134;;;;;;:::i;:::-;59316:4;59340:14;;;:7;:14;;;;;;;;:25;;;;;;;;;;;;;;;59239:134;;;;2631:14:1;;2624:22;2606:41;;2594:2;2579:18;59239:134:0;2466:187:1;38534:220:0;;;;;;:::i;:::-;;:::i;59672:129::-;;;;;;:::i;:::-;;:::i;58748:483::-;58865:55;58884:9;58895:6;58903:5;58910:9;58865:18;:55::i;:::-;58857:85;;;;;;;2860:2:1;58857:85:0;;;2842:21:1;2899:2;2879:18;;;2872:30;2938:19;2918:18;;;2911:47;2975:18;;58857:85:0;;;;;;;;;58970:12;;58961:5;:21;58953:50;;;;;;;3206:2:1;58953:50:0;;;3188:21:1;3245:2;3225:18;;;3218:30;3284:18;3264;;;3257:46;3320:18;;58953:50:0;3004:340:1;58953:50:0;59023:14;;;;:7;:14;;;;;;;;:25;;;;;;;;;;;;;59022:26;59014:64;;;;;;;3551:2:1;59014:64:0;;;3533:21:1;3590:2;3570:18;;;3563:30;3629:27;3609:18;;;3602:55;3674:18;;59014:64:0;3349:349:1;59014:64:0;59091:14;;;;:7;:14;;;;;;;;:25;;;;;;;;;;;:32;;;;59119:4;59091:32;;;;;;59136:6;:38;;:6;59106:9;59167:6;59136:19;:38::i;:::-;59205:9;59192:31;;59198:5;59192:31;59216:6;59192:31;;;;3849:25:1;;3837:2;3822:18;;3703:177;59192:31:0;;;;;;;;58748:483;;;;:::o;59478:97::-;37487:13;:11;:13::i;:::-;59547:12:::1;:20:::0;59478:97::o;59583:81::-;37487:13;:11;:13::i;:::-;59644:5:::1;:12:::0;59583:81::o;59381:89::-;37487:13;:11;:13::i;:::-;59446:7:::1;:16:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;59381:89::o;38276:103::-;37487:13;:11;:13::i;:::-;38341:30:::1;38368:1;38341:18;:30::i;:::-;38276:103::o:0;38534:220::-;37487:13;:11;:13::i;:::-;38619:22:::1;::::0;::::1;38615:93;;38665:31;::::0;::::1;::::0;;38693:1:::1;38665:31;::::0;::::1;2122:74:1::0;2095:18;;38665:31:0::1;1976:226:1::0;38615:93:0::1;38718:28;38737:8;38718:18;:28::i;:::-;38534:220:::0;:::o;59672:129::-;37487:13;:11;:13::i;:::-;59755:6:::1;::::0;:38:::1;::::0;:6:::1;;59775:9:::0;59786:6;59755:19:::1;:38::i;:::-;59672:129:::0;;:::o;59809:430::-;60054:5;;60011:49;;4131:66:1;4118:2;4114:15;;;4110:88;60011:49:0;;;4098:101:1;4215:12;;;4208:28;;;4252:12;;;4245:28;;;4289:12;;;4282:28;;;;59961:4:0;;;;4326:13:1;;60011:49:0;;;;;;;;;;;;60001:60;;;;;;59983:78;;60072:19;60094:48;60134:7;21521:34;21413:14;21508:48;;;21618:4;21611:25;;;;21717:4;21701:21;;;21337:467;60094:48;60199:7;;60072:70;;-1:-1:-1;60162:69:0;;60199:7;;60072:70;60221:9;60162:36;:69::i;:::-;60155:76;59809:430;-1:-1:-1;;;;;;;59809:430:0:o;53663:162::-;53773:43;;;53788:14;4542:55:1;;53773:43:0;;;4524:74:1;4614:18;;;;4607:34;;;53773:43:0;;;;;;;;;;4497:18:1;;;;53773:43:0;;;;;;;;;;;;;;53746:71;;53766:5;;53746:19;:71::i;:::-;53663:162;;;:::o;37766:166::-;37647:7;37674:6;37826:23;37674:6;35677:10;37826:23;37822:103;;37873:40;;;;;35677:10;37873:40;;;2122:74:1;2095:18;;37873:40:0;1976:226:1;38914:191:0;38988:16;39007:6;;;39024:17;;;;;;;;;;39057:40;;39007:6;;;;;;;39057:40;;38988:16;39057:40;38977:128;38914:191;:::o;33625:373::-;33731:4;33749:17;33768:24;33798:33;33815:4;33821:9;33798:16;:33::i;:::-;-1:-1:-1;33748:83:0;;-1:-1:-1;33748:83:0;-1:-1:-1;33872:26:0;33863:5;:35;;;;;;;;:::i;:::-;;:58;;;;;33915:6;33902:19;;:9;:19;;;33863:58;33862:128;;;;33939:51;33966:6;33974:4;33980:9;33939:26;:51::i;:::-;33842:148;;;;33625:373;;;;;;:::o;56474:638::-;56898:23;56924:33;:27;;;56952:4;56924:27;:33::i;:::-;56898:59;;56972:10;:17;56993:1;56972:22;;:57;;;;;57010:10;56999:30;;;;;;;;;;;;:::i;:::-;56998:31;56972:57;56968:137;;;57053:40;;;;;2152:42:1;2140:55;;57053:40:0;;;2122:74:1;2095:18;;57053:40:0;1976:226:1;26875:783:0;26956:7;26965:12;26979:7;27003:9;:16;27023:2;27003:22;26999:652;;27347:4;27332:20;;27326:27;27397:4;27382:20;;27376:27;27455:4;27440:20;;27434:27;27042:9;27426:36;27498:25;27509:4;27426:36;27326:27;27376;27498:10;:25::i;:::-;27491:32;;;;;;;;;;;26999:652;-1:-1:-1;;27621:16:0;;27572:1;;-1:-1:-1;27576:35:0;;26999:652;26875:783;;;;;:::o;34413:469::-;34560:4;34578:12;34592:19;34615:6;:17;;34690:4;34696:9;34647:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;34615:103;;;34647:60;34615:103;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34577:141;;;;34737:7;:43;;;;;34778:2;34761:6;:13;:19;;34737:43;:136;;;;-1:-1:-1;34797:29:0;;34838:34;;34797:29;;;;;;;;;;;;:::i;:::-;:76;;34413:469;-1:-1:-1;;;;;;34413:469:0:o;41922:153::-;41997:12;42029:38;42051:6;42059:4;42065:1;42029:21;:38::i;29952:1556::-;30083:7;;;31026:66;31013:79;;31009:166;;;-1:-1:-1;31125:1:0;;-1:-1:-1;31129:30:0;;-1:-1:-1;31161:1:0;31109:54;;31009:166;31289:24;;;31272:14;31289:24;;;;;;;;;6615:25:1;;;6688:4;6676:17;;6656:18;;;6649:45;;;;6710:18;;;6703:34;;;6753:18;;;6746:34;;;31289:24:0;;6587:19:1;;31289:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31289:24:0;;;;;;-1:-1:-1;;31328:20:0;;;31324:115;;-1:-1:-1;31381:1:0;;-1:-1:-1;31385:29:0;;-1:-1:-1;31381:1:0;;-1:-1:-1;31365:62:0;;31324:115;31459:6;-1:-1:-1;31467:20:0;;-1:-1:-1;31467:20:0;;-1:-1:-1;29952:1556:0;;;;;;;;;:::o;42410:398::-;42509:12;42562:5;42538:21;:29;42534:110;;;42591:41;;;;;42626:4;42591:41;;;2122:74:1;2095:18;;42591:41:0;1976:226:1;42534:110:0;42655:12;42669:23;42696:6;:11;;42715:5;42722:4;42696:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42654:73;;;;42745:55;42772:6;42780:7;42789:10;44034:12;44064:7;44059:417;;44088:19;44096:10;44088:7;:19::i;:::-;44059:417;;;44316:17;;:22;:49;;;;-1:-1:-1;44342:18:0;;;;:23;44316:49;44312:121;;;44393:24;;;;;2152:42:1;2140:55;;44393:24:0;;;2122:74:1;2095:18;;44393:24:0;1976:226:1;44312:121:0;-1:-1:-1;44454:10:0;44447:17;;45036:528;45169:17;;:21;45165:392;;45401:10;45395:17;45458:15;45445:10;45441:2;45437:19;45430:44;45165:392;45528:17;;;;;;;;;;;;;;14:196:1;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:184::-;267:77;264:1;257:88;364:4;361:1;354:15;388:4;385:1;378:15;404:1191;499:6;507;515;523;576:3;564:9;555:7;551:23;547:33;544:53;;;593:1;590;583:12;544:53;616:29;635:9;616:29;:::i;:::-;606:39;;692:2;681:9;677:18;664:32;654:42;;743:2;732:9;728:18;715:32;705:42;;798:2;787:9;783:18;770:32;821:18;862:2;854:6;851:14;848:34;;;878:1;875;868:12;848:34;916:6;905:9;901:22;891:32;;961:7;954:4;950:2;946:13;942:27;932:55;;983:1;980;973:12;932:55;1019:2;1006:16;1041:2;1037;1034:10;1031:36;;;1047:18;;:::i;:::-;1181:2;1175:9;1243:4;1235:13;;1086:66;1231:22;;;1255:2;1227:31;1223:40;1211:53;;;1279:18;;;1299:22;;;1276:46;1273:72;;;1325:18;;:::i;:::-;1365:10;1361:2;1354:22;1400:2;1392:6;1385:18;1440:7;1435:2;1430;1426;1422:11;1418:20;1415:33;1412:53;;;1461:1;1458;1451:12;1412:53;1517:2;1512;1508;1504:11;1499:2;1491:6;1487:15;1474:46;1562:1;1557:2;1552;1544:6;1540:15;1536:24;1529:35;1583:6;1573:16;;;;;;;404:1191;;;;;;;:::o;1600:180::-;1659:6;1712:2;1700:9;1691:7;1687:23;1683:32;1680:52;;;1728:1;1725;1718:12;1680:52;-1:-1:-1;1751:23:1;;1600:180;-1:-1:-1;1600:180:1:o;1785:186::-;1844:6;1897:2;1885:9;1876:7;1872:23;1868:32;1865:52;;;1913:1;1910;1903:12;1865:52;1936:29;1955:9;1936:29;:::i;2207:254::-;2275:6;2283;2336:2;2324:9;2315:7;2311:23;2307:32;2304:52;;;2352:1;2349;2342:12;2304:52;2375:29;2394:9;2375:29;:::i;:::-;2365:39;2451:2;2436:18;;;;2423:32;;-1:-1:-1;;;2207:254:1:o;4652:184::-;4704:77;4701:1;4694:88;4801:4;4798:1;4791:15;4825:4;4822:1;4815:15;4841:277;4908:6;4961:2;4949:9;4940:7;4936:23;4932:32;4929:52;;;4977:1;4974;4967:12;4929:52;5009:9;5003:16;5062:5;5055:13;5048:21;5041:5;5038:32;5028:60;;5084:1;5081;5074:12;5123:250;5208:1;5218:113;5232:6;5229:1;5226:13;5218:113;;;5308:11;;;5302:18;5289:11;;;5282:39;5254:2;5247:10;5218:113;;;-1:-1:-1;;5365:1:1;5347:16;;5340:27;5123:250::o;5378:524::-;5553:6;5542:9;5535:25;5596:2;5591;5580:9;5576:18;5569:30;5516:4;5628:6;5622:13;5671:6;5666:2;5655:9;5651:18;5644:34;5687:79;5759:6;5754:2;5743:9;5739:18;5734:2;5726:6;5722:15;5687:79;:::i;:::-;5818:2;5806:15;5823:66;5802:88;5787:104;;;;5893:2;5783:113;;5378:524;-1:-1:-1;;;5378:524:1:o;5907:287::-;6036:3;6074:6;6068:13;6090:66;6149:6;6144:3;6137:4;6129:6;6125:17;6090:66;:::i;:::-;6172:16;;;;;5907:287;-1:-1:-1;;5907:287:1:o;6199:184::-;6269:6;6322:2;6310:9;6301:7;6297:23;6293:32;6290:52;;;6338:1;6335;6328:12;6290:52;-1:-1:-1;6361:16:1;;6199:184;-1:-1:-1;6199:184:1:o

ipfs://1af415eb22c497b47fcb03d341e5c5f3c26ce0f84b4bbb94ebfb10baaf220d69