Gods Unchained Cards

0x0e3a2a1f2146d86a604adc220b4967a898d7fe07 Copy

About

Stats

Public Functions 52

Event Types 10

Code Size 79,916 bytes

Events (10)

Approval Event

Parameters

owner	address
approved	address
tokenId	uint256

ApprovalForAll Event

Parameters

owner	address
operator	address
approved	bool

CardsMinted Event

Parameters

start	uint256
to	address
protos	uint16[]
qualities	uint8[]

ClassPropertySet Event

Parameters

key	bytes32
value	bytes32

OwnershipTransferred Event

Parameters

previousOwner	address
newOwner	address

ProtoUpdated Event

Parameters

uint16

QualityChanged Event

Parameters

tokenId	uint256
quality	uint8
factory	address

SeasonStarted Event

Parameters

id	uint16
name	string
low	uint16
high	uint16

TokenPropertySet Event

Parameters

id	uint
key	bytes32
value	bytes32

Transfer Event

Parameters

from	address
to	address
tokenId	uint256

Constants (8)

MAX_UINT16 Constant

uint16

UNKNOWN VALUE - 1

MAX_UINT16 Constant

uint16

UNKNOWN VALUE - 1

MYTHIC_THRESHOLD Constant

uint16

65000

MAX_LENGTH Constant

uint256

UNKNOWN VALUE

_INTERFACE_ID_ERC721_METADATA Constant

bytes4

0x5b5e139f

_INTERFACE_ID_ERC165 Constant

bytes4

0x01ffc9a7

_ERC721_RECEIVED Constant

bytes4

0x150b7a02

_INTERFACE_ID_ERC721 Constant

bytes4

0x80ac58cd

State Variables (34)

old Variable

address

migrating Variable

bool

propertyManager Variable

address

baseURI Variable

string

batchSize Variable

uint256

nextBatch Variable

uint256

tokenCount Variable

uint256

seasonTradable Variable

mapping(uint256 => bool)

mythicTradable Variable

mapping(uint16 => bool)

mythicCreated Variable

mapping(uint16 => bool)

userIDToAddress Variable

mapping(uint48 => address)

addressToUserID Variable

mapping(address => uint48)

properties Variable

mapping(bytes32 => bytes32)

cardProtos Variable

uint16[]

Internal Variable

cardQualities Variable

uint8[]

Internal Variable

protoToSeason Variable

uint16[]

Internal Variable

protos Variable

Proto[]

Internal Variable

seasons Variable

Season[]

Internal Variable

factoryApproved Variable

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

Internal Variable

mythicApproved Variable

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

Internal Variable

_owner Variable

address

Internal Variable

ownerIDs Variable

uint48[]

Internal Variable

approvedIDs Variable

uint48[]

Internal Variable

batches Variable

mapping(uint => Batch)

Internal Variable

userCount Variable

uint48

Internal Variable

_balances Variable

mapping(address => uint)

Internal Variable

_name Variable

string

Internal Variable

_symbol Variable

string

Internal Variable

_tokenURIs Variable

mapping(uint256 => string)

Internal Variable

_supportedInterfaces Variable

mapping(bytes4 => bool)

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

Functions Expand All Collapse All

getProperty

Parameters

Name	Type
_id	uint
_key	bytes32

Properties

Visibility public

Mutability view

Source Code

function getProperty(uint256 _id, bytes32 _key)
  public
  view
  returns (bytes32 _value)
{
  return properties[getTokenKey(_id, _key)];
}

getTokenKey

Parameters

Name	Type
_tokenId	uint
_key	bytes32

Properties

Visibility public

Mutability pure

Source Code

function getTokenKey(uint256 _tokenId, bytes32 _key)
  public
  pure
  returns (bytes32)
{
  // one prefix to prevent collisions
  return keccak256(abi.encodePacked(uint256(1), _tokenId, _key));
}

getClassKey

Parameters

Name	Type
_key	bytes32

Properties

Visibility public

Mutability pure

Source Code

function getClassKey(bytes32 _key) public pure returns (bytes32) {
  // zero prefix to prevent collisions
  return keccak256(abi.encodePacked(uint256(0), _key));
}

getClassProperty

Parameters

Name	Type
_key	bytes32

Properties

Visibility public

Mutability view

Source Code

