MyCryptoHeroes:Land

0x617913dd43dbdf4236b85ec7bdf9adfd7e35b340 Copy

About

Stats

Public Functions 43

Event Types 10

Code Size 46,075 bytes

Events (10)

Approval Event

Parameters

owner	address
approved	address
tokenId	uint256

ApprovalForAll Event

Parameters

owner	address
operator	address
approved	bool

MintEvent Event

Parameters

assetOwner	address
tokenId	uint256
at	uint256
eventHash	bytes32

MinterAdded Event

Parameters

account

address

MinterRemoved Event

Parameters

account

address

Paused Event

Parameters

account

address

PauserAdded Event

Parameters

account

address

PauserRemoved Event

Parameters

account

address

Transfer Event

Parameters

from	address
to	address
tokenId	uint256

Unpaused Event

Parameters

account

address

Constants (12)

SHARE_RATE_DECIMAL Constant

uint256

UNKNOWN VALUE

LEGENDARY_RARITY Constant

uint16

EPIC_RARITY Constant

uint16

RARE_RARITY Constant

uint16

UNCOMMON_RARITY Constant

uint16

COMMON_RARITY Constant

uint16

NO_LAND Constant

uint16

_ERC721_RECEIVED Constant

bytes4

0x150b7a02

_INTERFACE_ID_ERC721 Constant

bytes4

0x80ac58cd

_INTERFACE_ID_ERC165 Constant

bytes4

0x01ffc9a7

_INTERFACE_ID_ERC721_ENUMERABLE Constant

bytes4

0x780e9d63

_INTERFACE_ID_ERC721_METADATA Constant

bytes4

0x5b5e139f

State Variables (24)

tokenURIPrefix Variable

string

landTypeToTotalVolume Variable

mapping(uint16 => uint256)

Internal Variable

landTypeToSectorSupplyLimit Variable

mapping(uint16 => uint256)

Internal Variable

landTypeAndRarityToSectorSupply Variable

mapping(uint16 => mapping(uint16 => uint256))

Internal Variable

landTypeToLandSectorList Variable

mapping(uint16 => uint256[])

Internal Variable

landTypeToLandSectorIndex Variable

mapping(uint16 => uint256)

Internal Variable

landTypeAndRarityToLandSectorCount Variable

mapping(uint16 => mapping(uint16 => uint256))

Internal Variable

rarityToSectorVolume Variable

mapping(uint16 => uint256)

Internal Variable

allowed Variable

mapping(uint256 => bool)

Internal Variable

_tokenOwner Variable

mapping(uint256 => address)

Internal Variable

_tokenApprovals Variable

mapping(uint256 => address)

Internal Variable

_ownedTokensCount Variable

mapping(address => uint256)

Internal Variable

_operatorApprovals Variable

mapping(address => mapping(address => bool))

Internal Variable

_supportedInterfaces Variable

mapping(bytes4 => bool)

Internal Variable

_ownedTokens Variable

mapping(address => uint256[])

Internal Variable

_ownedTokensIndex Variable

mapping(uint256 => uint256)

Internal Variable

_allTokens Variable

uint256[]

Internal Variable

_allTokensIndex Variable

mapping(uint256 => uint256)

Internal Variable

_name Variable

string

Internal Variable

_symbol Variable

string

Internal Variable

_tokenURIs Variable

mapping(uint256 => string)

Internal Variable

_minters Variable

Roles.Role

Internal Variable

_paused Variable

bool

Internal Variable

_pausers Variable

Roles.Role

Internal Variable

Functions Expand All Collapse All

isPauser

Parameters

Name	Type
account	address

Properties

Visibility public

Mutability view

Source Code

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

addPauser

Parameters

Name	Type
account	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyPauser checks for the following:

null

Source Code

function addPauser(address account) public onlyPauser {
  _addPauser(account);
}

renouncePauser

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Source Code

function renouncePauser() public {
  _removePauser(msg.sender);
}

