Contract 0x75D745EAeA0Ab0A8C9542959311C1C3166F6567D

 
Txn Hash
Block
From
To
Value
0x60c2544fae047b6d097dddb696e2a169b2cd491537e524ab5cd06b692602f47d111227822020-10-25 2:04:54130 days 20 hrs ago0x7f4d43c46073f656ff231a3a6bf3170043f731f3 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.000470870420.02
0x89e69d7d340611a8fa142665295b1ac8dbb3ecbd3d7351aef200353f8a11ca89111227822020-10-25 2:04:54130 days 20 hrs ago0xa6c58da995d30a3562d2e81eb06c42cfb5ffefd7 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.003968617420.9
0x085616fd63fdcd9f2e29fced5ebc5f08d7dab2cc910f9c0247b26155ccaf3a6b110371322020-10-11 22:57:48143 days 23 hrs ago0xc92d7f1fa2938c74b590f4495e53cb35b98c2d2a IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00417806422
0xe05fa7c5e2af914f10f2a8166ad3953399632f08bd2256c2210113c9331a67c9110371222020-10-11 22:56:28144 days 1 min ago0x03014be565459aa0829f2641935949d7be8b1ed9 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.01642649822
0xfa72957bd70756cac3fde5d032572315592cf00657d96cf9908d4ee3200aa2ab110371222020-10-11 22:56:28144 days 1 min ago0xf921f632516c5805720204eacef0a6d525b8f724 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00441509222
0x5fd21e26658b782315cb8ddb41c91f14175b133e92bf0021a6ba331bce21de9d110371212020-10-11 22:56:25144 days 1 min ago0x0d518269cfd6044b839927192ed35502055785e9 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.0164270722
0xf1ce28f7707c3497f7c7ca1fe63ff5745eef3bc44398343f688774691dd0f571110370892020-10-11 22:49:39144 days 8 mins ago0x6ba5835665a95462c414b5fad64782444402951e IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.01642764222
0xf43adc4aac6b7716517397c3f6a532ad3aaf23642252ba811001896012ac51ae110370852020-10-11 22:48:42144 days 8 mins ago0x555c6cdd6f1a4b6c3db8018b8e9c4ca9ed2018ae IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00441509222
0x75d8c6295f46604c4aef0397bad1998385cf1241c0cdcae7d8be6580a4b9b250110370812020-10-11 22:47:52144 days 9 mins ago0xa6c58da995d30a3562d2e81eb06c42cfb5ffefd7 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00441566422
0x4218ac14ce9a285640ce03678fb5a85c829d4582ef0c6dd6cc566b5130a10381110370812020-10-11 22:47:52144 days 9 mins ago0x1e849ad655f7f364c4022bd8129f51083570d95f IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00417749222
0xf3e8aadbfb480cb0f4a917b4fcb2896c2eca1274c470951d0d0b7680af1f4c16110370812020-10-11 22:47:52144 days 9 mins ago0x55f74949a15ce98c9e9d8ebbdd774d5d7a25b473 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00441509222
0xf40c6d2c0a908394c130833d1a99e4a10fb99bd52391ff9e7ff26d6c6a826887109257632020-09-24 14:04:15161 days 8 hrs ago0xd9a8ebfc5a7efa6b3e67fbbc014f1e493247294d IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00284211291
0x56f713d02d6a2db1f865e06eafe2a2d146fd3276e66f54572c76394e8f0221bb107949252020-09-04 12:44:28181 days 10 hrs ago0x6d0bf5653660fde9779cf875a613169d5660670a IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.008116401151
0x4bb22fa285a56a393a08e0c5631e1b99730db6e484a5b35262ce6419286970f0107948742020-09-04 12:34:53181 days 10 hrs ago0x6d0bf5653660fde9779cf875a613169d5660670a IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.009890184184
0x0f9e93b6cf3927aeb4c4ad4135dccf7323576c5e60404a161de61e62d1bb3aec107948692020-09-04 12:34:31181 days 10 hrs ago0x6d0bf5653660fde9779cf875a613169d5660670a IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.085 Ether0.0085783885159.5
0x39fd97bf1d3c0dac0db893885c05e300ae92707ca47292cfb98c0848af484ee1107714922020-08-31 22:29:32185 days 28 mins ago0xd18d7139e2f1ceece44c01e7adb06cb20716d66b IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.011035529179
0x54711c4247a0d09f414db1cb10085b1b7c1d8c8df5fabcc3f8e0a58302ba9729107285772020-08-25 8:43:26191 days 14 hrs ago0xf96da352d3790abc061401a92bcddbc7ec197cd7 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.085 Ether0.00392615973
0x791fc8a4f6f8e30806395a06a91a6a6bb50d28f36f4f6c0c21f9ad43908c3dd3107011562020-08-21 3:27:08195 days 19 hrs ago0xedc39c248210c592c37e2b73a01c6b7c3e7380d4 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.085 Ether0.00645396120
0x30c9f6adcbdc0a726c11123a706970a1d5cdc73402a20bfc2bd83b1a87365189106953652020-08-20 6:16:36196 days 16 hrs ago0x6a82d971fdde25d9314f5310baa59ac8fd9793a2 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.0043000880
0x69b53b3c3a7fca4fa137c30cb9e2a0f411652ac62a983ab817a49362b5519a20106466242020-08-12 17:54:24204 days 5 hrs ago0x5081b7c61d3c23462546736dcea8a65feabaa7a6 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.0107502200
0x4a9a6abbf5df724ff6ba728c4e49da497530f1ceca32f150098501a08137aaa5106190172020-08-08 11:50:15208 days 11 hrs ago0xc9afd69e7c1ac927f5ddad938b1f19ddc2fc58cf IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.00190562068735.452748553
0x36026c8299c15b4a816955a67acf16a5444649e72f635efc35ba6b51faf913cb106190172020-08-08 11:50:15208 days 11 hrs ago0xc9afd69e7c1ac927f5ddad938b1f19ddc2fc58cf IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0.017 Ether0.00190562068735.452748553
0x77b720f5b5197d414673315ce6043ff59b2fff9a77753acb6c6ec241fbd9e68e105628792020-07-30 19:46:28217 days 3 hrs ago0x7f4d43c46073f656ff231a3a6bf3170043f731f3 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00883018444
0x1b425766a5756b55bcdb1297cd99a4f914da25d14237b7730464c3e3ed5a79e1105628622020-07-30 19:42:51217 days 3 hrs ago0xa6c58da995d30a3562d2e81eb06c42cfb5ffefd7 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00835498444
0x9cc27d37759b02313962967c42b57d275fc6187a16553577045f0785a7bd5e90105628622020-07-30 19:42:51217 days 3 hrs ago0x55f74949a15ce98c9e9d8ebbdd774d5d7a25b473 IN  0x75d745eaea0ab0a8c9542959311c1c3166f6567d0 Ether0.00835727244
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xf40c6d2c0a908394c130833d1a99e4a10fb99bd52391ff9e7ff26d6c6a826887109257632020-09-24 14:04:15161 days 8 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xd9a8ebfc5a7efa6b3e67fbbc014f1e493247294d4.12305 Ether
0x39fd97bf1d3c0dac0db893885c05e300ae92707ca47292cfb98c0848af484ee1107714922020-08-31 22:29:32185 days 28 mins ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xdcae1cd1ce33dd96416cada0e4a583dbdb8cc9ae0.00085 Ether
0xa9419d49c3e439c23e28d34adc848335007e6f4b5610d45d1dd0566c89614d01104332572020-07-10 18:02:52237 days 4 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xdcae1cd1ce33dd96416cada0e4a583dbdb8cc9ae0.00085 Ether
0x3b9ffa3a83e297ff6666b6d36071452f9b122d77f9d5120f86b54ccb9b994077104144072020-07-07 20:07:24240 days 2 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0x4f399602d131ff400b764b7c4679658008db48219d4b25ca7a56a1b8b9ea54ec104022062020-07-05 22:51:21242 days 6 mins ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xd9a8ebfc5a7efa6b3e67fbbc014f1e493247294d14.8708 Ether
0x3fe4d0dfa27845a32e20800555fcaf2a012e7f2f269e188f736206845efb9b56103516682020-06-28 2:54:14249 days 20 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0x9fa8330b70245b01f4ab320519030e2ecd2ea5acbee1cf8182a5a26429800f10103263502020-06-24 4:36:40253 days 18 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xd06a2f3e1d1044a6be69beccf0afc569f6dbbc810.00085 Ether
0x18e5916782186d0f24c9e5d91d6f40fcb92ed9253d9de97c494667cf7888b2d7103263502020-06-24 4:36:40253 days 18 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xd06a2f3e1d1044a6be69beccf0afc569f6dbbc810.00085 Ether
0x23ef4f251da9249ead1bb51c085b98cf3ac1a352550306f6b0d6527fd7158e6c103179552020-06-22 21:22:29255 days 1 hr ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0x96080155dd976e98305fa9aea96834a03abda8640.00425 Ether
0xf37ba76aad36e522fde4617227162ed07c6ec74c4b7b1dfe2773257335881547102979172020-06-19 18:56:16258 days 4 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xd06a2f3e1d1044a6be69beccf0afc569f6dbbc810.00085 Ether
0xf37095316aa25ecf24af80c79a8e8b5a3c1852553406178ec813a9bfee73c785102906972020-06-18 16:16:36259 days 6 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0x96080155dd976e98305fa9aea96834a03abda8640.00425 Ether
0xd20d42628b753b3eb05392b9c70328a1ccc2f521498875c82f851776c16c68dd102856882020-06-17 21:37:42260 days 1 hr ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0x96080155dd976e98305fa9aea96834a03abda8640.00425 Ether
0x1cfacdc898d1eb16647740b1924a956d70987a7b300556d8f12a61b91b332a3b102810162020-06-17 4:09:27260 days 18 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0xb3085a7cc1f11a5f13c809e1c6b17e5b5833a33c8b5d9c81035a3a4e85be0310102661712020-06-14 21:00:05263 days 1 hr ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xd06a2f3e1d1044a6be69beccf0afc569f6dbbc810.00085 Ether
0x83819644b5699363aed6cc276ee89b6b1a5e14feca9def5273be2c4be9d1b3b6102570852020-06-13 11:30:10264 days 11 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0x0db6e402a4453f4ac671f3b6c485a0e8b029b8a8c2dd32d94a39304a7dedfd85102378672020-06-10 12:14:51267 days 10 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0x2a4ca79d1e65300490305584ab4133c318c9bcb1cf2cead978de365dcc0892a2102189972020-06-07 13:47:49270 days 9 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0x686ec672f9f824ea0e946c20f3e2dad15da1e26551954e793123e074c8c6d346101991502020-06-04 11:50:40273 days 11 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0xc13f2661bc651c53a9d6149eca3b47636deb4c4f320b4e671343be9dad077d38101865622020-06-02 13:02:18275 days 9 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00425 Ether
0xeb7d6e31e2bc5c099b2edf3b072c66e2d4d1eb86dd1b72fb27f9d8c061d61d07101703982020-05-31 0:35:13277 days 22 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00085 Ether
0x09c39aee2106faadd1b5210adf7c3d6323206212426fc05a6db0cbad9bbfbaba101639912020-05-30 0:48:35278 days 22 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00085 Ether
0x091d036fae6cadf93b7bf10603a519c950ea0d92121dd35ae2ae71cb67f2818e101606702020-05-29 12:26:32279 days 10 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00085 Ether
0xc3817f07a810cad78808af25c9df5ff6e4ba32fa773b0e24023ba45a989db97d101585312020-05-29 4:26:13279 days 18 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xdcae1cd1ce33dd96416cada0e4a583dbdb8cc9ae0.00085 Ether
0x1710fc0b04c4e36353ab0e2ea06b47f45860a533bfe5c9670d29178c6e8a7f3c101412402020-05-26 12:11:26282 days 10 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567dOpenSea: Wallet0.00085 Ether
0x34b4b122e1537c4e3c39ba1935215734ed4a87f6505b4ec554091453c6977630101319752020-05-25 1:12:48283 days 21 hrs ago 0x75d745eaea0ab0a8c9542959311c1c3166f6567d0xdcae1cd1ce33dd96416cada0e4a583dbdb8cc9ae0.00085 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Similar Match)
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x7f0a2c82cd2ef606310d377b9895ee76e1277ae6

