Decentraland LAND

0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d Copy

About

Stats

Public Functions 49

Event Types 12

Code Size 39,966 bytes

Events (12)

Approval Event

Parameters

owner	address
operator	address
assetId	uint256

ApprovalForAll Event

Parameters

holder	address
operator	address
authorized	bool

DeployAuthorized Event

Parameters

_caller	address
_deployer	address

DeployForbidden Event

Parameters

_caller	address
_deployer	address

EstateRegistrySet Event

Parameters

registry

address

OwnerUpdate Event

Parameters

_prevOwner	address
_newOwner	address

Transfer Event

Parameters

from	address
to	address
assetId	uint256
operator	address
userData	bytes
operatorData	bytes

Transfer Event

Parameters

from	address
to	address
assetId	uint256
operator	address
userData	bytes

Transfer Event

Parameters

from	address
to	address
assetId	uint256

Update Event

Parameters

assetId	uint256
holder	address
operator	address
data	string

UpdateManager Event

Parameters

_owner	address
_operator	address
_caller	address
_approved	bool

UpdateOperator Event

Parameters

assetId	uint256
operator	address

Constants (8)

GET_METADATA Constant

bytes4

UNKNOWN VALUE

clearLow Constant

uint256

0xffffffffffffffffffffffffffffffff00000000000000000000000000000000

clearHigh Constant

uint256

0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff

factor Constant

uint256

0x100000000000000000000000000000000

ERC721_RECEIVED Constant

bytes4

0x150b7a02

InterfaceId_ERC165 Constant

bytes4

0x01ffc9a7

Old_InterfaceId_ERC721 Constant

bytes4

0x7c0633c6

InterfaceId_ERC721 Constant

bytes4

0x80ac58cd

State Variables (19)

currentContract Variable

address

proxyOwner Variable

address

owner Variable

address

estateRegistry Variable

address

latestPing Variable

mapping(address => uint)

updateOperator Variable

mapping(uint256 => address)

authorizedDeploy Variable

mapping(address => bool)

_name Variable

string

Internal Variable

_symbol Variable

string

Internal Variable

_description Variable

string

Internal Variable

_count Variable

uint256

Internal Variable

_assetsOf Variable

mapping(address => uint256[])

Internal Variable

_holderOf Variable

mapping(uint256 => address)

Internal Variable

_indexOfAsset Variable

mapping(uint256 => uint256)

Internal Variable

_assetData Variable

mapping(uint256 => string)

Internal Variable

_operators Variable

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

Internal Variable

_approval Variable

mapping(uint256 => address)

Internal Variable

_deprecated_authorizedDeploy Variable

mapping(address => bool)

Internal Variable

updateManager Variable

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

Internal Variable

Functions Expand All Collapse All

name

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

symbol

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

description

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function description() external view returns (string) {
  return _description;
}

tokenMetadata

Parameters

Name	Type
assetId	uint256

Properties

Visibility public

Mutability view

Source Code

function tokenMetadata(uint256 assetId) external view returns (string) {
  return _tokenMetadata(assetId);
}

tokensOf

Parameters

Name	Type
owner	address

Properties

Visibility public

Mutability view

Source Code

function tokensOf(address owner) external view returns (uint256[]) {
  return _assetsOf[owner];
}

tokenOfOwnerByIndex

Parameters

Name	Type
owner	address
index	uint256

Properties

Visibility public

Mutability view

Requirements

index must be less than the number of values in undefined

index must be less than UNKNOWN VALUE

Source Code

function tokenOfOwnerByIndex(address owner, uint256 index)
  external
  view
  returns (uint256 assetId)
{
  require(index < _assetsOf[owner].length);
  require(index < (1 << 127));
  return _assetsOf[owner][index];
}

totalSupply

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function totalSupply() external view returns (uint256) {
  return _totalSupply();
}

ownerOf

Parameters

Name	Type
assetId	uint256

Properties

Visibility public

Mutability view

Source Code

function ownerOf(uint256 assetId) external view returns (address) {
  return _ownerOf(assetId);
}

balanceOf

Parameters

Name	Type
owner	address

Properties

Visibility public

Mutability view

Source Code

function balanceOf(address owner) external view returns (uint256) {
  return _balanceOf(owner);
}

isApprovedForAll

Parameters

Name	Type
assetHolder	address
operator	address

Properties

Visibility public

Mutability view

Source Code

function isApprovedForAll(address assetHolder, address operator)
  external
  view
  returns (bool)
{
  return _isApprovedForAll(assetHolder, operator);
}

getApproved