paused

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

pause

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyPauser checks for the following:

null

whenNotPaused checks for the following:

_paused must not be true

Source Code

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

unpause

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyPauser checks for the following:

null

whenPaused checks for the following:

_paused must be true

Source Code

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

balanceOf

Parameters

Name	Type
owner	address

Properties

Visibility public

Mutability view

Requirements

owner must not be equal to UNKNOWN VALUE

Source Code

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

ownerOf

Parameters

Name	Type
tokenId	uint256

Properties

Visibility public

Mutability view

Requirements

owner must not be equal to UNKNOWN VALUE

Source Code

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

approve

Parameters

Name	Type
_to	address
_tokenId	uint256

Properties

Visibility public

Mutability transaction

Requirements

to must not be equal to owner

One or more of the following: -null - OR owner must be equal to the sender's address

Source Code

function approve(address _to, uint256 _tokenId) public {
  require(allowed[_tokenId]);
  super.approve(_to, _tokenId);
}

getApproved

Parameters

Name	Type
tokenId	uint256

Properties

Visibility public

Mutability view

Requirements

null

Source Code

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

setApprovalForAll

Parameters

Name	Type
to	address
approved	bool

Properties

Visibility public

Mutability transaction

Modifiers

whenNotPaused checks for the following:

_paused must not be true

Requirements

to must not be equal to the sender's address

Source Code

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

isApprovedForAll

Parameters

Name	Type
owner	address
operator	address

Properties

Visibility public

Mutability view

Source Code

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

transferFrom

Parameters

Name	Type
_from	address
_to	address
_tokenId	uint256

Properties

Visibility public

Mutability transaction

Requirements

null

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function transferFrom(
  address _from,
  address _to,
  uint256 _tokenId
) public {
  require(allowed[_tokenId]);
  super.transferFrom(_from, _to, _tokenId);
}

safeTransferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility public

Mutability transaction

Requirements

null

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

null

Source Code

function safeTransferFrom(
  address from,
  address to,
  uint256 tokenId
) public {
  safeTransferFrom(from, to, tokenId, "");
}

safeTransferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

Properties

Visibility public

Mutability transaction

Requirements

null

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

null

Source Code

function safeTransferFrom(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) public {
  transferFrom(from, to, tokenId);
  require(_checkOnERC721Received(from, to, tokenId, _data));
}

supportsInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility public

Mutability view

Source Code

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

isMinter

Parameters

Name	Type
account	address

Properties

Visibility public

Mutability view

Source Code

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

addMinter

Parameters

Name	Type
account	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyMinter checks for the following:

null

Source Code

function addMinter(address account) public onlyMinter {
  _addMinter(account);
}

renounceMinter

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Source Code

function renounceMinter() public {
  _removeMinter(msg.sender);
}

mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyMinter checks for the following:

null

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

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

name

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

symbol

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