function getClassProperty(bytes32 _key) public view returns (bytes32) {
  return properties[getClassKey(_key)];
}

balanceOf

Parameters

Name	Type
_owner	address

Properties

Visibility public

Mutability view

Source Code

function balanceOf(address _owner) public view returns (uint256) {
  return _balances[_owner];
}

ownerOf

Parameters

Name	Type
tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function ownerOf(uint256 tokenId) public view returns (address) {
  uint48 uID = ownerIDs[tokenId];
  if (uID == 0) {
    uint256 start = getBatchStart(tokenId);
    Batch memory b = batches[start];

    require(start + b.size > tokenId, "BT: token does not exist");

    uID = b.userID;
    require(uID != 0, "BT: bad batch owner");
  }
  return userIDToAddress[uID];
}

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(_msgSender(), 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, "BT: approval to current owner");

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

  approvedIDs[tokenId] = _getUserID(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), "BT: approved query for nonexistent token");

  return userIDToAddress[approvedIDs[tokenId]];
}

setApprovalForAll

Parameters

Name	Type
to	address
approved	bool

Properties

Visibility public

Mutability transaction

Requirements

to must not be equal to the result of calling _msgSender

Source Code

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

  _operatorApprovals[_msgSender()][to] = approved;
  emit ApprovalForAll(_msgSender(), 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 {
  require(
    _isApprovedOrOwner(_msgSender(), tokenId),
    "ERC721: transfer caller is not owner nor approved"
  );
  _safeTransferFrom(from, to, tokenId, _data);
}

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) external view returns (string memory) {
  return
    string(
      abi.encodePacked(
        baseURI,
        String.fromAddress(address(this)),
        "/",
        String.fromUint(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];
}

getBatchStart

Parameters

Name	Type
tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function getBatchStart(uint256 tokenId) public view returns (uint256) {
  return tokenId.div(batchSize).mul(batchSize);
}

getBatch

Parameters

Name	Type
index	uint256

Properties

Visibility public

Mutability view

Source Code

function getBatch(uint256 index)
  public
  view
  returns (uint48 userID, uint16 size)
{
  return (batches[index].userID, batches[index].size);
}

totalSupply

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function totalSupply() public view returns (uint256) {
  return tokenCount;
}

transferBatch

Parameters

Name	Type
from	address
to	address
start	uint256
end	uint256

Properties

Visibility public

Mutability transaction

Source Code

function transferBatch(
  address from,
  address to,
  uint256 start,
  uint256 end
) public {
  for (uint256 i = start; i < end; i++) {
    transferFrom(from, to, i);
  }
}

transferAllFrom

Parameters

Name	Type
from	address
to	address
tokenIDs	uint256[]

Properties

Visibility public

Mutability transaction

Source Code

function transferAllFrom(
  address from,
  address to,
  uint256[] memory tokenIDs
) public {
  for (uint256 i = 0; i < tokenIDs.length; i++) {
    transferFrom(from, to, tokenIDs[i]);
  }
}

safeTransferBatch

Parameters

Name	Type
from	address
to	address
start	uint256
end	uint256

Properties

Visibility public

Mutability transaction

Source Code

function safeTransferBatch(
  address from,
  address to,
  uint256 start,
  uint256 end
) public {
  for (uint256 i = start; i < end; i++) {
    safeTransferFrom(from, to, i);
  }
}

safeTransferAllFrom

Parameters

Name	Type
from	address
to	address
tokenIDs	uint256[]

Properties

Visibility public

Mutability transaction

Source Code

function safeTransferAllFrom(
  address from,
  address to,
  uint256[] memory tokenIDs
) public {
  for (uint256 i = 0; i < tokenIDs.length; i++) {
    safeTransferFrom(from, to, tokenIDs[i]);
  }
}

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 _msgSender() == _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);
}

getDetails

Parameters

Name	Type
tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function getDetails(uint256 tokenId)
  public
  view
  returns (uint16 proto, uint8 quality)
{
  return
    isOld(tokenId)
      ? old.getDetails(tokenId)
      : (cardProtos[tokenId], cardQualities[tokenId]);
}

mintCard

Parameters

Name	Type
_to	address
_proto	uint16
_quality	uint8

Properties

Visibility public

Mutability transaction

Requirements

migrating must not be true

Source Code