Parameters

Name	Type
assetId	uint256

Properties

Visibility public

Mutability view

Source Code

function getApproved(uint256 assetId) external view returns (address) {
  return _getApprovedAddress(assetId);
}

getApprovedAddress

Parameters

Name	Type
assetId	uint256

Properties

Visibility public

Mutability view

Source Code

function getApprovedAddress(uint256 assetId) external view returns (address) {
  return _getApprovedAddress(assetId);
}

isAuthorized

Parameters

Name	Type
operator	address
assetId	uint256

Properties

Visibility public

Mutability view

Requirements

operator must not be equal to 0

Source Code

function isAuthorized(address operator, uint256 assetId)
  external
  view
  returns (bool)
{
  return _isAuthorized(operator, assetId);
}

setApprovalForAll

Parameters

Name	Type
operator	address
authorized	bool

Properties

Visibility public

Mutability transaction

Source Code

function setApprovalForAll(address operator, bool authorized) external {
  return _setApprovalForAll(operator, authorized);
}

approve

Parameters

Name	Type
operator	address
assetId	uint256

Properties

Visibility public

Mutability transaction

Requirements

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

operator must not be equal to holder

Source Code

function approve(address operator, uint256 assetId) external {
  address holder = _ownerOf(assetId);
  require(msg.sender == holder || _isApprovedForAll(msg.sender, holder));
  require(operator != holder);

  if (_getApprovedAddress(assetId) != operator) {
    _approval[assetId] = operator;
    emit Approval(holder, operator, assetId);
  }
}

safeTransferFrom

Parameters

Name	Type
from	address
to	address
assetId	uint256

Properties

Visibility public

Mutability transaction

Source Code

function safeTransferFrom(
  address from,
  address to,
  uint256 assetId
) external {
  return _doTransferFrom(from, to, assetId, "", true);
}

safeTransferFrom

Parameters

Name	Type
from	address
to	address
assetId	uint256
userData	bytes

Properties

Visibility public

Mutability transaction

Source Code

function safeTransferFrom(
  address from,
  address to,
  uint256 assetId,
  bytes userData
) external {
  return _doTransferFrom(from, to, assetId, userData, true);
}

transferFrom

Parameters

Name	Type
from	address
to	address
assetId	uint256

Properties

Visibility public

Mutability transaction

Requirements

to must not be equal to UNKNOWN VALUE

Source Code

function transferFrom(
  address from,
  address to,
  uint256 assetId
) external {
  require(
    to != address(estateRegistry),
    "EstateRegistry unsafe transfers are not allowed"
  );
  return _doTransferFrom(from, to, assetId, "", false);
}

supportsInterface

Parameters

Name	Type
_interfaceID	bytes4

Properties

Visibility public

Mutability view

Source Code

function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
  if (_interfaceID == 0xffffffff) {
    return false;
  }
  return
    _interfaceID == InterfaceId_ERC165 ||
    _interfaceID == Old_InterfaceId_ERC721 ||
    _interfaceID == InterfaceId_ERC721;
}

exists

Parameters

Name	Type
assetId	uint256

Properties

Visibility public

Mutability view

Source Code

function exists(uint256 assetId) external view returns (bool) {
  return _exists(assetId);
}

decimals

Parameters

This function has no parameters.

Properties

Visibility public

Mutability pure

Source Code

function decimals() external pure returns (uint256) {
  return 0;
}

transferOwnership

Parameters

Name	Type
_newOwner	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

_newOwner must not be equal to owner

Source Code

function transferOwnership(address _newOwner) public onlyOwner {
  require(_newOwner != owner, "Cannot transfer to yourself");
  owner = _newOwner;
}

initialize

Parameters

Name	Type
	bytes

Properties

Visibility public

Mutability transaction

Source Code

function initialize(bytes) external {
  _name = "Decentraland LAND";
  _symbol = "LAND";
  _description = "Contract that stores the Decentraland LAND registry";
}

isUpdateAuthorized

Parameters

Name	Type
operator	address
assetId	uint256

Properties

Visibility public

Mutability view

Source Code

function isUpdateAuthorized(address operator, uint256 assetId)
  external
  view
  returns (bool)
{
  return _isUpdateAuthorized(operator, assetId);
}

authorizeDeploy

Parameters

Name	Type
beneficiary	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyProxyOwner checks for the following:

proxyOwner must be equal to the sender's address

Requirements

beneficiary must not be equal to UNKNOWN VALUE

authorizedDeploy for beneficiary must be equal to false

Source Code