tokenURI

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function tokenURI(uint256 _tokenId) public view returns (string memory) {
  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

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

tokenOfOwnerByIndex

Parameters

Name	Type
owner	address
index	uint256

Properties

Visibility public

Mutability view

Requirements

index must be less than the result of calling balanceOf with owner

Source Code

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

tokenByIndex

Parameters

Name	Type
index	uint256

Properties

Visibility public

Mutability view

Requirements

index must be less than the result of calling totalSupply

Source Code

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

setSupplyAndSector

Parameters

Name	Type
_landType	uint16
_totalVolume	uint256
_sectorSupplyLimit	uint256
legendarySupply	uint256
epicSupply	uint256
rareSupply	uint256
uncommonSupply	uint256
commonSupply	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyMinter checks for the following:

null

Requirements

_landType must not be equal to 0

_totalVolume must not be equal to 0

the result of calling getMintedSectorCount with _landType must be equal to 0

_totalVolume must be equal to UNKNOWN VALUE

_sectorSupplyLimit must be equal to UNKNOWN VALUE

Source Code

function setSupplyAndSector(
  uint16 _landType,
  uint256 _totalVolume,
  uint256 _sectorSupplyLimit,
  uint256 legendarySupply,
  uint256 epicSupply,
  uint256 rareSupply,
  uint256 uncommonSupply,
  uint256 commonSupply
) external onlyMinter {
  require(_landType != 0, "landType 0 is noland");
  require(_totalVolume != 0, "totalVolume must not be 0");
  require(getMintedSectorCount(_landType) == 0, "This LandType already exists");
  require(
    legendarySupply
    .mul(rarityToSectorVolume[LEGENDARY_RARITY])
    .add(epicSupply.mul(rarityToSectorVolume[EPIC_RARITY]))
    .add(rareSupply.mul(rarityToSectorVolume[RARE_RARITY]))
    .add(uncommonSupply.mul(rarityToSectorVolume[UNCOMMON_RARITY]))
    .add(commonSupply.mul(rarityToSectorVolume[COMMON_RARITY])) == _totalVolume
  );
  require(
    legendarySupply.add(epicSupply).add(rareSupply).add(uncommonSupply).add(
      commonSupply
    ) == _sectorSupplyLimit
  );
  landTypeToTotalVolume[_landType] = _totalVolume;
  landTypeToSectorSupplyLimit[_landType] = _sectorSupplyLimit;
  landTypeAndRarityToSectorSupply[_landType][
    LEGENDARY_RARITY
  ] = legendarySupply;
  landTypeAndRarityToSectorSupply[_landType][EPIC_RARITY] = epicSupply;
  landTypeAndRarityToSectorSupply[_landType][RARE_RARITY] = rareSupply;
  landTypeAndRarityToSectorSupply[_landType][UNCOMMON_RARITY] = uncommonSupply;
  landTypeAndRarityToSectorSupply[_landType][COMMON_RARITY] = commonSupply;
}

unLockToken

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyMinter checks for the following:

null

Source Code

function unLockToken(uint256 _tokenId) public onlyMinter {
  allowed[_tokenId] = true;
}

setTokenURIPrefix

Parameters

Name	Type
_tokenURIPrefix	string

Properties

Visibility public

Mutability transaction

Modifiers

onlyMinter checks for the following:

null

Source Code

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

isAlreadyMinted

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function isAlreadyMinted(uint256 _tokenId) public view returns (bool) {
  return _exists(_tokenId);
}

isValidLandSector

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function isValidLandSector(uint256 _tokenId) public view returns (bool) {
  uint16 rarity = getRarity(_tokenId);
  if (!(rarityToSectorVolume[rarity] > 0)) {
    return false;
  }
  uint16 landType = getLandType(_tokenId);
  if (!(landTypeToTotalVolume[landType] > 0)) {
    return false;
  }
  uint256 serial = _tokenId % 10000;
  if (serial == 0) {
    return false;
  }
  if (serial > landTypeAndRarityToSectorSupply[landType][rarity]) {
    return false;
  }
  return true;
}

canTransfer

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function canTransfer(uint256 _tokenId) public view returns (bool) {
  return allowed[_tokenId];
}

getTotalVolume

Parameters

Name	Type
_landType	uint16

Properties

Visibility public

Mutability view

Source Code

function getTotalVolume(uint16 _landType) public view returns (uint256) {
  return landTypeToTotalVolume[_landType];
}

getSectorSupplyLimit

Parameters

Name	Type
_landType	uint16

Properties

Visibility public

Mutability view

Source Code

function getSectorSupplyLimit(uint16 _landType) public view returns (uint256) {
  return landTypeToSectorSupplyLimit[_landType];
}

getLandType

Parameters

Name	Type
_landSector	uint256

Properties

Visibility public

Mutability view

Source Code

function getLandType(uint256 _landSector) public view returns (uint16) {
  uint16 _landType = uint16((_landSector.div(10000)) % 1000);
  return _landType;
}

getRarity

Parameters

Name	Type
_landSector	uint256

Properties

Visibility public

Mutability view

Source Code

function getRarity(uint256 _landSector) public view returns (uint16) {
  return uint16(_landSector.div(10**7));
}

getMintedSectorCount

Parameters

Name	Type
_landType	uint16

Properties

Visibility public

Mutability view

Source Code

function getMintedSectorCount(uint16 _landType) public view returns (uint256) {
  return landTypeToLandSectorIndex[_landType];
}

getMintedSectorCountByRarity

Parameters

Name	Type
_landType	uint16
_rarity	uint16

Properties

Visibility public

Mutability view

Source Code

function getMintedSectorCountByRarity(uint16 _landType, uint16 _rarity)
  public
  view
  returns (uint256)
{
  return landTypeAndRarityToLandSectorCount[_landType][_rarity];
}

getSectorSupplyByRarity

Parameters

Name	Type
_landType	uint16
_rarity	uint16

Properties

Visibility public

Mutability view

Source Code

function getSectorSupplyByRarity(uint16 _landType, uint16 _rarity)
  public
  view
  returns (uint256)
{
  return landTypeAndRarityToSectorSupply[_landType][_rarity];
}

getMintedSectorList

Parameters

Name	Type
_landType	uint16

Properties

Visibility public

Mutability view

Source Code

function getMintedSectorList(uint16 _landType)
  public
  view
  returns (uint256[] memory)
{
  return landTypeToLandSectorList[_landType];
}

getSectorVolumeByRarity

Parameters

Name	Type
_rarity	uint16

Properties

Visibility public

Mutability view

Source Code

function getSectorVolumeByRarity(uint16 _rarity) public view returns (uint256) {
  return rarityToSectorVolume[_rarity];
}

getShareRateWithDecimal

Parameters

Name	Type
_landSector	uint256

Properties

Visibility public

Mutability view

Source Code

function getShareRateWithDecimal(uint256 _landSector)
  public
  view
  returns (uint256, uint256)
{
  return (
    getSectorVolumeByRarity(getRarity(_landSector)).mul(SHARE_RATE_DECIMAL).div(
      getTotalVolume(getLandType(_landSector))
    ),
    SHARE_RATE_DECIMAL
  );
}

mintLandSector

Parameters

Name	Type
_owner	address
_landSector	uint256
_eventHash	bytes32

Properties

Visibility public

Mutability transaction

Modifiers

onlyMinter checks for the following:

null

Requirements

the result of calling isAlreadyMinted with _landSector must not be true

null

landTypeToLandSectorIndex for _landType must be less than landTypeToSectorSupplyLimit for _landType

landTypeAndRarityToLandSectorCount for _landType for rarity must be less than landTypeAndRarityToSectorSupply for _landType for rarity

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function mintLandSector(
  address _owner,
  uint256 _landSector,
  bytes32 _eventHash
) public onlyMinter {
  require(!isAlreadyMinted(_landSector));
  require(isValidLandSector(_landSector));
  uint16 _landType = getLandType(_landSector);
  require(
    landTypeToLandSectorIndex[_landType] <
      landTypeToSectorSupplyLimit[_landType]
  );
  uint16 rarity = getRarity(_landSector);
  require(
    landTypeAndRarityToLandSectorCount[_landType][rarity] <
      landTypeAndRarityToSectorSupply[_landType][rarity],
    "supply over"
  );
  _mint(_owner, _landSector);
  landTypeToLandSectorList[_landType].push(_landSector);
  landTypeToLandSectorIndex[_landType]++;
  landTypeAndRarityToLandSectorCount[_landType][rarity]++;

  emit MintEvent(_owner, _landSector, block.timestamp, _eventHash);
}

Internal Functions Expand All Collapse All

Internal functions are parts of the contract that can't be used directly, but instead are used by the public functions listed above.

internal ERC721._exists

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 tokenId) internal view returns (bool) {
  address owner = _tokenOwner[tokenId];
  return owner != address(0);
}