function mintCard(
  address _to,
  uint16 _proto,
  uint8 _quality
) public returns (uint256 id) {
  require(!migrating, "must not be migrating");
  super.mintCard(_to, _proto, _quality);
}

mintCards

Parameters

Name	Type
_to	address
_protos	uint16[]
_qualities	uint8[]

Properties

Visibility public

Mutability transaction

Requirements

migrating must not be true

the number of values in _protos must be greater than 0

the number of values in _protos must be equal to the number of values in _qualities

Source Code

function mintCards(
  address _to,
  uint16[] memory _protos,
  uint8[] memory _qualities
) public returns (uint256 id) {
  require(!migrating, "must not be migrating");
  super.mintCards(_to, _protos, _qualities);
}

addFactory

Parameters

Name	Type
_factory	address
_season	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

_season must be less than or equal to the number of values in seasons

_season must be greater than 0

factoryApproved for _factory for _season must not be true

seasonTradable for _season must not be true

Source Code

function addFactory(address _factory, uint256 _season) public onlyOwner {
  require(seasons.length >= _season, "Core: season must exist");

  require(_season > 0, "Core: season must not be 0");

  require(
    !factoryApproved[_factory][_season],
    "Core: this factory is already approved"
  );

  require(!seasonTradable[_season], "Core: season must not be tradable");

  factoryApproved[_factory][_season] = true;
}

approveForMythic

Parameters

Name	Type
_factory	address
_mythic	uint16

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

_mythic must be greater than or equal to MYTHIC_THRESHOLD

mythicApproved for _mythic for _factory must not be true

Source Code

function approveForMythic(address _factory, uint16 _mythic) public onlyOwner {
  require(_mythic >= MYTHIC_THRESHOLD, "not a mythic");

  require(
    !mythicApproved[_mythic][_factory],
    "Core: this factory is already approved for this mythic"
  );

  mythicApproved[_mythic][_factory] = true;
}

makeMythicTradable

Parameters

Name	Type
_mythic	uint16

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

_mythic must be greater than or equal to MYTHIC_THRESHOLD

mythicTradable for _mythic must not be true

Source Code

function makeMythicTradable(uint16 _mythic) public onlyOwner {
  require(_mythic >= MYTHIC_THRESHOLD, "Core: not a mythic");

  require(!mythicTradable[_mythic], "Core: must not be tradable already");

  mythicTradable[_mythic] = true;
}

unlockTrading

Parameters

Name	Type
_season	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

_season must be less than or equal to the number of values in seasons

_season must be greater than 0

seasonTradable for _season must not be true

Source Code

function unlockTrading(uint256 _season) public onlyOwner {
  require(
    _season > 0 && _season <= seasons.length,
    "Core: must be a current season"
  );

  require(!seasonTradable[_season], "Core: season must not be tradable");

  seasonTradable[_season] = true;
}

burn

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability transaction

Requirements

null

Source Code

function burn(uint256 _tokenId) public {
  require(isTradable(_tokenId), "Core: not yet tradable");

  super._burn(_tokenId);
}

burnAll

Parameters

Name	Type
tokenIDs	uint256[]

Properties

Visibility public

Mutability transaction

Source Code

function burnAll(uint256[] memory tokenIDs) public {
  for (uint256 i = 0; i < tokenIDs.length; i++) {
    burn(tokenIDs[i]);
  }
}

isTradable

Parameters

Name	Type
_tokenId	uint256

Properties

Visibility public

Mutability view

Source Code

function isTradable(uint256 _tokenId) public view returns (bool) {
  uint16 proto = getProto(_tokenId);
  if (proto >= MYTHIC_THRESHOLD) {
    return mythicTradable[proto];
  }
  return seasonTradable[protoToSeason[proto]];
}

startSeason

Parameters

Name	Type
name	string
low	uint16
high	uint16

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

low must be greater than 0

high must be greater than low

One or more of the following: - low must be greater than undefined.high - OR the number of values in seasons must be equal to 0

MYTHIC_THRESHOLD must be greater than high

Source Code

