Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• 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(
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
•    - function paused()
•    - function _pause()
•    - function _unpause()
•  contract SamuraiLevels is Ownable, ... *
•    - function levelUp(uint256 _data)
•    - function getUserInfo()
•    - function setRewardRate(uint256 _rewar ...
•    - function setStreakCap(uint256 _streak ...
•    - function pause(bool en)

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at ftmscan.com on 2023-01-03
*/

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

//
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
/**
 * @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;
  }
}

//
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
 * @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;
  }
}

//
// OpenZeppelin Contracts v4.4.1 (access/Ownable.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);
  }
}

//
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
  /**
   * @dev Returns true if this contract implements the interface defined by
   * `interfaceId`. See the corresponding
   * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
   * to learn more about how these ids are created.
   *
   * This function call must use less than 30 000 gas.
   */
  function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

//
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
  /**
   * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
   */
  event Transfer(
    address indexed from,
    address indexed to,
    uint256 indexed tokenId
  );

  /**
   * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
   */
  event Approval(
    address indexed owner,
    address indexed approved,
    uint256 indexed tokenId
  );

  /**
   * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
   */
  event ApprovalForAll(
    address indexed owner,
    address indexed operator,
    bool approved
  );

  /**
   * @dev Returns the number of tokens in ``owner``'s account.
   */
  function balanceOf(address owner) external view returns (uint256 balance);

  /**
   * @dev Returns the owner of the `tokenId` token.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   */
  function ownerOf(uint256 tokenId) external view returns (address owner);

  /**
   * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
   * are aware of the ERC721 protocol to prevent tokens from being forever locked.
   *
   * Requirements:
   *
   * - `from` cannot be the zero address.
   * - `to` cannot be the zero address.
   * - `tokenId` token must exist and be owned by `from`.
   * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
   * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
   *
   * Emits a {Transfer} event.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId
  ) external;

  /**
   * @dev Transfers `tokenId` token from `from` to `to`.
   *
   * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
   *
   * Requirements:
   *
   * - `from` cannot be the zero address.
   * - `to` cannot be the zero address.
   * - `tokenId` token must be owned by `from`.
   * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
   *
   * Emits a {Transfer} event.
   */
  function transferFrom(
    address from,
    address to,
    uint256 tokenId
  ) external;

  /**
   * @dev Gives permission to `to` to transfer `tokenId` token to another account.
   * The approval is cleared when the token is transferred.
   *
   * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
   *
   * Requirements:
   *
   * - The caller must own the token or be an approved operator.
   * - `tokenId` must exist.
   *
   * Emits an {Approval} event.
   */
  function approve(address to, uint256 tokenId) external;

  /**
   * @dev Returns the account approved for `tokenId` token.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   */
  function getApproved(uint256 tokenId)
    external
    view
    returns (address operator);

  /**
   * @dev Approve or remove `operator` as an operator for the caller.
   * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
   *
   * Requirements:
   *
   * - The `operator` cannot be the caller.
   *
   * Emits an {ApprovalForAll} event.
   */
  function setApprovalForAll(address operator, bool _approved) external;

  /**
   * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
   *
   * See {setApprovalForAll}
   */
  function isApprovedForAll(address owner, address operator)
    external
    view
    returns (bool);

  /**
   * @dev Safely transfers `tokenId` token from `from` to `to`.
   *
   * Requirements:
   *
   * - `from` cannot be the zero address.
   * - `to` cannot be the zero address.
   * - `tokenId` token must exist and be owned by `from`.
   * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
   * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
   *
   * Emits a {Transfer} event.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes calldata data
  ) external;
}

//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol)
//
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
/**
 * @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 `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);

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

//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)
//
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
  /**
   * @dev Returns the addition of two unsigned integers, with an overflow flag.
   *
   * _Available since v3.4._
   */
  function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
      uint256 c = a + b;
      if (c < a) return (false, 0);
      return (true, c);
    }
  }

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

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

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

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

  /**
   * @dev Returns the addition of two unsigned integers, reverting on
   * overflow.
   *
   * Counterpart to Solidity's `+` operator.
   *
   * Requirements:
   *
   * - Addition cannot overflow.
   */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    return a + b;
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   *
   * - Subtraction cannot overflow.
   */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return a - b;
  }

  /**
   * @dev Returns the multiplication of two unsigned integers, reverting on
   * overflow.
   *
   * Counterpart to Solidity's `*` operator.
   *
   * Requirements:
   *
   * - Multiplication cannot overflow.
   */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    return a * b;
  }

  /**
   * @dev Returns the integer division of two unsigned integers, reverting on
   * division by zero. The result is rounded towards zero.
   *
   * Counterpart to Solidity's `/` operator.
   *
   * Requirements:
   *
   * - The divisor cannot be zero.
   */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return a / b;
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * reverting when dividing by zero.
   *
   * Counterpart to Solidity's `%` operator. This function uses a `revert`
   * opcode (which leaves remaining gas untouched) while Solidity uses an
   * invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   *
   * - The divisor cannot be zero.
   */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return a % b;
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
   * overflow (when the result is negative).
   *
   * CAUTION: This function is deprecated because it requires allocating memory for the error
   * message unnecessarily. For custom revert reasons use {trySub}.
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   *
   * - Subtraction cannot overflow.
   */
  function sub(
    uint256 a,
    uint256 b,
    string memory errorMessage
  ) internal pure returns (uint256) {
    unchecked {
      require(b <= a, errorMessage);
      return a - b;
    }
  }

  /**
   * @dev Returns the integer division of two unsigned integers, reverting with custom message on
   * division by zero. The result is rounded towards zero.
   *
   * Counterpart to Solidity's `/` operator. Note: this function uses a
   * `revert` opcode (which leaves remaining gas untouched) while Solidity
   * uses an invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   *
   * - The divisor cannot be zero.
   */
  function div(
    uint256 a,
    uint256 b,
    string memory errorMessage
  ) internal pure returns (uint256) {
    unchecked {
      require(b > 0, errorMessage);
      return a / b;
    }
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * reverting with custom message when dividing by zero.
   *
   * CAUTION: This function is deprecated because it requires allocating memory for the error
   * message unnecessarily. For custom revert reasons use {tryMod}.
   *
   * Counterpart to Solidity's `%` operator. This function uses a `revert`
   * opcode (which leaves remaining gas untouched) while Solidity uses an
   * invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   *
   * - The divisor cannot be zero.
   */
  function mod(
    uint256 a,
    uint256 b,
    string memory errorMessage
  ) internal pure returns (uint256) {
    unchecked {
      require(b > 0, errorMessage);
      return a % b;
    }
  }
}