function authorizeDeploy(address beneficiary) external onlyProxyOwner {
  require(beneficiary != address(0), "invalid address");
  require(
    authorizedDeploy[beneficiary] == false,
    "address is already authorized"
  );

  authorizedDeploy[beneficiary] = true;
  emit DeployAuthorized(msg.sender, beneficiary);
}

forbidDeploy

Parameters

Name	Type
beneficiary	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyProxyOwner checks for the following:

proxyOwner must be equal to the sender's address

Requirements

beneficiary must not be equal to UNKNOWN VALUE

Source Code

function forbidDeploy(address beneficiary) external onlyProxyOwner {
  require(beneficiary != address(0), "invalid address");
  require(authorizedDeploy[beneficiary], "address is already forbidden");

  authorizedDeploy[beneficiary] = false;
  emit DeployForbidden(msg.sender, beneficiary);
}

assignNewParcel

Parameters

Name	Type
x	int
y	int
beneficiary	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyDeployer checks for the following:

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

Requirements

_holderOf for the result of calling _encodeTokenId with x, y must be equal to 0

Source Code

function assignNewParcel(
  int256 x,
  int256 y,
  address beneficiary
) external onlyDeployer {
  _generate(_encodeTokenId(x, y), beneficiary);
}

assignMultipleParcels

Parameters

Name	Type
x	int[]
y	int[]
beneficiary	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyDeployer checks for the following:

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

Source Code

function assignMultipleParcels(
  int256[] x,
  int256[] y,
  address beneficiary
) external onlyDeployer {
  for (uint256 i = 0; i < x.length; i++) {
    _generate(_encodeTokenId(x[i], y[i]), beneficiary);
  }
}

ping

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Source Code

function ping() external {
  // solium-disable-next-line security/no-block-members
  latestPing[msg.sender] = block.timestamp;
}

setLatestToNow

Parameters

Name	Type
user	address

Properties

Visibility public

Mutability transaction

Requirements

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

Source Code

function setLatestToNow(address user) external {
  require(
    msg.sender == proxyOwner || _isApprovedForAll(msg.sender, user),
    "Unauthorized user"
  );
  // solium-disable-next-line security/no-block-members
  latestPing[user] = block.timestamp;
}

encodeTokenId

Parameters

Name	Type
x	int
y	int

Properties

Visibility public

Mutability pure

Requirements

y must be less than 1000000

y must be greater than UNKNOWN VALUE

x must be less than 1000000

x must be greater than UNKNOWN VALUE

Source Code

function encodeTokenId(int256 x, int256 y) external pure returns (uint256) {
  return _encodeTokenId(x, y);
}

decodeTokenId

Parameters

Name	Type
value	uint

Properties

Visibility public

Mutability pure

Requirements

y must be less than 1000000

y must be greater than UNKNOWN VALUE

x must be less than 1000000

x must be greater than UNKNOWN VALUE

Source Code

function decodeTokenId(uint256 value) external pure returns (int256, int256) {
  return _decodeTokenId(value);
}

exists

Parameters

Name	Type
x	int
y	int

Properties

Visibility public

Mutability view

Source Code

function exists(int256 x, int256 y) external view returns (bool) {
  return _exists(x, y);
}

ownerOfLand

Parameters

Name	Type
x	int
y	int

Properties

Visibility public

Mutability view

Source Code

function ownerOfLand(int256 x, int256 y) external view returns (address) {
  return _ownerOfLand(x, y);
}

ownerOfLandMany

Parameters

Name	Type
x	int[]
y	int[]

Properties

Visibility public

Mutability view

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

Source Code

function ownerOfLandMany(int256[] x, int256[] y)
  external
  view
  returns (address[])
{
  require(x.length > 0, "You should supply at least one coordinate");
  require(x.length == y.length, "The coordinates should have the same length");

  address[] memory addrs = new address[](x.length);
  for (uint256 i = 0; i < x.length; i++) {
    addrs[i] = _ownerOfLand(x[i], y[i]);
  }

  return addrs;
}

landOf

Parameters

Name	Type
owner	address

Properties

Visibility public

Mutability view

Source Code

function landOf(address owner) external view returns (int256[], int256[]) {
  uint256 len = _assetsOf[owner].length;
  int256[] memory x = new int256[](len);
  int256[] memory y = new int256[](len);

  int256 assetX;
  int256 assetY;
  for (uint256 i = 0; i < len; i++) {
    (assetX, assetY) = _decodeTokenId(_assetsOf[owner][i]);
    x[i] = assetX;
    y[i] = assetY;
  }

  return (x, y);
}

