Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

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(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 ...
• 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 Strings
•    - function toString(uint256 value)
•    - function toString(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(bytes32 hash, uin ...
•    - function recover(bytes32 hash, uint8 ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function toDataWithIntendedValidatorH ...
• 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 ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
•  contract Presale is Ownable, Reent ... *
•    - function depositTokens()
•    - function isWhitelisted(bytes memory s ...
•    - function contribute(bytes memory sign ...
•    - function claim()
•    - function _vestedBonusTokens(uint256 b ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at gnosisscan.io on 2024-10-22
*/

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.9.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) {
                // 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.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 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 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


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

pragma solidity ^0.8.0;

/**
 * @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: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.9.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 `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(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) {
        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);
    }

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.9.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 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @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 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.9.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: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: contracts/Presale.sol


pragma solidity 0.8.22;

// Importing necessary OpenZeppelin contracts and libraries





/**
 * @title Presale Contract
 * @dev This contract manages a token presale with bonus thresholds and vesting for bonus tokens.
 * Users can contribute ETH during the presale period and claim their tokens after the claim period starts.
 * The contract supports a whitelist for early contributions and applies bonuses based on contribution thresholds.
 */
contract Presale is Ownable, ReentrancyGuard {
    /// @dev Structure to store each contributor's information
    struct Contribution {
        uint256 amount; // Actual ETH invested by the user
        uint256 effectiveAmount; // Effective ETH after applying bonuses
        uint256 claimedBonusTokens; // Bonus tokens already claimed by the user
        bool claimed; // Whether the user has claimed their initial tokens
    }

    // Custom errors for more gas-efficient error handling

    error TransferFailed(); // Thrown when ETH transfer to treasury wallet fails
    error LowContribution(); // Thrown when ETH sent does not meet the minimum contribution
    error AlreadyDeposited(); // Thrown when tokens have already been deposited
    error InvalidWalletInput(); // Thrown when an invalid wallet address is provided
    error InvalidPresaleClaimInput(); // Thrown when presale claim time is invalid
    error InvalidPresaleInput(); // Thrown when presale parameters are invalid
    error InvalidWhitelistInput(); // Thrown when whitelist parameters are invalid
    error NotWhitelisted(); // Thrown when a user is not whitelisted
    error ClaimPeriodNotStarted(); // Thrown when claim period hasn't started yet
    error NoContributionsToClaim(); // Thrown when a user has no contributions to claim
    error NotInContributionPeriod(); // Thrown when contributions are made outside the allowed period

    /// @notice Emitted when tokens are deposited into the contract
    /// @param amount The amount of tokens deposited
    event TokensDeposited(uint256 amount);

    /// @notice Emitted when a user makes a contribution
    /// @param user The address of the contributor
    /// @param amount The amount of ETH contributed
    /// @param effectiveAmount The effective amount after applying bonuses
    event ContributionReceived(address indexed user, uint256 amount, uint256 effectiveAmount);

    /// @notice Emitted when a user claims their initial tokens
    /// @param user The address of the user
    /// @param amount The amount of tokens claimed
    event TokensClaimed(address indexed user, uint256 amount);

    /// @notice Emitted when a user claims their bonus tokens
    /// @param user The address of the user
    /// @param amount The amount of bonus tokens claimed
    event BonusTokensClaimed(address indexed user, uint256 amount);

    // Constants for percentage calculations
    uint256 private constant ONE_PERCENT = 10 ** 27; // Represents 1% in fixed-point arithmetic
    uint256 private constant ONE_HUNDRED_PERCENT = 100 * ONE_PERCENT; // Represents 100%

    /// @notice The ERC20 token being sold
    IERC20 public token;

    /// @notice Indicates whether tokens have been deposited into the contract
    bool public tokensDeposited;

    /// @notice Total number of tokens allocated for the presale
    uint256 public presaleSupply;

    /// @notice Total actual ETH collected from contributors
    uint256 public totalEth;

    /// @notice Total effective ETH after applying bonuses
    uint256 public totalEthEffective;

    /// @notice Start time for the whitelist contribution period
    uint256 public whitelistStartTime;

    /// @notice End time for the whitelist contribution period
    uint256 public whitelistEndTime;

    /// @notice Start time for the public presale
    uint256 public publicPresaleStartTime;

    /// @notice End time for the public presale
    uint256 public publicPresaleEndTime;

    /// @notice Start time when token claims can begin
    uint256 public presaleClaimStartTime;

    /// @notice End time for the vesting period of bonus tokens
    uint256 public presaleVestingEndTime;

    /// @notice Array of bonus rates corresponding to thresholds
    uint256[] public bonusRates;

    /// @notice Array of ETH thresholds for bonus rates
    uint256[] public bonusThresholds;

    /// @notice Mapping of contributions by user address
    mapping(address => Contribution) public contributions;

    /// @notice Address of the treasury wallet where collected ETH is sent
    address public treasuryWallet;

    /// @notice Address of the signer for whitelist verification
    address public whitelistSigner;

    /// @dev Modifier to ensure the function is called after the claim period has started
    modifier afterClaimStart() {
        if (block.timestamp <= presaleClaimStartTime) revert ClaimPeriodNotStarted();
        _;
    }

    /**
     * @notice Constructor to initialize the presale contract
     * @param _token The ERC20 token being sold
     * @param _presaleSupply The total number of tokens allocated for the presale
     * @param _whitelistSigner The address of the whitelist signer
     * @param _treasuryWallet The address of the treasury wallet to receive ETH
     * @param _whitelistStartTime The start time for the whitelist contribution period
     * @param _whitelistEndTime The end time for the whitelist contribution period
     * @param _publicPresaleStartTime The start time for the public presale
     * @param _publicPresaleEndTime The end time for the public presale
     * @param _presaleClaimStartTime The start time when token claims can begin
     */
    constructor(
        IERC20 _token,
        uint256 _presaleSupply,
        address _whitelistSigner,
        address payable _treasuryWallet,
        uint256 _whitelistStartTime,
        uint256 _whitelistEndTime,
        uint256 _publicPresaleStartTime,
        uint256 _publicPresaleEndTime,
        uint256 _presaleClaimStartTime
    ) {
        // Validate treasury wallet address
        if (_treasuryWallet == address(0)) revert InvalidWalletInput();

        // Validate whitelist and presale times
        if (_whitelistEndTime < _whitelistStartTime) revert InvalidWhitelistInput();
        if (_publicPresaleStartTime < _whitelistEndTime) revert InvalidWhitelistInput();
        if (_publicPresaleEndTime < _publicPresaleStartTime) revert InvalidPresaleInput();
        if (_presaleClaimStartTime < _publicPresaleEndTime) revert InvalidPresaleClaimInput();

        // Initialize state variables
        token = _token; // Address of the ERC20 token being sold
        presaleSupply = _presaleSupply; // Total number of tokens allocated for the presale

        whitelistStartTime = _whitelistStartTime; // Start time for the whitelist period
        whitelistEndTime = _whitelistEndTime; // End time for the whitelist period
        publicPresaleStartTime = _publicPresaleStartTime; // Start time for the public presale
        publicPresaleEndTime = _publicPresaleEndTime; // End time for the public presale
        presaleClaimStartTime = _presaleClaimStartTime; // Start time for token claims
        presaleVestingEndTime = presaleClaimStartTime + 30 days; // Vesting ends 30 days after claim start

        treasuryWallet = _treasuryWallet; // Address of the treasury wallet
        whitelistSigner = _whitelistSigner; // Address of the whitelist signer

        // Initialize bonus thresholds and rates
        bonusRates = [
            uint256(40) * ONE_PERCENT, // 40% bonus rate
            uint256(30) * ONE_PERCENT, // 30% bonus rate
            uint256(15) * ONE_PERCENT, // 15% bonus rate
            0 // 0% bonus rate beyond thresholds
        ];
        bonusThresholds = [5 ether, 10 ether, 20 ether]; // Bonus thresholds at 5 ETH, 10 ETH, and 20 ETH
    }

    /**
     * @notice Allows the owner to deposit tokens into the contract for the presale
     */
    function depositTokens() external onlyOwner {
        if (tokensDeposited) revert AlreadyDeposited();
        token.transferFrom(msg.sender, address(this), presaleSupply);
        tokensDeposited = true;
        emit TokensDeposited(presaleSupply);
    }

    /**
     * @notice Checks if an address is whitelisted
     * @param signature The signature provided by the user
     * @return bool indicating whether the user is whitelisted
     */
    function isWhitelisted(bytes memory signature) external view returns (bool) {
        // Recreate the signed message hash
        bytes32 messageHash = keccak256(abi.encodePacked(msg.sender));
        bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(messageHash);

        // Verify the signature
        return ECDSA.recover(ethSignedMessageHash, signature) == whitelistSigner;
    }

    /**
     * @notice Allows users to contribute ETH during the presale period
     * @param signature The signature for whitelist verification during the whitelist period
     */
    function contribute(bytes memory signature) public payable nonReentrant {
        if (msg.value == 0) {
            revert LowContribution(); // Ensure no dust eth is sent
        }

        // Check if contribution is within allowed time frames
        if (block.timestamp < whitelistStartTime || block.timestamp > publicPresaleEndTime) {
            revert NotInContributionPeriod();
        }

        // If within whitelist period, verify signature
        if (block.timestamp <= whitelistEndTime) {
            if (signature.length == 0) {
                revert NotWhitelisted();
            }

            // Recreate the signed message hash
            bytes32 messageHash = keccak256(abi.encodePacked(msg.sender));
            bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(messageHash);

            // Verify the signature
            if (ECDSA.recover(ethSignedMessageHash, signature) != whitelistSigner) {
                revert NotWhitelisted();
            }
        }

        uint256 remainingDeposit = msg.value; // Remaining ETH to process
        uint256 effectiveAmount = 0; // Total effective amount after bonuses

        // Iterate through bonus thresholds and apply bonuses
        for (uint256 i = 0; i < bonusThresholds.length; i++) {
            if (remainingDeposit == 0 || totalEth >= bonusThresholds[i]) {
                // If no remaining ETH to process or we've exceeded the threshold, break
                continue;
            }

            uint256 thresholdAmount = bonusThresholds[i] - totalEth;
            uint256 amountInThisThreshold = remainingDeposit <= thresholdAmount
                ? remainingDeposit
                : thresholdAmount; // Calculate how much ETH can be processed in this threshold
            uint256 bonusAmount = (amountInThisThreshold * bonusRates[i]) / ONE_HUNDRED_PERCENT; // Calculate bonus

            effectiveAmount += amountInThisThreshold + bonusAmount; // Update effective amount
            remainingDeposit -= amountInThisThreshold; // Update remaining deposit
            totalEth += amountInThisThreshold; // Update total ETH collected
        }

        // Any remaining deposit beyond thresholds gets no bonus
        if (remainingDeposit > 0) {
            effectiveAmount += remainingDeposit; // Add remaining deposit to effective amount
            totalEth += remainingDeposit; // Update total ETH collected
        }

        totalEthEffective += effectiveAmount; // Update total effective ETH

        // Update user's contribution
        Contribution storage userContribution = contributions[msg.sender];
        userContribution.amount += msg.value; // Update actual amount contributed
        userContribution.effectiveAmount += effectiveAmount; // Update effective amount

        // Transfer the contributed ETH to the treasury wallet
        (bool success, ) = treasuryWallet.call{value: msg.value}("");
        if (!success) {
            revert TransferFailed(); // Revert if transfer fails
        }

        emit ContributionReceived(msg.sender, msg.value, effectiveAmount); // Emit event
    }

    /**
     * @notice Allows users to claim their tokens after the claim period has started
     */
    function claim() external afterClaimStart nonReentrant {
        Contribution storage userContribution = contributions[msg.sender];
        if (userContribution.amount == 0 && userContribution.effectiveAmount == 0)
            revert NoContributionsToClaim(); // Ensure the user has contributions to claim

        // Claim initial tokens if not already claimed
        if (!userContribution.claimed) {
            // Calculate the amount of tokens to distribute immediately
            uint256 userAmountTokens = (userContribution.amount * presaleSupply) /
                totalEthEffective;

            userContribution.claimed = true; // Mark as claimed

            token.transfer(msg.sender, userAmountTokens); // Transfer tokens to the user

            emit TokensClaimed(msg.sender, userAmountTokens); // Emit event
        }

        // Calculate bonus tokens
        uint256 bonusAmountEth = userContribution.effectiveAmount - userContribution.amount;

        if (bonusAmountEth > 0) {
            // Calculate vested bonus tokens
            uint256 vestedTokens = _vestedBonusTokens(bonusAmountEth);
            // Calculate claimable amount (vested amount minus already claimed)
            uint256 claimableTokens = vestedTokens - userContribution.claimedBonusTokens;

            if (claimableTokens > 0) {
                // Update user's claimed bonus tokens
                userContribution.claimedBonusTokens =
                    userContribution.claimedBonusTokens +
                    claimableTokens;

                token.transfer(msg.sender, claimableTokens); // Transfer bonus tokens to the user

                emit BonusTokensClaimed(msg.sender, claimableTokens); // Emit event
            }
        }
    }

    /**
     * @dev Internal function to calculate the number of vested bonus tokens for a user
     * @param bonusAmountEth The bonus ETH amount contributed by the user
     * @return The amount of bonus tokens that have vested
     */
    function _vestedBonusTokens(uint256 bonusAmountEth) internal view returns (uint256) {
        if (block.timestamp >= presaleVestingEndTime) {
            // All bonus tokens have vested
            return (bonusAmountEth * presaleSupply) / totalEthEffective;
        } else {
            uint256 vestingDuration = presaleVestingEndTime - presaleClaimStartTime; // Total vesting duration
            uint256 timeElapsed = block.timestamp - presaleClaimStartTime; // Time elapsed since claim start

            // Calculate vested amount proportionally
            return
                (((bonusAmountEth * timeElapsed) / vestingDuration) * presaleSupply) /
                totalEthEffective;
        }
    }

    /**
     * @notice Fallback function to receive ETH contributions
     * Users can send ETH directly to the contract address to participate in the presale
     */
    receive() external payable {
        contribute(""); // Calls the contribute function without a signature (for public presale)
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_presaleSupply","type":"uint256"},{"internalType":"address","name":"_whitelistSigner","type":"address"},{"internalType":"address payable","name":"_treasuryWallet","type":"address"},{"internalType":"uint256","name":"_whitelistStartTime","type":"uint256"},{"internalType":"uint256","name":"_whitelistEndTime","type":"uint256"},{"internalType":"uint256","name":"_publicPresaleStartTime","type":"uint256"},{"internalType":"uint256","name":"_publicPresaleEndTime","type":"uint256"},{"internalType":"uint256","name":"_presaleClaimStartTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyDeposited","type":"error"},{"inputs":[],"name":"ClaimPeriodNotStarted","type":"error"},{"inputs":[],"name":"InvalidPresaleClaimInput","type":"error"},{"inputs":[],"name":"InvalidPresaleInput","type":"error"},{"inputs":[],"name":"InvalidWalletInput","type":"error"},{"inputs":[],"name":"InvalidWhitelistInput","type":"error"},{"inputs":[],"name":"LowContribution","type":"error"},{"inputs":[],"name":"NoContributionsToClaim","type":"error"},{"inputs":[],"name":"NotInContributionPeriod","type":"error"},{"inputs":[],"name":"NotWhitelisted","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BonusTokensClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"effectiveAmount","type":"uint256"}],"name":"ContributionReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensDeposited","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bonusRates","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bonusThresholds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"contribute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"contributions","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"effectiveAmount","type":"uint256"},{"internalType":"uint256","name":"claimedBonusTokens","type":"uint256"},{"internalType":"bool","name":"claimed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depositTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"isWhitelisted","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":"presaleClaimStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"presaleSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"presaleVestingEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicPresaleEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicPresaleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensDeposited","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalEth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalEthEffective","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000680daad643a0b8a3e359316d53c0f2dfa720ba48000000000000000000000000000000000000000f2568bc2d21591d7f800000000000000000000000000000005df06d366e58ab44590d35d620c4e666b3b166530000000000000000000000003f719fc043f7dcd2d33c6bfefc44e77eb9e1eb470000000000000000000000000000000000000000000000000000000067166263000000000000000000000000000000000000000000000000000000006716638f000000000000000000000000000000000000000000000000000000006716638f00000000000000000000000000000000000000000000000000000000671664bb00000000000000000000000000000000000000000000000000000000671664f7

-----Decoded View---------------
Arg [0] : _token (address): 0x680daaD643A0B8a3e359316D53c0F2dfa720bA48
Arg [1] : _presaleSupply (uint256): 1200000000000000000000000000000
Arg [2] : _whitelistSigner (address): 0x5df06d366E58Ab44590d35D620C4E666B3b16653
Arg [3] : _treasuryWallet (address): 0x3f719FC043F7dCd2D33C6BFefC44e77Eb9E1eB47
Arg [4] : _whitelistStartTime (uint256): 1729520227
Arg [5] : _whitelistEndTime (uint256): 1729520527
Arg [6] : _publicPresaleStartTime (uint256): 1729520527
Arg [7] : _publicPresaleEndTime (uint256): 1729520827
Arg [8] : _presaleClaimStartTime (uint256): 1729520887

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 000000000000000000000000680daad643a0b8a3e359316d53c0f2dfa720ba48
Arg [1] : 000000000000000000000000000000000000000f2568bc2d21591d7f80000000
Arg [2] : 0000000000000000000000005df06d366e58ab44590d35d620c4e666b3b16653
Arg [3] : 0000000000000000000000003f719fc043f7dcd2d33c6bfefc44e77eb9e1eb47
Arg [4] : 0000000000000000000000000000000000000000000000000000000067166263
Arg [5] : 000000000000000000000000000000000000000000000000000000006716638f
Arg [6] : 000000000000000000000000000000000000000000000000000000006716638f
Arg [7] : 00000000000000000000000000000000000000000000000000000000671664bb
Arg [8] : 00000000000000000000000000000000000000000000000000000000671664f7

36847:15030:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51778:14;;;;;;;;;;;;;:10;:14::i;:::-;36847:15030;;;;;40753:32;;;;;;;;;;-1:-1:-1;40753:32:0;;;;;:::i;:::-;;:::i;:::-;;;345:25:1;;;333:2;318:18;40753:32:0;;;;;;;;39647:27;;;;;;;;;;-1:-1:-1;39647:27:0;;;;-1:-1:-1;;;39647:27:0;;;;;;;;;546:14:1;;539:22;521:41;;509:2;494:18;39647:27:0;381:187:1;39848:23:0;;;;;;;;;;;;;;;;40852:53;;;;;;;;;;-1:-1:-1;40852:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1089:25:1;;;1145:2;1130:18;;1123:34;;;;1173:18;;;1166:34;1243:14;1236:22;1231:2;1216:18;;1209:50;1076:3;1061:19;40852:53:0;864:401:1;45525:3176:0;;;;;;:::i;:::-;;:::i;40990:29::-;;;;;;;;;;-1:-1:-1;40990:29:0;;;;-1:-1:-1;;;;;40990:29:0;;;;;;-1:-1:-1;;;;;2492:32:1;;;2474:51;;2462:2;2447:18;40990:29:0;2328:203:1;48813:1778:0;;;;;;;;;;;;;:::i;32294:103::-;;;;;;;;;;;;;:::i;39940:32::-;;;;;;;;;;;;;;;;44469:259;;;;;;;;;;;;;:::i;40660:27::-;;;;;;;;;;-1:-1:-1;40660:27:0;;;;;:::i;:::-;;:::i;44930:402::-;;;;;;;;;;-1:-1:-1;44930:402:0;;;;;:::i;:::-;;:::i;31653:87::-;;;;;;;;;;-1:-1:-1;31699:7:0;31726:6;-1:-1:-1;;;;;31726:6:0;31653:87;;40047:33;;;;;;;;;;;;;;;;39749:28;;;;;;;;;;;;;;;;40439:36;;;;;;;;;;;;;;;;40339:35;;;;;;;;;;;;;;;;40153:31;;;;;;;;;;;;;;;;41094:30;;;;;;;;;;-1:-1:-1;41094:30:0;;;;-1:-1:-1;;;;;41094:30:0;;;32552:201;;;;;;;;;;-1:-1:-1;32552:201:0;;;;;:::i;:::-;;:::i;40244:37::-;;;;;;;;;;;;;;;;40549:36;;;;;;;;;;;;;;;;39539:19;;;;;;;;;;-1:-1:-1;39539:19:0;;;;-1:-1:-1;;;;;39539:19:0;;;45525:3176;35456:21;:19;:21::i;:::-;45612:9:::1;45625:1;45612:14:::0;45608:101:::1;;45650:17;;-1:-1:-1::0;;;45650:17:0::1;;;;;;;;;;;45608:101;45807:18;;45789:15;:36;:78;;;;45847:20;;45829:15;:38;45789:78;45785:143;;;45891:25;;-1:-1:-1::0;;;45891:25:0::1;;;;;;;;;;;45785:143;46020:16;;46001:15;:35;45997:548;;46057:9;:16;46077:1;46057:21:::0;46053:85:::1;;46106:16;;-1:-1:-1::0;;;46106:16:0::1;;;;;;;;;;;46053:85;46235:28;::::0;;-1:-1:-1;;46252:10:0::1;2908:2:1::0;2904:15;2900:53;46235:28:0::1;::::0;;::::1;2888:66:1::0;;;;46235:28:0;;;;;;;;;2970:12:1;;;;46235:28:0;;;46225:39;;;::::1;::::0;24888:34;46203:19:::1;24875:48:::0;;;24944:4;24937:18;;;24996:4;24980:21;;46459:15:::1;::::0;-1:-1:-1;;;;;46459:15:0::1;46409:46;24980:21:::0;46445:9;46409:13:::1;:46::i;:::-;-1:-1:-1::0;;;;;46409:65:0::1;;46405:129;;46502:16;;-1:-1:-1::0;;;46502:16:0::1;;;;;;;;;;;46405:129;46038:507;;45997:548;46584:9;46557:24;::::0;46775:936:::1;46799:15;:22:::0;46795:26;::::1;46775:936;;;46847:21:::0;;;:55:::1;;;46884:15;46900:1;46884:18;;;;;;;;:::i;:::-;;;;;;;;;46872:8;;:30;;46847:55;47013:8;46843:194;47053:23;47100:8;;47079:15;47095:1;47079:18;;;;;;;;:::i;:::-;;;;;;;;;:29;;;;:::i;:::-;47053:55;;47123:29;47175:15;47155:16;:35;;:106;;47246:15;47155:106;;;47210:16;47155:106;47123:138:::0;-1:-1:-1;47337:19:0::1;39450:17;39345:8;39450:3;:17;:::i;:::-;47384:10;47395:1;47384:13;;;;;;;;:::i;:::-;;;;;;;;;47360:21;:37;;;;:::i;:::-;47359:61;;;;:::i;:::-;47337:83:::0;-1:-1:-1;47475:35:0::1;47337:83:::0;47475:21;:35:::1;:::i;:::-;47456:54;::::0;;::::1;:::i;:::-;::::0;-1:-1:-1;47552:41:0::1;47572:21:::0;47552:41;::::1;:::i;:::-;;;47648:21;47636:8;;:33;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;46775:936:0::1;46823:3;;46775:936;;;-1:-1:-1::0;47793:20:0;;47789:206:::1;;47830:35;47849:16:::0;47830:35;::::1;:::i;:::-;;;47937:16;47925:8;;:28;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;47789:206:0::1;48028:15;48007:17;;:36;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;48179:10:0::1;48125:37;48165:25:::0;;;:13:::1;:25;::::0;;;;48201:36;;48165:25;;48228:9:::1;::::0;48165:25;;48125:37;48201:36:::1;::::0;48228:9;;48201:36:::1;:::i;:::-;;;;;;;;48320:15;48284:16;:32;;;:51;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;48458:14:0::1;::::0;:41:::1;::::0;48440:12:::1;::::0;-1:-1:-1;;;;;48458:14:0::1;::::0;48485:9:::1;::::0;48440:12;48458:41;48440:12;48458:41;48485:9;48458:14;:41:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48439:60;;;48515:7;48510:92;;48546:16;;-1:-1:-1::0;;;48546:16:0::1;;;;;;;;;;;48510:92;48619:60;::::0;;48652:9:::1;4299:25:1::0;;4355:2;4340:18;;4333:34;;;48640:10:0::1;::::0;48619:60:::1;::::0;4272:18:1;48619:60:0::1;;;;;;;45597:3104;;;;35500:20:::0;34894:1;36020:22;;35837:213;35500:20;45525:3176;:::o;40753:32::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40753:32:0;:::o;48813:1778::-;41285:21;;41266:15;:40;41262:76;;41315:23;;-1:-1:-1;;;41315:23:0;;;;;;;;;;;41262:76;35456:21:::1;:19;:21::i;:::-;48933:10:::2;48879:37;48919:25:::0;;;:13:::2;:25;::::0;;;;48959:23;;:28;:69;::::2;;;-1:-1:-1::0;48991:32:0::2;::::0;::::2;::::0;:37;48959:69:::2;48955:119;;;49050:24;;-1:-1:-1::0;;;49050:24:0::2;;;;;;;;;;;48955:119;49194:24;::::0;::::2;::::0;::::2;;49189:474;;49396:17;::::0;49362:13:::2;::::0;49336:23;;49308:24:::2;::::0;49396:17;49336:39:::2;::::0;::::2;:::i;:::-;49335:78;;;;:::i;:::-;49430:24;::::0;::::2;:31:::0;;-1:-1:-1;;49430:31:0::2;49457:4;49430:31;::::0;;49497:5:::2;::::0;:44:::2;::::0;-1:-1:-1;;;49497:44:0;;49512:10:::2;49497:44;::::0;::::2;4552:51:1::0;4619:18;;;4612:34;;;;;-1:-1:-1;;;;;;49497:5:0::2;::::0;:14:::2;::::0;4525:18:1;;49497:44:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;49594:43:0::2;::::0;345:25:1;;;49608:10:0::2;::::0;49594:43:::2;::::0;333:2:1;318:18;49594:43:0::2;;;;;;;49220:443;49189:474;49770:23:::0;;49735:32:::2;::::0;::::2;::::0;49710:22:::2;::::0;49735:58:::2;::::0;::::2;:::i;:::-;49710:83:::0;-1:-1:-1;49810:18:0;;49806:778:::2;;49891:20;49914:34;49933:14;49914:18;:34::i;:::-;49891:57;;50044:23;50085:16;:35;;;50070:12;:50;;;;:::i;:::-;50044:76:::0;-1:-1:-1;50141:19:0;;50137:436:::2;;50354:15;50295:16;:35;;;:74;;;;:::i;:::-;50236:35;::::0;;::::2;:133:::0;;;;50390:5;:43:::2;::::0;-1:-1:-1;;;50390:43:0;;50405:10:::2;50390:43;::::0;::::2;4552:51:1::0;4619:18;;;4612:34;;;-1:-1:-1;;;;;50390:5:0;;::::2;::::0;:14:::2;::::0;4525:18:1;;50390:43:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;50496:47:0::2;::::0;345:25:1;;;50515:10:0::2;::::0;50496:47:::2;::::0;333:2:1;318:18;50496:47:0::2;;;;;;;50137:436;49830:754;;49806:778;48868:1723;;35500:20:::1;34894:1:::0;36020:22;;35837:213;35500:20:::1;48813:1778::o:0;32294:103::-;31539:13;:11;:13::i;:::-;32359:30:::1;32386:1;32359:18;:30::i;44469:259::-:0;31539:13;:11;:13::i;:::-;44528:15:::1;::::0;-1:-1:-1;;;44528:15:0;::::1;;;44524:46;;;44552:18;;-1:-1:-1::0;;;44552:18:0::1;;;;;;;;;;;44524:46;44581:5;::::0;44627:13:::1;::::0;44581:60:::1;::::0;-1:-1:-1;;;44581:60:0;;44600:10:::1;44581:60;::::0;::::1;5179:34:1::0;44620:4:0::1;5229:18:1::0;;;5222:43;5281:18;;;5274:34;;;;-1:-1:-1;;;;;44581:5:0;;::::1;::::0;:18:::1;::::0;5114::1;;44581:60:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;44652:15:0::1;:22:::0;;-1:-1:-1;;;;44652:22:0::1;-1:-1:-1::0;;;44652:22:0::1;::::0;;44706:13:::1;::::0;44690:30:::1;::::0;::::1;::::0;::::1;::::0;345:25:1;;;333:2;318:18;;199:177;44690:30:0::1;;;;;;;;44469:259::o:0;40660:27::-;;;;;;;;;;;;44930:402;45094:28;;-1:-1:-1;;45111:10:0;2908:2:1;2904:15;2900:53;45094:28:0;;;2888:66:1;45000:4:0;;;;2970:12:1;;45094:28:0;;;;;;;;;;;;45084:39;;;;;;45062:61;;45134:28;45165:41;45194:11;24888:34;24683:15;24875:48;;;24944:4;24937:18;;;;24996:4;24980:21;;;24614:405;45165:41;45309:15;;45134:72;;-1:-1:-1;;;;;;45309:15:0;45259:46;45134:72;45295:9;45259:13;:46::i;:::-;-1:-1:-1;;;;;45259:65:0;;;44930:402;-1:-1:-1;;;;44930:402:0:o;32552:201::-;31539:13;:11;:13::i;:::-;-1:-1:-1;;;;;32641:22:0;::::1;32633:73;;;::::0;-1:-1:-1;;;32633:73:0;;5521:2:1;32633:73:0::1;::::0;::::1;5503:21:1::0;5560:2;5540:18;;;5533:30;5599:34;5579:18;;;5572:62;-1:-1:-1;;;5650:18:1;;;5643:36;5696:19;;32633:73:0::1;;;;;;;;;32717:28;32736:8;32717:18;:28::i;35536:293::-:0;34938:1;35670:7;;:19;35662:63;;;;-1:-1:-1;;;35662:63:0;;5928:2:1;35662:63:0;;;5910:21:1;5967:2;5947:18;;;5940:30;6006:33;5986:18;;;5979:61;6057:18;;35662:63:0;5726:355:1;35662:63:0;34938:1;35803:7;:18;35536:293::o;21078:231::-;21156:7;21177:17;21196:18;21218:27;21229:4;21235:9;21218:10;:27::i;:::-;21176:69;;;;21256:18;21268:5;21256:11;:18::i;:::-;-1:-1:-1;21292:9:0;-1:-1:-1;21078:231:0;;;;;:::o;50841:720::-;50916:7;50959:21;;50940:15;:40;50936:618;;51084:17;;51067:13;;51050:30;;:14;:30;:::i;:::-;51049:52;;;;:::i;50936:618::-;51134:23;51184:21;;51160;;:45;;;;:::i;:::-;51134:71;;51246:19;51286:21;;51268:15;:39;;;;:::i;:::-;51246:61;;51525:17;;51491:13;;51472:15;51457:11;51440:14;:28;;;;:::i;:::-;51439:48;;;;:::i;:::-;51438:66;;;;:::i;:::-;51437:105;;;;:::i;:::-;51413:129;50841:720;-1:-1:-1;;;;50841:720:0:o;31818:132::-;31699:7;31726:6;-1:-1:-1;;;;;31726:6:0;30284:10;31882:23;31874:68;;;;-1:-1:-1;;;31874:68:0;;6288:2:1;31874:68:0;;;6270:21:1;;;6307:18;;;6300:30;6366:34;6346:18;;;6339:62;6418:18;;31874:68:0;6086:356:1;32913:191:0;32987:16;33006:6;;-1:-1:-1;;;;;33023:17:0;;;-1:-1:-1;;;;;;33023:17:0;;;;;;33056:40;;33006:6;;;;;;;33056:40;;32987:16;33056:40;32976:128;32913:191;:::o;19529:747::-;19610:7;19619:12;19648:9;:16;19668:2;19648:22;19644:625;;19992:4;19977:20;;19971:27;20042:4;20027:20;;20021:27;20100:4;20085:20;;20079:27;19687:9;20071:36;20143:25;20154:4;20071:36;19971:27;20021;20143:10;:25::i;:::-;20136:32;;;;;;;;;19644:625;-1:-1:-1;20217:1:0;;-1:-1:-1;20221:35:0;19644:625;19529:747;;;;;:::o;17922:521::-;18000:20;17991:5;:29;;;;;;;;:::i;:::-;;17987:449;;17922:521;:::o;17987:449::-;18098:29;18089:5;:38;;;;;;;;:::i;:::-;;18085:351;;18144:34;;-1:-1:-1;;;18144:34:0;;6781:2:1;18144:34:0;;;6763:21:1;6820:2;6800:18;;;6793:30;6859:26;6839:18;;;6832:54;6903:18;;18144:34:0;6579:348:1;18085:351:0;18209:35;18200:5;:44;;;;;;;;:::i;:::-;;18196:240;;18261:41;;-1:-1:-1;;;18261:41:0;;7134:2:1;18261:41:0;;;7116:21:1;7173:2;7153:18;;;7146:30;7212:33;7192:18;;;7185:61;7263:18;;18261:41:0;6932:355:1;18196:240:0;18333:30;18324:5;:39;;;;;;;;:::i;:::-;;18320:116;;18380:44;;-1:-1:-1;;;18380:44:0;;7494:2:1;18380:44:0;;;7476:21:1;7533:2;7513:18;;;7506:30;7572:34;7552:18;;;7545:62;-1:-1:-1;;;7623:18:1;;;7616:32;7665:19;;18380:44:0;7292:398:1;22462:1477:0;22550:7;;23484:66;23471:79;;23467:163;;;-1:-1:-1;23583:1:0;;-1:-1:-1;23587:30:0;23567:51;;23467:163;23744:24;;;23727:14;23744:24;;;;;;;;;7922:25:1;;;7995:4;7983:17;;7963:18;;;7956:45;;;;8017:18;;;8010:34;;;8060:18;;;8053:34;;;23744:24:0;;7894:19:1;;23744:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23744:24:0;;-1:-1:-1;;23744:24:0;;;-1:-1:-1;;;;;;;23783:20:0;;23779:103;;23836:1;23840:29;23820:50;;;;;;;23779:103;23902:6;-1:-1:-1;23910:20:0;;-1:-1:-1;22462:1477:0;;;;;;;;:::o;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;573:286::-;632:6;685:2;673:9;664:7;660:23;656:32;653:52;;;701:1;698;691:12;653:52;727:23;;-1:-1:-1;;;;;779:31:1;;769:42;;759:70;;825:1;822;815:12;759:70;848:5;573:286;-1:-1:-1;;;573:286:1:o;1270:127::-;1331:10;1326:3;1322:20;1319:1;1312:31;1362:4;1359:1;1352:15;1386:4;1383:1;1376:15;1402:921;1470:6;1523:2;1511:9;1502:7;1498:23;1494:32;1491:52;;;1539:1;1536;1529:12;1491:52;1579:9;1566:23;1608:18;1649:2;1641:6;1638:14;1635:34;;;1665:1;1662;1655:12;1635:34;1703:6;1692:9;1688:22;1678:32;;1748:7;1741:4;1737:2;1733:13;1729:27;1719:55;;1770:1;1767;1760:12;1719:55;1806:2;1793:16;1828:2;1824;1821:10;1818:36;;;1834:18;;:::i;:::-;1909:2;1903:9;1877:2;1963:13;;-1:-1:-1;;1959:22:1;;;1983:2;1955:31;1951:40;1939:53;;;2007:18;;;2027:22;;;2004:46;2001:72;;;2053:18;;:::i;:::-;2093:10;2089:2;2082:22;2128:2;2120:6;2113:18;2168:7;2163:2;2158;2154;2150:11;2146:20;2143:33;2140:53;;;2189:1;2186;2179:12;2140:53;2245:2;2240;2236;2232:11;2227:2;2219:6;2215:15;2202:46;2290:1;2268:15;;;2285:2;2264:24;2257:35;;;;-1:-1:-1;2272:6:1;1402:921;-1:-1:-1;;;;;1402:921:1:o;2993:127::-;3054:10;3049:3;3045:20;3042:1;3035:31;3085:4;3082:1;3075:15;3109:4;3106:1;3099:15;3125:127;3186:10;3181:3;3177:20;3174:1;3167:31;3217:4;3214:1;3207:15;3241:4;3238:1;3231:15;3257:128;3324:9;;;3345:11;;;3342:37;;;3359:18;;:::i;3390:168::-;3463:9;;;3494;;3511:15;;;3505:22;;3491:37;3481:71;;3532:18;;:::i;3563:217::-;3603:1;3629;3619:132;;3673:10;3668:3;3664:20;3661:1;3654:31;3708:4;3705:1;3698:15;3736:4;3733:1;3726:15;3619:132;-1:-1:-1;3765:9:1;;3563:217::o;3785:125::-;3850:9;;;3871:10;;;3868:36;;;3884:18;;:::i;4657:277::-;4724:6;4777:2;4765:9;4756:7;4752:23;4748:32;4745:52;;;4793:1;4790;4783:12;4745:52;4825:9;4819:16;4878:5;4871:13;4864:21;4857:5;4854:32;4844:60;;4900:1;4897;4890:12;6447:127;6508:10;6503:3;6499:20;6496:1;6489:31;6539:4;6536:1;6529:15;6563:4;6560:1;6553:15

ipfs://a686012d8981d88fb0aa68d45b897bbdf3e157eb8533037fa270f09e01ac1f42