Contract Name:
PackSale

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2018-12-04
*/

pragma solidity ^0.4.24;

// File: contracts/openzeppelin-solidity/introspection/ERC165.sol

/**
 * @title ERC165
 * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
 */
interface ERC165 {

  /**
   * @notice Query if a contract implements an interface
   * @param _interfaceId The interface identifier, as specified in ERC-165
   * @dev Interface identification is specified in ERC-165. This function
   * uses less than 30,000 gas.
   */
  function supportsInterface(bytes4 _interfaceId)
    external
    view
    returns (bool);
}

// File: contracts/openzeppelin-solidity/token/ERC721/ERC721Basic.sol

/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Basic is ERC165 {
  event Transfer(
    address indexed _from,
    address indexed _to,
    uint256 indexed _tokenId
  );
  event Approval(
    address indexed _owner,
    address indexed _approved,
    uint256 indexed _tokenId
  );
  event ApprovalForAll(
    address indexed _owner,
    address indexed _operator,
    bool _approved
  );

  function balanceOf(address _owner) public view returns (uint256 _balance);
  function ownerOf(uint256 _tokenId) public view returns (address _owner);
  function exists(uint256 _tokenId) public view returns (bool _exists);

  function approve(address _to, uint256 _tokenId) public;
  function getApproved(uint256 _tokenId)
    public view returns (address _operator);

  function setApprovalForAll(address _operator, bool _approved) public;
  function isApprovedForAll(address _owner, address _operator)
    public view returns (bool);

  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function safeTransferFrom(address _from, address _to, uint256 _tokenId)
    public;

  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes _data
  )
    public;
}