landData

Parameters

Name	Type
x	int
y	int

Properties

Visibility public

Mutability view

Source Code

function landData(int256 x, int256 y) external view returns (string) {
  return _tokenMetadata(_encodeTokenId(x, y));
}

transferLand

Parameters

Name	Type
x	int
y	int
to	address

Properties

Visibility public

Mutability transaction

Source Code

function transferLand(
  int256 x,
  int256 y,
  address to
) external {
  uint256 tokenId = _encodeTokenId(x, y);
  _doTransferFrom(_ownerOf(tokenId), to, tokenId, "", true);
}

transferManyLand

Parameters

Name	Type
x	int[]
y	int[]
to	address

Properties

Visibility public

Mutability transaction

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

Source Code

function transferManyLand(
  int256[] x,
  int256[] y,
  address to
) external {
  require(x.length > 0, "You should supply at least one coordinate");
  require(x.length == y.length, "The coordinates should have the same length");

  for (uint256 i = 0; i < x.length; i++) {
    uint256 tokenId = _encodeTokenId(x[i], y[i]);
    _doTransferFrom(_ownerOf(tokenId), to, tokenId, "", true);
  }
}

transferLandToEstate

Parameters

Name	Type
x	int
y	int
estateId	uint256

Properties

Visibility public

Mutability transaction

Requirements

UNKNOWN VALUE must be equal to the sender's address

Source Code

function transferLandToEstate(
  int256 x,
  int256 y,
  uint256 estateId
) external {
  require(
    estateRegistry.ownerOf(estateId) == msg.sender,
    "You must own the Estate you want to transfer to"
  );

  uint256 tokenId = _encodeTokenId(x, y);
  _doTransferFrom(
    _ownerOf(tokenId),
    address(estateRegistry),
    tokenId,
    toBytes(estateId),
    true
  );
}

transferManyLandToEstate

Parameters

Name	Type
x	int[]
y	int[]
estateId	uint256

Properties

Visibility public

Mutability transaction

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

UNKNOWN VALUE must be equal to the sender's address

Source Code

function transferManyLandToEstate(
  int256[] x,
  int256[] y,
  uint256 estateId
) external {
  require(x.length > 0, "You should supply at least one coordinate");
  require(x.length == y.length, "The coordinates should have the same length");
  require(
    estateRegistry.ownerOf(estateId) == msg.sender,
    "You must own the Estate you want to transfer to"
  );

  for (uint256 i = 0; i < x.length; i++) {
    uint256 tokenId = _encodeTokenId(x[i], y[i]);
    _doTransferFrom(
      _ownerOf(tokenId),
      address(estateRegistry),
      tokenId,
      toBytes(estateId),
      true
    );
  }
}

setUpdateOperator

Parameters

Name	Type
assetId	uint256
operator	address

Properties

Visibility public

Mutability transaction

Modifiers

canSetUpdateOperator checks for the following:

One or more of the following: -null

Source Code

function setUpdateOperator(uint256 assetId, address operator)
  public
  canSetUpdateOperator(assetId)
{
  updateOperator[assetId] = operator;
  emit UpdateOperator(assetId, operator);
}

setManyUpdateOperator

Parameters

Name	Type
_assetIds	uint256[]
_operator	address

Properties

Visibility public

Mutability transaction

Source Code

function setManyUpdateOperator(uint256[] _assetIds, address _operator) public {
  for (uint256 i = 0; i < _assetIds.length; i++) {
    setUpdateOperator(_assetIds[i], _operator);
  }
}

setUpdateManager

Parameters

Name	Type
_owner	address
_operator	address
_approved	bool

Properties

Visibility public

Mutability transaction

Requirements

_operator must not be equal to the sender's address

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

Source Code

function setUpdateManager(
  address _owner,
  address _operator,
  bool _approved
) external {
  require(
    _operator != msg.sender,
    "The operator should be different from owner"
  );
  require(
    _owner == msg.sender || _isApprovedForAll(_owner, msg.sender),
    "Unauthorized user"
  );

  updateManager[_owner][_operator] = _approved;

  emit UpdateManager(_owner, _operator, msg.sender, _approved);
}

setEstateRegistry

Parameters

Name	Type
registry	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyProxyOwner checks for the following:

proxyOwner must be equal to the sender's address

Source Code

function setEstateRegistry(address registry) external onlyProxyOwner {
  estateRegistry = IEstateRegistry(registry);
  emit EstateRegistrySet(registry);
}

createEstate

Parameters

Name	Type
x	int[]
y	int[]
beneficiary	address

