MyCryptoHeroes:Hero

0x273f7f8e6489682df756151f5525576e322d51a3

isPauser keyboard_arrow_up

  function isPauser(address account) public view returns (bool) {
    return pausers.has(account);
  }

addPauser keyboard_arrow_up

  function addPauser(address account) public onlyPauser {
    pausers.add(account);
    emit PauserAdded(account);
  }

renouncePauser keyboard_arrow_up

  function renouncePauser() public {
    pausers.remove(msg.sender);
  }

paused keyboard_arrow_up

  function paused() public view returns(bool) {
    return _paused;
  }

pause keyboard_arrow_up

  function pause() public onlyPauser whenNotPaused {
    _paused = true;
    emit Paused();
  }

unpause keyboard_arrow_up

  function unpause() public onlyPauser whenPaused {
    _paused = false;
    emit Unpaused();
  }

balanceOf keyboard_arrow_up

  function balanceOf(address owner) public view returns (uint256) {
    require(owner != address(0));
    return _ownedTokensCount[owner];
  }

ownerOf keyboard_arrow_up

  function ownerOf(uint256 tokenId) public view returns (address) {
    address owner = _tokenOwner[tokenId];
    require(owner != address(0));
    return owner;
  }

approve keyboard_arrow_up

  function approve(
    address to,
    uint256 tokenId
  )
    public
    whenNotPaused
  {
    super.approve(to, tokenId);
  }

getApproved keyboard_arrow_up

  function getApproved(uint256 tokenId) public view returns (address) {
    require(_exists(tokenId));
    return _tokenApprovals[tokenId];
  }

setApprovalForAll keyboard_arrow_up

  function setApprovalForAll(
    address to,
    bool approved
  )
    public
    whenNotPaused
  {
    super.setApprovalForAll(to, approved);
  }

isApprovedForAll keyboard_arrow_up

  function isApprovedForAll(
    address owner,
    address operator
  )
    public
    view
    returns (bool)
  {
    return _operatorApprovals[owner][operator];
  }

transferFrom keyboard_arrow_up

  function transferFrom(
    address from,
    address to,
    uint256 tokenId
  )
    public
    whenNotPaused
  {
    super.transferFrom(from, to, tokenId);
  }

safeTransferFrom keyboard_arrow_up

  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId
  )
    public
  {
    // solium-disable-next-line arg-overflow
    safeTransferFrom(from, to, tokenId, "");
  }

safeTransferFrom keyboard_arrow_up

  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes _data
  )
    public
  {
    transferFrom(from, to, tokenId);
    // solium-disable-next-line arg-overflow
    require(_checkAndCallSafeTransfer(from, to, tokenId, _data));
  }

supportsInterface keyboard_arrow_up

  function supportsInterface(bytes4 interfaceId)
    external
    view
    returns (bool)
  {
    return _supportedInterfaces[interfaceId];
  }

isMinter keyboard_arrow_up

  function isMinter(address account) public view returns (bool) {
    return minters.has(account);
  }

addMinter keyboard_arrow_up

  function addMinter(address account) public onlyMinter {
    minters.add(account);
    emit MinterAdded(account);
  }

renounceMinter keyboard_arrow_up

  function renounceMinter() public {
    minters.remove(msg.sender);
  }

name keyboard_arrow_up

  function name() external view returns (string) {
    return _name;
  }

symbol keyboard_arrow_up

  function symbol() external view returns (string) {
    return _symbol;
  }

tokenURI keyboard_arrow_up

    function tokenURI(uint256 tokenId) public view returns (string) {
        bytes32 tokenIdBytes;
        if (tokenId == 0) {
            tokenIdBytes = "0";
        } else {
            uint256 value = tokenId;
            while (value > 0) {
                tokenIdBytes = bytes32(uint256(tokenIdBytes) / (2 ** 8));
                tokenIdBytes |= bytes32(((value % 10) + 48) * 2 ** (8 * 31));
                value /= 10;
            }
        }

        bytes memory prefixBytes = bytes(tokenURIPrefix);
        bytes memory tokenURIBytes = new bytes(prefixBytes.length + tokenIdBytes.length);

        uint8 i;
        uint8 index = 0;
        
        for (i = 0; i < prefixBytes.length; i++) {
            tokenURIBytes[index] = prefixBytes[i];
            index++;
        }
        
        for (i = 0; i < tokenIdBytes.length; i++) {
            tokenURIBytes[index] = tokenIdBytes[i];
            index++;
        }
        
        return string(tokenURIBytes);
    }

totalSupply keyboard_arrow_up

  function totalSupply() public view returns (uint256) {
    return _allTokens.length;
  }

tokenOfOwnerByIndex keyboard_arrow_up

  function tokenOfOwnerByIndex(
    address owner,
    uint256 index
  )
    public
    view
    returns (uint256)
  {
    require(index < balanceOf(owner));
    return _ownedTokens[owner][index];
  }

tokenByIndex keyboard_arrow_up

  function tokenByIndex(uint256 index) public view returns (uint256) {
    require(index < totalSupply());
    return _allTokens[index];
  }

mintingFinished keyboard_arrow_up

  function mintingFinished() public view returns(bool) {
    return _mintingFinished;
  }

mint keyboard_arrow_up

  function mint(
    address to,
    uint256 tokenId
  )
    public
    onlyMinter
    onlyBeforeMintingFinished
    returns (bool)
  {
    _mint(to, tokenId);
    return true;
  }

mintWithTokenURI keyboard_arrow_up

  function mintWithTokenURI(
    address to,
    uint256 tokenId,
    string tokenURI
  )
    public
    onlyMinter
    onlyBeforeMintingFinished
    returns (bool)
  {
    mint(to, tokenId);
    _setTokenURI(tokenId, tokenURI);
    return true;
  }

finishMinting keyboard_arrow_up

  function finishMinting()
    public
    onlyMinter
    onlyBeforeMintingFinished
    returns (bool)
  {
    _mintingFinished = true;
    emit MintingFinished();
    return true;
  }

setSupplyLimit keyboard_arrow_up

    function setSupplyLimit(uint16 _heroType, uint16 _supplyLimit) external onlyMinter {
        require(heroTypeToSupplyLimit[_heroType] == 0 || _supplyLimit < heroTypeToSupplyLimit[_heroType],
            "_supplyLimit is bigger");
        heroTypeToSupplyLimit[_heroType] = _supplyLimit;
    }

setTokenURIPrefix keyboard_arrow_up

    function setTokenURIPrefix(string _tokenURIPrefix) external onlyMinter {
        tokenURIPrefix = _tokenURIPrefix;
    }

getSupplyLimit keyboard_arrow_up

    function getSupplyLimit(uint16 _heroType) public view returns (uint16) {
        return heroTypeToSupplyLimit[_heroType];
    }

mintHeroAsset keyboard_arrow_up

    function mintHeroAsset(address _owner, uint256 _tokenId) public onlyMinter {
        uint16 _heroType = uint16(_tokenId / HERO_TYPE_OFFSET);
        uint16 _heroTypeIndex = uint16(_tokenId % HERO_TYPE_OFFSET) - 1;
        require(_heroTypeIndex < heroTypeToSupplyLimit[_heroType], "supply over");
        _mint(_owner, _tokenId);
    }