dcl://xmas_2020

0xecf073f91101ce5628669c487aee8f5822a101b1 Copy

About

Identical Contracts

The following contracts have identical source code.

dcl://dg_summer_2020 (DCLDGSMMR2020) - 0xbf53c33235cbfc22cef5a61a83484b86342679c5

Stats

Public Functions 32

Event Types 9

Code Size 53,830 bytes

Events (9)

AddWearable Event

Parameters

_wearableIdKey	bytes32
_wearableId	string
_maxIssuance	uint256

Allowed Event

Parameters

_operator	address
_allowed	bool

Approval Event

Parameters

owner	address
approved	address
tokenId	uint256

ApprovalForAll Event

Parameters

owner	address
operator	address
approved	bool

BaseURI Event

Parameters

_oldBaseURI	string
_newBaseURI	string

Complete Event

Parameters

Issue Event

Parameters

_beneficiary	address
_tokenId	uint256
_wearableIdKey	bytes32
_wearableId	string
_issuedId	uint256

OwnershipTransferred Event

Parameters

previousOwner	address
newOwner	address

Transfer Event

Parameters

from	address
to	address
tokenId	uint256

Constants (5)

_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 (20)

baseURI Variable

string

isComplete Variable

bool

maxIssuance Variable

mapping(bytes32 => uint256)

issued Variable

mapping(bytes32 => uint)

allowed Variable

mapping(address => bool)

_owner Variable

address

Internal Variable

_tokenOwner Variable

mapping(uint256 => address)

Internal Variable

_tokenApprovals Variable

mapping(uint256 => address)

Internal Variable

_ownedTokensCount Variable

mapping(address => Counters.Counter)

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

_tokenPaths Variable

mapping(uint256 => string)

Internal Variable

wearables Variable

string[]

Internal Variable

Functions Expand All Collapse All

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), "ERC721: balance query for the zero address");

  return _ownedTokensCount[owner].current();
}

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), "ERC721: owner query for nonexistent token");

  return owner;
}

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, "");
}

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 {
  //solhint-disable-next-line max-line-length
  require(
    _isApprovedOrOwner(msg.sender, tokenId),
    "ERC721: transfer caller is not owner nor approved"
  );

  _transferFrom(from, to, tokenId);
}

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 {
  address owner = ownerOf(tokenId);
  require(to != owner, "ERC721: approval to current owner");

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

  _tokenApprovals[tokenId] = to;
  emit Approval(owner, 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), "ERC721: approved query for nonexistent token");

  return _tokenApprovals[tokenId];
}

setApprovalForAll

Parameters

Name	Type
to	address
approved	bool

Properties

Visibility public

Mutability transaction

Requirements

to must not be equal to the sender's address

Source Code

function setApprovalForAll(address to, bool approved) public {
  require(to != msg.sender, "ERC721: approve to caller");

  _operatorApprovals[msg.sender][to] = approved;
  emit ApprovalForAll(msg.sender, 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];
}

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),
    "ERC721: transfer to non ERC721Receiver implementer"
  );
}

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

Requirements

null

Source Code

function tokenURI(uint256 _tokenId) external view returns (string memory) {
  require(
    _exists(_tokenId),
    "ERC721Metadata: received a URI query for a nonexistent token"
  );
  return string(abi.encodePacked(baseURI, _tokenPaths[_tokenId]));
}

supportsInterface

Parameters

Name	Type
interfaceId	bytes4

Properties

Visibility public

Mutability view

Source Code

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

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),
    "ERC721Enumerable: owner index out of bounds"
  );
  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(),
    "ERC721Enumerable: global index out of bounds"
  );
  return _allTokens[index];
}

owner

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function owner() public view returns (address) {
  return _owner;
}

isOwner

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function isOwner() public view returns (bool) {
  return msg.sender == _owner;
}

renounceOwnership

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Source Code

function renounceOwnership() public onlyOwner {
  emit OwnershipTransferred(_owner, address(0));
  _owner = address(0);
}

transferOwnership

Parameters

Name	Type
newOwner	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

newOwner must not be equal to UNKNOWN VALUE

Source Code

function transferOwnership(address newOwner) public onlyOwner {
  _transferOwnership(newOwner);
}

setBaseURI

Parameters

Name	Type
_baseURI	string

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Source Code

function setBaseURI(string memory _baseURI) public onlyOwner {
  emit BaseURI(baseURI, _baseURI);
  baseURI = _baseURI;
}

setAllowed

Parameters

Name	Type
_operator	address
_allowed	bool

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

_operator must not be equal to UNKNOWN VALUE

_allowed must not be equal to allowed for _operator

Source Code