internal ERC721._isApprovedOrOwner

Parameters

Name	Type
spender	address
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  address owner = ownerOf(tokenId);
  return (spender == owner ||
    getApproved(tokenId) == spender ||
    isApprovedForAll(owner, spender));
}

internal ERC721._mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(address to, uint256 tokenId) internal {
  require(to != address(0));
  require(!_exists(tokenId));

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

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

internal ERC721._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

owner must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  require(ownerOf(tokenId) == owner);

  _clearApproval(tokenId);

  _ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
  _tokenOwner[tokenId] = address(0);

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

internal ERC721._burn

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(uint256 tokenId) internal {
  _burn(ownerOf(tokenId), tokenId);
}

internal ERC721._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(ownerOf(tokenId) == from);
  require(to != address(0));

  _clearApproval(tokenId);

  _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

  _tokenOwner[tokenId] = to;

  emit Transfer(from, to, tokenId);
}

internal ERC721._checkOnERC721Received

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

Properties

Visibility internal

Mutability transaction

Source Code

function _checkOnERC721Received(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) internal returns (bool) {
  if (!to.isContract()) {
    return true;
  }

  bytes4 retval = IERC721Receiver(to).onERC721Received(
    msg.sender,
    from,
    tokenId,
    _data
  );
  return (retval == _ERC721_RECEIVED);
}