// File: contracts/openzeppelin-solidity/token/ERC721/ERC721.sol

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Enumerable is ERC721Basic {
  function totalSupply() public view returns (uint256);
  function tokenOfOwnerByIndex(
    address _owner,
    uint256 _index
  )
    public
    view
    returns (uint256 _tokenId);

  function tokenByIndex(uint256 _index) public view returns (uint256);
}


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Metadata is ERC721Basic {
  function name() external view returns (string _name);
  function symbol() external view returns (string _symbol);
  function tokenURI(uint256 _tokenId) public view returns (string);
}


/**
 * @title ERC-721 Non-Fungible Token Standard, full implementation interface
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}

// File: contracts/openzeppelin-solidity/token/ERC721/ERC721Receiver.sol

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
contract ERC721Receiver {
  /**
   * @dev Magic value to be returned upon successful reception of an NFT
   *  Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`,
   *  which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
   */
  bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;

  /**
   * @notice Handle the receipt of an NFT
   * @dev The ERC721 smart contract calls this function on the recipient
   * after a `safetransfer`. This function MAY throw to revert and reject the
   * transfer. Return of other than the magic value MUST result in the 
   * transaction being reverted.
   * Note: the contract address is always the message sender.
   * @param _operator The address which called `safeTransferFrom` function
   * @param _from The address which previously owned the token
   * @param _tokenId The NFT identifier which is being transfered
   * @param _data Additional data with no specified format
   * @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
   */
  function onERC721Received(
    address _operator,
    address _from,
    uint256 _tokenId,
    bytes _data
  )
    public
    returns(bytes4);
}

// File: contracts/openzeppelin-solidity/math/SafeMath.sol

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return a / b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
    c = a + b;
    assert(c >= a);
    return c;
  }
}

// File: contracts/openzeppelin-solidity/AddressUtils.sol

/**
 * Utility library of inline functions on addresses
 */
library AddressUtils {

  /**
   * Returns whether the target address is a contract
   * @dev This function will return false if invoked during the constructor of a contract,
   * as the code is not actually created until after the constructor finishes.
   * @param addr address to check
   * @return whether the target address is a contract
   */
  function isContract(address addr) internal view returns (bool) {
    uint256 size;
    // XXX Currently there is no better way to check if there is a contract in an address
    // than to check the size of the code at that address.
    // See https://ethereum.stackexchange.com/a/14016/36603
    // for more details about how this works.
    // TODO Check this again before the Serenity release, because all addresses will be
    // contracts then.
    // solium-disable-next-line security/no-inline-assembly
    assembly { size := extcodesize(addr) }
    return size > 0;
  }

}

// File: contracts/openzeppelin-solidity/introspection/SupportsInterfaceWithLookup.sol

/**
 * @title SupportsInterfaceWithLookup
 * @author Matt Condon (@shrugs)
 * @dev Implements ERC165 using a lookup table.
 */
contract SupportsInterfaceWithLookup is ERC165 {
  bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
  /**
   * 0x01ffc9a7 ===
   *   bytes4(keccak256('supportsInterface(bytes4)'))
   */

  /**
   * @dev a mapping of interface id to whether or not it's supported
   */
  mapping(bytes4 => bool) internal supportedInterfaces;

  /**
   * @dev A contract implementing SupportsInterfaceWithLookup
   * implement ERC165 itself
   */
  constructor()
    public
  {
    _registerInterface(InterfaceId_ERC165);
  }

  /**
   * @dev implement supportsInterface(bytes4) using a lookup table
   */
  function supportsInterface(bytes4 _interfaceId)
    external
    view
    returns (bool)
  {
    return supportedInterfaces[_interfaceId];
  }

  /**
   * @dev private method for registering an interface
   */
  function _registerInterface(bytes4 _interfaceId)
    internal
  {
    require(_interfaceId != 0xffffffff);
    supportedInterfaces[_interfaceId] = true;
  }
}