Properties

Visibility public

Mutability transaction

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

UNKNOWN VALUE must not be equal to 0

Source Code

function createEstate(
  int256[] x,
  int256[] y,
  address beneficiary
) external returns (uint256) {
  // solium-disable-next-line arg-overflow
  return _createEstate(x, y, beneficiary, "");
}

createEstateWithMetadata

Parameters

Name	Type
x	int[]
y	int[]
beneficiary	address
metadata	string

Properties

Visibility public

Mutability transaction

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

UNKNOWN VALUE must not be equal to 0

Source Code

function createEstateWithMetadata(
  int256[] x,
  int256[] y,
  address beneficiary,
  string metadata
) external returns (uint256) {
  // solium-disable-next-line arg-overflow
  return _createEstate(x, y, beneficiary, metadata);
}

updateLandData

Parameters

Name	Type
x	int
y	int
data	string

Properties

Visibility public

Mutability transaction

Source Code

function updateLandData(
  int256 x,
  int256 y,
  string data
) external {
  return _updateLandData(x, y, data);
}

updateManyLandData

Parameters

Name	Type
x	int[]
y	int[]
data	string

Properties

Visibility public

Mutability transaction

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

Source Code

function updateManyLandData(
  int256[] x,
  int256[] y,
  string data
) external {
  require(x.length > 0, "You should supply at least one coordinate");
  require(x.length == y.length, "The coordinates should have the same length");
  for (uint256 i = 0; i < x.length; i++) {
    _updateLandData(x[i], y[i], data);
  }
}

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 LANDRegistry._isUpdateAuthorized

Parameters

Name	Type
operator	address
assetId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _isUpdateAuthorized(address operator, uint256 assetId)
  internal
  view
  returns (bool)
{
  address owner = _ownerOf(assetId);

  return
    owner == operator ||
    updateOperator[assetId] == operator ||
    updateManager[owner][operator];
}

internal LANDRegistry._encodeTokenId

Parameters

Name	Type
x	int
y	int

Properties

Visibility internal

Mutability pure

Requirements

y must be less than 1000000

y must be greater than UNKNOWN VALUE

x must be less than 1000000

x must be greater than UNKNOWN VALUE

Source Code

function _encodeTokenId(int256 x, int256 y)
  internal
  pure
  returns (uint256 result)
{
  require(
    -1000000 < x && x < 1000000 && -1000000 < y && y < 1000000,
    "The coordinates should be inside bounds"
  );
  return _unsafeEncodeTokenId(x, y);
}

internal LANDRegistry._unsafeEncodeTokenId

Parameters

Name	Type
x	int
y	int

Properties

Visibility internal

Mutability pure

Source Code

function _unsafeEncodeTokenId(int256 x, int256 y)
  internal
  pure
  returns (uint256)
{
  return ((uint256(x) * factor) & clearLow) | (uint256(y) & clearHigh);
}

internal LANDRegistry._unsafeDecodeTokenId

Parameters

Name	Type
value	uint

Properties

Visibility internal

Mutability pure

Source Code

function _unsafeDecodeTokenId(uint256 value)
  internal
  pure
  returns (int256 x, int256 y)
{
  x = expandNegative128BitCast((value & clearLow) >> 128);
  y = expandNegative128BitCast(value & clearHigh);
}

internal LANDRegistry._decodeTokenId

Parameters

Name	Type
value	uint

Properties

Visibility internal

Mutability pure

Requirements

y must be less than 1000000

y must be greater than UNKNOWN VALUE

x must be less than 1000000

x must be greater than UNKNOWN VALUE

Source Code

function _decodeTokenId(uint256 value)
  internal
  pure
  returns (int256 x, int256 y)
{
  (x, y) = _unsafeDecodeTokenId(value);
  require(
    -1000000 < x && x < 1000000 && -1000000 < y && y < 1000000,
    "The coordinates should be inside bounds"
  );
}

internal LANDRegistry.expandNegative128BitCast

Parameters

Name	Type
value	uint

Properties

Visibility internal

Mutability pure

Source Code

function expandNegative128BitCast(uint256 value)
  internal
  pure
  returns (int256)
{
  if (value & (1 << 127) != 0) {
    return int256(value | clearLow);
  }
  return int256(value);
}

internal LANDRegistry._exists

Parameters

Name	Type
x	int
y	int

Properties

Visibility internal

Mutability view

Source Code

function _exists(int256 x, int256 y) internal view returns (bool) {
  return _exists(_encodeTokenId(x, y));
}