internal ERC721._clearApproval

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _clearApproval(uint256 tokenId) private {
  if (_tokenApprovals[tokenId] != address(0)) {
    _tokenApprovals[tokenId] = address(0);
  }
}

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal ERC721Enumerable._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  super._transferFrom(from, to, tokenId);

  _removeTokenFromOwnerEnumeration(from, tokenId);

  _addTokenToOwnerEnumeration(to, tokenId);
}

internal ERC721Enumerable._mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(address to, uint256 tokenId) internal {
  super._mint(to, tokenId);

  _addTokenToOwnerEnumeration(to, tokenId);

  _addTokenToAllTokensEnumeration(tokenId);
}

internal ERC721Enumerable._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  super._burn(owner, tokenId);

  _removeTokenFromOwnerEnumeration(owner, tokenId);
  // Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
  _ownedTokensIndex[tokenId] = 0;

  _removeTokenFromAllTokensEnumeration(tokenId);
}

internal ERC721Enumerable._tokensOfOwner

Parameters

Name	Type
owner	address

Properties

Visibility internal

Mutability view

Source Code

function _tokensOfOwner(address owner)
  internal
  view
  returns (uint256[] storage)
{
  return _ownedTokens[owner];
}

internal ERC721Enumerable._addTokenToOwnerEnumeration

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
  _ownedTokensIndex[tokenId] = _ownedTokens[to].length;
  _ownedTokens[to].push(tokenId);
}

internal ERC721Enumerable._addTokenToAllTokensEnumeration

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
  _allTokensIndex[tokenId] = _allTokens.length;
  _allTokens.push(tokenId);
}

internal ERC721Enumerable._removeTokenFromOwnerEnumeration

Parameters

Name	Type
from	address
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

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 = _ownedTokens[from].length.sub(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
  _ownedTokens[from].length--;

  // Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occcupied by
  // lasTokenId, or just over the end of the array if the token was the last one).
}

internal ERC721Enumerable._removeTokenFromAllTokensEnumeration

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

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.sub(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
  _allTokens.length--;
  _allTokensIndex[tokenId] = 0;
}

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal ERC721._exists

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 tokenId) internal view returns (bool) {
  address owner = _tokenOwner[tokenId];
  return owner != address(0);
}

internal ERC721._isApprovedOrOwner

Parameters

Name	Type
spender	address
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  address owner = ownerOf(tokenId);
  return (spender == owner ||
    getApproved(tokenId) == spender ||
    isApprovedForAll(owner, spender));
}