// File: contracts/openzeppelin-solidity/token/ERC721/ERC721BasicToken.sol

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {

  bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
  /*
   * 0x80ac58cd ===
   *   bytes4(keccak256('balanceOf(address)')) ^
   *   bytes4(keccak256('ownerOf(uint256)')) ^
   *   bytes4(keccak256('approve(address,uint256)')) ^
   *   bytes4(keccak256('getApproved(uint256)')) ^
   *   bytes4(keccak256('setApprovalForAll(address,bool)')) ^
   *   bytes4(keccak256('isApprovedForAll(address,address)')) ^
   *   bytes4(keccak256('transferFrom(address,address,uint256)')) ^
   *   bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
   *   bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
   */

  bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
  /*
   * 0x4f558e79 ===
   *   bytes4(keccak256('exists(uint256)'))
   */

  using SafeMath for uint256;
  using AddressUtils for address;

  // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
  // which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
  bytes4 private constant ERC721_RECEIVED = 0x150b7a02;

  // Mapping from token ID to owner
  mapping (uint256 => address) internal tokenOwner;

  // Mapping from token ID to approved address
  mapping (uint256 => address) internal tokenApprovals;

  // Mapping from owner to number of owned token
  mapping (address => uint256) internal ownedTokensCount;

  // Mapping from owner to operator approvals
  mapping (address => mapping (address => bool)) internal operatorApprovals;

  /**
   * @dev Guarantees msg.sender is owner of the given token
   * @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
   */
  modifier onlyOwnerOf(uint256 _tokenId) {
    require(ownerOf(_tokenId) == msg.sender);
    _;
  }

  /**
   * @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
   * @param _tokenId uint256 ID of the token to validate
   */
  modifier canTransfer(uint256 _tokenId) {
    require(isApprovedOrOwner(msg.sender, _tokenId));
    _;
  }

  constructor()
    public
  {
    // register the supported interfaces to conform to ERC721 via ERC165
    _registerInterface(InterfaceId_ERC721);
    _registerInterface(InterfaceId_ERC721Exists);
  }

  /**
   * @dev Gets the balance of the specified address
   * @param _owner address to query the balance of
   * @return uint256 representing the amount owned by the passed address
   */
  function balanceOf(address _owner) public view returns (uint256) {
    require(_owner != address(0));
    return ownedTokensCount[_owner];
  }

  /**
   * @dev Gets the owner of the specified token ID
   * @param _tokenId uint256 ID of the token to query the owner of
   * @return owner address currently marked as the owner of the given token ID
   */
  function ownerOf(uint256 _tokenId) public view returns (address) {
    address owner = tokenOwner[_tokenId];
    require(owner != address(0));
    return owner;
  }

  /**
   * @dev Returns whether the specified token exists
   * @param _tokenId uint256 ID of the token to query the existence of
   * @return whether the token exists
   */
  function exists(uint256 _tokenId) public view returns (bool) {
    address owner = tokenOwner[_tokenId];
    return owner != address(0);
  }

  /**
   * @dev Approves another address to transfer the given token ID
   * The zero address indicates there is no approved address.
   * There can only be one approved address per token at a given time.
   * Can only be called by the token owner or an approved operator.
   * @param _to address to be approved for the given token ID
   * @param _tokenId uint256 ID of the token to be approved
   */
  function approve(address _to, uint256 _tokenId) public {
    address owner = ownerOf(_tokenId);
    require(_to != owner);
    require(msg.sender == owner || isApprovedForAll(owner, msg.sender));

    tokenApprovals[_tokenId] = _to;
    emit Approval(owner, _to, _tokenId);
  }

  /**
   * @dev Gets the approved address for a token ID, or zero if no address set
   * @param _tokenId uint256 ID of the token to query the approval of
   * @return address currently approved for the given token ID
   */
  function getApproved(uint256 _tokenId) public view returns (address) {
    return tokenApprovals[_tokenId];
  }

  /**
   * @dev Sets or unsets the approval of a given operator
   * An operator is allowed to transfer all tokens of the sender on their behalf
   * @param _to operator address to set the approval
   * @param _approved representing the status of the approval to be set
   */
  function setApprovalForAll(address _to, bool _approved) public {
    require(_to != msg.sender);
    operatorApprovals[msg.sender][_to] = _approved;
    emit ApprovalForAll(msg.sender, _to, _approved);
  }

  /**
   * @dev Tells whether an operator is approved by a given owner
   * @param _owner owner address which you want to query the approval of
   * @param _operator operator address which you want to query the approval of
   * @return bool whether the given operator is approved by the given owner
   */
  function isApprovedForAll(
    address _owner,
    address _operator
  )
    public
    view
    returns (bool)
  {
    return operatorApprovals[_owner][_operator];
  }

  /**
   * @dev Transfers the ownership of a given token ID to another address
   * Usage of this method is discouraged, use `safeTransferFrom` whenever possible
   * Requires the msg sender to be the owner, approved, or operator
   * @param _from current owner of the token
   * @param _to address to receive the ownership of the given token ID
   * @param _tokenId uint256 ID of the token to be transferred
  */
  function transferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  )
    public
    canTransfer(_tokenId)
  {
    require(_from != address(0));
    require(_to != address(0));

    clearApproval(_from, _tokenId);
    removeTokenFrom(_from, _tokenId);
    addTokenTo(_to, _tokenId);

    emit Transfer(_from, _to, _tokenId);
  }

  /**
   * @dev Safely transfers the ownership of a given token ID to another address
   * If the target address is a contract, it must implement `onERC721Received`,
   * which is called upon a safe transfer, and return the magic value
   * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
   * the transfer is reverted.
   *
   * Requires the msg sender to be the owner, approved, or operator
   * @param _from current owner of the token
   * @param _to address to receive the ownership of the given token ID
   * @param _tokenId uint256 ID of the token to be transferred
  */
  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  )
    public
    canTransfer(_tokenId)
  {
    // solium-disable-next-line arg-overflow
    safeTransferFrom(_from, _to, _tokenId, "");
  }

  /**
   * @dev Safely transfers the ownership of a given token ID to another address
   * If the target address is a contract, it must implement `onERC721Received`,
   * which is called upon a safe transfer, and return the magic value
   * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
   * the transfer is reverted.
   * Requires the msg sender to be the owner, approved, or operator
   * @param _from current owner of the token
   * @param _to address to receive the ownership of the given token ID
   * @param _tokenId uint256 ID of the token to be transferred
   * @param _data bytes data to send along with a safe transfer check
   */
  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes _data
  )
    public
    canTransfer(_tokenId)
  {
    transferFrom(_from, _to, _tokenId);
    // solium-disable-next-line arg-overflow
    require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
  }

  /**
   * @dev Returns whether the given spender can transfer a given token ID
   * @param _spender address of the spender to query
   * @param _tokenId uint256 ID of the token to be transferred
   * @return bool whether the msg.sender is approved for the given token ID,
   *  is an operator of the owner, or is the owner of the token
   */
  function isApprovedOrOwner(
    address _spender,
    uint256 _tokenId
  )
    internal
    view
    returns (bool)
  {
    address owner = ownerOf(_tokenId);
    // Disable solium check because of
    // https://github.com/duaraghav8/Solium/issues/175
    // solium-disable-next-line operator-whitespace
    return (
      _spender == owner ||
      getApproved(_tokenId) == _spender ||
      isApprovedForAll(owner, _spender)
    );
  }

  /**
   * @dev Internal function to mint a new token
   * Reverts if the given token ID already exists
   * @param _to The address that will own the minted token
   * @param _tokenId uint256 ID of the token to be minted by the msg.sender
   */
  function _mint(address _to, uint256 _tokenId) internal {
    require(_to != address(0));
    addTokenTo(_to, _tokenId);
    emit Transfer(address(0), _to, _tokenId);
  }

  /**
   * @dev Internal function to burn a specific token
   * Reverts if the token does not exist
   * @param _tokenId uint256 ID of the token being burned by the msg.sender
   */
  function _burn(address _owner, uint256 _tokenId) internal {
    clearApproval(_owner, _tokenId);
    removeTokenFrom(_owner, _tokenId);
    emit Transfer(_owner, address(0), _tokenId);
  }

  /**
   * @dev Internal function to clear current approval of a given token ID
   * Reverts if the given address is not indeed the owner of the token
   * @param _owner owner of the token
   * @param _tokenId uint256 ID of the token to be transferred
   */
  function clearApproval(address _owner, uint256 _tokenId) internal {
    require(ownerOf(_tokenId) == _owner);
    if (tokenApprovals[_tokenId] != address(0)) {
      tokenApprovals[_tokenId] = address(0);
    }
  }

  /**
   * @dev Internal function to add a token ID to the list of a given address
   * @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 addTokenTo(address _to, uint256 _tokenId) internal {
    require(tokenOwner[_tokenId] == address(0));
    tokenOwner[_tokenId] = _to;
    ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
  }

  /**
   * @dev Internal function to remove a token ID from the list of a given address
   * @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 removeTokenFrom(address _from, uint256 _tokenId) internal {
    require(ownerOf(_tokenId) == _from);
    ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
    tokenOwner[_tokenId] = address(0);
  }

  /**
   * @dev Internal function to invoke `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 whether the call correctly returned the expected magic value
   */
  function checkAndCallSafeTransfer(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes _data
  )
    internal
    returns (bool)
  {
    if (!_to.isContract()) {
      return true;
    }
    bytes4 retval = ERC721Receiver(_to).onERC721Received(
      msg.sender, _from, _tokenId, _data);
    return (retval == ERC721_RECEIVED);
  }
}

