Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

import "./Address.sol";
import "./Ownable.sol";
import "./Pausable.sol";
import "./ReentrancyGuard.sol";
import "./IERC721Receiver.sol";
import "./IVillage.sol";
import "./IRandomizer.sol";
import "./IGOLD.sol";
import "./ITraits.sol";
import "./VAndV.sol";

contract Village is IVillage, Ownable, IERC721Receiver, Pausable, ReentrancyGuard {
  using Address for address;

  // Events
  event GoldTaxed(address from, uint256 taxed);
  event GoldStolen(address from, uint256 total);

  // struct to store a stake's token, owner, and earning values
  struct Stake {
    uint16 tokenId;
    uint80 value;
    address owner;
  }

  // maximum alpha score for a viking
  uint8 public constant MAX_ALPHA = 8;
  // villagers earn 10000 $GOLD per day
  uint256 public constant DAILY_GOLD_RATE = 10000 ether;
  // villagers must have 2 days worth of $GOLD to unstake
  uint256 public constant MINIMUM_TO_EXIT = 2 days;
  // vikings take a 20% tax on all $GOLD earned
  uint256 public constant GOLD_CLAIM_TAX_PERCENTAGE = 20;
  // there will only ever be (roughly) 4 billion $GOLD earned through staking
  uint256 public constant MAXIMUM_GLOBAL_GOLD = 4000000000 ether;

  // total alpha scores staked
  uint256 public totalAlphaStaked = 0;
  // any rewards distributed when no vikings are staked
  uint256 public unaccountedRewards = 0;
  // amount of $GOLD due for each alpha point staked
  uint256 public rewardsPerAlpha = 0;
  // amount of $GOLD earned so far
  uint256 public totalGoldEarned = 0;
  // number of villagers staked
  uint256 public totalVillagersStaked = 0;
  // number of vikings staked
  uint256 public totalVikingsStaked = 0;
  // the last time $GOLD was claimed
  uint256 public lastClaimTimestamp = 0;

  // maps tokenId to stake
  mapping(uint256 => Stake) private village;
  // maps alpha to all viking raid parties with that alpha
  mapping(uint8 => Stake[]) private parties;
  // tracks location of each viking in raid parties
  mapping(uint256 => uint256) private partyIndices;
  // tracks token IDs owned by which addresses
  mapping(address => uint256[]) private ownerTokens;
  // tracks location of each token in owner tokens
  mapping(uint256 => uint256) private ownerTokensIndices;

  // reference to randomizer
  IRandomizer private randomizer;
  // reference to $GOLD
  IGOLD private gold;
  // reference to traits
  ITraits private traits;
  // reference to vandv
  VAndV private vandv;

  /**
   * create the contract
   */
  constructor() {
    _pause();
  }

  /**
   * add your villagers and vikings to the contract
   * @param tokenIds the IDs of the tokens to stake
   */
  function stakeTokens(uint16[] calldata tokenIds) external nonReentrant whenNotPaused {
    require(tx.origin == _msgSender() && !_msgSender().isContract(), "VILLAGE: Only EOA");

    for (uint i = 0; i < tokenIds.length; i++) {
      require(vandv.ownerOf(tokenIds[i]) == _msgSender(), "VILLAGE: Doesn't own that token");

      vandv.transferFrom(_msgSender(), address(this), tokenIds[i]);

      ownerTokensIndices[tokenIds[i]] = ownerTokens[_msgSender()].length;
      ownerTokens[_msgSender()].push(tokenIds[i]);

      if (_isVillager(tokenIds[i])) {
        _addVillagerToVillage(_msgSender(), tokenIds[i]);
      } else {
        _addVikingToRaidParty(_msgSender(), tokenIds[i]);
      }
    }
  }

  /**
   * realize $GOLD earnings and optionally unstake tokens
   * @param tokenIds the IDs of the tokens to claim earnings from
   * @param shouldUnstake whether or not to unstake the tokens
   */
  function claimEarnings(uint16[] calldata tokenIds, bool shouldUnstake) external nonReentrant whenNotPaused _updateEarnings {
    require(tx.origin == _msgSender() && !_msgSender().isContract(), "VILLAGE: Only EOA");

    uint256 totalEarned = 0;

    for (uint i = 0; i < tokenIds.length; i++) {
      require(vandv.ownerOf(tokenIds[i]) == address(this), "VILLAGE: Token not owned by village contract");

      if (_isVillager(tokenIds[i])) {
        totalEarned += _claimVillagerRewards(tokenIds[i], shouldUnstake);
      } else {
        totalEarned += _claimVikingRewards(tokenIds[i], shouldUnstake);
      }
    }

    if (totalEarned > 0) {
      gold.mint(_msgSender(), totalEarned);
    }
  }

  /**
   * get the token IDs owned by an address that are currently staked here
   * @param owner the owner's address
   * @return the token ids staked
   */
  function getTokensForOwner(address owner) external view returns (uint256[] memory) {
    require(owner == _msgSender(), "VILLAGE: Only the owner can check their tokens");

    return ownerTokens[owner];
  }

  /**
   * calculate the total $GOLD earnings for a staked token
   * @param tokenId the token ID
   * @return the total earnings
   */
  function getEarningsForToken(uint256 tokenId) external view returns (uint256) {
    uint256 owed = 0;

    if (_isVillager(tokenId)) {
      Stake memory stake = village[tokenId];

      require(stake.owner == _msgSender(), "VILLAGE: Only the owner can check their earnings");

      if (totalGoldEarned < MAXIMUM_GLOBAL_GOLD) {
        owed = (block.timestamp - stake.value) * DAILY_GOLD_RATE / 1 days;
      } else if (stake.value > lastClaimTimestamp) {
        owed = 0; // $GOLD production stopped already
      } else {
        owed = (lastClaimTimestamp - stake.value) * DAILY_GOLD_RATE / 1 days; // stop earning additional $GOLD if it's all been earned
      }
    } else {
      uint8 alpha = _alphaForViking(tokenId);
      Stake memory stake = parties[alpha][partyIndices[tokenId]];

      require(stake.owner == _msgSender(), "VILLAGE: Only the owner can check their earnings");

      owed = alpha * (rewardsPerAlpha - stake.value);
    }

    return owed;
  }

  /**
   * check if the owner can unstake a token
   * @param tokenId the token ID
   * @return whether the token can be unstaked
   */
  function canUnstake(uint256 tokenId) external view returns (bool) {
    if (_isVillager(tokenId)) {
      Stake memory stake = village[tokenId];

      require(stake.owner == _msgSender(), "VILLAGE: Only the owner can check their tokens");

      return block.timestamp - stake.value >= MINIMUM_TO_EXIT;
    } else {
      uint8 alpha = _alphaForViking(tokenId);
      Stake memory stake = parties[alpha][partyIndices[tokenId]];

      require(stake.owner == _msgSender(), "VILLAGE: Only the owner can check their tokens");

      return true;
    }
  }

  /**
   * used by the minting contract to find a randomly staked viking to award
   * a stolen villager to
   * @param seed a random value to choose a viking from
   * @return the owner of the viking
   */
  function randomVikingOwner(uint256 seed) external override view returns (address) {
    if (totalAlphaStaked == 0) {
      return address(0x0);
    }

    uint256 bucket = (seed & 0xFFFFFFFF) % totalAlphaStaked; // choose a value from 0 to total alpha staked
    uint256 cumulative;

    seed >>= 32;

    // loop through each bucket of vikings in parties until we find the correct bucket
    for (uint8 i = MAX_ALPHA - 3; i <= MAX_ALPHA; i++) {
      cumulative += parties[i].length * i;

      if (bucket >= cumulative) {
        continue;
      }

      return parties[i][seed % parties[i].length].owner;
    }

    return address(0x0);
  }

  /**
   * @param from the address that sent the token
   * @return whether the token should be accepted
   */
  function onERC721Received(address, address from, uint256, bytes calldata) external pure override returns (bytes4) {
    require(from == address(0x0), "VILLAGE: Cannot send tokens directly");

    return IERC721Receiver.onERC721Received.selector;
  }

  /**
   * set the address of our randomizer contract
   * @param _randomizer the address
   */
  function setRandomizer(address _randomizer) external onlyOwner {
    randomizer = IRandomizer(_randomizer);
  }

  /**
   * set the address of the gold contract
   * @param _gold the address
   */
  function setGold(address _gold) external onlyOwner {
    gold = IGOLD(_gold);
  }

  /**
   * set the address of the traits contract
   * @param _traits the address
   */
  function setTraits(address _traits) external onlyOwner {
    traits = ITraits(_traits);
  }

  /**
   * set the address of the V&V contract
   * @param _vandv the address
   */
  function setVAndV(address _vandv) external onlyOwner {
    vandv = VAndV(_vandv);
  }

  /**
   * enables owner to pause/unpause staking/claiming
   * @param enabled if we should pause or unpause
   */
  function setPaused(bool enabled) external onlyOwner {
    if (enabled) {
      _pause();
    } else {
      _unpause();
    }
  }

  /**
   * adds a villager to the village so they start producing $GOLD
   * @param owner the address of the staker
   * @param tokenId the token ID
   */
  function _addVillagerToVillage(address owner, uint256 tokenId) internal _updateEarnings {
    village[tokenId] = Stake({
      owner: owner,
      tokenId: uint16(tokenId),
      value: uint80(block.timestamp)
    });

    totalVillagersStaked += 1;
  }

  /**
   * adds a viking to the relevant raid party with the same alpha score
   * @param owner the address of the staker
   * @param tokenId the token ID
   */
  function _addVikingToRaidParty(address owner, uint256 tokenId) internal {
    uint8 alpha = _alphaForViking(tokenId);

    partyIndices[tokenId] = parties[alpha].length;

    parties[alpha].push(Stake({
      owner: owner,
      tokenId: uint16(tokenId),
      value: uint80(rewardsPerAlpha)
    }));

    totalVikingsStaked += 1;
    totalAlphaStaked += alpha; // Portion of earnings ranges from 8 to 5
  }

  /**
   * figure out how much $GOLD the villager earned and do some accounting
   * if not unstaking, pay a 20% tax to the staked vikings
   * if unstaking, there is a 50% chance all $GOLD is stolen
   * @param tokenId the ID of the villager to claim earnings from
   * @param shouldUnstake whether or not to unstake the villager
   * @return owed the amount of $GOLD earned
   */
  function _claimVillagerRewards(uint256 tokenId, bool shouldUnstake) internal returns (uint256 owed) {
    Stake memory stake = village[tokenId];

    require(stake.owner == _msgSender(), "VILLAGE: Unable to claim because wrong owner");

    if (shouldUnstake) {
      require(block.timestamp - stake.value >= MINIMUM_TO_EXIT, "VILLAGE: Can't unstake and claim yet");
    }

    if (totalGoldEarned < MAXIMUM_GLOBAL_GOLD) {
      owed = (block.timestamp - stake.value) * DAILY_GOLD_RATE / 1 days;
    } else if (stake.value > lastClaimTimestamp) {
      owed = 0; // $GOLD production stopped already
    } else {
      owed = (lastClaimTimestamp - stake.value) * DAILY_GOLD_RATE / 1 days; // stop earning additional $GOLD if it's all been earned
    }

    if (shouldUnstake) {
      // 50% chance that all $GOLD is stolen by vikings
      if (randomizer.random(tokenId) & 1 == 1) {
        _addTaxedRewards(owed);
        emit GoldStolen(_msgSender(), owed);
        owed = 0;
      }

      delete village[tokenId];

      uint256 lastTokenId = ownerTokens[_msgSender()][ownerTokens[_msgSender()].length - 1];
      ownerTokens[_msgSender()][ownerTokensIndices[tokenId]] = lastTokenId;
      ownerTokensIndices[lastTokenId] = ownerTokensIndices[tokenId];
      ownerTokens[_msgSender()].pop();
      delete ownerTokensIndices[tokenId];

      totalVillagersStaked -= 1;

      vandv.safeTransferFrom(address(this), _msgSender(), tokenId, "");
    } else {
      uint256 tax = owed * GOLD_CLAIM_TAX_PERCENTAGE / 100;
      _addTaxedRewards(tax);
      emit GoldTaxed(_msgSender(), tax);
      owed -= tax;

      // reset the stake timestamp
      village[tokenId] = Stake({
        owner: _msgSender(),
        tokenId: uint16(tokenId),
        value: uint80(block.timestamp)
      });
    }
  }

  /**
   * claim earned $GOLD for staked vikings
   * @param tokenId the ID of the viking to claim earnings from
   * @param shouldUnstake whether or not to unstake the viking
   * @return owed the amount of $GOLD earned
   */
  function _claimVikingRewards(uint256 tokenId, bool shouldUnstake) internal returns (uint256 owed) {
    uint8 alpha = _alphaForViking(tokenId);
    Stake memory stake = parties[alpha][partyIndices[tokenId]];

    require(stake.owner == _msgSender(), "VILLAGE: Unable to claim because wrong owner");

    owed = alpha * (rewardsPerAlpha - stake.value);

    if (shouldUnstake) {
      Stake memory lastStake = parties[alpha][parties[alpha].length - 1];
      parties[alpha][partyIndices[tokenId]] = lastStake;
      partyIndices[lastStake.tokenId] = partyIndices[tokenId];
      parties[alpha].pop();
      delete partyIndices[tokenId];

      uint256 lastTokenId = ownerTokens[_msgSender()][ownerTokens[_msgSender()].length - 1];
      ownerTokens[_msgSender()][ownerTokensIndices[tokenId]] = lastTokenId;
      ownerTokensIndices[lastTokenId] = ownerTokensIndices[tokenId];
      ownerTokens[_msgSender()].pop();
      delete ownerTokensIndices[tokenId];

      totalVikingsStaked -= 1;
      totalAlphaStaked -= alpha;

      vandv.safeTransferFrom(address(this), _msgSender(), tokenId, "");
    } else {
      // reset the stake timestamp
      parties[alpha][partyIndices[tokenId]] = Stake({
        owner: _msgSender(),
        tokenId: uint16(tokenId),
        value: uint80(rewardsPerAlpha)
      });
    }
  }

  /**
   * do some accounting to add the $GOLD taxed from villagers when they
   * claim their earnings
   * @param amount the total $GOLD to add to the unclaimed rewards
   */
  function _addTaxedRewards(uint256 amount) internal {
    // if there's no staked vikings keep track of the gold
    if (totalAlphaStaked == 0) {
      unaccountedRewards += amount;
      return;
    }

    rewardsPerAlpha += (amount + unaccountedRewards) / totalAlphaStaked;
    unaccountedRewards = 0;
  }

  /**
   * checks if a token is a villager
   * @param tokenId the ID of the token to check
   * @return whether the token is a villager
   */
  function _isVillager(uint256 tokenId) internal view returns (bool) {
    return traits.getTokenTraits(tokenId).isVillager;
  }

  /**
   * gets the alpha score for a viking
   * @param tokenId the token ID to check
   * @return the alpha score from 5-8
   */
  function _alphaForViking(uint256 tokenId) internal view returns (uint8) {
    return MAX_ALPHA - traits.getTokenTraits(tokenId).alphaIndex;
  }

  /**
   * make this function calculate the total $GOLD earned by villagers and
   * ensure we never go beyond the earnings cap
   */
  modifier _updateEarnings() {
    if (totalGoldEarned < MAXIMUM_GLOBAL_GOLD) {
      totalGoldEarned += (block.timestamp - lastClaimTimestamp) * totalVillagersStaked * DAILY_GOLD_RATE / 1 days;
      lastClaimTimestamp = block.timestamp;
    }

    _;
  }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./IERC721Enumerable.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IBattleground {}

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.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;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IGOLD {
  function mint(address to, uint256 amount) external;
  function burn(address from, uint256 amount) external;
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IRandomizer {
  function getChunkId() external view returns (uint256);
  function random(uint256 data) external returns (uint256);
  function randomChunk(uint256 chunkId, uint256 data) external returns (uint256);
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface ITraits {
  struct TokenTraits {
    bool isVillager;
    uint8 alphaIndex;
  }

  function getTokenTraits(uint256 tokenId) external view returns (TokenTraits memory);
  function generateTokenTraits(uint256 tokenId, uint256 seed) external;
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IVAndV {}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IVAndVMinter {}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IVillage {
  function randomVikingOwner(uint256 seed) external view returns (address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

    bool private _paused;

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and 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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

import "./Address.sol";
import "./Ownable.sol";
import "./Strings.sol";
import "./ERC721Enumerable.sol";
import "./IVAndV.sol";
import "./IVAndVMinter.sol";
import "./ITraits.sol";
import "./IVillage.sol";
import "./IBattleground.sol";

contract VAndV is IVAndV, ERC721Enumerable, Ownable {
  using Address for address;
  using Strings for uint256;

  // max number of tokens that can be minted - 75000 in production
  uint256 public immutable MAX_TOKENS;
  // number of tokens that can be claimed for free - 20% of MAX_TOKENS
  uint256 public immutable PAID_TOKENS;

  // number of tokens have been minted so far
  uint16 public minted = 0;

  // refernece to V&V minter
  IVAndVMinter private vandvMinter;
  // reference to village
  IVillage private village;
  // reference to battleground (coming soon)
  IBattleground private battleground;

  /**
   * create the contract with a name and symbol and references to other contracts
   * @param _maxTokens total tokens available
   */
  constructor(uint256 _maxTokens) ERC721("Vikings & Villagers", "VANDV") {
    MAX_TOKENS = _maxTokens;
    PAID_TOKENS = _maxTokens / 5;
  }

  /**
   * mint a token to an address
   * @param to who to send the new token to
   */
  function mint(address to) external returns (uint256) {
    require(_msgSender() == address(vandvMinter), "V&V: Only minter can call this function");
    require(minted + 1 <= MAX_TOKENS, "V&V: All tokens minted");

    minted++;

    _safeMint(to, minted);

    return minted;
  }

  /**
   * @param tokenId the token ID
   * @return the token's fully formed URI to get metadata
   */
  function tokenURI(uint256 tokenId) public view override returns (string memory) {
    require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

    return string(abi.encodePacked("https://vikingsandvillagers.com/metadata/", tokenId.toString()));
  }

  /**
   * @param from the address sending the token
   * @param to the address we're sending to
   * @param tokenId the token ID being transferred
   */
  function transferFrom(address from, address to, uint256 tokenId) public virtual override {
    // Hardcode approval for our contracts to transfer tokens to prevent users having
    // to manually approve their token for transfer, saving them gas
    if (_msgSender() != address(vandvMinter) && _msgSender() != address(village) && _msgSender() != address(battleground)) {
      require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
    }

    _transfer(from, to, tokenId);
  }

  /**
   * get how many tokens have been minted
   * @return number of tokens minted
   */
  function getMinted() external view returns (uint16) {
    return minted;
  }

  /**
   * get the number of tokens available for minting ever
   * @return max tokens
   */
  function getMaxTokens() external view returns (uint256) {
    return MAX_TOKENS;
  }

  /**
   * get the number of paid tokens
   * @return total paid tokens
   */
  function getPaidTokens() external view returns (uint256) {
    return PAID_TOKENS;
  }

  /**
   * set the address of the V&V minter contract
   * @param _vandvMinter the address
   */
  function setVAndVMinter(address _vandvMinter) external onlyOwner {
    vandvMinter = IVAndVMinter(_vandvMinter);
  }

  /**
   * set the address of the village contract
   * @param _village the address
   */
  function setVillage(address _village) external onlyOwner {
    village = IVillage(_village);
  }

  /**
   * set the address of the battleground contract
   * doesn't exist yet, will be used in the future
   * @param _battleground the address
   */
  function setBattleground(address _battleground) external onlyOwner {
    battleground = IBattleground(_battleground);
  }

}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"}],"name":"GoldStolen","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"taxed","type":"uint256"}],"name":"GoldTaxed","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":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DAILY_GOLD_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GOLD_CLAIM_TAX_PERCENTAGE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_GLOBAL_GOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_ALPHA","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINIMUM_TO_EXIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"canUnstake","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"},{"internalType":"bool","name":"shouldUnstake","type":"bool"}],"name":"claimEarnings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getEarningsForToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getTokensForOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastClaimTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","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":[{"internalType":"uint256","name":"seed","type":"uint256"}],"name":"randomVikingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardsPerAlpha","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_gold","type":"address"}],"name":"setGold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_randomizer","type":"address"}],"name":"setRandomizer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_traits","type":"address"}],"name":"setTraits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vandv","type":"address"}],"name":"setVAndV","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"stakeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAlphaStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalGoldEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalVikingsStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalVillagersStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unaccountedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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