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 SamuraiTrade is Ownable, ... *
•    - function sell(uint256[] calldata _tok ...
•    - function buy(uint256[] calldata _toke ...
•    - function setPause(bool _isPaused)
•    - function setBuyEnabled(bool _isEnable ...
•    - function setBuyPrice(uint256 _buyPric ...
•    - function setSellPrice(uint256 _sellPr ...
•    - function release()
•    - function batchTransfer(uint256[] call ...
•    - function uncheckedIncrement(uint256 i ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at ftmscan.com on 2022-11-18
*/

// 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 SamuraiTrade is Ownable, ReentrancyGuard, Pausable {
  using SafeMath for uint256;

  uint256 public buyPrice;
  uint256 public sellPrice;
  bool public isBuyEnabled;

  IERC721 public hnrNodes;
  IERC20 public xHnr;

  event BuyNode(address nodeBuyer, uint256[] tokenIds, uint256 amount);
  event SellNode(address nodeSeller, uint256[] tokenIds, uint256 amount);

  constructor(
    uint256 _buyPrice,
    uint256 _sellPrice,
    address _hnrNodes,
    address _xHnr
  ) {
    buyPrice = _buyPrice;
    sellPrice = _sellPrice;
    hnrNodes = IERC721(_hnrNodes);
    xHnr = IERC20(_xHnr);
    isBuyEnabled = false;
  }

  // we need to check if the seller actually owns all the tokens and if the contract has them to sell
  modifier ownsAll(uint256[] calldata _tokenIds, bool isContractOwner) {
    uint256 arrSize = _tokenIds.length;
    address tokenOwner = isContractOwner ? address(this) : msg.sender;
    for (uint256 i = 0; i < arrSize; i = uncheckedIncrement(i)) {
      require(
        hnrNodes.ownerOf(_tokenIds[i]) == tokenOwner,
        isContractOwner
          ? "Contract: token ID unavailable"
          : "Owner: not an owner!"
      );
    }
    _;
  }

  function sell(uint256[] calldata _tokenIds)
    external
    whenNotPaused
    ownsAll(_tokenIds, false)
    nonReentrant
  {
    address nodeSeller = msg.sender;
    uint256 amount = uint256(_tokenIds.length).mul(sellPrice);
    // transfer token ids to contract
    batchTransfer(_tokenIds, true);
    xHnr.transfer(nodeSeller, amount);

    emit SellNode(nodeSeller, _tokenIds, amount);
  }

  function buy(uint256[] calldata _tokenIds)
    external
    ownsAll(_tokenIds, true)
    nonReentrant
  {
    require(isBuyEnabled, "Contract: Buy Not Enabled!");

    address nodeBuyer = msg.sender;
    uint256 quantity = _tokenIds.length;
    uint256 amount = quantity.mul(buyPrice);
    xHnr.transferFrom(nodeBuyer, address(this), amount);
    // transfer out tokenIds to the buyer
    batchTransfer(_tokenIds, false);

    emit BuyNode(nodeBuyer, _tokenIds, amount);
  }

  function setPause(bool _isPaused) external onlyOwner {
    _isPaused ? _pause() : _unpause();
  }

  function setBuyEnabled(bool _isEnabled) external onlyOwner {
    isBuyEnabled = _isEnabled;
  }

  function setBuyPrice(uint256 _buyPrice) external onlyOwner {
    buyPrice = _buyPrice;
  }

  function setSellPrice(uint256 _sellPrice) external onlyOwner {
    sellPrice = _sellPrice;
  }

  function release() external onlyOwner {
    uint256 totalBalance = xHnr.balanceOf(address(this));
    xHnr.transfer(owner(), totalBalance);
  }

  function batchTransfer(uint256[] calldata _tokenIds, bool isSell) internal {
    uint256 length = _tokenIds.length;
    address sender = msg.sender;
    address contractAddress = address(this);

    for (uint256 i = 0; i < length; i = uncheckedIncrement(i)) {
      isSell
        ? hnrNodes.transferFrom(sender, contractAddress, _tokenIds[i])
        : hnrNodes.transferFrom(contractAddress, sender, _tokenIds[i]);
    }
  }

  // gas optimisation
  function uncheckedIncrement(uint256 i) internal pure returns (uint256) {
    unchecked {
      return i + 1;
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_buyPrice","type":"uint256"},{"internalType":"uint256","name":"_sellPrice","type":"uint256"},{"internalType":"address","name":"_hnrNodes","type":"address"},{"internalType":"address","name":"_xHnr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nodeBuyer","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BuyNode","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nodeSeller","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SellNode","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"buy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buyPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hnrNodes","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isBuyEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"sell","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_isEnabled","type":"bool"}],"name":"setBuyEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_buyPrice","type":"uint256"}],"name":"setBuyPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isPaused","type":"bool"}],"name":"setPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sellPrice","type":"uint256"}],"name":"setSellPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xHnr","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000000000000000001d8b64f4775be4000000000000000000000000000000000000000000000000001beb0f8b69be2c00000000000000000000000000004f89c90e64ae57eaf805ff2abf868fe2ad6c55f3000000000000000000000000d5aa2a5acfc000c08e8dab3af830ed4f09120478

-----Decoded View---------------
Arg [0] : _buyPrice (uint256): 545000000000000000000
Arg [1] : _sellPrice (uint256): 515000000000000000000
Arg [2] : _hnrNodes (address): 0x4f89c90E64AE57eaf805Ff2Abf868fE2aD6c55f3
Arg [3] : _xHnr (address): 0xd5aa2a5AcFC000c08E8dab3Af830ed4f09120478

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000001d8b64f4775be40000
Arg [1] : 00000000000000000000000000000000000000000000001beb0f8b69be2c0000
Arg [2] : 0000000000000000000000004f89c90e64ae57eaf805ff2abf868fe2ad6c55f3
Arg [3] : 000000000000000000000000d5aa2a5acfc000c08e8dab3af830ed4f09120478

22466:3280:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22592:24;;;;;;;;;160:25:1;;;148:2;133:18;22592:24:0;;;;;;;;23690:406;;;;;;:::i;:::-;;:::i;:::-;;21386:80;21453:7;;;;21386:80;;;981:14:1;;974:22;956:41;;944:2;929:18;21386:80:0;816:187:1;24805:92:0;;;;;;:::i;:::-;;:::i;22652:23::-;;;;;;;;-1:-1:-1;;;;;22652:23:0;;;;;;-1:-1:-1;;;;;1372:32:1;;;1354:51;;1342:2;1327:18;22652:23:0;1193:218:1;22680:18:0;;;;;-1:-1:-1;;;;;22680:18:0;;;5017:97;;;:::i;22564:23::-;;;;;;25005:146;;;:::i;4406:81::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;4406:81;;24597:99;;;;;;:::i;:::-;;:::i;24102:489::-;;;;;;:::i;:::-;;:::i;24702:97::-;;;;;;:::i;:::-;;:::i;22621:24::-;;;;;;;;;5259:191;;;;;;:::i;:::-;;:::i;24903:96::-;;;;;;:::i;:::-;;:::i;23690:406::-;21453:7;;;;21685:9;21677:38;;;;-1:-1:-1;;;21677:38:0;;2805:2:1;21677:38:0;;;2787:21:1;2844:2;2824:18;;;2817:30;-1:-1:-1;;;2863:18:1;;;2856:46;2919:18;;21677:38:0;;;;;;;;;23780:9;;23791:5:::1;23780:9:::0;23398:10:::1;23791:5:::0;23415:256:::1;23439:7;23435:1;:11;23415:256;;;23502:8;::::0;-1:-1:-1;;;;;23502:44:0;;::::1;::::0;:8:::1;::::0;::::1;;:16;23519:9:::0;;23529:1;23519:12;;::::1;;;;;:::i;:::-;;;;;;;23502:30;;;;;;;;;;;;;160:25:1::0;;148:2;133:18;;14:177;23502:30:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;23502:44:0::1;;23557:15;:97;;;;;;;;;;;;;;;-1:-1:-1::0;;;23557:97:0::1;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;23484:179;;;;;-1:-1:-1::0;;;23484:179:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;25729:1:0;25725:5;23415:256:::1;;;;1756:1:::2;2320:7;;:19:::0;2312:63:::2;;;::::0;-1:-1:-1;;;2312:63:0;;4140:2:1;2312:63:0::2;::::0;::::2;4122:21:1::0;4179:2;4159:18;;;4152:30;4218:33;4198:18;;;4191:61;4269:18;;2312:63:0::2;3938:355:1::0;2312:63:0::2;1756:1;2445:7;:18:::0;23911:9:::3;::::0;23847:10:::3;::::0;23826:18:::3;::::0;23881:40:::3;::::0;23889:9;;23881:29:::3;:40::i;:::-;23864:57;;23967:30;23981:9;;23992:4;23967:13;:30::i;:::-;24004:4;::::0;:33:::3;::::0;-1:-1:-1;;;24004:33:0;;-1:-1:-1;;;;;4490:32:1;;;24004:33:0::3;::::0;::::3;4472:51:1::0;4539:18;;;4532:34;;;24004:4:0;;::::3;::::0;:13:::3;::::0;4445:18:1;;24004:33:0::3;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24051:39;24060:10;24072:9;;24083:6;24051:39;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;1714:1:0::2;2608:22:::0;;-1:-1:-1;;;;;;;23690:406:0:o;24805:92::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;24871:8:::1;:20:::0;24805:92::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;25005:146::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;25073:4:::1;::::0;:29:::1;::::0;-1:-1:-1;;;25073:29:0;;25096:4:::1;25073:29;::::0;::::1;1354:51:1::0;25050:20:0::1;::::0;-1:-1:-1;;;;;25073:4:0::1;::::0;:14:::1;::::0;1327:18:1;;25073:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25109:4;::::0;25050:52;;-1:-1:-1;;;;;;25109:4:0::1;:13;25123:7;4452::::0;4475:6;-1:-1:-1;;;;;4475:6:0;;4406:81;25123:7:::1;25109:36;::::0;-1:-1:-1;;;;;;25109:36:0::1;::::0;;;;;;-1:-1:-1;;;;;4490:32:1;;;25109:36:0::1;::::0;::::1;4472:51:1::0;4539:18;;;4532:34;;;4445:18;;25109:36:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;25043:108;25005:146::o:0;24597:99::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;24657:9:::1;:33;;24680:10;:8;:10::i;:::-;24597:99:::0;:::o;24657:33::-:1;24669:8;:6;:8::i;24102:489::-:0;24172:9;;24183:4;24172:9;23390:4;23302:15;23415:256;23439:7;23435:1;:11;23415:256;;;23502:8;;-1:-1:-1;;;;;23502:44:0;;;;:8;;;;:16;23519:9;;23529:1;23519:12;;;;;;;:::i;:::-;;;;;;;23502:30;;;;;;;;;;;;;160:25:1;;148:2;133:18;;14:177;23502:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;23502:44:0;;23557:15;:97;;;;;;;;;;;;;;;-1:-1:-1;;;23557:97:0;;;;;;;;;;;;;;;;;;;;;;;;23484:179;;;;;-1:-1:-1;;;23484:179:0;;;;;;;;:::i;:::-;-1:-1:-1;25729:1:0;25725:5;23415:256;;;;1756:1:::1;2320:7;;:19:::0;2312:63:::1;;;::::0;-1:-1:-1;;;2312:63:0;;4140:2:1;2312:63:0::1;::::0;::::1;4122:21:1::0;4179:2;4159:18;;;4152:30;4218:33;4198:18;;;4191:61;4269:18;;2312:63:0::1;3938:355:1::0;2312:63:0::1;1756:1;2445:7;:18:::0;24225:12:::2;::::0;::::2;;24217:51;;;::::0;-1:-1:-1;;;24217:51:0;;6240:2:1;24217:51:0::2;::::0;::::2;6222:21:1::0;6279:2;6259:18;;;6252:30;6318:28;6298:18;;;6291:56;6364:18;;24217:51:0::2;6038:350:1::0;24217:51:0::2;24386:8;::::0;24297:10:::2;::::0;24333:9;;24277:17:::2;::::0;24373:22:::2;::::0;24333:9;;24373:12:::2;:22::i;:::-;24402:4;::::0;:51:::2;::::0;-1:-1:-1;;;24402:51:0;;-1:-1:-1;;;;;6651:15:1;;;24402:51:0::2;::::0;::::2;6633:34:1::0;24439:4:0::2;6683:18:1::0;;;6676:43;6735:18;;;6728:34;;;24356:39:0;;-1:-1:-1;24402:4:0;::::2;::::0;:17:::2;::::0;6568:18:1;;24402:51:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24503:31;24517:9;;24528:5;24503:13;:31::i;:::-;24548:37;24556:9;24567;;24578:6;24548:37;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;1714:1:0::1;2608:22:::0;;-1:-1:-1;;;;;;;;24102:489:0:o;24702:97::-;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;24768:12:::1;:25:::0;;-1:-1:-1;;24768:25:0::1;::::0;::::1;;::::0;;;::::1;::::0;;24702:97::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;;6975:2:1;5336:73:0::1;::::0;::::1;6957:21:1::0;7014:2;6994:18;;;6987:30;7053:34;7033:18;;;7026:62;-1:-1:-1;;;7104:18:1;;;7097:36;7150:19;;5336:73:0::1;6773:402:1::0;5336:73:0::1;5416:28;5435:8;5416:18;:28::i;24903:96::-:0;4452:7;4475:6;-1:-1:-1;;;;;4475:6:0;3315:10;4608:23;4600:68;;;;-1:-1:-1;;;4600:68:0;;;;;;;:::i;:::-;24971:9:::1;:22:::0;24903:96::o;17214:92::-;17272:7;17295:5;17299:1;17295;:5;:::i;:::-;17288:12;17214:92;-1:-1:-1;;;17214:92:0:o;25157:435::-;25256:9;25296:10;25347:4;25239:14;25361:226;25385:6;25381:1;:10;25361:226;;;25429:6;:150;;25519:8;;;;;-1:-1:-1;;;;;25519:8:0;:21;25541:15;25558:6;25566:9;;25576:1;25566:12;;;;;;;:::i;:::-;25519:60;;-1:-1:-1;;;;;;25519:60:0;;;;;;;-1:-1:-1;;;;;6651:15:1;;;25519:60:0;;;6633:34:1;6703:15;;;;6683:18;;;6676:43;-1:-1:-1;25566:12:0;;;;;;6735:18:1;;;6728:34;6568:18;;25519:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25429:150;;;25447:8;;;;;-1:-1:-1;;;;;25447:8:0;:21;25469:6;25477:15;25494:9;;25504:1;25494:12;;;;;;;:::i;:::-;25447:60;;-1:-1:-1;;;;;;25447:60:0;;;;;;;-1:-1:-1;;;;;6651:15:1;;;25447:60:0;;;6633:34:1;6703:15;;;;6683:18;;;6676:43;-1:-1:-1;25494:12:0;;;;;;6735:18:1;;;6728:34;6568:18;;25447:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25429:150;25729:1;25725:5;25361:226;;;;25232:360;;;25157:435;;;:::o;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;22345:110::-;21453:7;;;;21929:41;;;;-1:-1:-1;;;21929:41:0;;7652:2:1;21929:41:0;;;7634:21:1;7691:2;7671:18;;;7664:30;-1:-1:-1;;;7710:18:1;;;7703:50;7770:18;;21929:41:0;7450:344:1;21929:41:0;22400:7:::1;: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;;;;;1372:32:1;;;1354:51;;1342:2;1327:18;22427:22:0::1;;;;;;;22345:110::o:0;22112:108::-;21453:7;;;;21685:9;21677:38;;;;-1:-1:-1;;;21677:38:0;;2805:2:1;21677:38:0;;;2787:21:1;2844:2;2824:18;;;2817:30;-1:-1:-1;;;2863:18:1;;;2856:46;2919:18;;21677:38:0;2603:340:1;21677:38:0;22168:7:::1;:14:::0;;-1:-1:-1;;22168:14:0::1;22178:4;22168:14;::::0;;22194:20:::1;22201:12;3315:10:::0;;3239:92;196:615:1;282:6;290;343:2;331:9;322:7;318:23;314:32;311:52;;;359:1;356;349:12;311:52;399:9;386:23;428:18;469:2;461:6;458:14;455:34;;;485:1;482;475:12;455:34;523:6;512:9;508:22;498:32;;568:7;561:4;557:2;553:13;549:27;539:55;;590:1;587;580:12;539:55;630:2;617:16;656:2;648:6;645:14;642:34;;;672:1;669;662:12;642:34;725:7;720:2;710:6;707:1;703:14;699:2;695:23;691:32;688:45;685:65;;;746:1;743;736:12;685:65;777:2;769:11;;;;;799:6;;-1:-1:-1;196:615:1;;-1:-1:-1;;;;196:615:1:o;1008:180::-;1067:6;1120:2;1108:9;1099:7;1095:23;1091:32;1088:52;;;1136:1;1133;1126:12;1088:52;-1:-1:-1;1159:23:1;;1008:180;-1:-1:-1;1008:180:1:o;1846:118::-;1932:5;1925:13;1918:21;1911:5;1908:32;1898:60;;1954:1;1951;1944:12;1969:241;2025:6;2078:2;2066:9;2057:7;2053:23;2049:32;2046:52;;;2094:1;2091;2084:12;2046:52;2133:9;2120:23;2152:28;2174:5;2152:28;:::i;2215:131::-;-1:-1:-1;;;;;2290:31:1;;2280:42;;2270:70;;2336:1;2333;2326:12;2351:247;2410:6;2463:2;2451:9;2442:7;2438:23;2434:32;2431:52;;;2479:1;2476;2469:12;2431:52;2518:9;2505:23;2537:31;2562:5;2537:31;:::i;2948:127::-;3009:10;3004:3;3000:20;2997:1;2990:31;3040:4;3037:1;3030:15;3064:4;3061:1;3054:15;3080:251;3150:6;3203:2;3191:9;3182:7;3178:23;3174:32;3171:52;;;3219:1;3216;3209:12;3171:52;3251:9;3245:16;3270:31;3295:5;3270:31;:::i;3336:597::-;3448:4;3477:2;3506;3495:9;3488:21;3538:6;3532:13;3581:6;3576:2;3565:9;3561:18;3554:34;3606:1;3616:140;3630:6;3627:1;3624:13;3616:140;;;3725:14;;;3721:23;;3715:30;3691:17;;;3710:2;3687:26;3680:66;3645:10;;3616:140;;;3774:6;3771:1;3768:13;3765:91;;;3844:1;3839:2;3830:6;3819:9;3815:22;3811:31;3804:42;3765:91;-1:-1:-1;3917:2:1;3896:15;-1:-1:-1;;3892:29:1;3877:45;;;;3924:2;3873:54;;3336:597;-1:-1:-1;;;3336:597:1:o;4577:245::-;4644:6;4697:2;4685:9;4676:7;4672:23;4668:32;4665:52;;;4713:1;4710;4703:12;4665:52;4745:9;4739:16;4764:28;4786:5;4764:28;:::i;4827:656::-;-1:-1:-1;;;;;5072:32:1;;5054:51;;5141:2;5136;5121:18;;5114:30;;;5160:18;;5153:34;;;-1:-1:-1;;;;;;5199:31:1;;5196:51;;;5243:1;5240;5233:12;5196:51;5277:6;5274:1;5270:14;5335:6;5327;5321:3;5310:9;5306:19;5293:49;5413:1;5365:22;;;5389:3;5361:32;5402:13;;;5465:2;5450:18;;;5443:34;;;;5361:32;4827:656;-1:-1:-1;;;;4827:656:1:o;5488:356::-;5690:2;5672:21;;;5709:18;;;5702:30;5768:34;5763:2;5748:18;;5741:62;5835:2;5820:18;;5488:356::o;5849:184::-;5919:6;5972:2;5960:9;5951:7;5947:23;5943:32;5940:52;;;5988:1;5985;5978:12;5940:52;-1:-1:-1;6011:16:1;;5849:184;-1:-1:-1;5849:184:1:o;7180:265::-;7220:7;7286:1;7282;7278:6;7274:14;7271:1;7268:21;7263:1;7256:9;7249:17;7245:45;7242:168;;;7332:10;7327:3;7323:20;7320:1;7313:31;7367:4;7364:1;7357:15;7395:4;7392:1;7385:15;7242:168;-1:-1:-1;7430:9:1;;7180:265::o

ipfs://53d0d7b3e46ac9c4c8ecf3ab7d0c80f40c20e134d0466a82d4a9d24a05f24ec6