// File: contracts/openzeppelin-solidity/token/ERC721/ERC721Token.sol

/**
 * @title Full ERC721 Token
 * This implementation includes all the required and some optional functionality of the ERC721 standard
 * Moreover, it includes approve all functionality using operator terminology
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {

  bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
  /**
   * 0x780e9d63 ===
   *   bytes4(keccak256('totalSupply()')) ^
   *   bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
   *   bytes4(keccak256('tokenByIndex(uint256)'))
   */

  bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
  /**
   * 0x5b5e139f ===
   *   bytes4(keccak256('name()')) ^
   *   bytes4(keccak256('symbol()')) ^
   *   bytes4(keccak256('tokenURI(uint256)'))
   */

  // Token name
  string internal name_;

  // Token symbol
  string internal symbol_;

  // Mapping from owner to list of owned token IDs
  mapping(address => uint256[]) internal ownedTokens;

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

  // Array with all token ids, used for enumeration
  uint256[] internal allTokens;

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

  // Optional mapping for token URIs
  mapping(uint256 => string) internal tokenURIs;

  /**
   * @dev Constructor function
   */
  constructor(string _name, string _symbol) public {
    name_ = _name;
    symbol_ = _symbol;

    // register the supported interfaces to conform to ERC721 via ERC165
    _registerInterface(InterfaceId_ERC721Enumerable);
    _registerInterface(InterfaceId_ERC721Metadata);
  }

  /**
   * @dev Gets the token name
   * @return string representing the token name
   */
  function name() external view returns (string) {
    return name_;
  }

  /**
   * @dev Gets the token symbol
   * @return string representing the token symbol
   */
  function symbol() external view returns (string) {
    return symbol_;
  }

  /**
   * @dev Returns an URI for a given token ID
   * Throws if the token ID does not exist. May return an empty string.
   * @param _tokenId uint256 ID of the token to query
   */
  function tokenURI(uint256 _tokenId) public view returns (string) {
    require(exists(_tokenId));
    return tokenURIs[_tokenId];
  }

  /**
   * @dev Gets the token ID at a given index of the tokens list of the requested owner
   * @param _owner address owning the tokens list to be accessed
   * @param _index uint256 representing the index to be accessed of the requested tokens list
   * @return uint256 token ID at the given index of the tokens list owned by the requested address
   */
  function tokenOfOwnerByIndex(
    address _owner,
    uint256 _index
  )
    public
    view
    returns (uint256)
  {
    require(_index < balanceOf(_owner));
    return ownedTokens[_owner][_index];
  }

  /**
   * @dev Gets the total amount of tokens stored by the contract
   * @return uint256 representing the total amount of tokens
   */
  function totalSupply() public view returns (uint256) {
    return allTokens.length;
  }

  /**
   * @dev Gets the token ID at a given index of all the tokens in this contract
   * Reverts if the index is greater or equal to the total number of tokens
   * @param _index uint256 representing the index to be accessed of the tokens list
   * @return uint256 token ID at the given index of the tokens list
   */
  function tokenByIndex(uint256 _index) public view returns (uint256) {
    require(_index < totalSupply());
    return allTokens[_index];
  }

  /**
   * @dev Internal function to set the token URI for a given token
   * Reverts if the token ID does not exist
   * @param _tokenId uint256 ID of the token to set its URI
   * @param _uri string URI to assign
   */
  function _setTokenURI(uint256 _tokenId, string _uri) internal {
    require(exists(_tokenId));
    tokenURIs[_tokenId] = _uri;
  }

  /**
   * @dev Internal function to add a token ID to the list of a given address
   * @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 addTokenTo(address _to, uint256 _tokenId) internal {
    super.addTokenTo(_to, _tokenId);
    uint256 length = ownedTokens[_to].length;
    ownedTokens[_to].push(_tokenId);
    ownedTokensIndex[_tokenId] = length;
  }

  /**
   * @dev Internal function to remove a token ID from the list of a given address
   * @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 removeTokenFrom(address _from, uint256 _tokenId) internal {
    super.removeTokenFrom(_from, _tokenId);

    uint256 tokenIndex = ownedTokensIndex[_tokenId];
    uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
    uint256 lastToken = ownedTokens[_from][lastTokenIndex];

    ownedTokens[_from][tokenIndex] = lastToken;
    ownedTokens[_from][lastTokenIndex] = 0;
    // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
    // be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping
    // the lastToken to the first position, and then dropping the element placed in the last position of the list

    ownedTokens[_from].length--;
    ownedTokensIndex[_tokenId] = 0;
    ownedTokensIndex[lastToken] = tokenIndex;
  }

  /**
   * @dev Internal function to mint a new token
   * Reverts if the given token ID already exists
   * @param _to address the beneficiary that will own the minted token
   * @param _tokenId uint256 ID of the token to be minted by the msg.sender
   */
  function _mint(address _to, uint256 _tokenId) internal {
    super._mint(_to, _tokenId);

    allTokensIndex[_tokenId] = allTokens.length;
    allTokens.push(_tokenId);
  }

  /**
   * @dev Internal function to burn a specific token
   * Reverts if the token does not exist
   * @param _owner owner of the token to burn
   * @param _tokenId uint256 ID of the token being burned by the msg.sender
   */
  function _burn(address _owner, uint256 _tokenId) internal {
    super._burn(_owner, _tokenId);

    // Clear metadata (if any)
    if (bytes(tokenURIs[_tokenId]).length != 0) {
      delete tokenURIs[_tokenId];
    }

    // Reorg all tokens array
    uint256 tokenIndex = allTokensIndex[_tokenId];
    uint256 lastTokenIndex = allTokens.length.sub(1);
    uint256 lastToken = allTokens[lastTokenIndex];

    allTokens[tokenIndex] = lastToken;
    allTokens[lastTokenIndex] = 0;

    allTokens.length--;
    allTokensIndex[_tokenId] = 0;
    allTokensIndex[lastToken] = tokenIndex;
  }

}