function setAllowed(address _operator, bool _allowed) public onlyOwner {
  require(_operator != address(0), "Invalid address");
  require(allowed[_operator] != _allowed, "You should set a different value");

  allowed[_operator] = _allowed;
  emit Allowed(_operator, _allowed);
}

batchTransferFrom

Parameters

Name	Type
_from	address
_to	address
_tokenIds	uint256[]

Properties

Visibility public

Mutability transaction

Source Code

function batchTransferFrom(
  address _from,
  address _to,
  uint256[] calldata _tokenIds
) external {
  for (uint256 i = 0; i < _tokenIds.length; i++) {
    transferFrom(_from, _to, _tokenIds[i]);
  }
}

wearablesCount

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function wearablesCount() external view returns (uint256) {
  return wearables.length;
}

completeCollection

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

isComplete must not be true

Source Code

function completeCollection() external onlyOwner {
  require(!isComplete, "The collection is already completed");
  isComplete = true;
  emit Complete();
}

addWearables

Parameters

Name	Type
_wearableIds	bytes32[]
_maxIssuances	uint256[]

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

the number of values in _wearableIds must be equal to the number of values in _maxIssuances

Source Code

function addWearables(
  bytes32[] calldata _wearableIds,
  uint256[] calldata _maxIssuances
) external onlyOwner {
  require(
    _wearableIds.length == _maxIssuances.length,
    "Parameters should have the same length"
  );

  for (uint256 i = 0; i < _wearableIds.length; i++) {
    addWearable(_wearableIds[i].bytes32ToString(), _maxIssuances[i]);
  }
}

addWearable

Parameters

Name	Type
_wearableId	string
_maxIssuance	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

isComplete must not be true

maxIssuance for key must be equal to 0

_maxIssuance must be greater than 0

Source Code

function addWearable(string memory _wearableId, uint256 _maxIssuance)
  public
  onlyOwner
{
  require(!isComplete, "The collection is complete");
  bytes32 key = getWearableKey(_wearableId);

  require(maxIssuance[key] == 0, "Can not modify an existing wearable");
  require(_maxIssuance > 0, "Max issuance should be greater than 0");

  maxIssuance[key] = _maxIssuance;
  wearables.push(_wearableId);

  emit AddWearable(key, _wearableId, _maxIssuance);
}

safeBatchTransferFrom

Parameters

Name	Type
_from	address
_to	address
_tokenIds	uint256[]

Properties

Visibility public

Mutability transaction

Source Code

function safeBatchTransferFrom(
  address _from,
  address _to,
  uint256[] memory _tokenIds
) public {
  safeBatchTransferFrom(_from, _to, _tokenIds, "");
}

safeBatchTransferFrom

Parameters

Name	Type
_from	address
_to	address
_tokenIds	uint256[]
_data	bytes

Properties

Visibility public

Mutability transaction

Source Code

function safeBatchTransferFrom(
  address _from,
  address _to,
  uint256[] memory _tokenIds,
  bytes memory _data
) public {
  for (uint256 i = 0; i < _tokenIds.length; i++) {
    safeTransferFrom(_from, _to, _tokenIds[i], _data);
  }
}

getWearableKey

Parameters

Name	Type
_wearableId	string

Properties

Visibility public

Mutability pure

Source Code

function getWearableKey(string memory _wearableId)
  public
  pure
  returns (bytes32)
{
  return keccak256(abi.encodePacked(_wearableId));
}

issueToken

Parameters

Name	Type
_beneficiary	address
_wearableId	string

Properties

Visibility public

Mutability transaction

Modifiers

onlyAllowed checks for the following:

Requirements

issuedId must be less than or equal to maxIssuance for key

issuedId must be greater than 0

issued for key must be less than maxIssuance for key

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function issueToken(address _beneficiary, string calldata _wearableId)
  external
  onlyAllowed
{
  _issueToken(_beneficiary, _wearableId);
}

issueTokens

Parameters

Name	Type
_beneficiaries	address[]
_wearableIds	bytes32[]

Properties

Visibility public

Mutability transaction

Modifiers

onlyAllowed checks for the following:

Requirements

the number of values in _beneficiaries must be equal to the number of values in _wearableIds

Source Code

function issueTokens(
  address[] calldata _beneficiaries,
  bytes32[] calldata _wearableIds
) external onlyAllowed {
  require(
    _beneficiaries.length == _wearableIds.length,
    "Parameters should have the same length"
  );

  for (uint256 i = 0; i < _wearableIds.length; i++) {
    _issueToken(_beneficiaries[i], _wearableIds[i].bytes32ToString());
  }
}

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 ERC721Collection._issueToken

Parameters

Name	Type
_beneficiary	address
_wearableId	string

Properties

Visibility internal

Mutability transaction

Requirements