internal LANDRegistry._ownerOfLand

Parameters

Name	Type
x	int
y	int

Properties

Visibility internal

Mutability view

Source Code

function _ownerOfLand(int256 x, int256 y) internal view returns (address) {
  return _ownerOf(_encodeTokenId(x, y));
}

internal LANDRegistry._tokenMetadata

Parameters

Name	Type
assetId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _tokenMetadata(uint256 assetId) internal view returns (string) {
  address _owner = _ownerOf(assetId);
  if (_isContract(_owner) && _owner != address(estateRegistry)) {
    if ((ERC165(_owner)).supportsInterface(GET_METADATA)) {
      return IMetadataHolder(_owner).getMetadata(assetId);
    }
  }
  return _assetData[assetId];
}

internal LANDRegistry._createEstate

Parameters

Name	Type
x	int[]
y	int[]
beneficiary	address
metadata	string

Properties

Visibility internal

Mutability transaction

Requirements

the number of values in x must be greater than 0

the number of values in x must be equal to the number of values in y

UNKNOWN VALUE must not be equal to 0

Source Code

function _createEstate(
  int256[] x,
  int256[] y,
  address beneficiary,
  string metadata
) internal returns (uint256) {
  require(x.length > 0, "You should supply at least one coordinate");
  require(x.length == y.length, "The coordinates should have the same length");
  require(address(estateRegistry) != 0, "The Estate registry should be set");

  uint256 estateTokenId = estateRegistry.mint(beneficiary, metadata);
  bytes memory estateTokenIdBytes = toBytes(estateTokenId);

  for (uint256 i = 0; i < x.length; i++) {
    uint256 tokenId = _encodeTokenId(x[i], y[i]);
    _doTransferFrom(
      _ownerOf(tokenId),
      address(estateRegistry),
      tokenId,
      estateTokenIdBytes,
      true
    );
  }

  return estateTokenId;
}

internal LANDRegistry.toBytes

Parameters

Name	Type
x	uint256

Properties

Visibility internal

Mutability pure

Source Code

function toBytes(uint256 x) internal pure returns (bytes b) {
  b = new bytes(32);
  // solium-disable-next-line security/no-inline-assembly
  assembly {
    mstore(add(b, 32), x)
  }
}

internal LANDRegistry._updateLandData

Parameters

Name	Type
x	int
y	int
data	string

Properties

Visibility internal

Mutability transaction

Modifiers

onlyUpdateAuthorized checks for the following:

One or more of the following: -null - ORnull - OR the sender's address must be equal to the result of calling _ownerOf with UNKNOWN ARGUMENT

Source Code

function _updateLandData(
  int256 x,
  int256 y,
  string data
) internal onlyUpdateAuthorized(_encodeTokenId(x, y)) {
  uint256 assetId = _encodeTokenId(x, y);
  address owner = _holderOf[assetId];

  _update(assetId, data);

  emit Update(assetId, owner, msg.sender, data);
}

internal LANDRegistry._doTransferFrom

Parameters

Name	Type
from	address
to	address
assetId	uint256
userData	bytes
doCheck	bool

Properties

Visibility internal

Mutability transaction

Source Code

function _doTransferFrom(
  address from,
  address to,
  uint256 assetId,
  bytes userData,
  bool doCheck
) internal {
  updateOperator[assetId] = address(0);

  super._doTransferFrom(from, to, assetId, userData, doCheck);
}

internal LANDRegistry._isContract

Parameters

Name	Type
addr	address

Properties

Visibility internal

Mutability view

Source Code

function _isContract(address addr) internal view returns (bool) {
  uint256 size;
  // solium-disable-next-line security/no-inline-assembly
  assembly {
    size := extcodesize(addr)
  }
  return size > 0;
}

internal OwnableStorage.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  owner = msg.sender;
}

internal OwnableStorage.constructor

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability transaction

Source Code

constructor() internal {
  owner = msg.sender;
}

internal FullAssetRegistry._exists

Parameters

Name	Type
assetId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _exists(uint256 assetId) internal view returns (bool) {
  return _holderOf[assetId] != 0;
}

internal ERC721Base._totalSupply

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability view

Source Code

function _totalSupply() internal view returns (uint256) {
  return _count;
}

internal ERC721Base._ownerOf

Parameters

Name	Type
assetId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _ownerOf(uint256 assetId) internal view returns (address) {
  return _holderOf[assetId];
}

internal ERC721Base._balanceOf

Parameters

Name	Type
owner	address

Properties

Visibility internal

Mutability view

Source Code