// File: contracts/openzeppelin-solidity/ownership/Ownable.sol

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to relinquish control of the contract.
   * @notice Renouncing to ownership will leave the contract without an owner.
   * It will not be possible to call the functions with the `onlyOwner`
   * modifier anymore.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(address _newOwner) public onlyOwner {
    _transferOwnership(_newOwner);
  }

  /**
   * @dev Transfers control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function _transferOwnership(address _newOwner) internal {
    require(_newOwner != address(0));
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

// File: contracts/ERC721TokenWithData.sol

// import "./ERC721SlimTokenArray.sol";



// an ERC721 token with additional data storage,
contract ERC721TokenWithData is ERC721Token("CryptoAssaultUnit", "CAU"), Ownable {

  /**
   * @dev Returns whether the given spender can transfer a given token ID
   * @param _spender address of the spender to query
   * @param _tokenId uint256 ID of the token to be transferred
   * @return bool whether the msg.sender is approved for the given token ID,
   *  is an operator of the owner, or is the owner of the token
   */
	function isApprovedOrOwner(
		address _spender,
		uint256 _tokenId
	)
		internal
		view
		returns (bool)
	{
		address owner = ownerOf(_tokenId);
		// Disable solium check because of
		// https://github.com/duaraghav8/Solium/issues/175
		// solium-disable-next-line operator-whitespace
		return (
			_spender == owner ||
			approvedContractAddresses[_spender] ||
			getApproved(_tokenId) == _spender ||
			isApprovedForAll(owner, _spender)
		);
	}

	mapping (address => bool) internal approvedContractAddresses;
	bool approvedContractsFinalized = false;

	/**
	* @notice Approve a contract address for minting tokens and transferring tokens, when approved by the owner
	* @param contractAddress The address that will be approved
	*/
	function addApprovedContractAddress(address contractAddress) public onlyOwner
	{
		require(!approvedContractsFinalized);
		approvedContractAddresses[contractAddress] = true;
	}

	/**
	* @notice Unapprove a contract address for minting tokens and transferring tokens
	* @param contractAddress The address that will be unapproved
	*/
	function removeApprovedContractAddress(address contractAddress) public onlyOwner
	{
		require(!approvedContractsFinalized);
		approvedContractAddresses[contractAddress] = false;
	}

	/**
	* @notice Finalize the contract so it will be forever impossible to change the approved contracts list
	*/
	function finalizeApprovedContracts() public onlyOwner {
		approvedContractsFinalized = true;
	}

	mapping(uint256 => mapping(uint256 => uint256)) data;

	function getData(uint256 _tokenId, uint256 _index) public view returns (uint256) {
		return data[_index][_tokenId];
	}

	function getData3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3, uint256 _index) public view returns (uint256, uint256, uint256) {
		return (
			data[_index][_tokenId1],
			data[_index][_tokenId2],
			data[_index][_tokenId3]
		);
	}
	
	function getDataAndOwner3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3, uint256 _index) public view returns (uint256, uint256, uint256, address, address, address) {
		return (
			data[_index][_tokenId1],
			data[_index][_tokenId2],
			data[_index][_tokenId3],
			ownerOf(_tokenId1),
			ownerOf(_tokenId2),
			ownerOf(_tokenId3)
		);
	}
	
	function _setData(uint256 _tokenId, uint256 _index, uint256 _data) internal {
		
		data[_index][_tokenId] = _data;
	}

	function setData(uint256 _tokenId, uint256 _index, uint256 _data) public {
		
		require(approvedContractAddresses[msg.sender], "not an approved sender");
		data[_index][_tokenId] = _data;
	}

	/**
	* @notice Gets the list of tokens owned by a given address
	* @param _owner address to query the tokens of
	* @return uint256[] representing the list of tokens owned by the passed address
	*/
	function tokensOfWithData(address _owner, uint256 _index) public view returns (uint256[], uint256[]) {
		uint256[] memory tokensList = ownedTokens[_owner];
		uint256[] memory dataList = new uint256[](tokensList.length);
		for (uint i=0; i<tokensList.length; i++) {
			dataList[i] = data[_index][tokensList[i]];
		}
		return (tokensList, dataList);
	}

	// The tokenId of the next minted token. It auto-increments.
	uint256 nextTokenId = 1;

	function getNextTokenId() public view returns (uint256) {
		return nextTokenId;
	}

	/**
	* @notice Mint token function
	* @param _to The address that will own the minted token
	*/
	function mintAndSetData(address _to, uint256 _data) public returns (uint256) {

		require(approvedContractAddresses[msg.sender], "not an approved sender");

		uint256 tokenId = nextTokenId;
		nextTokenId++;
		_mint(_to, tokenId);
		_setData(tokenId, 0, _data);

		return tokenId;
	}

	function burn(uint256 _tokenId) public {
		require(
			approvedContractAddresses[msg.sender] ||
			msg.sender == owner, "burner not approved"
		);

		_burn(ownerOf(_tokenId), _tokenId);
	}
	
	function burn3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) public {
		require(
			approvedContractAddresses[msg.sender] ||
			msg.sender == owner, "burner not approved"
		);

		_burn(ownerOf(_tokenId1), _tokenId1);
		_burn(ownerOf(_tokenId2), _tokenId2);
		_burn(ownerOf(_tokenId3), _tokenId3);
	}
}