issuedId must be less than or equal to maxIssuance for key

issuedId must be greater than 0

issued for key must be less than maxIssuance for key

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _issueToken(address _beneficiary, string memory _wearableId) internal {
  bytes32 key = getWearableKey(_wearableId);
  uint256 issuedId = issued[key] + 1;
  uint256 tokenId = this.totalSupply();

  _mint(_beneficiary, tokenId, key, _wearableId, issuedId);
  _setTokenURI(
    tokenId,
    string(abi.encodePacked(_wearableId, "/", issuedId.uintToString()))
  );
}

internal ERC721Collection._setTokenURI

Parameters

Name	Type
_tokenId	uint256
_uri	string

Properties

Visibility internal

Mutability transaction

Source Code

function _setTokenURI(uint256 _tokenId, string memory _uri) internal {
  _tokenPaths[_tokenId] = _uri;
}

internal Ownable.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  _owner = msg.sender;
  emit OwnershipTransferred(address(0), _owner);
}

internal Ownable._transferOwnership

Parameters

Name	Type
newOwner	address

Properties

Visibility internal

Mutability transaction

Requirements

newOwner must not be equal to UNKNOWN VALUE

Source Code

function _transferOwnership(address newOwner) internal {
  require(newOwner != address(0), "Ownable: new owner is the zero address");
  emit OwnershipTransferred(_owner, newOwner);
  _owner = newOwner;
}

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

Requirements

null

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  require(_exists(tokenId), "ERC721: operator query for nonexistent token");
  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), "ERC721: mint to the zero address");
  require(!_exists(tokenId), "ERC721: token already minted");

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to].increment();

  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, "ERC721: burn of token that is not own");

  _clearApproval(tokenId);

  _ownedTokensCount[owner].decrement();
  _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,
    "ERC721: transfer of token that is not own"
  );
  require(to != address(0), "ERC721: transfer to the zero address");

  _clearApproval(tokenId);

  _ownedTokensCount[from].decrement();
  _ownedTokensCount[to].increment();

  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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 occupied by
  // lastTokenId, 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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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

Requirements

null

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  require(_exists(tokenId), "ERC721: operator query for nonexistent token");
  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), "ERC721: mint to the zero address");
  require(!_exists(tokenId), "ERC721: token already minted");

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to].increment();

  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, "ERC721: burn of token that is not own");

  _clearApproval(tokenId);

  _ownedTokensCount[owner].decrement();
  _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,
    "ERC721: transfer of token that is not own"
  );
  require(to != address(0), "ERC721: transfer to the zero address");

  _clearApproval(tokenId);

  _ownedTokensCount[from].decrement();
  _ownedTokensCount[to].increment();

  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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), "ERC721Metadata: URI set of nonexistent token");
  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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

Requirements

null

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  require(_exists(tokenId), "ERC721: operator query for nonexistent token");
  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), "ERC721: mint to the zero address");
  require(!_exists(tokenId), "ERC721: token already minted");

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to].increment();

  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, "ERC721: burn of token that is not own");

  _clearApproval(tokenId);

  _ownedTokensCount[owner].decrement();
  _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,
    "ERC721: transfer of token that is not own"
  );
  require(to != address(0), "ERC721: transfer to the zero address");

  _clearApproval(tokenId);

  _ownedTokensCount[from].decrement();
  _ownedTokensCount[to].increment();

  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _supportedInterfaces[interfaceId] = true;
}

internal ERC721BaseCollection._mint

Parameters

Name	Type
_beneficiary	address
_tokenId	uint256
_wearableIdKey	bytes32
_wearableId	string
_issuedId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

issuedId must be less than or equal to maxIssuance for key

issuedId must be greater than 0

issued for key must be less than maxIssuance for key

to must not be equal to UNKNOWN VALUE

the result of calling _exists with tokenId must not be true

Source Code

function _mint(
  address _beneficiary,
  uint256 _tokenId,
  bytes32 _wearableIdKey,
  string memory _wearableId,
  uint256 _issuedId
) internal {
  // Check issuance
  require(
    _issuedId > 0 && _issuedId <= maxIssuance[_wearableIdKey],
    "Invalid issued id"
  );
  require(
    issued[_wearableIdKey] < maxIssuance[_wearableIdKey],
    "Option exhausted"
  );

  // Mint erc721 token
  super._mint(_beneficiary, _tokenId);

  // Increase issuance
  issued[_wearableIdKey] = issued[_wearableIdKey] + 1;

  // Log
  emit Issue(_beneficiary, _tokenId, _wearableIdKey, _wearableId, _issuedId);
}

internal Ownable.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  _owner = msg.sender;
  emit OwnershipTransferred(address(0), _owner);
}