internal ERC721._mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(address to, uint256 tokenId) internal {
  require(to != address(0));
  require(!_exists(tokenId));

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

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

internal ERC721._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  require(ownerOf(tokenId) == owner);

  _clearApproval(tokenId);

  _ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
  _tokenOwner[tokenId] = address(0);

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

internal ERC721._burn

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(uint256 tokenId) internal {
  _burn(ownerOf(tokenId), tokenId);
}

internal ERC721._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(ownerOf(tokenId) == from);
  require(to != address(0));

  _clearApproval(tokenId);

  _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

  _tokenOwner[tokenId] = to;

  emit Transfer(from, to, tokenId);
}

internal ERC721._checkOnERC721Received

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

Properties

Visibility internal

Mutability transaction

Source Code

function _checkOnERC721Received(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) internal returns (bool) {
  if (!to.isContract()) {
    return true;
  }

  bytes4 retval = IERC721Receiver(to).onERC721Received(
    msg.sender,
    from,
    tokenId,
    _data
  );
  return (retval == _ERC721_RECEIVED);
}

internal ERC721._clearApproval

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _clearApproval(uint256 tokenId) private {
  if (_tokenApprovals[tokenId] != address(0)) {
    _tokenApprovals[tokenId] = address(0);
  }
}

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal ERC721Metadata._setTokenURI

Parameters

Name	Type
tokenId	uint256
uri	string

Properties

Visibility internal

Mutability transaction

Requirements

null

Source Code

function _setTokenURI(uint256 tokenId, string memory uri) internal {
  require(_exists(tokenId));
  _tokenURIs[tokenId] = uri;
}

internal ERC721Metadata._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  super._burn(owner, tokenId);

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

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal ERC721._exists

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 tokenId) internal view returns (bool) {
  address owner = _tokenOwner[tokenId];
  return owner != address(0);
}

internal ERC721._isApprovedOrOwner

Parameters

Name	Type
spender	address
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  address owner = ownerOf(tokenId);
  return (spender == owner ||
    getApproved(tokenId) == spender ||
    isApprovedForAll(owner, spender));
}

internal ERC721._mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(address to, uint256 tokenId) internal {
  require(to != address(0));
  require(!_exists(tokenId));

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

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

internal ERC721._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  require(ownerOf(tokenId) == owner);

  _clearApproval(tokenId);

  _ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
  _tokenOwner[tokenId] = address(0);

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

internal ERC721._burn

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(uint256 tokenId) internal {
  _burn(ownerOf(tokenId), tokenId);
}

internal ERC721._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(ownerOf(tokenId) == from);
  require(to != address(0));

  _clearApproval(tokenId);

  _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

  _tokenOwner[tokenId] = to;

  emit Transfer(from, to, tokenId);
}

internal ERC721._checkOnERC721Received

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

Properties

Visibility internal

Mutability transaction

Source Code

function _checkOnERC721Received(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) internal returns (bool) {
  if (!to.isContract()) {
    return true;
  }

  bytes4 retval = IERC721Receiver(to).onERC721Received(
    msg.sender,
    from,
    tokenId,
    _data
  );
  return (retval == _ERC721_RECEIVED);
}

internal ERC721._clearApproval

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _clearApproval(uint256 tokenId) private {
  if (_tokenApprovals[tokenId] != address(0)) {
    _tokenApprovals[tokenId] = address(0);
  }
}

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal ERC721._exists

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 tokenId) internal view returns (bool) {
  address owner = _tokenOwner[tokenId];
  return owner != address(0);
}

internal ERC721._isApprovedOrOwner

Parameters

Name	Type
spender	address
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  address owner = ownerOf(tokenId);
  return (spender == owner ||
    getApproved(tokenId) == spender ||
    isApprovedForAll(owner, spender));
}

