Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Math
•    - 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(
•    - function mulDiv(
•    - 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 ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function _domainSeparatorV4()
•    - function _buildDomainSeparator(
•    - function _hashTypedDataV4(bytes32 str ...
•  contract EIP712Verifier is EIP712
•    - function verify(bytes32 digest, uint8 ...
• 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(
•  contract Rabbit is EIP712Verifier *
•    - function withdraw(
•    - function setPaymentToken(address _pay ...
•    - function allocateDepositId()
•    - function deposit(uint256 amount)
•    - function withdrawTokensTo(uint256 amo ...
•    - function changeSigner(address new_sig ...
•    - function makeTransfer(address to, uin ...
•    - function makeTransferFrom(address fro ...
•    - function tokenCall(bytes memory data)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-06-26
*/

// File @openzeppelin/contracts/utils/math/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && 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 down.
     *
     * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

    /**
     * @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), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

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


// File @openzeppelin/contracts/utils/cryptography/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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


// File contracts/EIP712Verifier.sol

pragma solidity ^0.8.17;


contract EIP712Verifier is EIP712 {
    address public external_signer;

    constructor(string memory domainName, string memory version, address signer) EIP712(domainName, version) {
        external_signer = signer;
        require(signer != address(0), "ZERO_SIGNER");
    }

    /* 
        Standard EIP712 verifier but with different v combinations
    */
    function verify(bytes32 digest, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {

        address recovered_signer = ecrecover(digest, v, r, s);
        if (recovered_signer != external_signer) {
            uint8 other_v = 27;
            if (other_v == v) {
                other_v = 28;
            }

            recovered_signer = ecrecover(digest, other_v, r, s);
        }

        if (recovered_signer != external_signer) {
            return false;
        }

        return true;
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount
    ) external returns (bool);
}


// File contracts/Rabbit.sol

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.19;




contract Rabbit is EIP712Verifier {

    uint256 constant UNLOCKED = 1;
    uint256 constant LOCKED = 2;

    address public immutable owner;
    IERC20 public paymentToken;

    // record of already processed withdrawals
    mapping(uint256 => bool) public processedWithdrawals;


    uint256 nextDepositId = 37000;
    uint256 reentryLockStatus = UNLOCKED;

    event Deposit(uint256 indexed id, address indexed trader, uint256 amount);
    event Withdraw(address indexed trader, uint256 amount);
    event WithdrawTo(address indexed to, uint256 amount);
    event WithdrawalReceipt(uint256 indexed id, address indexed trader, uint256 amount);
    event UnknownReceipt(uint256 indexed messageType, uint[] payload);
    event MsgNotFound(uint256 indexed fromAddress, uint[] payload);

    modifier onlyOwner() {
        require(msg.sender == owner, "ONLY_OWNER");
        _;
    }

    modifier nonReentrant() {
        require(reentryLockStatus == UNLOCKED, "NO_REENTRY");
        reentryLockStatus = LOCKED;
        _;
        reentryLockStatus = UNLOCKED;
    }

    constructor(address _owner, address _signer, address _paymentToken
    	) EIP712Verifier("RabbitXWithdrawal", "1", _signer) {
        owner = _owner;
        paymentToken = IERC20(_paymentToken);
    }
    
    function withdraw(
        uint256 id, address trader, uint256 amount, uint8 v, bytes32 r, bytes32 s
        ) external nonReentrant {
        require(amount > 0, "WRONG_AMOUNT");
        require(processedWithdrawals[id] == false, "ALREADY_PROCESSED");
        processedWithdrawals[id] = true;
        bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
            keccak256("withdrawal(uint256 id,address trader,uint256 amount)"),
            id,
            trader,
            amount
        )));

        bool valid = verify(digest, v, r, s);
        require(valid, "INVALID_SIGNATURE");

        emit WithdrawalReceipt(id, trader, amount);
        bool success = makeTransfer(trader, amount);
        require(success, "TRANSFER_FAILED");
    }

    function setPaymentToken(address _paymentToken) external onlyOwner {
        paymentToken = IERC20(_paymentToken);
    }

    function allocateDepositId() private returns (uint256 depositId) {
        depositId = nextDepositId;
        nextDepositId++;
        return depositId;
    }

    function deposit(uint256 amount) external nonReentrant {
        bool success = makeTransferFrom(msg.sender, address(this) , amount);
        require(success, "TRANSFER_FAILED");
        uint256 depositId = allocateDepositId();
        emit Deposit(depositId, msg.sender, amount);
    }

    function withdrawTokensTo(uint256 amount, address to) external onlyOwner {
        require(amount > 0, "WRONG_AMOUNT");
        require(to != address(0), "ZERO_ADDRESS");
        bool success = makeTransfer(to, amount);
        require(success, "TRANSFER_FAILED");
        emit WithdrawTo(to, amount);
    }
    
    function changeSigner(address new_signer) external onlyOwner {
        require(new_signer != address(0), "ZERO_SIGNER");
        external_signer = new_signer;
    }

    function makeTransfer(address to, uint256 amount) private returns (bool success) {
        return tokenCall(abi.encodeWithSelector(paymentToken.transfer.selector, to, amount));
    }

    function makeTransferFrom(address from, address to, uint256 amount) private returns (bool success) {
        return tokenCall(abi.encodeWithSelector(paymentToken.transferFrom.selector, from, to, amount));
    }

    function tokenCall(bytes memory data) private returns (bool) {
        (bool success, bytes memory returndata) = address(paymentToken).call(data);
        if (success && returndata.length > 0) {
            success = abi.decode(returndata, (bool));
        }
        return success;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_signer","type":"address"},{"internalType":"address","name":"_paymentToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromAddress","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"}],"name":"MsgNotFound","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"messageType","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"}],"name":"UnknownReceipt","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawTo","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawalReceipt","type":"event"},{"inputs":[{"internalType":"address","name":"new_signer","type":"address"}],"name":"changeSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"external_signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paymentToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"processedWithdrawals","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_paymentToken","type":"address"}],"name":"setPaymentToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"trader","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdrawTokensTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000062705e45c18fc8745c644ac23bffb321eef3f0b90000000000000000000000005d8f5f9b0dfdaf2d1b691b3bf6a1cee2f6c7fdc9000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

-----Decoded View---------------
Arg [0] : _owner (address): 0x62705e45c18fC8745c644AC23Bffb321eef3F0B9
Arg [1] : _signer (address): 0x5D8f5F9b0DFdaf2D1b691b3bf6a1ceE2F6c7FDc9
Arg [2] : _paymentToken (address): 0xdAC17F958D2ee523a2206206994597C13D831ec7

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000062705e45c18fc8745c644ac23bffb321eef3f0b9
Arg [1] : 0000000000000000000000005d8f5f9b0dfdaf2d1b691b3bf6a1cee2f6c7fdc9
Arg [2] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

32581:3910:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28723:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32733:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33903:772;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34683:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;32696:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35607:167;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34983:291;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35282:313;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;32816:52;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;28723:30;;;;;;;;;;;;:::o;32733:26::-;;;;;;;;;;;;;:::o;33903:772::-;32652:1;33538:17;;:29;33530:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;32686:1;33593:17;:26;;;;34066:1:::1;34057:6;:10;34049:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;34131:5;34103:33;;:20;:24;34124:2;34103:24;;;;;;;;;;;;;;;;;;;;;:33;;;34095:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;34196:4;34169:20;:24;34190:2;34169:24;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;34211:14;34228:189;34280:65;34360:2;34377:6;34398;34255:160;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;34245:171;;;;;;34228:16;:189::i;:::-;34211:206;;34430:10;34443:23;34450:6;34458:1;34461;34464;34443:6;:23::i;:::-;34430:36;;34485:5;34477:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;34552:6;34530:37;;34548:2;34530:37;34560:6;34530:37;;;;;;:::i;:::-;;;;;;;;34578:12;34593:28;34606:6;34614;34593:12;:28::i;:::-;34578:43;;34640:7;34632:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;34038:637;;;32652:1:::0;33642:17;:28;;;;33903:772;;;;;;:::o;34683:122::-;33447:5;33433:19;;:10;:19;;;33425:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;34783:13:::1;34761:12;;:36;;;;;;;;;;;;;;;;;;34683:122:::0;:::o;32696:30::-;;;:::o;35607:167::-;33447:5;33433:19;;:10;:19;;;33425:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;35709:1:::1;35687:24;;:10;:24;;::::0;35679:48:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;35756:10;35738:15;::::0;:28:::1;;;;;;;;;;;;;;;;;;35607:167:::0;:::o;34983:291::-;32652:1;33538:17;;:29;33530:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;32686:1;33593:17;:26;;;;35049:12:::1;35064:52;35081:10;35101:4;35109:6;35064:16;:52::i;:::-;35049:67;;35135:7;35127:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;35173:17;35193:19;:17;:19::i;:::-;35173:39;;35247:10;35228:38;;35236:9;35228:38;35259:6;35228:38;;;;;;:::i;:::-;;;;;;;;35038:236;;32652:1:::0;33642:17;:28;;;;34983:291;:::o;35282:313::-;33447:5;33433:19;;:10;:19;;;33425:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;35383:1:::1;35374:6;:10;35366:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;35434:1;35420:16;;:2;:16;;::::0;35412:41:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;35464:12;35479:24;35492:2;35496:6;35479:12;:24::i;:::-;35464:39;;35522:7;35514:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;35576:2;35565:22;;;35580:6;35565:22;;;;;;:::i;:::-;;;;;;;;35355:240;35282:313:::0;;:::o;32816:52::-;;;;;;;;;;;;;;;;;;;;;;:::o;28436:167::-;28513:7;28540:55;28562:20;:18;:20::i;:::-;28584:10;28540:21;:55::i;:::-;28533:62;;28436:167;;;:::o;29058:525::-;29144:4;29163:24;29190:26;29200:6;29208:1;29211;29214;29190:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29163:53;;29251:15;;;;;;;;;;29231:35;;:16;:35;;;29227:233;;29283:13;29299:2;29283:18;;29331:1;29320:12;;:7;:12;;;29316:65;;29363:2;29353:12;;29316:65;29416:32;29426:6;29434:7;29443:1;29446;29416:32;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29397:51;;29268:192;29227:233;29496:15;;;;;;;;;;29476:35;;:16;:35;;;29472:80;;29535:5;29528:12;;;;;29472:80;29571:4;29564:11;;;29058:525;;;;;;;:::o;35782:184::-;35849:12;35881:77;35914:30;;;35946:2;35950:6;35891:66;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35881:9;:77::i;:::-;35874:84;;35782:184;;;;:::o;35974:212::-;36059:12;36091:87;36124:34;;;36160:4;36166:2;36170:6;36101:76;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36091:9;:87::i;:::-;36084:94;;35974:212;;;;;:::o;34813:162::-;34859:17;34901:13;;34889:25;;34925:13;;:15;;;;;;;;;:::i;:::-;;;;;;34813:162;:::o;27209:314::-;27262:7;27303:12;27286:29;;27294:4;27286:29;;;:66;;;;;27336:16;27319:13;:33;27286:66;27282:234;;;27376:24;27369:31;;;;27282:234;27440:64;27462:10;27474:12;27488:15;27440:21;:64::i;:::-;27433:71;;27209:314;;:::o;23769:196::-;23862:7;23928:15;23945:10;23899:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23889:68;;;;;;23882:75;;23769:196;;;;:::o;36194:294::-;36249:4;36267:12;36281:23;36316:12;;;;;;;;;;;36308:26;;36335:4;36308:32;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36266:74;;;;36355:7;:32;;;;;36386:1;36366:10;:17;:21;36355:32;36351:105;;;36425:10;36414:30;;;;;;;;;;;;:::i;:::-;36404:40;;36351:105;36473:7;36466:14;;;;36194:294;;;:::o;27531:263::-;27675:7;27723:8;27733;27743:11;27756:13;27779:4;27712:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;27702:84;;;;;;27695:91;;27531:263;;;;;:::o;7:126:1:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;593:60::-;621:3;642:5;635:12;;593:60;;;:::o;659:142::-;709:9;742:53;760:34;769:24;787:5;769:24;:::i;:::-;760:34;:::i;:::-;742:53;:::i;:::-;729:66;;659:142;;;:::o;807:126::-;857:9;890:37;921:5;890:37;:::i;:::-;877:50;;807:126;;;:::o;939:141::-;1004:9;1037:37;1068:5;1037:37;:::i;:::-;1024:50;;939:141;;;:::o;1086:161::-;1188:52;1234:5;1188:52;:::i;:::-;1183:3;1176:65;1086:161;;:::o;1253:252::-;1361:4;1399:2;1388:9;1384:18;1376:26;;1412:86;1495:1;1484:9;1480:17;1471:6;1412:86;:::i;:::-;1253:252;;;;:::o;1592:117::-;1701:1;1698;1691:12;1838:77;1875:7;1904:5;1893:16;;1838:77;;;:::o;1921:122::-;1994:24;2012:5;1994:24;:::i;:::-;1987:5;1984:35;1974:63;;2033:1;2030;2023:12;1974:63;1921:122;:::o;2049:139::-;2095:5;2133:6;2120:20;2111:29;;2149:33;2176:5;2149:33;:::i;:::-;2049:139;;;;:::o;2194:122::-;2267:24;2285:5;2267:24;:::i;:::-;2260:5;2257:35;2247:63;;2306:1;2303;2296:12;2247:63;2194:122;:::o;2322:139::-;2368:5;2406:6;2393:20;2384:29;;2422:33;2449:5;2422:33;:::i;:::-;2322:139;;;;:::o;2467:86::-;2502:7;2542:4;2535:5;2531:16;2520:27;;2467:86;;;:::o;2559:118::-;2630:22;2646:5;2630:22;:::i;:::-;2623:5;2620:33;2610:61;;2667:1;2664;2657:12;2610:61;2559:118;:::o;2683:135::-;2727:5;2765:6;2752:20;2743:29;;2781:31;2806:5;2781:31;:::i;:::-;2683:135;;;;:::o;2824:77::-;2861:7;2890:5;2879:16;;2824:77;;;:::o;2907:122::-;2980:24;2998:5;2980:24;:::i;:::-;2973:5;2970:35;2960:63;;3019:1;3016;3009:12;2960:63;2907:122;:::o;3035:139::-;3081:5;3119:6;3106:20;3097:29;;3135:33;3162:5;3135:33;:::i;:::-;3035:139;;;;:::o;3180:1053::-;3282:6;3290;3298;3306;3314;3322;3371:3;3359:9;3350:7;3346:23;3342:33;3339:120;;;3378:79;;:::i;:::-;3339:120;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3625:2;3651:53;3696:7;3687:6;3676:9;3672:22;3651:53;:::i;:::-;3641:63;;3596:118;3753:2;3779:53;3824:7;3815:6;3804:9;3800:22;3779:53;:::i;:::-;3769:63;;3724:118;3881:2;3907:51;3950:7;3941:6;3930:9;3926:22;3907:51;:::i;:::-;3897:61;;3852:116;4007:3;4034:53;4079:7;4070:6;4059:9;4055:22;4034:53;:::i;:::-;4024:63;;3978:119;4136:3;4163:53;4208:7;4199:6;4188:9;4184:22;4163:53;:::i;:::-;4153:63;;4107:119;3180:1053;;;;;;;;:::o;4239:329::-;4298:6;4347:2;4335:9;4326:7;4322:23;4318:32;4315:119;;;4353:79;;:::i;:::-;4315:119;4473:1;4498:53;4543:7;4534:6;4523:9;4519:22;4498:53;:::i;:::-;4488:63;;4444:117;4239:329;;;;:::o;4574:::-;4633:6;4682:2;4670:9;4661:7;4657:23;4653:32;4650:119;;;4688:79;;:::i;:::-;4650:119;4808:1;4833:53;4878:7;4869:6;4858:9;4854:22;4833:53;:::i;:::-;4823:63;;4779:117;4574:329;;;;:::o;4909:474::-;4977:6;4985;5034:2;5022:9;5013:7;5009:23;5005:32;5002:119;;;5040:79;;:::i;:::-;5002:119;5160:1;5185:53;5230:7;5221:6;5210:9;5206:22;5185:53;:::i;:::-;5175:63;;5131:117;5287:2;5313:53;5358:7;5349:6;5338:9;5334:22;5313:53;:::i;:::-;5303:63;;5258:118;4909:474;;;;;:::o;5389:90::-;5423:7;5466:5;5459:13;5452:21;5441:32;;5389:90;;;:::o;5485:109::-;5566:21;5581:5;5566:21;:::i;:::-;5561:3;5554:34;5485:109;;:::o;5600:210::-;5687:4;5725:2;5714:9;5710:18;5702:26;;5738:65;5800:1;5789:9;5785:17;5776:6;5738:65;:::i;:::-;5600:210;;;;:::o;5816:169::-;5900:11;5934:6;5929:3;5922:19;5974:4;5969:3;5965:14;5950:29;;5816:169;;;;:::o;5991:160::-;6131:12;6127:1;6119:6;6115:14;6108:36;5991:160;:::o;6157:366::-;6299:3;6320:67;6384:2;6379:3;6320:67;:::i;:::-;6313:74;;6396:93;6485:3;6396:93;:::i;:::-;6514:2;6509:3;6505:12;6498:19;;6157:366;;;:::o;6529:419::-;6695:4;6733:2;6722:9;6718:18;6710:26;;6782:9;6776:4;6772:20;6768:1;6757:9;6753:17;6746:47;6810:131;6936:4;6810:131;:::i;:::-;6802:139;;6529:419;;;:::o;6954:162::-;7094:14;7090:1;7082:6;7078:14;7071:38;6954:162;:::o;7122:366::-;7264:3;7285:67;7349:2;7344:3;7285:67;:::i;:::-;7278:74;;7361:93;7450:3;7361:93;:::i;:::-;7479:2;7474:3;7470:12;7463:19;;7122:366;;;:::o;7494:419::-;7660:4;7698:2;7687:9;7683:18;7675:26;;7747:9;7741:4;7737:20;7733:1;7722:9;7718:17;7711:47;7775:131;7901:4;7775:131;:::i;:::-;7767:139;;7494:419;;;:::o;7919:167::-;8059:19;8055:1;8047:6;8043:14;8036:43;7919:167;:::o;8092:366::-;8234:3;8255:67;8319:2;8314:3;8255:67;:::i;:::-;8248:74;;8331:93;8420:3;8331:93;:::i;:::-;8449:2;8444:3;8440:12;8433:19;;8092:366;;;:::o;8464:419::-;8630:4;8668:2;8657:9;8653:18;8645:26;;8717:9;8711:4;8707:20;8703:1;8692:9;8688:17;8681:47;8745:131;8871:4;8745:131;:::i;:::-;8737:139;;8464:419;;;:::o;8889:118::-;8976:24;8994:5;8976:24;:::i;:::-;8971:3;8964:37;8889:118;;:::o;9013:::-;9100:24;9118:5;9100:24;:::i;:::-;9095:3;9088:37;9013:118;;:::o;9137:553::-;9314:4;9352:3;9341:9;9337:19;9329:27;;9366:71;9434:1;9423:9;9419:17;9410:6;9366:71;:::i;:::-;9447:72;9515:2;9504:9;9500:18;9491:6;9447:72;:::i;:::-;9529;9597:2;9586:9;9582:18;9573:6;9529:72;:::i;:::-;9611;9679:2;9668:9;9664:18;9655:6;9611:72;:::i;:::-;9137:553;;;;;;;:::o;9696:167::-;9836:19;9832:1;9824:6;9820:14;9813:43;9696:167;:::o;9869:366::-;10011:3;10032:67;10096:2;10091:3;10032:67;:::i;:::-;10025:74;;10108:93;10197:3;10108:93;:::i;:::-;10226:2;10221:3;10217:12;10210:19;;9869:366;;;:::o;10241:419::-;10407:4;10445:2;10434:9;10430:18;10422:26;;10494:9;10488:4;10484:20;10480:1;10469:9;10465:17;10458:47;10522:131;10648:4;10522:131;:::i;:::-;10514:139;;10241:419;;;:::o;10666:222::-;10759:4;10797:2;10786:9;10782:18;10774:26;;10810:71;10878:1;10867:9;10863:17;10854:6;10810:71;:::i;:::-;10666:222;;;;:::o;10894:165::-;11034:17;11030:1;11022:6;11018:14;11011:41;10894:165;:::o;11065:366::-;11207:3;11228:67;11292:2;11287:3;11228:67;:::i;:::-;11221:74;;11304:93;11393:3;11304:93;:::i;:::-;11422:2;11417:3;11413:12;11406:19;;11065:366;;;:::o;11437:419::-;11603:4;11641:2;11630:9;11626:18;11618:26;;11690:9;11684:4;11680:20;11676:1;11665:9;11661:17;11654:47;11718:131;11844:4;11718:131;:::i;:::-;11710:139;;11437:419;;;:::o;11862:160::-;12002:12;11998:1;11990:6;11986:14;11979:36;11862:160;:::o;12028:366::-;12170:3;12191:67;12255:2;12250:3;12191:67;:::i;:::-;12184:74;;12267:93;12356:3;12267:93;:::i;:::-;12385:2;12380:3;12376:12;12369:19;;12028:366;;;:::o;12400:419::-;12566:4;12604:2;12593:9;12589:18;12581:26;;12653:9;12647:4;12643:20;12639:1;12628:9;12624:17;12617:47;12681:131;12807:4;12681:131;:::i;:::-;12673:139;;12400:419;;;:::o;12825:161::-;12965:13;12961:1;12953:6;12949:14;12942:37;12825:161;:::o;12992:366::-;13134:3;13155:67;13219:2;13214:3;13155:67;:::i;:::-;13148:74;;13231:93;13320:3;13231:93;:::i;:::-;13349:2;13344:3;13340:12;13333:19;;12992:366;;;:::o;13364:419::-;13530:4;13568:2;13557:9;13553:18;13545:26;;13617:9;13611:4;13607:20;13603:1;13592:9;13588:17;13581:47;13645:131;13771:4;13645:131;:::i;:::-;13637:139;;13364:419;;;:::o;13789:162::-;13929:14;13925:1;13917:6;13913:14;13906:38;13789:162;:::o;13957:366::-;14099:3;14120:67;14184:2;14179:3;14120:67;:::i;:::-;14113:74;;14196:93;14285:3;14196:93;:::i;:::-;14314:2;14309:3;14305:12;14298:19;;13957:366;;;:::o;14329:419::-;14495:4;14533:2;14522:9;14518:18;14510:26;;14582:9;14576:4;14572:20;14568:1;14557:9;14553:17;14546:47;14610:131;14736:4;14610:131;:::i;:::-;14602:139;;14329:419;;;:::o;14754:112::-;14837:22;14853:5;14837:22;:::i;:::-;14832:3;14825:35;14754:112;;:::o;14872:545::-;15045:4;15083:3;15072:9;15068:19;15060:27;;15097:71;15165:1;15154:9;15150:17;15141:6;15097:71;:::i;:::-;15178:68;15242:2;15231:9;15227:18;15218:6;15178:68;:::i;:::-;15256:72;15324:2;15313:9;15309:18;15300:6;15256:72;:::i;:::-;15338;15406:2;15395:9;15391:18;15382:6;15338:72;:::i;:::-;14872:545;;;;;;;:::o;15423:332::-;15544:4;15582:2;15571:9;15567:18;15559:26;;15595:71;15663:1;15652:9;15648:17;15639:6;15595:71;:::i;:::-;15676:72;15744:2;15733:9;15729:18;15720:6;15676:72;:::i;:::-;15423:332;;;;;:::o;15761:442::-;15910:4;15948:2;15937:9;15933:18;15925:26;;15961:71;16029:1;16018:9;16014:17;16005:6;15961:71;:::i;:::-;16042:72;16110:2;16099:9;16095:18;16086:6;16042:72;:::i;:::-;16124;16192:2;16181:9;16177:18;16168:6;16124:72;:::i;:::-;15761:442;;;;;;:::o;16209:180::-;16257:77;16254:1;16247:88;16354:4;16351:1;16344:15;16378:4;16375:1;16368:15;16395:233;16434:3;16457:24;16475:5;16457:24;:::i;:::-;16448:33;;16503:66;16496:5;16493:77;16490:103;;16573:18;;:::i;:::-;16490:103;16620:1;16613:5;16609:13;16602:20;;16395:233;;;:::o;16634:148::-;16736:11;16773:3;16758:18;;16634:148;;;;:::o;16788:214::-;16928:66;16924:1;16916:6;16912:14;16905:90;16788:214;:::o;17008:400::-;17168:3;17189:84;17271:1;17266:3;17189:84;:::i;:::-;17182:91;;17282:93;17371:3;17282:93;:::i;:::-;17400:1;17395:3;17391:11;17384:18;;17008:400;;;:::o;17414:79::-;17453:7;17482:5;17471:16;;17414:79;;;:::o;17499:157::-;17604:45;17624:24;17642:5;17624:24;:::i;:::-;17604:45;:::i;:::-;17599:3;17592:58;17499:157;;:::o;17662:663::-;17903:3;17925:148;18069:3;17925:148;:::i;:::-;17918:155;;18083:75;18154:3;18145:6;18083:75;:::i;:::-;18183:2;18178:3;18174:12;18167:19;;18196:75;18267:3;18258:6;18196:75;:::i;:::-;18296:2;18291:3;18287:12;18280:19;;18316:3;18309:10;;17662:663;;;;;:::o;18331:98::-;18382:6;18416:5;18410:12;18400:22;;18331:98;;;:::o;18435:147::-;18536:11;18573:3;18558:18;;18435:147;;;;:::o;18588:246::-;18669:1;18679:113;18693:6;18690:1;18687:13;18679:113;;;18778:1;18773:3;18769:11;18763:18;18759:1;18754:3;18750:11;18743:39;18715:2;18712:1;18708:10;18703:15;;18679:113;;;18826:1;18817:6;18812:3;18808:16;18801:27;18650:184;18588:246;;;:::o;18840:386::-;18944:3;18972:38;19004:5;18972:38;:::i;:::-;19026:88;19107:6;19102:3;19026:88;:::i;:::-;19019:95;;19123:65;19181:6;19176:3;19169:4;19162:5;19158:16;19123:65;:::i;:::-;19213:6;19208:3;19204:16;19197:23;;18948:278;18840:386;;;;:::o;19232:271::-;19362:3;19384:93;19473:3;19464:6;19384:93;:::i;:::-;19377:100;;19494:3;19487:10;;19232:271;;;;:::o;19509:116::-;19579:21;19594:5;19579:21;:::i;:::-;19572:5;19569:32;19559:60;;19615:1;19612;19605:12;19559:60;19509:116;:::o;19631:137::-;19685:5;19716:6;19710:13;19701:22;;19732:30;19756:5;19732:30;:::i;:::-;19631:137;;;;:::o;19774:345::-;19841:6;19890:2;19878:9;19869:7;19865:23;19861:32;19858:119;;;19896:79;;:::i;:::-;19858:119;20016:1;20041:61;20094:7;20085:6;20074:9;20070:22;20041:61;:::i;:::-;20031:71;;19987:125;19774:345;;;;:::o;20125:664::-;20330:4;20368:3;20357:9;20353:19;20345:27;;20382:71;20450:1;20439:9;20435:17;20426:6;20382:71;:::i;:::-;20463:72;20531:2;20520:9;20516:18;20507:6;20463:72;:::i;:::-;20545;20613:2;20602:9;20598:18;20589:6;20545:72;:::i;:::-;20627;20695:2;20684:9;20680:18;20671:6;20627:72;:::i;:::-;20709:73;20777:3;20766:9;20762:19;20753:6;20709:73;:::i;:::-;20125:664;;;;;;;;:::o

ipfs://febaff6b8c82ed74adc72afc1cdbf5c5eb2f1bc8181442df5216b7eb61131755