internal Ownable._transferOwnership

Parameters

Name	Type
newOwner	address

Properties

Visibility internal

Mutability transaction

Requirements

newOwner must not be equal to UNKNOWN VALUE

Source Code

function _transferOwnership(address newOwner) internal {
  require(newOwner != address(0), "Ownable: new owner is the zero address");
  emit OwnershipTransferred(_owner, newOwner);
  _owner = newOwner;
}

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

Requirements

null

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  require(_exists(tokenId), "ERC721: operator query for nonexistent token");
  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), "ERC721: mint to the zero address");
  require(!_exists(tokenId), "ERC721: token already minted");

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to].increment();

  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, "ERC721: burn of token that is not own");

  _clearApproval(tokenId);

  _ownedTokensCount[owner].decrement();
  _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,
    "ERC721: transfer of token that is not own"
  );
  require(to != address(0), "ERC721: transfer to the zero address");

  _clearApproval(tokenId);

  _ownedTokensCount[from].decrement();
  _ownedTokensCount[to].increment();

  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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 occupied by
  // lastTokenId, 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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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

Requirements

null

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  require(_exists(tokenId), "ERC721: operator query for nonexistent token");
  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), "ERC721: mint to the zero address");
  require(!_exists(tokenId), "ERC721: token already minted");

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to].increment();

  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, "ERC721: burn of token that is not own");

  _clearApproval(tokenId);

  _ownedTokensCount[owner].decrement();
  _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,
    "ERC721: transfer of token that is not own"
  );
  require(to != address(0), "ERC721: transfer to the zero address");

  _clearApproval(tokenId);

  _ownedTokensCount[from].decrement();
  _ownedTokensCount[to].increment();

  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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), "ERC721Metadata: URI set of nonexistent token");
  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _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

Requirements

null

Source Code

function _isApprovedOrOwner(address spender, uint256 tokenId)
  internal
  view
  returns (bool)
{
  require(_exists(tokenId), "ERC721: operator query for nonexistent token");
  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), "ERC721: mint to the zero address");
  require(!_exists(tokenId), "ERC721: token already minted");

  _tokenOwner[tokenId] = to;
  _ownedTokensCount[to].increment();

  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, "ERC721: burn of token that is not own");

  _clearApproval(tokenId);

  _ownedTokensCount[owner].decrement();
  _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,
    "ERC721: transfer of token that is not own"
  );
  require(to != address(0), "ERC721: transfer to the zero address");

  _clearApproval(tokenId);

  _ownedTokensCount[from].decrement();
  _ownedTokensCount[to].increment();

  _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 {
  // Derived contracts need only register support for their own interfaces,
  // we register support for ERC165 itself here
  _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, "ERC165: invalid interface id");
  _supportedInterfaces[interfaceId] = true;
}

dcl://xmas_2020

About

Identical Contracts

Stats

Events (9) keyboard_arrow_up

AddWearable Event

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

Allowed Event

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

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.

BaseURI Event

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

Complete Event

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

Issue Event

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

OwnershipTransferred 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.

Constants (5) keyboard_arrow_up

_ERC721_RECEIVED Constant

_INTERFACE_ID_ERC721 Constant

_INTERFACE_ID_ERC165 Constant

_INTERFACE_ID_ERC721_ENUMERABLE Constant

_INTERFACE_ID_ERC721_METADATA Constant

State Variables (20) keyboard_arrow_up

baseURI Variable

isComplete Variable

maxIssuance Variable

issued Variable

allowed Variable

_owner 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

_tokenPaths Variable

wearables Variable

Functions Expand All Collapse All

balanceOf keyboard_arrow_up

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

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

ownerOf keyboard_arrow_up

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

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

safeTransferFrom keyboard_arrow_up

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

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

transferFrom keyboard_arrow_up

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

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

approve keyboard_arrow_up

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

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

getApproved keyboard_arrow_up

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

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Events (9)

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Constants (5)

State Variables (20)

balanceOf

Parameters

Requirements

ownerOf

Parameters

Requirements

safeTransferFrom

Parameters

Requirements

transferFrom

Parameters

Requirements

approve

Parameters

Requirements

getApproved

Parameters

Requirements

setApprovalForAll

Parameters

Requirements

isApprovedForAll

Parameters

safeTransferFrom

Parameters

Requirements

name

Parameters

symbol

Parameters

tokenURI

Parameters

Requirements

supportsInterface

Parameters

totalSupply

Parameters

tokenOfOwnerByIndex

Parameters

Requirements

tokenByIndex

Parameters

Requirements

owner

Parameters

isOwner

Parameters

renounceOwnership

Parameters

Modifiers

transferOwnership

Parameters

Modifiers

Requirements

setBaseURI

Parameters