internal ERC721._mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(address to, uint256 tokenId) internal {
  require(to != address(0));
  require(!_exists(tokenId));

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

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

internal ERC721._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  require(ownerOf(tokenId) == owner);

  _clearApproval(tokenId);

  _ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
  _tokenOwner[tokenId] = address(0);

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

internal ERC721._burn

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(uint256 tokenId) internal {
  _burn(ownerOf(tokenId), tokenId);
}

internal ERC721._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(ownerOf(tokenId) == from);
  require(to != address(0));

  _clearApproval(tokenId);

  _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

  _tokenOwner[tokenId] = to;

  emit Transfer(from, to, tokenId);
}

internal ERC721._checkOnERC721Received

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

Properties

Visibility internal

Mutability transaction

Source Code

function _checkOnERC721Received(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) internal returns (bool) {
  if (!to.isContract()) {
    return true;
  }

  bytes4 retval = IERC721Receiver(to).onERC721Received(
    msg.sender,
    from,
    tokenId,
    _data
  );
  return (retval == _ERC721_RECEIVED);
}

internal ERC721._clearApproval

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _clearApproval(uint256 tokenId) private {
  if (_tokenApprovals[tokenId] != address(0)) {
    _tokenApprovals[tokenId] = address(0);
  }
}

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal MinterRole.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  _addMinter(msg.sender);
}

internal MinterRole._addMinter

Parameters

Name	Type
account	address

Properties

Visibility internal

Mutability transaction

Source Code

function _addMinter(address account) internal {
  _minters.add(account);
  emit MinterAdded(account);
}

internal MinterRole._removeMinter

Parameters

Name	Type
account	address

Properties

Visibility internal

Mutability transaction

Source Code

function _removeMinter(address account) internal {
  _minters.remove(account);
  emit MinterRemoved(account);
}

internal ERC721._exists

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 tokenId) internal view returns (bool) {
  address owner = _tokenOwner[tokenId];
  return owner != address(0);
}

internal ERC721._isApprovedOrOwner

Parameters

Name	Type
spender	address
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  address owner = ownerOf(tokenId);
  return (spender == owner ||
    getApproved(tokenId) == spender ||
    isApprovedForAll(owner, spender));
}

internal ERC721._mint

Parameters

Name	Type
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(address to, uint256 tokenId) internal {
  require(to != address(0));
  require(!_exists(tokenId));

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

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

internal ERC721._burn

Parameters

Name	Type
owner	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(address owner, uint256 tokenId) internal {
  require(ownerOf(tokenId) == owner);

  _clearApproval(tokenId);

  _ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
  _tokenOwner[tokenId] = address(0);

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

internal ERC721._burn

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

the result of calling ownerOf with tokenId must be equal to the result of calling ownerOf with tokenId

Source Code

function _burn(uint256 tokenId) internal {
  _burn(ownerOf(tokenId), tokenId);
}

internal ERC721._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

from must be equal to the result of calling ownerOf with tokenId

to must not be equal to UNKNOWN VALUE

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(ownerOf(tokenId) == from);
  require(to != address(0));

  _clearApproval(tokenId);

  _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
  _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

  _tokenOwner[tokenId] = to;

  emit Transfer(from, to, tokenId);
}

internal ERC721._checkOnERC721Received

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

Properties

Visibility internal

Mutability transaction

Source Code

function _checkOnERC721Received(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) internal returns (bool) {
  if (!to.isContract()) {
    return true;
  }

  bytes4 retval = IERC721Receiver(to).onERC721Received(
    msg.sender,
    from,
    tokenId,
    _data
  );
  return (retval == _ERC721_RECEIVED);
}

internal ERC721._clearApproval

Parameters

Name	Type
tokenId	uint256

Properties

Visibility private

Mutability transaction

Source Code

function _clearApproval(uint256 tokenId) private {
  if (_tokenApprovals[tokenId] != address(0)) {
    _tokenApprovals[tokenId] = address(0);
  }
}

internal ERC165.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

constructor() internal {
  _registerInterface(_INTERFACE_ID_ERC165);
}

internal ERC165._registerInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility internal

Mutability transaction

Requirements

_INTERFACE_ID_ERC165 must not be equal to 0xffffffff

Source Code

function _registerInterface(bytes4 interfaceId) internal {
  require(interfaceId != 0xffffffff);
  _supportedInterfaces[interfaceId] = true;
}

internal Pausable.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  _paused = false;
}