// File: contracts/strings/Strings.sol

library Strings {
  // via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
  function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
      bytes memory _ba = bytes(_a);
      bytes memory _bb = bytes(_b);
      bytes memory _bc = bytes(_c);
      bytes memory _bd = bytes(_d);
      bytes memory _be = bytes(_e);
      string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
      bytes memory babcde = bytes(abcde);
      uint k = 0;
      for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
      for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
      for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
      for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
      for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
      return string(babcde);
    }

    function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
        return strConcat(_a, _b, _c, _d, "");
    }

    function strConcat(string _a, string _b, string _c) internal pure returns (string) {
        return strConcat(_a, _b, _c, "", "");
    }

    function strConcat(string _a, string _b) internal pure returns (string) {
        return strConcat(_a, _b, "", "", "");
    }

    function uint2str(uint i) internal pure returns (string) {
        if (i == 0) return "0";
        uint j = i;
        uint len;
        while (j != 0){
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (i != 0){
            bstr[k--] = byte(48 + i % 10);
            i /= 10;
        }
        return string(bstr);
    }
}

// File: contracts/Token.sol

contract Token is ERC721TokenWithData {

	string metadataUrlPrefix = "https://metadata.cryptoassault.io/unit/";

	/**
	* @dev Returns an URI for a given token ID
	* Throws if the token ID does not exist. May return an empty string.
	* @param _tokenId uint256 ID of the token to query
	*/
	function tokenURI(uint256 _tokenId) public view returns (string) {
		require(exists(_tokenId));
		return Strings.strConcat(metadataUrlPrefix, Strings.uint2str(_tokenId));
	}

	function setMetadataUrlPrefix(string _metadataUrlPrefix) public onlyOwner
	{
		metadataUrlPrefix = _metadataUrlPrefix;
	}
}

// File: contracts/openzeppelin-solidity/lifecycle/Pausable.sol

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
  event Pause();
  event Unpause();

  bool public paused = false;


  /**
   * @dev Modifier to make a function callable only when the contract is not paused.
   */
  modifier whenNotPaused() {
    require(!paused);
    _;
  }

  /**
   * @dev Modifier to make a function callable only when the contract is paused.
   */
  modifier whenPaused() {
    require(paused);
    _;
  }

  /**
   * @dev called by the owner to pause, triggers stopped state
   */
  function pause() onlyOwner whenNotPaused public {
    paused = true;
    emit Pause();
  }

  /**
   * @dev called by the owner to unpause, returns to normal state
   */
  function unpause() onlyOwner whenPaused public {
    paused = false;
    emit Unpause();
  }
}

// File: contracts/PackSale.sol