function _balanceOf(address owner) internal view returns (uint256) {
  return _assetsOf[owner].length;
}

internal ERC721Base._isApprovedForAll

Parameters

Name	Type
assetHolder	address
operator	address

Properties

Visibility internal

Mutability view

Source Code

function _isApprovedForAll(address assetHolder, address operator)
  internal
  view
  returns (bool)
{
  return _operators[assetHolder][operator];
}

internal ERC721Base._getApprovedAddress

Parameters

Name	Type
assetId	uint256

Properties

Visibility internal

Mutability view

Source Code

function _getApprovedAddress(uint256 assetId) internal view returns (address) {
  return _approval[assetId];
}

internal ERC721Base._isAuthorized

Parameters

Name	Type
operator	address
assetId	uint256

Properties

Visibility internal

Mutability view

Requirements

operator must not be equal to 0

Source Code

function _isAuthorized(address operator, uint256 assetId)
  internal
  view
  returns (bool)
{
  require(operator != 0);
  address owner = _ownerOf(assetId);
  if (operator == owner) {
    return true;
  }
  return
    _isApprovedForAll(owner, operator) ||
    _getApprovedAddress(assetId) == operator;
}

internal ERC721Base._setApprovalForAll

Parameters

Name	Type
operator	address
authorized	bool

Properties

Visibility internal

Mutability transaction

Source Code

function _setApprovalForAll(address operator, bool authorized) internal {
  if (authorized) {
    require(!_isApprovedForAll(msg.sender, operator));
    _addAuthorization(operator, msg.sender);
  } else {
    require(_isApprovedForAll(msg.sender, operator));
    _clearAuthorization(operator, msg.sender);
  }
  emit ApprovalForAll(msg.sender, operator, authorized);
}

internal ERC721Base._addAuthorization

Parameters

Name	Type
operator	address
holder	address

Properties

Visibility private

Mutability transaction

Source Code

function _addAuthorization(address operator, address holder) private {
  _operators[holder][operator] = true;
}

internal ERC721Base._clearAuthorization

Parameters

Name	Type
operator	address
holder	address

Properties

Visibility private

Mutability transaction

Source Code

function _clearAuthorization(address operator, address holder) private {
  _operators[holder][operator] = false;
}

internal ERC721Base._addAssetTo

Parameters

Name	Type
to	address
assetId	uint256

Properties

Visibility internal

Mutability transaction

Source Code

function _addAssetTo(address to, uint256 assetId) internal {
  _holderOf[assetId] = to;

  uint256 length = _balanceOf(to);

  _assetsOf[to].push(assetId);

  _indexOfAsset[assetId] = length;

  _count = _count.add(1);
}

internal ERC721Base._removeAssetFrom

Parameters

Name	Type
from	address
assetId	uint256

Properties

Visibility internal

Mutability transaction

Source Code

function _removeAssetFrom(address from, uint256 assetId) internal {
  uint256 assetIndex = _indexOfAsset[assetId];
  uint256 lastAssetIndex = _balanceOf(from).sub(1);
  uint256 lastAssetId = _assetsOf[from][lastAssetIndex];

  _holderOf[assetId] = 0;

  // Insert the last asset into the position previously occupied by the asset to be removed
  _assetsOf[from][assetIndex] = lastAssetId;

  // Resize the array
  _assetsOf[from][lastAssetIndex] = 0;
  _assetsOf[from].length--;

  // Remove the array if no more assets are owned to prevent pollution
  if (_assetsOf[from].length == 0) {
    delete _assetsOf[from];
  }

  // Update the index of positions for the asset
  _indexOfAsset[assetId] = 0;
  _indexOfAsset[lastAssetId] = assetIndex;

  _count = _count.sub(1);
}

internal ERC721Base._clearApproval

Parameters

Name	Type
holder	address
assetId	uint256

Properties

Visibility internal

Mutability transaction

Source Code

function _clearApproval(address holder, uint256 assetId) internal {
  if (_ownerOf(assetId) == holder && _approval[assetId] != 0) {
    _approval[assetId] = 0;
    emit Approval(holder, 0, assetId);
  }
}

internal ERC721Base._generate

Parameters

Name	Type
assetId	uint256
beneficiary	address

Properties

Visibility internal

Mutability transaction

Requirements

_holderOf for the result of calling _encodeTokenId with x, y must be equal to 0

Source Code

function _generate(uint256 assetId, address beneficiary) internal {
  require(_holderOf[assetId] == 0);

  _addAssetTo(beneficiary, assetId);

  emit Transfer(0, beneficiary, assetId);
}