//
// OpenZeppelin Contracts v4.4.1 (security/Pausable.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());
  }
}

//
contract SamuraiLevels is Ownable, Pausable, ReentrancyGuard {
  struct UserInfo {
    uint256 experience;
    uint256 lastClaimed;
    uint256 streak;
  }
  mapping(address => UserInfo) public users;
  uint256 public rewardRate;
  uint256 public streakCap;

  IERC20 public xhnr;
  IERC721 public hnrNodes;

  using SafeMath for uint256;

  constructor(
    address _xhnr,
    address _hnrNodes,
    uint256 _rewardRate,
    uint256 _streakCap
  ) {
    xhnr = IERC20(_xhnr);
    hnrNodes = IERC721(_hnrNodes);
    rewardRate = _rewardRate;
    streakCap = _streakCap;
  }

  function levelUp(uint256 _data) external whenNotPaused nonReentrant {
    require(_data <= 20, "Contract: too many questions!");

    address sender = msg.sender;
    require(hnrNodes.balanceOf(sender) >= 1, "Contract: not a holder!");

    UserInfo storage user = users[sender];

    uint256 blockTimeNow = block.timestamp;
    uint256 oneDay = 24 * 60 * 60;
    uint256 twoDays = oneDay * 2;
    uint256 timeDiff = blockTimeNow - user.lastClaimed;

    require(timeDiff >= oneDay, "Contract: not refreshed yet!");

    if (user.streak == 0) {
      user.streak = 1;
    } else {
      if (timeDiff <= twoDays && (user.streak + 1 <= streakCap)) {
        user.streak += 1;
      } else if (timeDiff > twoDays && user.streak > 1) {
        user.streak = 1;
      }
    }

    // 50 is the xp gain rate
    uint256 newXp = _data * 50 * user.streak;
    // multiply before divide
    uint256 reward = (rewardRate * _data * user.streak) / 2;

    user.experience += newXp;
    user.lastClaimed = blockTimeNow;

    xhnr.transfer(sender, reward);
  }

  function getUserInfo()
    external
    view
    returns (
      uint256,
      uint256,
      uint256
    )
  {
    UserInfo memory user = users[msg.sender];
    return (user.experience, user.lastClaimed, user.streak);
  }

  function setRewardRate(uint256 _rewardRate) external onlyOwner {
    rewardRate = _rewardRate;
  }

  function setStreakCap(uint256 _streakCap) external onlyOwner {
    streakCap = _streakCap;
  }

  function pause(bool en) external onlyOwner {
    en ? _pause() : _unpause();
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_xhnr","type":"address"},{"internalType":"address","name":"_hnrNodes","type":"address"},{"internalType":"uint256","name":"_rewardRate","type":"uint256"},{"internalType":"uint256","name":"_streakCap","type":"uint256"}],"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":"getUserInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hnrNodes","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_data","type":"uint256"}],"name":"levelUp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"en","type":"bool"}],"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":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardRate","type":"uint256"}],"name":"setRewardRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_streakCap","type":"uint256"}],"name":"setStreakCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"streakCap","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":[{"internalType":"address","name":"","type":"address"}],"name":"users","outputs":[{"internalType":"uint256","name":"experience","type":"uint256"},{"internalType":"uint256","name":"lastClaimed","type":"uint256"},{"internalType":"uint256","name":"streak","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xhnr","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000d5aa2a5acfc000c08e8dab3af830ed4f091204780000000000000000000000004f89c90e64ae57eaf805ff2abf868fe2ad6c55f3000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000000000000000014

-----Decoded View---------------
Arg [0] : _xhnr (address): 0xd5aa2a5AcFC000c08E8dab3Af830ed4f09120478
Arg [1] : _hnrNodes (address): 0x4f89c90E64AE57eaf805Ff2Abf868fE2aD6c55f3
Arg [2] : _rewardRate (uint256): 20000000000000000000
Arg [3] : _streakCap (uint256): 20

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000d5aa2a5acfc000c08e8dab3af830ed4f09120478
Arg [1] : 0000000000000000000000004f89c90e64ae57eaf805ff2abf868fe2ad6c55f3
Arg [2] : 000000000000000000000000000000000000000000000001158e460913d00000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000014

22466:2223:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24604:82;;;;;;:::i;:::-;;:::i;:::-;;22737:18;;;;;-1:-1:-1;;;;;22737:18:0;;;;;;-1:-1:-1;;;;;561:32:1;;;543:51;;531:2;516:18;22737::0;;;;;;;;22706:24;;;;;;;;;751:25:1;;;739:2;724:18;22706:24:0;605:177:1;23070:1080:0;;;;;;:::i;:::-;;:::i;24502:96::-;;;;;;:::i;:::-;;:::i;21386:80::-;21433:4;21453:7;-1:-1:-1;;;21453:7:0;;;;21386:80;;1137:14:1;;1130:22;1112:41;;1100:2;1085:18;21386:80:0;972:187:1;24156:234:0;24311:10;24225:7;24305:17;;;:5;:17;;;;;;;;;24282:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24156:234;;;;1366:25:1;;;1422:2;1407:18;;1400:34;;;;1450:18;;;1443:34;1354:2;1339:18;24156:234:0;1164:319:1;22760:23:0;;;;;-1:-1:-1;;;;;22760:23:0;;;5017:97;;;:::i;22676:25::-;;;;;;4406:81;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;4406:81;;24396:100;;;;;;:::i;:::-;;:::i;22630:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;5259:191;;;;;;:::i;:::-;;:::i;24604:82::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;;;;;;;;;24654:2:::1;:26;;24670:10;:8;:10::i;:::-;24604:82:::0;:::o;24654:26::-:1;24659:8;:6;:8::i;23070:1080::-:0;21433:4;21453:7;-1:-1:-1;;;21453:7:0;;;;21685:9;21677:38;;;;-1:-1:-1;;;21677:38:0;;2773:2:1;21677:38:0;;;2755:21:1;2812:2;2792:18;;;2785:30;-1:-1:-1;;;2831:18:1;;;2824:46;2887:18;;21677:38:0;2571:340:1;21677:38:0;1756:1:::1;2320:7;;:19:::0;2312:63:::1;;;::::0;-1:-1:-1;;;2312:63:0;;3118:2:1;2312:63:0::1;::::0;::::1;3100:21:1::0;3157:2;3137:18;;;3130:30;3196:33;3176:18;;;3169:61;3247:18;;2312:63:0::1;2916:355:1::0;2312:63:0::1;1756:1;2445:7;:18:::0;23162:2:::2;23153:11:::0;::::2;;23145:53;;;::::0;-1:-1:-1;;;23145:53:0;;3478:2:1;23145:53:0::2;::::0;::::2;3460:21:1::0;3517:2;3497:18;;;3490:30;3556:31;3536:18;;;3529:59;3605:18;;23145:53:0::2;3276:353:1::0;23145:53:0::2;23249:8;::::0;:26:::2;::::0;-1:-1:-1;;;23249:26:0;;23224:10:::2;23249:26;::::0;::::2;543:51:1::0;;;23224:10:0;23279:1:::2;::::0;-1:-1:-1;;;;;23249:8:0;;::::2;::::0;:18:::2;::::0;516::1;;23249:26:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:31;;23241:67;;;::::0;-1:-1:-1;;;23241:67:0;;4025:2:1;23241:67:0::2;::::0;::::2;4007:21:1::0;4064:2;4044:18;;;4037:30;4103:25;4083:18;;;4076:53;4146:18;;23241:67:0::2;3823:347:1::0;23241:67:0::2;-1:-1:-1::0;;;;;23341:13:0;::::2;23317:21;23341:13:::0;;;:5:::2;:13;::::0;;;;;;;23386:15:::2;::::0;23425:12:::2;::::0;23317:21;23462:10:::2;::::0;23425:12;;23462:10:::2;:::i;:::-;23444:28;;23479:16;23513:4;:16;;;23498:12;:31;;;;:::i;:::-;23479:50;;23558:6;23546:8;:18;;23538:59;;;::::0;-1:-1:-1;;;23538:59:0;;4812:2:1;23538:59:0::2;::::0;::::2;4794:21:1::0;4851:2;4831:18;;;4824:30;4890;4870:18;;;4863:58;4938:18;;23538:59:0::2;4610:352:1::0;23538:59:0::2;23610:4;:11;;;23625:1;23610:16:::0;23606:257:::2;;23651:1;23637:11;::::0;::::2;:15:::0;23606:257:::2;;;23691:7;23679:8;:19;;:53;;;;-1:-1:-1::0;23722:9:0::2;::::0;23703:11:::2;::::0;::::2;::::0;:15:::2;::::0;23717:1:::2;23703:15;:::i;:::-;:28;;23679:53;23675:181;;;23760:1;23745:4;:11;;;:16;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;23675:181:0::2;::::0;-1:-1:-1;23675:181:0::2;;23792:7;23781:8;:18;:37;;;;;23817:1;23803:4;:11;;;:15;23781:37;23777:79;;;23845:1;23831:11;::::0;::::2;:15:::0;23777:79:::2;23931:11;::::0;::::2;::::0;23902:13:::2;::::0;23918:10:::2;:5:::0;23926:2:::2;23918:10;:::i;:::-;:24;;;;:::i;:::-;23902:40;;23980:14;24034:1;24019:4;:11;;;24011:5;23998:10;;:18;;;;:::i;:::-;:32;;;;:::i;:::-;23997:38;;;;:::i;:::-;23980:55;;24063:5;24044:4;:15;;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;24075:16:0::2;::::0;::::2;:31:::0;;;24115:4:::2;::::0;:29:::2;::::0;-1:-1:-1;;;24115:29:0;;-1:-1:-1;;;;;5514:32:1;;;24115:29:0::2;::::0;::::2;5496:51:1::0;5563:18;;;5556:34;;;24115:4:0;;::::2;::::0;:13:::2;::::0;5469:18:1;;24115:29:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;1714:1:0::1;2608:22:::0;;-1:-1:-1;;;;;;;;23070:1080:0:o;24502:96::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;24570:9:::1;:22:::0;24502:96::o;5017:97::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;5078:30:::1;5105:1;5078:18;:30::i;:::-;5017:97::o:0;24396:100::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;24466:10:::1;:24:::0;24396:100::o;5259:191::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;5344:22:0;::::1;5336:73;;;::::0;-1:-1:-1;;;5336:73:0;;6053:2:1;5336:73:0::1;::::0;::::1;6035:21:1::0;6092:2;6072:18;;;6065:30;6131:34;6111:18;;;6104:62;-1:-1:-1;;;6182:18:1;;;6175:36;6228:19;;5336:73:0::1;5851:402:1::0;5336:73:0::1;5416:28;5435:8;5416:18;:28::i;22345:110::-:0;21433:4;21453:7;-1:-1:-1;;;21453:7:0;;;;21929:41;;;;-1:-1:-1;;;21929:41:0;;6460:2:1;21929:41:0;;;6442:21:1;6499:2;6479:18;;;6472:30;-1:-1:-1;;;6518:18:1;;;6511:50;6578:18;;21929:41:0;6258:344:1;21929:41:0;22410:5:::1;22400:15:::0;;-1:-1:-1;;;;22400:15:0::1;::::0;;22427:22:::1;3315:10:::0;22436:12:::1;22427:22;::::0;-1:-1:-1;;;;;561:32:1;;;543:51;;531:2;516:18;22427:22:0::1;;;;;;;22345:110::o:0;22112:108::-;21433:4;21453:7;-1:-1:-1;;;21453:7:0;;;;21685:9;21677:38;;;;-1:-1:-1;;;21677:38:0;;2773:2:1;21677:38:0;;;2755:21:1;2812:2;2792:18;;;2785:30;-1:-1:-1;;;2831:18:1;;;2824:46;2887:18;;21677:38:0;2571:340:1;21677:38:0;22168:7:::1;:14:::0;;-1:-1:-1;;;;22168:14:0::1;-1:-1:-1::0;;;22168:14:0::1;::::0;;22194:20:::1;22201:12;3315:10:::0;;3239:92;5600:177;5670:16;5689:6;;-1:-1:-1;;;;;5702:17:0;;;-1:-1:-1;;;;;;5702:17:0;;;;;;5731:40;;5689:6;;;;;;;5731:40;;5670:16;5731:40;5663:114;5600:177;:::o;14:118:1:-;100:5;93:13;86:21;79:5;76:32;66:60;;122:1;119;112:12;137:241;193:6;246:2;234:9;225:7;221:23;217:32;214:52;;;262:1;259;252:12;214:52;301:9;288:23;320:28;342:5;320:28;:::i;:::-;367:5;137:241;-1:-1:-1;;;137:241:1:o;787:180::-;846:6;899:2;887:9;878:7;874:23;870:32;867:52;;;915:1;912;905:12;867:52;-1:-1:-1;938:23:1;;787:180;-1:-1:-1;787:180:1:o;1919:286::-;1978:6;2031:2;2019:9;2010:7;2006:23;2002:32;1999:52;;;2047:1;2044;2037:12;1999:52;2073:23;;-1:-1:-1;;;;;2125:31:1;;2115:42;;2105:70;;2171:1;2168;2161:12;2210:356;2412:2;2394:21;;;2431:18;;;2424:30;2490:34;2485:2;2470:18;;2463:62;2557:2;2542:18;;2210:356::o;3634:184::-;3704:6;3757:2;3745:9;3736:7;3732:23;3728:32;3725:52;;;3773:1;3770;3763:12;3725:52;-1:-1:-1;3796:16:1;;3634:184;-1:-1:-1;3634:184:1:o;4175:127::-;4236:10;4231:3;4227:20;4224:1;4217:31;4267:4;4264:1;4257:15;4291:4;4288:1;4281:15;4307:168;4347:7;4413:1;4409;4405:6;4401:14;4398:1;4395:21;4390:1;4383:9;4376:17;4372:45;4369:71;;;4420:18;;:::i;:::-;-1:-1:-1;4460:9:1;;4307:168::o;4480:125::-;4520:4;4548:1;4545;4542:8;4539:34;;;4553:18;;:::i;:::-;-1:-1:-1;4590:9:1;;4480:125::o;4967:128::-;5007:3;5038:1;5034:6;5031:1;5028:13;5025:39;;;5044:18;;:::i;:::-;-1:-1:-1;5080:9:1;;4967:128::o;5100:217::-;5140:1;5166;5156:132;;5210:10;5205:3;5201:20;5198:1;5191:31;5245:4;5242:1;5235:15;5273:4;5270:1;5263:15;5156:132;-1:-1:-1;5302:9:1;;5100:217::o;5601:245::-;5668:6;5721:2;5709:9;5700:7;5696:23;5692:32;5689:52;;;5737:1;5734;5727:12;5689:52;5769:9;5763:16;5788:28;5810:5;5788:28;:::i

ipfs://091403474c3674e50b22caf6fe958581f7d778836173600b65f1a9d0bd84efcf