contract PackSale is Pausable {

	event Sold(address buyer, uint256 sku, uint256 totalPrice);
	event Hatched(address buyer, uint256 amount);

	uint256 constant PRESALE_START_TIME = 1544126400;
	uint256 constant NUM_UNIT_TYPES = 30;

	Token token;

	function setTokenContractAddress(address newAddress) onlyOwner public {
		token = Token(newAddress);
	}
	
	struct WaitingToHatch {
		address owner;
		uint16 amount;
		uint16 rarity;
		uint16 sku;
		uint48 purchasedOnBlockNumber;
	}
	mapping (uint256 => WaitingToHatch) waitingToHatch; // This is a FIFO queue.

	uint64 waitingToHatchNum = 0;
	uint64 waitingToHatchFirstIndex = 0;
	uint64 hatchNonce = 1;

	// maps amount to a price.
	mapping(uint256 => uint256) prices;

	constructor() public {
		prices[1] = 0.017 ether;
		prices[2] = 0.085 ether;
		prices[3] = 0.33 ether;
		prices[4] = 0.587 ether;
		prices[5] = 1.2 ether;
		prices[6] = 2.99 ether;
	}
	
	function withdrawBalance() onlyOwner public {
		owner.transfer(address(this).balance);
	}

	function setPrice(uint32 sku, uint64 price) public onlyOwner {
		prices[sku] = price;
	}

	function getPrice(uint32 sku) public view returns (uint256)
	{
		require(now >= PRESALE_START_TIME, "The sale hasn't started yet");

		uint256 price = prices[sku];
		require (price > 0);

		// Apply the pre-sale discount
		uint256 intervalsSinceSaleStarted = (now - PRESALE_START_TIME) / (2 days);
		// The discount starts at 30% and goes down 1% every 2 days.
		uint256 pricePercentage = 70 + intervalsSinceSaleStarted;
		if (pricePercentage < 100) {
			price = (price * pricePercentage) / 100;
		}

		return price;
	}

	function pushHatch(address to, uint16 amount, uint16 rarity, uint16 sku) private {

		waitingToHatch[waitingToHatchFirstIndex + waitingToHatchNum] = WaitingToHatch(to, amount, rarity, sku, uint32(block.number));
		waitingToHatchNum = waitingToHatchNum + 1;
	}

	function popHatch() private {

		require(waitingToHatchNum > 0, "trying to popHatch() an empty stack");
		waitingToHatchNum = waitingToHatchNum - 1;
		waitingToHatchFirstIndex = waitingToHatchFirstIndex + 1;
	}

	function peekHatch() private view returns (WaitingToHatch) {

		return waitingToHatch[waitingToHatchFirstIndex];
	}

	function buy(uint16 sku, address referral) external payable whenNotPaused {

		uint256 price = getPrice(sku);
		require(msg.value >= price, "Amount paid is too low");

		// push the purchase onto a FIFO, to be minted in a later transaction.

		if (sku == 1) {
			pushHatch(msg.sender, 1, 0, sku); // 1 common or better
		} else if (sku == 2) {
			pushHatch(msg.sender, 5, 0, sku); // 5 common or better
		} else if (sku == 3) {
			// 20 common or better
			pushHatch(msg.sender, 10, 0, sku); 
			pushHatch(msg.sender, 10, 0, sku); 
		} else if (sku == 4) {
			pushHatch(msg.sender, 10, 1, sku);  // 10 rare or better
		} else if (sku == 5) {
			pushHatch(msg.sender, 10, 1, sku);  // 10 rare or better
			// 40 common or better
			pushHatch(msg.sender, 10, 0, sku);
			pushHatch(msg.sender, 10, 0, sku);
			pushHatch(msg.sender, 10, 0, sku);
			pushHatch(msg.sender, 10, 0, sku);
		} else if (sku == 6) {
			// 3 epic or better
			pushHatch(msg.sender, 3, 2, sku);
			// 47 rare or better
			pushHatch(msg.sender, 10, 1, sku);
			pushHatch(msg.sender, 10, 1, sku);
			pushHatch(msg.sender, 10, 1, sku);
			pushHatch(msg.sender, 10, 1, sku);
			pushHatch(msg.sender, 7, 1, sku);
		} else {
			require(false, "Invalid sku");
		}

		// Pay the referral 5%
		if (referral != address(0) && referral != msg.sender) {
			referral.transfer(price / 20);
		}

		emit Sold(msg.sender, sku, price);
	}

	function giveFreeUnit(address to, uint16 minRarity) onlyOwner public
	{
		pushHatch(to, 1, minRarity, 0);
	}

	function getNumMyHatchingUnits() public view returns (uint256) {
		uint256 num = 0;
		for (uint256 i=0; i<waitingToHatchNum; i++) {
			if (waitingToHatch[waitingToHatchFirstIndex + i].owner == msg.sender) {
				num += waitingToHatch[waitingToHatchFirstIndex + i].amount;
			}
		}
		return num;
	}

	function hatchingsNeeded() external view returns (uint256) {

		return waitingToHatchNum;
	}
	
	function getProjectedBlockHash(uint256 blockNumber) internal view returns (uint256) {

		uint256 blockToHash = blockNumber;
		uint256 blocksAgo = block.number - blockToHash;
		blockToHash += ((blocksAgo-1) / 256) * 256;
		return uint256(blockhash(blockToHash));
	}

	function getRandomType(uint16 rand) internal pure returns (uint8)
	{
		return uint8(rand % NUM_UNIT_TYPES);
	}
 
	function getRandomRarity(uint32 rand, uint256 minimumRarity) internal pure returns (uint256)
	{

		uint256 rarityRand;
		if (minimumRarity == 0) {
			rarityRand = rand % 100;
		} else if (minimumRarity == 1) {
			rarityRand = rand % 20 + 80;
		} else if (minimumRarity == 2) {
			rarityRand = rand % 5 + 95;
		} else if (minimumRarity == 3) {
			rarityRand = 99;
		} else {
			require(false, "Invalid minimumRarity");
		}

		if (rarityRand < 80) return 0;
		if (rarityRand < 95) return 1;
		if (rarityRand < 99) return 2;
		return 3;
	}

	function hatch() external whenNotPaused {

		require(waitingToHatchNum > 0, "nothing to hatch");

		WaitingToHatch memory w = peekHatch();
		
		// can't hatch on the same block. its block hash would be unknown.
		require (w.purchasedOnBlockNumber < block.number, "Can't hatch on the same block.");

		uint256 rand = getProjectedBlockHash(w.purchasedOnBlockNumber) + hatchNonce;

		for (uint256 i=0; i<w.amount; i++) {
			rand = uint256(keccak256(abi.encodePacked(rand)));
			uint256 thisRand = rand;
			uint8 unitType = getRandomType(uint16(thisRand));
			thisRand >>= 16;

			uint256 rarity = getRandomRarity(uint32(thisRand), w.rarity);
			thisRand >>= 32;

			// TPRDATEDARSKRANDOM__RANDOM__RANDOM__RANDOM__RAND0000000000000000

			uint256 data = unitType; // 8 bits

			data <<= 4;
			// data |= 0; // tier 0

			// birth timestamp
			data <<= 24;
			data |= now / (1 days);

			data <<= 4;
			data |= rarity;
			data <<= 8;
			data |= w.sku;
			data <<= 208;
			data |= thisRand & 0xffffffffffffffffffffffffffffffffffff0000000000000000;

			token.mintAndSetData(w.owner, data);
		}

		popHatch();

		hatchNonce++;

		emit Hatched(w.owner, w.amount);
	}

}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"hatchingsNeeded","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawBalance","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getNumMyHatchingUnits","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"minRarity","type":"uint16"}],"name":"giveFreeUnit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"sku","type":"uint32"},{"name":"price","type":"uint64"}],"name":"setPrice","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"newAddress","type":"address"}],"name":"setTokenContractAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"hatch","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"sku","type":"uint32"}],"name":"getPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"sku","type":"uint16"},{"name":"referral","type":"address"}],"name":"buy","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"buyer","type":"address"},{"indexed":false,"name":"sku","type":"uint256"},{"indexed":false,"name":"totalPrice","type":"uint256"}],"name":"Sold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"buyer","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"Hatched","type":"event"},{"anonymous":false,"inputs":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"}],"name":"OwnershipRenounced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

Swarm Source

bzzr://5e05bf5cad345f31f0014e4d18815fec6dc38e92d01f24037c39a31b5d658962
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.