internal PauserRole.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  _addPauser(msg.sender);
}

internal PauserRole._addPauser

Parameters

Name	Type
account	address

Properties

Visibility internal

Mutability transaction

Source Code

function _addPauser(address account) internal {
  _pausers.add(account);
  emit PauserAdded(account);
}

internal PauserRole._removePauser

Parameters

Name	Type
account	address

Properties

Visibility internal

Mutability transaction

Source Code

function _removePauser(address account) internal {
  _pausers.remove(account);
  emit PauserRemoved(account);
}

MyCryptoHeroes:Land

About

Stats

Events (10) keyboard_arrow_up

Approval Event

Parameters help Event parameters list the data that an event contains.

ApprovalForAll Event

Parameters help Event parameters list the data that an event contains.

MintEvent Event

Parameters help Event parameters list the data that an event contains.

MinterAdded Event

Parameters help Event parameters list the data that an event contains.

MinterRemoved Event

Parameters help Event parameters list the data that an event contains.

Paused Event

Parameters help Event parameters list the data that an event contains.

PauserAdded Event

Parameters help Event parameters list the data that an event contains.

PauserRemoved Event

Parameters help Event parameters list the data that an event contains.

Transfer Event

Parameters help Event parameters list the data that an event contains.

Unpaused Event

Parameters help Event parameters list the data that an event contains.

Constants (12) keyboard_arrow_up

SHARE_RATE_DECIMAL Constant

LEGENDARY_RARITY Constant

EPIC_RARITY Constant

RARE_RARITY Constant

UNCOMMON_RARITY Constant

COMMON_RARITY Constant

NO_LAND Constant

_ERC721_RECEIVED Constant

_INTERFACE_ID_ERC721 Constant

_INTERFACE_ID_ERC165 Constant

_INTERFACE_ID_ERC721_ENUMERABLE Constant

_INTERFACE_ID_ERC721_METADATA Constant

State Variables (24) keyboard_arrow_up

tokenURIPrefix Variable

landTypeToTotalVolume Variable

landTypeToSectorSupplyLimit Variable

landTypeAndRarityToSectorSupply Variable

landTypeToLandSectorList Variable

landTypeToLandSectorIndex Variable

landTypeAndRarityToLandSectorCount Variable

rarityToSectorVolume Variable

allowed Variable

_tokenOwner Variable

_tokenApprovals Variable

_ownedTokensCount Variable

_operatorApprovals Variable

_supportedInterfaces Variable

_ownedTokens Variable

_ownedTokensIndex Variable

_allTokens Variable

_allTokensIndex Variable

_name Variable

_symbol Variable

_tokenURIs Variable

_minters Variable

_paused Variable

_pausers Variable

Functions Expand All Collapse All

isPauser keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Source Code

addPauser keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Modifiers help Modifiers are additions to a function that typically make various checks before the function is run.

onlyPauser checks for the following:

Source Code

renouncePauser keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Source Code

paused keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Events (10)

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Constants (12)

State Variables (24)

isPauser

Parameters

addPauser

Parameters

Modifiers

renouncePauser

Parameters

paused

Parameters

pause

Parameters

Modifiers

unpause

Parameters

Modifiers

balanceOf

Parameters

Requirements

ownerOf

Parameters

Requirements

approve

Parameters

Requirements

getApproved

Parameters

Requirements

setApprovalForAll

Parameters

Modifiers

Requirements

isApprovedForAll

Parameters

transferFrom

Parameters

Requirements

safeTransferFrom

Parameters

Requirements

safeTransferFrom

Parameters

Requirements

supportsInterface

Parameters

isMinter

Parameters