function startSeason(
  string memory name,
  uint16 low,
  uint16 high
) public onlyOwner returns (uint256) {
  require(low > 0, "Core: must not be zero proto");

  require(high > low, "Core: must be a valid range");

  require(
    seasons.length == 0 || low > seasons[seasons.length - 1].high,
    "Core: seasons cannot overlap"
  );

  require(MYTHIC_THRESHOLD > high, "Core: cannot go into mythic territory");

  // seasons start at 1
  uint16 id = uint16(seasons.push(Season({high: high, low: low})));

  uint256 cp;
  assembly {
    cp := protoToSeason_slot
  }
  StorageWrite.repeatUint16(cp, low, (high - low) + 1, id);

  emit SeasonStarted(id, name, low, high);

  return id;
}

updateProtos

Parameters

Name	Type
_ids	uint16[]
_gods	uint8[]
_cardTypes	uint8[]
_rarities	uint8[]
_manas	uint8[]
_attacks	uint8[]
_healths	uint8[]
_tribes	uint8[]

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Source Code

function updateProtos(
  uint16[] memory _ids,
  uint8[] memory _gods,
  uint8[] memory _cardTypes,
  uint8[] memory _rarities,
  uint8[] memory _manas,
  uint8[] memory _attacks,
  uint8[] memory _healths,
  uint8[] memory _tribes
) public onlyOwner {
  for (uint256 i = 0; i < _ids.length; i++) {
    uint16 id = _ids[i];

    require(id > 0, "Core: proto must not be zero");

    Proto memory proto = protos[id];
    require(!proto.locked, "Core: proto is locked");

    protos[id] = Proto({
      locked: false,
      exists: true,
      god: _gods[i],
      cardType: _cardTypes[i],
      rarity: _rarities[i],
      mana: _manas[i],
      attack: _attacks[i],
      health: _healths[i],
      tribe: _tribes[i]
    });
    emit ProtoUpdated(id);
  }
}

lockProtos

Parameters

Name	Type
_ids	uint16[]

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Requirements

the number of values in _ids must be greater than 0

Source Code

function lockProtos(uint16[] memory _ids) public onlyOwner {
  require(_ids.length > 0, "must lock some");

  for (uint256 i = 0; i < _ids.length; i++) {
    uint16 id = _ids[i];
    require(id > 0, "proto must not be zero");

    Proto storage proto = protos[id];

    require(!proto.locked, "proto is locked");

    require(proto.exists, "proto must exist");

    proto.locked = true;
    emit ProtoUpdated(id);
  }
}

setQuality

Parameters

Name	Type
_tokenId	uint256
_quality	uint8

Properties

Visibility public

Mutability transaction

Source Code

function setQuality(uint256 _tokenId, uint8 _quality) public {
  uint16 proto = cardProtos[_tokenId];
  // wont' be able to change mythic season
  uint256 season = protoToSeason[proto];

  require(
    factoryApproved[msg.sender][season],
    "Core: factory can't change quality of this season"
  );

  cardQualities[_tokenId] = _quality;
  emit QualityChanged(_tokenId, _quality, msg.sender);
}

setPropertyManager

Parameters

Name	Type
_manager	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Source Code

function setPropertyManager(address _manager) public onlyOwner {
  propertyManager = _manager;
}

setProperty

Parameters

Name	Type
_id	uint256
_key	bytes32
_value	bytes32

Properties

Visibility public

Mutability transaction

Requirements

propertyManager must be equal to the sender's address

Source Code

function setProperty(
  uint256 _id,
  bytes32 _key,
  bytes32 _value
) public {
  require(msg.sender == propertyManager, "Core: must be property manager");

  _setProperty(_id, _key, _value);
}

setClassProperty

Parameters

Name	Type
_key	bytes32
_value	bytes32

Properties

Visibility public

Mutability transaction

Requirements

propertyManager must be equal to the sender's address

Source Code

function setClassProperty(bytes32 _key, bytes32 _value) public {
  require(msg.sender == propertyManager, "Core: must be property manager");

  _setClassProperty(_key, _value);
}

setBaseURI

Parameters

Name	Type
uri	string

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Source Code

function setBaseURI(string memory uri) public onlyOwner {
  baseURI = uri;
}

setMigrating

Parameters

Name	Type
_migrating	bool

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

null

Source Code

function setMigrating(bool _migrating) public onlyOwner {
  migrating = _migrating;
}

copyUntil

Parameters

Name	Type
gasThreshold	uint

Properties

Visibility public

Mutability transaction

Source Code

function copyUntil(uint256 gasThreshold) public {
  while (gasleft() > gasThreshold) {
    copyNextBatch();
  }
}

