Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

contract SNACRewards is Ownable, Pausable, ReentrancyGuard {
    using ECDSA for bytes32;
    using EnumerableSet for EnumerableSet.UintSet;

    address public signerAddress;
    address public ERC20Address;
    mapping(address => EnumerableSet.UintSet) seenNonces;

    constructor(address _ERC20Adress) {
        _pause();
        ERC20Address = _ERC20Adress;
    }

    function withdrawERC20Balance(address _address) external onlyOwner {
        uint256 contractBalance = IERC20(ERC20Address).balanceOf(address(this));
        IERC20(ERC20Address).transfer(_address, contractBalance);
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function setERC20Address(address _ERC20Address) external onlyOwner {
        ERC20Address = _ERC20Address;
    }

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

    function verifySignature(
        bytes memory signature,
        uint256 reward,
        uint256 nonce
    ) private view returns (bool) {
        bytes32 hash = keccak256(abi.encodePacked(msg.sender, reward, nonce, address(this)));
        bytes32 messageHash = hash.toEthSignedMessageHash();
        return messageHash.recover(signature) == signerAddress;
    }

    function claimReward(
        bytes memory signature,
        uint256 reward,
        uint256 nonce
    ) external whenNotPaused nonReentrant {
        require(verifySignature(signature, reward, nonce), "Invalid transaction");
        require(!seenNonces[msg.sender].contains(nonce), "Used signature");

        seenNonces[msg.sender].add(nonce);
        IERC20(ERC20Address).transfer(msg.sender, reward * 10**18);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

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

    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");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' 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) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        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.
            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 if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } 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;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 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 (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // 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));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_ERC20Adress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"ERC20Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ERC20Address","type":"address"}],"name":"setERC20Address","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signerAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"withdrawERC20Balance","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000f827f408171dcf69b858c34530212c92df649ef6

-----Decoded View---------------
Arg [0] : _ERC20Adress (address): 0xF827F408171dCf69b858C34530212C92Df649EF6

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000f827f408171dcf69b858c34530212c92df649ef6