Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• interface IDetailedERC20 is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
• interface IMintableERC20 is IDetailed ...
•    - function mint(address _recipient, uin ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
•  contract MGGTokenBox is Reentrancy ... *
•    - function setPendingGovernance(address ...
•    - function acceptGovernance()
•    - function updateRewardRate(uint256 rew ...
•    - function currentWeek()
•    - function startWeek()
•    - function getClaimStatus(uint256 week, ...
•    - function claimById(uint256 tokenId, u ...
•    - function claimAllForOwner(uint256 wee ...
•    - function _claim(uint256 tokenId, addr ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-09-11
*/

// Sources flattened with hardhat v2.6.3 https://hardhat.org

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <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 () internal {
        _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 make 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;
    }
}


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

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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) {
        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) {
        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) {
        // 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) {
        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) {
        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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @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. 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) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


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

pragma solidity >=0.6.0 <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);
}


// File contracts/interface/IDetailedERC20.sol

pragma solidity ^0.6.12;

interface IDetailedERC20 is IERC20 {
  function name() external returns (string memory);
  function symbol() external returns (string memory);
  function decimals() external returns (uint8);
}


// File contracts/interface/IMintableERC20.sol

pragma solidity ^0.6.12;

interface IMintableERC20 is IDetailedERC20{
  function mint(address _recipient, uint256 _amount) external;
}


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

pragma solidity >=0.6.0 <0.8.0;

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


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

pragma solidity >=0.6.2 <0.8.0;

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


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

pragma solidity >=0.6.2 <0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


// File contracts/MGGTokenBox.sol

pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;



///
/// @dev A contract which allows HOE owner to claim their MGG every week
///

contract MGGTokenBox is ReentrancyGuard {
  using SafeMath for uint256;

  event PendingGovernanceUpdated(
    address pendingGovernance
  );

  event GovernanceUpdated(
    address governance
  );

  event RewardRateUpdated(
    uint256 rewardRate
  );

  event TokensClaimed(
    address indexed user,
    uint256 week,
    uint256 hoeId,
    uint256 amount
  );

  /// @dev The token which will be minted as a reward for staking.
  IMintableERC20 public reward;

  IERC721Enumerable public hoeContract;

  /// @dev The address of the account which currently has administrative capabilities over this contract.
  address public governance;

  address public pendingGovernance;

  uint256 private constant SECONDS_PER_WEEK = 604800; /* 86400 seconds in a day , 604800 seconds in a week */

  // Track claimed tokens by week
  // IMPORTANT: The format of the mapping is:
  // weekClaimedByTokenId[week][tokenId][claimed]

  mapping(uint256 => mapping(uint256 => bool)) public weekClaimedByTokenId;

  uint256 private _startTimestamp;

  uint256 public tokenIdStart = 0;
  uint256 public tokenIdEnd = 9999;

  uint256 public rewardPerHOEPerWeek;


  constructor(
    IMintableERC20 _reward,
    address _hoeContractAddress,
    uint256 startTimestamp_,
    uint256 _rewardPerHOEPerWeek,
    address _governance
  ) public {
    require(_governance != address(0), "MGGTokenBox: governance address cannot be 0x0");

    reward = _reward;
    hoeContract = IERC721Enumerable(_hoeContractAddress);
    _startTimestamp = startTimestamp_;
    rewardPerHOEPerWeek = _rewardPerHOEPerWeek;
    governance = _governance;
  }

  /// @dev A modifier which reverts when the caller is not the governance.
  modifier onlyGovernance() {
    require(msg.sender == governance, "MGGTokenBox: only governance");
    _;
  }

  /// @dev Sets the governance.
  ///
  /// This function can only called by the current governance.
  ///
  /// @param _pendingGovernance the new pending governance.
  function setPendingGovernance(address _pendingGovernance) external onlyGovernance {
    require(_pendingGovernance != address(0), "MGGTokenBox: pending governance address cannot be 0x0");
    pendingGovernance = _pendingGovernance;

    emit PendingGovernanceUpdated(_pendingGovernance);
  }

  function acceptGovernance() external {
    require(msg.sender == pendingGovernance, "MGGTokenBox: only pending governance");

    address _pendingGovernance = pendingGovernance;
    governance = _pendingGovernance;

    emit GovernanceUpdated(_pendingGovernance);
  }

  function updateRewardRate(uint256 rewardRate) external onlyGovernance {
    rewardPerHOEPerWeek = rewardRate;
    emit RewardRateUpdated(rewardRate);
  }

  function currentWeek() public view returns (uint256 weekNumber) {
      return uint256(block.timestamp / SECONDS_PER_WEEK);
  }

  function startWeek()public view returns (uint256 weekNumber) {
      return uint256(_startTimestamp / SECONDS_PER_WEEK);
  }

  function getClaimStatus(uint256 week, uint256 tokenId)public view returns (bool claimed) {
      return weekClaimedByTokenId[week][tokenId];
  }

  /// @notice Claim MGG for a given HOE ID
  /// @param tokenId The tokenId of the HOE NFT
  function claimById(uint256 tokenId, uint256 week) external nonReentrant{

      // Check that the msgSender owns the token that is being claimed
      require(
          msg.sender == hoeContract.ownerOf(tokenId),
          "MUST_OWN_TOKEN_ID"
      );

      require(
          !weekClaimedByTokenId[week][tokenId],
          "Already Claimed"
      );

      // Further Checks, Effects, and Interactions are contained within the
      // _claim() function
      _claim(tokenId, msg.sender, week);
  }

    /// @notice Claim MGG for all tokens owned by the sender
    /// @notice This function will run out of gas if you have too much HOE!
    function claimAllForOwner(uint256 week) external {
        uint256 tokenBalanceOwner = hoeContract.balanceOf(msg.sender);

        // Checks
        require(tokenBalanceOwner > 0, "NO_TOKENS_OWNED");

        // i < tokenBalanceOwner because tokenBalanceOwner is 1-indexed
        for (uint256 i = 0; i < tokenBalanceOwner; i++) {
            // Further Checks, Effects, and Interactions are contained within
            // the _claim() function

            if(!weekClaimedByTokenId[week][hoeContract.tokenOfOwnerByIndex(msg.sender, i)]){
              _claim(
                  hoeContract.tokenOfOwnerByIndex(msg.sender, i),
                  msg.sender,
                  week
              );
            }
        }
    }

    /// @dev Internal function to mint MGG upon claiming
    function _claim(uint256 tokenId, address tokenOwner, uint256 week) internal {
        // Checks
        // Check that the token ID is in range
        // We use >= and <= to here because all of the token IDs are 0-indexed
        require(
            tokenId >= tokenIdStart && tokenId <= tokenIdEnd,
            "TOKEN_ID_OUT_OF_RANGE"
        );

        require(
            week >= startWeek() && week <= currentWeek(),
            "Need Valid Week"
        );

        // Check that MGG have not already been claimed this week
        // for a given tokenId
        require(
            !weekClaimedByTokenId[week][tokenId],
            "Already Claimed"
        );

        // Mark that MGG has been claimed for this week for the
        // given tokenId
        weekClaimedByTokenId[week][tokenId] = true;



        // Send MGG to the owner of the token ID
        reward.mint(tokenOwner, rewardPerHOEPerWeek);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IMintableERC20","name":"_reward","type":"address"},{"internalType":"address","name":"_hoeContractAddress","type":"address"},{"internalType":"uint256","name":"startTimestamp_","type":"uint256"},{"internalType":"uint256","name":"_rewardPerHOEPerWeek","type":"uint256"},{"internalType":"address","name":"_governance","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"governance","type":"address"}],"name":"GovernanceUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pendingGovernance","type":"address"}],"name":"PendingGovernanceUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardRate","type":"uint256"}],"name":"RewardRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"week","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"hoeId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"inputs":[],"name":"acceptGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"week","type":"uint256"}],"name":"claimAllForOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"week","type":"uint256"}],"name":"claimById","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentWeek","outputs":[{"internalType":"uint256","name":"weekNumber","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"week","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getClaimStatus","outputs":[{"internalType":"bool","name":"claimed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hoeContract","outputs":[{"internalType":"contract IERC721Enumerable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingGovernance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"reward","outputs":[{"internalType":"contract IMintableERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerHOEPerWeek","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pendingGovernance","type":"address"}],"name":"setPendingGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startWeek","outputs":[{"internalType":"uint256","name":"weekNumber","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIdEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIdStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rewardRate","type":"uint256"}],"name":"updateRewardRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"weekClaimedByTokenId","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000b435eeffe949182aebe85506eb88d4a0ffea8f9e000000000000000000000000f1ef40f5aea5d1501c1b8bcd216cf305764fca4000000000000000000000000000000000000000000000000000000000613c14a8000000000000000000000000000000000000000000000001158e460913d00000000000000000000000000000954d24a9fb20afe9de86b9052175b0266e0f71f0

-----Decoded View---------------
Arg [0] : _reward (address): 0xB435EEffE949182AeBe85506EB88D4a0fFeA8f9E
Arg [1] : _hoeContractAddress (address): 0xf1eF40f5aEa5D1501C1B8BCD216CF305764fca40
Arg [2] : startTimestamp_ (uint256): 1631327400
Arg [3] : _rewardPerHOEPerWeek (uint256): 20000000000000000000
Arg [4] : _governance (address): 0x954d24a9fB20AFE9de86B9052175B0266e0F71f0

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000b435eeffe949182aebe85506eb88d4a0ffea8f9e
Arg [1] : 000000000000000000000000f1ef40f5aea5d1501c1b8bcd216cf305764fca40
Arg [2] : 00000000000000000000000000000000000000000000000000000000613c14a8
Arg [3] : 000000000000000000000000000000000000000000000001158e460913d00000
Arg [4] : 000000000000000000000000954d24a9fb20afe9de86b9052175b0266e0f71f0

20316:5738:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23107:129;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22363:296;;;;;;:::i;:::-;;:::i;:::-;;24284:746;;;;;;:::i;:::-;;:::i;20774:28::-;;;:::i;:::-;;;;;;;:::i;22665:274::-;;;:::i;21395:31::-;;;:::i;21431:32::-;;;:::i;21470:34::-;;;:::i;20959:25::-;;;:::i;23374:146::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;20809:36::-;;;:::i;22945:156::-;;;;;;:::i;:::-;;:::i;21278:72::-;;;;;;:::i;:::-;;:::i;23242:126::-;;;:::i;20991:32::-;;;:::i;23619:518::-;;;;;;:::i;:::-;;:::i;23107:129::-;23151:18;21074:6;23195:15;:34;;23180:50;;23107:129;:::o;22363:296::-;22128:10;;-1:-1:-1;;;;;22128:10:0;22114;:24;22106:65;;;;-1:-1:-1;;;22106:65:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;22460:32:0;::::1;22452:98;;;;-1:-1:-1::0;;;22452:98:0::1;;;;;;;:::i;:::-;22557:17;:38:::0;;-1:-1:-1;;;;;;22557:38:0::1;-1:-1:-1::0;;;;;22557:38:0;::::1;;::::0;;22609:44:::1;::::0;::::1;::::0;::::1;::::0;22557:38;;22609:44:::1;:::i;:::-;;;;;;;;22363:296:::0;:::o;24284:746::-;24372:11;;:33;;-1:-1:-1;;;24372:33:0;;24344:25;;-1:-1:-1;;;;;24372:11:0;;:21;;:33;;24394:10;;24372:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24344:61;;24465:1;24445:17;:21;24437:49;;;;-1:-1:-1;;;24437:49:0;;;;;;;:::i;:::-;24577:9;24572:451;24596:17;24592:1;:21;24572:451;;;24758:26;;;;:20;:26;;;;;;24785:11;;:46;;-1:-1:-1;;;24785:46:0;;24758:26;;;-1:-1:-1;;;;;24785:11:0;;:31;;:46;;24817:10;;24829:1;;24785:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24758:74;;;;;;;;;;;-1:-1:-1;24758:74:0;;;;24754:258;;24877:11;;:46;;-1:-1:-1;;;24877:46:0;;24850:146;;-1:-1:-1;;;;;24877:11:0;;:31;;:46;;24909:10;;24921:1;;24877:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24944:10;24975:4;24850:6;:146::i;:::-;24615:3;;24572:451;;;;24284:746;;:::o;20774:28::-;;;-1:-1:-1;;;;;20774:28:0;;:::o;22665:274::-;22731:17;;-1:-1:-1;;;;;22731:17:0;22717:10;:31;22709:80;;;;-1:-1:-1;;;22709:80:0;;;;;;;:::i;:::-;22827:17;;22851:10;:31;;-1:-1:-1;;;;;;22851:31:0;-1:-1:-1;;;;;22827:17:0;;;22851:31;;;;;22896:37;;;;;;22827:17;;22896:37;:::i;21395:31::-;;;;:::o;21431:32::-;;;;:::o;21470:34::-;;;;:::o;20959:25::-;;;-1:-1:-1;;;;;20959:25:0;;:::o;23374:146::-;23449:12;23479:26;;;:20;:26;;;;;;;;:35;;;;;;;;;;;;23374:146::o;20809:36::-;;;-1:-1:-1;;;;;20809:36:0;;:::o;22945:156::-;22128:10;;-1:-1:-1;;;;;22128:10:0;22114;:24;22106:65;;;;-1:-1:-1;;;22106:65:0;;;;;;;:::i;:::-;23022:19:::1;:32:::0;;;23066:29:::1;::::0;::::1;::::0;::::1;::::0;23044:10;;23066:29:::1;:::i;21278:72::-:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;23242:126::-;23283:18;21074:6;23327:15;;:34;;;;20991:32;;;-1:-1:-1;;;;;20991:32:0;;:::o;23619:518::-;1853:1;2459:7;;:19;;2451:63;;;;-1:-1:-1;;;2451:63:0;;;;;;;:::i;:::-;1853:1;2592:7;:18;;;23807:11;:28:::1;::::0;-1:-1:-1;;;23807:28:0;;-1:-1:-1;;;;;23807:11:0;;::::1;::::0;:19:::1;::::0;:28:::1;::::0;23827:7;;23807:28:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;23793:42:0::1;:10;-1:-1:-1::0;;;;;23793:42:0::1;;23773:103;;;;-1:-1:-1::0;;;23773:103:0::1;;;;;;;:::i;:::-;23908:26;::::0;;;:20:::1;:26;::::0;;;;;;;:35;;;;;;;;;::::1;;23907:36;23887:95;;;;-1:-1:-1::0;;;23887:95:0::1;;;;;;;:::i;:::-;24098:33;24105:7;24114:10;24126:4;24098:6;:33::i;:::-;-1:-1:-1::0;;1809:1:0;2771:7;:22;23619:518::o;25096:953::-;25363:12;;25352:7;:23;;:48;;;;;25390:10;;25379:7;:21;;25352:48;25330:119;;;;-1:-1:-1;;;25330:119:0;;;;;;;:::i;:::-;25492:11;:9;:11::i;:::-;25484:4;:19;;:44;;;;;25515:13;:11;:13::i;:::-;25507:4;:21;;25484:44;25462:109;;;;-1:-1:-1;;;25462:109:0;;;;;;;:::i;:::-;25706:26;;;;:20;:26;;;;;;;;:35;;;;;;;;;;;25705:36;25683:101;;;;-1:-1:-1;;;25683:101:0;;;;;;;:::i;:::-;25888:26;;;;:20;:26;;;;;;;;:35;;;;;;;;;;:42;;-1:-1:-1;;25888:42:0;25926:4;25888:42;;;;;;25997:6;26021:19;;25997:44;;-1:-1:-1;;;25997:44:0;;-1:-1:-1;;;;;25997:6:0;;;;:11;;:44;;26009:10;;25997:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25096:953;;;:::o;561:241:-1:-;;665:2;653:9;644:7;640:23;636:32;633:2;;;-1:-1;;671:12;633:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;723:63;627:175;-1:-1;;;627:175::o;809:263::-;;924:2;912:9;903:7;899:23;895:32;892:2;;;-1:-1;;930:12;892:2;226:6;220:13;238:33;265:5;238:33;:::i;1079:241::-;;1183:2;1171:9;1162:7;1158:23;1154:32;1151:2;;;-1:-1;;1189:12;1151:2;-1:-1;350:20;;1145:175;-1:-1;1145:175::o;1327:263::-;;1442:2;1430:9;1421:7;1417:23;1413:32;1410:2;;;-1:-1;;1448:12;1410:2;-1:-1;498:13;;1404:186;-1:-1;1404:186::o;1597:366::-;;;1718:2;1706:9;1697:7;1693:23;1689:32;1686:2;;;-1:-1;;1724:12;1686:2;-1:-1;;350:20;;;1876:2;1915:22;;;350:20;;-1:-1;1680:283::o;5916:222::-;-1:-1;;;;;12315:54;;;;2190:37;;6043:2;6028:18;;6014:124::o;6390:349::-;-1:-1;;;;;12315:54;;;;2049:58;;6725:2;6710:18;;5867:37;6553:2;6538:18;;6524:215::o;7086:210::-;12227:13;;12220:21;2304:34;;7207:2;7192:18;;7178:118::o;7855:416::-;8055:2;8069:47;;;2935:2;8040:18;;;11995:19;2971:34;12035:14;;;2951:55;-1:-1;;;3026:12;;;3019:45;3083:12;;;8026:245::o;8278:416::-;8478:2;8492:47;;;3334:2;8463:18;;;11995:19;3370:34;12035:14;;;3350:55;-1:-1;;;3425:12;;;3418:28;3465:12;;;8449:245::o;8701:416::-;8901:2;8915:47;;;3716:2;8886:18;;;11995:19;-1:-1;;;12035:14;;;3732:40;3791:12;;;8872:245::o;9124:416::-;9324:2;9338:47;;;4042:2;9309:18;;;11995:19;4078:30;12035:14;;;4058:51;4128:12;;;9295:245::o;9547:416::-;9747:2;9761:47;;;4379:2;9732:18;;;11995:19;-1:-1;;;12035:14;;;4395:38;4452:12;;;9718:245::o;9970:416::-;10170:2;10184:47;;;4703:2;10155:18;;;11995:19;-1:-1;;;12035:14;;;4719:38;4776:12;;;10141:245::o;10393:416::-;10593:2;10607:47;;;5027:2;10578:18;;;11995:19;-1:-1;;;12035:14;;;5043:44;5106:12;;;10564:245::o;10816:416::-;11016:2;11030:47;;;5357:2;11001:18;;;11995:19;-1:-1;;;12035:14;;;5373:38;5430:12;;;10987:245::o;11239:416::-;11439:2;11453:47;;;5681:2;11424:18;;;11995:19;5717:33;12035:14;;;5697:54;5770:12;;;11410:245::o;11662:222::-;5867:37;;;11789:2;11774:18;;11760:124::o;13466:117::-;-1:-1;;;;;12315:54;;13525:35;;13515:2;;13574:1;;13564:12;13515:2;13509:74;:::o

ipfs://65eb1b1c87956771769f057cca13fdf9abb4fac7b2b5ff29d9643bdeb361b709