copyNextBatch

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Requirements

migrating must be true

userID must be greater than 0

size must be greater than 0

Source Code

function copyNextBatch() public {
  require(migrating, "must be migrating");
  uint256 start = nextBatch;
  (uint48 userID, uint16 size) = old.batches(start);
  require(size > 0 && userID > 0, "incorrect batch or limit reached");
  if (old.cardProtos(start) != 0) {
    address to = old.userIDToAddress(userID);
    uint48 uID = _getUserID(to);
    batches[start] = Batch({userID: uID, size: size});
    uint256 end = start.add(size);
    for (uint256 i = start; i < end; i++) {
      emit Transfer(address(0), to, i);
    }
    _balances[to] = _balances[to].add(size);
    tokenCount = tokenCount.add(size);
  }
  nextBatch = nextBatch.add(batchSize);
}

isOld

Parameters

Name	Type
_tokenId	uint

Properties

Visibility public

Mutability view

Requirements

null

Source Code

function isOld(uint256 _tokenId) public view returns (bool) {
  require(_exists(_tokenId), "card does not exist");
  return cardProtos[_tokenId] == 0;
}

getProto

Parameters

Name	Type
_tokenId	uint

Properties

Visibility public

Mutability view

Source Code

function getProto(uint256 _tokenId) public view returns (uint16) {
  return isOld(_tokenId) ? old.cardProtos(_tokenId) : cardProtos[_tokenId];
}

getQuality

Parameters

Name	Type
_tokenId	uint

Properties

Visibility public

Mutability view

Source Code

function getQuality(uint256 _tokenId) public view returns (uint8) {
  return
    isOld(_tokenId) ? old.cardQualities(_tokenId) : cardQualities[_tokenId];
}

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 BatchWrapper._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint

Properties

Visibility internal

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 _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(isTradable(tokenId), "BW: not yet tradable");
  super._transferFrom(from, to, tokenId);
}

internal BatchWrapper._validateProtos

Parameters

Name	Type
_protos	uint16[]

Properties

Visibility internal

Mutability transaction

Source Code

function _validateProtos(uint16[] memory _protos) internal {
  uint16 maxProto = 0;
  uint16 minProto = MAX_UINT16;
  for (uint256 i = 0; i < _protos.length; i++) {
    uint16 proto = _protos[i];
    if (proto >= MYTHIC_THRESHOLD) {
      _checkCanCreateMythic(proto);
    } else {
      require(proto != 0, "proto is zero");
      if (proto > maxProto) {
        maxProto = proto;
      }
      if (minProto > proto) {
        minProto = proto;
      }
    }
  }

  if (maxProto != 0) {
    uint256 season = protoToSeason[maxProto];
    // cards must be from the same season
    require(season != 0, "Core: must have season set");

    require(
      season == protoToSeason[minProto],
      "Core: can only create cards from the same season"
    );

    require(
      factoryApproved[msg.sender][season],
      "Core: must be approved factory for this season"
    );
  }
}

internal NewCards._transferFrom

Parameters

Name	Type
from	address
to	address
tokenId	uint256

Properties

Visibility internal

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 _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(isTradable(tokenId), "Core: not yet tradable");

  super._transferFrom(from, to, tokenId);
}

internal NewCards._validateAndSaveDetails

Parameters

Name	Type
start	uint256
_protos	uint16[]
_qualities	uint8[]

Properties

Visibility internal

Mutability transaction

Source Code

function _validateAndSaveDetails(
  uint256 start,
  uint16[] memory _protos,
  uint8[] memory _qualities
) internal {
  _validateProtos(_protos);

  uint256 cp;
  assembly {
    cp := cardProtos_slot
  }
  StorageWrite.uint16s(cp, start, _protos);
  uint256 cq;
  assembly {
    cq := cardQualities_slot
  }
  StorageWrite.uint8s(cq, start, _qualities);
}

internal NewCards._validateProto

Parameters

Name	Type
proto	uint16

Properties

Visibility internal

Mutability transaction

Source Code

function _validateProto(uint16 proto) internal {
  if (proto >= MYTHIC_THRESHOLD) {
    _checkCanCreateMythic(proto);
  } else {
    uint256 season = protoToSeason[proto];

    require(season != 0, "Core: must have season set");

    require(
      factoryApproved[msg.sender][season],
      "Core: must be approved factory for this season"
    );
  }
}