internal ERC721Base._destroy

Parameters

Name	Type
assetId	uint256

Properties

Visibility internal

Mutability transaction

Requirements

holder must not be equal to 0

Source Code

function _destroy(uint256 assetId) internal {
  address holder = _holderOf[assetId];
  require(holder != 0);

  _removeAssetFrom(holder, assetId);

  emit Transfer(holder, 0, assetId);
}

internal ERC721Base._doTransferFrom

Parameters

Name	Type
from	address
to	address
assetId	uint256
userData	bytes
doCheck	bool

Properties

Visibility internal

Mutability transaction

Modifiers

onlyAuthorized checks for the following:

null

Source Code

function _doTransferFrom(
  address from,
  address to,
  uint256 assetId,
  bytes userData,
  bool doCheck
) internal onlyAuthorized(assetId) {
  _moveToken(from, to, assetId, userData, doCheck);
}

internal ERC721Base._moveToken

Parameters

Name	Type
from	address
to	address
assetId	uint256
userData	bytes
doCheck	bool

Properties

Visibility private

Mutability transaction

Modifiers

isDestinataryDefined checks for the following:

to must not be equal to 0

destinataryIsNotHolder checks for the following:

to must not be equal to the result of calling _ownerOf with assetId

isCurrentOwner checks for the following:

from must be equal to the result of calling _ownerOf with assetId

Source Code

function _moveToken(
  address from,
  address to,
  uint256 assetId,
  bytes userData,
  bool doCheck
)
  private
  isDestinataryDefined(to)
  destinataryIsNotHolder(assetId, to)
  isCurrentOwner(from, assetId)
{
  address holder = _holderOf[assetId];
  _clearApproval(holder, assetId);
  _removeAssetFrom(holder, assetId);
  _addAssetTo(to, assetId);
  emit Transfer(holder, to, assetId);

  if (doCheck && _isContract(to)) {
    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))
    require(
      IERC721Receiver(to).onERC721Received(
        msg.sender,
        holder,
        assetId,
        userData
      ) == ERC721_RECEIVED
    );
  }
}

internal ERC721Base._isContract

Parameters

Name	Type
addr	address

Properties

Visibility internal

Mutability view

Source Code

function _isContract(address addr) internal view returns (bool) {
  uint256 size;
  assembly {
    size := extcodesize(addr)
  }
  return size > 0;
}

internal ERC721Metadata._update

Parameters

Name	Type
assetId	uint256
data	string

Properties

Visibility internal

Mutability transaction

Source Code

function _update(uint256 assetId, string data) internal {
  _assetData[assetId] = data;
}

Decentraland LAND

About

Stats

Events (12) 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.

DeployAuthorized Event

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

DeployForbidden Event

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

EstateRegistrySet Event

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

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

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

Update Event

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

UpdateManager Event

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

UpdateOperator Event

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

Constants (8) keyboard_arrow_up

GET_METADATA Constant

clearLow Constant

clearHigh Constant

factor Constant

ERC721_RECEIVED Constant

InterfaceId_ERC165 Constant

Old_InterfaceId_ERC721 Constant

InterfaceId_ERC721 Constant

State Variables (19) keyboard_arrow_up

currentContract Variable

proxyOwner Variable

owner Variable

estateRegistry Variable

latestPing Variable

updateOperator Variable

authorizedDeploy Variable

_name Variable

_symbol Variable

_description Variable

_count Variable

_assetsOf Variable

_holderOf Variable

_indexOfAsset Variable

_assetData Variable

_operators Variable

_approval Variable

_deprecated_authorizedDeploy Variable

updateManager Variable

Functions Expand All Collapse All

name 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

symbol 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

description 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

tokenMetadata 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

tokensOf 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

tokenOfOwnerByIndex keyboard_arrow_up

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

Events (12)

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Constants (8)

State Variables (19)

name

Parameters

symbol

Parameters

description

Parameters

tokenMetadata

Parameters

tokensOf

Parameters

tokenOfOwnerByIndex

Parameters

Requirements

totalSupply

Parameters

ownerOf

Parameters

balanceOf

Parameters

isApprovedForAll

Parameters

getApproved

Parameters

getApprovedAddress

Parameters

isAuthorized

Parameters

Requirements

setApprovalForAll

Parameters

approve

Parameters

Requirements

safeTransferFrom

Parameters

safeTransferFrom

Parameters

transferFrom

Parameters

Requirements

supportsInterface

Parameters

exists

Parameters

decimals

Parameters

transferOwnership

Parameters