internal NewCards._validateProtos

Parameters

Name	Type
_protos	uint16[]

Properties

Visibility internal

Mutability transaction

Source Code

function _validateProtos(uint16[] memory _protos) internal {
  uint16 maxProto = 0;
  uint16 minProto = MAX_UINT16;
  for (uint256 i = 0; i < _protos.length; i++) {
    uint16 proto = _protos[i];
    if (proto >= MYTHIC_THRESHOLD) {
      _checkCanCreateMythic(proto);
    } else {
      if (proto > maxProto) {
        maxProto = proto;
      }
      if (minProto > proto) {
        minProto = proto;
      }
    }
  }

  if (maxProto != 0) {
    uint256 season = protoToSeason[maxProto];
    // cards must be from the same season
    require(season != 0, "Core: must have season set");

    require(
      season == protoToSeason[minProto],
      "Core: can only create cards from the same season"
    );

    require(
      factoryApproved[msg.sender][season],
      "Core: must be approved factory for this season"
    );
  }
}

internal NewCards._checkCanCreateMythic

Parameters

Name	Type
proto	uint16

Properties

Visibility internal

Mutability transaction

Requirements

mythicCreated for proto must not be true

Source Code

function _checkCanCreateMythic(uint16 proto) internal {
  require(
    mythicApproved[proto][msg.sender],
    "Core: not approved to create this mythic"
  );

  require(!mythicCreated[proto], "Core: mythic has already been created");

  mythicCreated[proto] = true;
}

internal Ownable.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  _owner = _msgSender();
  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 Context.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {}

internal Context._msgSender

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _msgSender() internal view returns (address payable) {
  return msg.sender;
}

internal Context._msgData

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _msgData() internal view returns (bytes memory) {
  this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
  return msg.data;
}

internal BatchToken._getUserID

Parameters

Name	Type
to	address

Properties

Visibility internal

Mutability transaction

Source Code

function _getUserID(address to) internal returns (uint48) {
  if (to == address(0)) {
    return 0;
  }
  uint48 uID = addressToUserID[to];
  if (uID == 0) {
    require(userCount + 1 > userCount, "BT: must not overflow");
    uID = userCount++;
    userIDToAddress[uID] = to;
    addressToUserID[to] = uID;
  }
  return uID;
}

internal BatchToken._batchMint

Parameters

Name	Type
to	address
size	uint16

Properties

Visibility internal

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

size must be less than or equal to batchSize

size must be greater than 0

Source Code

function _batchMint(address to, uint16 size) internal returns (uint256) {
  require(to != address(0), "BT: must not be null");

  require(size > 0 && size <= batchSize, "BT: size must be within limits");

  uint256 start = nextBatch;
  uint48 uID = _getUserID(to);
  batches[start] = Batch({userID: uID, size: size});
  uint256 end = start.add(size);
  for (uint256 i = start; i < end; i++) {
    emit Transfer(address(0), to, i);
  }
  nextBatch = nextBatch.add(batchSize);
  _balances[to] = _balances[to].add(size);
  tokenCount = tokenCount.add(size);
  return start;
}

internal BatchToken._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

null

Source Code

function _transferFrom(
  address from,
  address to,
  uint256 tokenId
) internal {
  require(ownerOf(tokenId) == from, "BT: transfer of token that is not own");

  require(to != address(0), "BT: transfer to the zero address");

  require(
    _isApprovedOrOwner(msg.sender, tokenId),
    "BT: caller is not owner nor approved"
  );

  _cancelApproval(tokenId);
  _balances[from] = _balances[from].sub(1);
  _balances[to] = _balances[to].add(1);
  ownerIDs[tokenId] = _getUserID(to);
  emit Transfer(from, to, tokenId);
}

internal BatchToken._burn

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

null

Source Code

function _burn(uint256 tokenId) internal {
  require(
    _isApprovedOrOwner(msg.sender, tokenId),
    "BT: caller is not owner nor approved"
  );

  _cancelApproval(tokenId);
  address owner = ownerOf(tokenId);
  _balances[owner] = _balances[owner].sub(1);
  ownerIDs[tokenId] = 0;
  tokenCount = tokenCount.sub(1);
  emit Transfer(owner, address(0), tokenId);
}

internal BatchToken._cancelApproval

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability transaction

Source Code

function _cancelApproval(uint256 tokenId) internal {
  if (approvedIDs[tokenId] != 0) {
    approvedIDs[tokenId] = 0;
  }
}

internal BatchToken._exists

Parameters

Name	Type
tokenId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 tokenId) internal view returns (bool) {
  return ownerOf(tokenId) != address(0);
}

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

owner 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 Context.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {}

internal Context._msgSender

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _msgSender() internal view returns (address payable) {
  return msg.sender;
}

internal Context._msgData

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _msgData() internal view returns (bytes memory) {
  this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
  return msg.data;
}

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

Parameters

Name	Type
from	address
to	address
tokenId	uint256
_data	bytes

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

null

Source Code

function _safeTransferFrom(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) internal {
  _transferFrom(from, to, tokenId);
  require(
    _checkOnERC721Received(from, to, tokenId, _data),
    "ERC721: transfer to non ERC721Receiver implementer"
  );
}

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

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

null

Source Code

function _safeMint(address to, uint256 tokenId) internal {
  _safeMint(to, tokenId, "");
}

internal ERC721._safeMint

Parameters

Name	Type
to	address
tokenId	uint256
_data	bytes

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

null

Source Code

function _safeMint(
  address to,
  uint256 tokenId,
  bytes memory _data
) internal {
  _mint(to, tokenId);
  require(
    _checkOnERC721Received(address(0), to, tokenId, _data),
    "ERC721: transfer to non ERC721Receiver implementer"
  );
}

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(
    _msgSender(),
    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 Context.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {}

internal Context._msgSender

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _msgSender() internal view returns (address payable) {
  return msg.sender;
}

internal Context._msgData

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _msgData() internal view returns (bytes memory) {
  this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
  return msg.data;
}

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 InscribableToken._setProperty

Parameters

Name	Type
_id	uint
_key	bytes32
_value	bytes32

Properties

Visibility internal

Mutability transaction

Source Code

function _setProperty(
  uint256 _id,
  bytes32 _key,
  bytes32 _value
) internal {
  properties[getTokenKey(_id, _key)] = _value;
  emit TokenPropertySet(_id, _key, _value);
}

internal InscribableToken._setClassProperty

Parameters

Name	Type
_key	bytes32
_value	bytes32

Properties

Visibility internal

Mutability transaction

Source Code

function _setClassProperty(bytes32 _key, bytes32 _value) internal {
  emit ClassPropertySet(_key, _value);
  properties[getClassKey(_key)] = _value;
}

Gods Unchained Cards

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.

CardsMinted Event

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

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

ProtoUpdated Event

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

QualityChanged Event

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

SeasonStarted Event

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

TokenPropertySet 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 (8) keyboard_arrow_up

MAX_UINT16 Constant

MAX_UINT16 Constant

MYTHIC_THRESHOLD Constant

MAX_LENGTH Constant

_INTERFACE_ID_ERC721_METADATA Constant

_INTERFACE_ID_ERC165 Constant

_ERC721_RECEIVED Constant

_INTERFACE_ID_ERC721 Constant

State Variables (34) keyboard_arrow_up

old Variable

migrating Variable

propertyManager Variable

baseURI Variable

batchSize Variable

nextBatch Variable

tokenCount Variable

seasonTradable Variable

mythicTradable Variable

mythicCreated Variable

userIDToAddress Variable

addressToUserID Variable

properties Variable

cardProtos Variable

cardQualities Variable

protoToSeason Variable

protos Variable

seasons Variable

factoryApproved Variable

mythicApproved Variable

_owner Variable

ownerIDs Variable

approvedIDs Variable

batches Variable

userCount Variable

_balances Variable

_name Variable

_symbol Variable

_tokenURIs Variable

_supportedInterfaces Variable

_tokenOwner Variable

_tokenApprovals Variable

_ownedTokensCount Variable

_operatorApprovals Variable

Functions Expand All Collapse All

getProperty 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

getTokenKey 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

getClassKey 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 (8)

State Variables (34)

getProperty

Parameters

getTokenKey

Parameters

getClassKey

Parameters

getClassProperty

Parameters

balanceOf

Parameters

ownerOf

Parameters

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

supportsInterface

Parameters

getBatchStart

Parameters

getBatch

Parameters