diff --git a/contracts/AddressUtils.sol b/contracts/AddressUtils.sol new file mode 100644 index 00000000000..7a2c08e90a8 --- /dev/null +++ b/contracts/AddressUtils.sol @@ -0,0 +1,21 @@ +pragma solidity ^0.4.18; + +/** + * Utility library of inline functions on addresses + */ +library AddressUtils { + + /** + * Returns whether there is code in the target address + * @dev This function will return false if invoked during the constructor of a contract, + * as the code is not actually created until after the constructor finishes. + * @param addr address address to check + * @return whether there is code in the target address + */ + function isContract(address addr) internal view returns (bool) { + uint256 size; + assembly { size := extcodesize(addr) } + return size > 0; + } + +} diff --git a/contracts/mocks/ERC721BasicTokenMock.sol b/contracts/mocks/ERC721BasicTokenMock.sol new file mode 100644 index 00000000000..e4064a4d13b --- /dev/null +++ b/contracts/mocks/ERC721BasicTokenMock.sol @@ -0,0 +1,17 @@ +pragma solidity ^0.4.18; + +import "../token/ERC721/ERC721BasicToken.sol"; + +/** + * @title ERC721BasicTokenMock + * This mock just provides a public mint and burn functions for testing purposes + */ +contract ERC721BasicTokenMock is ERC721BasicToken { + function mint(address _to, uint256 _tokenId) public { + super._mint(_to, _tokenId); + } + + function burn(uint256 _tokenId) public { + super._burn(ownerOf(_tokenId), _tokenId); + } +} diff --git a/contracts/mocks/ERC721ReceiverMock.sol b/contracts/mocks/ERC721ReceiverMock.sol new file mode 100644 index 00000000000..3d7439578ff --- /dev/null +++ b/contracts/mocks/ERC721ReceiverMock.sol @@ -0,0 +1,21 @@ +pragma solidity ^0.4.18; + +import "../token/ERC721/ERC721Receiver.sol"; + +contract ERC721ReceiverMock is ERC721Receiver { + bytes4 retval; + bool reverts; + + event Received(address _address, uint256 _tokenId, bytes _data, uint256 _gas); + + function ERC721ReceiverMock(bytes4 _retval, bool _reverts) public { + retval = _retval; + reverts = _reverts; + } + + function onERC721Received(address _address, uint256 _tokenId, bytes _data) public returns(bytes4) { + require(!reverts); + Received(_address, _tokenId, _data, msg.gas); + return retval; + } +} diff --git a/contracts/mocks/ERC721TokenMock.sol b/contracts/mocks/ERC721TokenMock.sol index 5cb6cb67961..008a9335c1a 100644 --- a/contracts/mocks/ERC721TokenMock.sol +++ b/contracts/mocks/ERC721TokenMock.sol @@ -4,16 +4,23 @@ import "../token/ERC721/ERC721Token.sol"; /** * @title ERC721TokenMock - * This mock just provides a public mint and burn functions for testing purposes. + * This mock just provides a public mint and burn functions for testing purposes, + * and a public setter for metadata URI */ contract ERC721TokenMock is ERC721Token { - function ERC721TokenMock() ERC721Token() public { } + function ERC721TokenMock(string name, string symbol) public + ERC721Token(name, symbol) + { } function mint(address _to, uint256 _tokenId) public { super._mint(_to, _tokenId); } function burn(uint256 _tokenId) public { - super._burn(_tokenId); + super._burn(ownerOf(_tokenId), _tokenId); } -} + + function setTokenURI(uint256 _tokenId, string _uri) public { + super._setTokenURI(_tokenId, _uri); + } +} \ No newline at end of file diff --git a/contracts/token/ERC721/DeprecatedERC721.sol b/contracts/token/ERC721/DeprecatedERC721.sol new file mode 100644 index 00000000000..01b6c234a8d --- /dev/null +++ b/contracts/token/ERC721/DeprecatedERC721.sol @@ -0,0 +1,15 @@ +pragma solidity ^0.4.18; + +import "./ERC721.sol"; + +/** + * @title ERC-721 methods shipped in OpenZeppelin v1.7.0, removed in the latest version of the standard + * @dev Only use this interface for compatibility with previously deployed contracts + * @dev Use ERC721 for interacting with new contracts which are standard-compliant + */ +contract DeprecatedERC721 is ERC721 { + function takeOwnership(uint256 _tokenId) public; + function transfer(address _to, uint256 _tokenId) public; + function tokensOf(address _owner) public view returns (uint256[]); +} + diff --git a/contracts/token/ERC721/ERC721.sol b/contracts/token/ERC721/ERC721.sol index f88376f6110..a2fc4e324aa 100644 --- a/contracts/token/ERC721/ERC721.sol +++ b/contracts/token/ERC721/ERC721.sol @@ -1,16 +1,30 @@ pragma solidity ^0.4.18; +import "./ERC721Basic.sol"; + +/** + * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension + * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md + */ +contract ERC721Enumerable is ERC721Basic { + function totalSupply() public view returns (uint256); + function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId); + function tokenByIndex(uint256 _index) public view returns (uint256); +} + /** - * @title ERC721 interface - * @dev see https://github.com/ethereum/eips/issues/721 + * @title ERC-721 Non-Fungible Token Standard, optional metadata extension + * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ -contract ERC721 { - event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); - event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); +contract ERC721Metadata is ERC721Basic { + function name() public view returns (string _name); + function symbol() public view returns (string _symbol); + function tokenURI(uint256 _tokenId) public view returns (string); +} - function balanceOf(address _owner) public view returns (uint256 _balance); - function ownerOf(uint256 _tokenId) public view returns (address _owner); - function transfer(address _to, uint256 _tokenId) public; - function approve(address _to, uint256 _tokenId) public; - function takeOwnership(uint256 _tokenId) public; +/** + * @title ERC-721 Non-Fungible Token Standard, full implementation interface + * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md + */ +contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata { } diff --git a/contracts/token/ERC721/ERC721Basic.sol b/contracts/token/ERC721/ERC721Basic.sol new file mode 100644 index 00000000000..5ebbfc3cb41 --- /dev/null +++ b/contracts/token/ERC721/ERC721Basic.sol @@ -0,0 +1,25 @@ +pragma solidity ^0.4.18; + +/** + * @title ERC721 Non-Fungible Token Standard basic interface + * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md + */ +contract ERC721Basic { + event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); + event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); + event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); + + function balanceOf(address _owner) public view returns (uint256 _balance); + function ownerOf(uint256 _tokenId) public view returns (address _owner); + function exists(uint256 _tokenId) public view returns (bool _exists); + + function approve(address _to, uint256 _tokenId) public; + function getApproved(uint256 _tokenId) public view returns (address _operator); + + function setApprovalForAll(address _operator, bool _approved) public; + function isApprovedForAll(address _owner, address _operator) public view returns (bool); + + function transferFrom(address _from, address _to, uint256 _tokenId) public; + function safeTransferFrom(address _from, address _to, uint256 _tokenId) public; + function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public; +} diff --git a/contracts/token/ERC721/ERC721BasicToken.sol b/contracts/token/ERC721/ERC721BasicToken.sol new file mode 100644 index 00000000000..f6826a4650d --- /dev/null +++ b/contracts/token/ERC721/ERC721BasicToken.sol @@ -0,0 +1,270 @@ +pragma solidity ^0.4.18; + +import "./ERC721Basic.sol"; +import "./ERC721Receiver.sol"; +import "../../math/SafeMath.sol"; +import "../../AddressUtils.sol"; + +/** + * @title ERC721 Non-Fungible Token Standard basic implementation + * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md + */ +contract ERC721BasicToken is ERC721Basic { + using SafeMath for uint256; + using AddressUtils for address; + + // Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))` + // which can be also obtained as `ERC721Receiver(0).onERC721Received.selector` + bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba; + + // Mapping from token ID to owner + mapping (uint256 => address) internal tokenOwner; + + // Mapping from token ID to approved address + mapping (uint256 => address) internal tokenApprovals; + + // Mapping from owner to number of owned token + mapping (address => uint256) internal ownedTokensCount; + + // Mapping from owner to operator approvals + mapping (address => mapping (address => bool)) internal operatorApprovals; + + /** + * @dev Guarantees msg.sender is owner of the given token + * @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender + */ + modifier onlyOwnerOf(uint256 _tokenId) { + require(ownerOf(_tokenId) == msg.sender); + _; + } + + /** + * @dev Checks msg.sender can transfer a token, by being owner, approved, or operator + * @param _tokenId uint256 ID of the token to validate + */ + modifier canTransfer(uint256 _tokenId) { + require(isApprovedOrOwner(msg.sender, _tokenId)); + _; + } + + /** + * @dev Gets the balance of the specified address + * @param _owner address to query the balance of + * @return uint256 representing the amount owned by the passed address + */ + function balanceOf(address _owner) public view returns (uint256) { + require(_owner != address(0)); + return ownedTokensCount[_owner]; + } + + /** + * @dev Gets the owner of the specified token ID + * @param _tokenId uint256 ID of the token to query the owner of + * @return owner address currently marked as the owner of the given token ID + */ + function ownerOf(uint256 _tokenId) public view returns (address) { + address owner = tokenOwner[_tokenId]; + require(owner != address(0)); + return owner; + } + + /** + * @dev Returns whether the specified token exists + * @param _tokenId uint256 ID of the token to query the existance of + * @return whether the token exists + */ + function exists(uint256 _tokenId) public view returns (bool) { + address owner = tokenOwner[_tokenId]; + return owner != address(0); + } + + /** + * @dev Approves another address to transfer the given token ID + * @dev The zero address indicates there is no approved address. + * @dev There can only be one approved address per token at a given time. + * @dev Can only be called by the token owner or an approved operator. + * @param _to address to be approved for the given token ID + * @param _tokenId uint256 ID of the token to be approved + */ + function approve(address _to, uint256 _tokenId) public { + address owner = ownerOf(_tokenId); + require(_to != owner); + require(msg.sender == owner || isApprovedForAll(owner, msg.sender)); + + if (getApproved(_tokenId) != address(0) || _to != address(0)) { + tokenApprovals[_tokenId] = _to; + Approval(owner, _to, _tokenId); + } + } + + /** + * @dev Gets the approved address for a token ID, or zero if no address set + * @param _tokenId uint256 ID of the token to query the approval of + * @return address currently approved for a the given token ID + */ + function getApproved(uint256 _tokenId) public view returns (address) { + return tokenApprovals[_tokenId]; + } + + + /** + * @dev Sets or unsets the approval of a given operator + * @dev An operator is allowed to transfer all tokens of the sender on their behalf + * @param _to operator address to set the approval + * @param _approved representing the status of the approval to be set + */ + function setApprovalForAll(address _to, bool _approved) public { + require(_to != msg.sender); + operatorApprovals[msg.sender][_to] = _approved; + ApprovalForAll(msg.sender, _to, _approved); + } + + /** + * @dev Tells whether an operator is approved by a given owner + * @param _owner owner address which you want to query the approval of + * @param _operator operator address which you want to query the approval of + * @return bool whether the given operator is approved by the given owner + */ + function isApprovedForAll(address _owner, address _operator) public view returns (bool) { + return operatorApprovals[_owner][_operator]; + } + + /** + * @dev Transfers the ownership of a given token ID to another address + * @dev Usage of this method is discouraged, use `safeTransferFrom` whenever possible + * @dev Requires the msg sender to be the owner, approved, or operator + * @param _from current owner of the token + * @param _to address to receive the ownership of the given token ID + * @param _tokenId uint256 ID of the token to be transferred + */ + function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) { + require(_from != address(0)); + require(_to != address(0)); + + clearApproval(_from, _tokenId); + removeTokenFrom(_from, _tokenId); + addTokenTo(_to, _tokenId); + + Transfer(_from, _to, _tokenId); + } + + /** + * @dev Safely transfers the ownership of a given token ID to another address + * @dev If the target address is a contract, it must implement `onERC721Received`, + * which is called upon a safe transfer, and return the magic value + * `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise, + * the transfer is reverted. + * @dev Requires the msg sender to be the owner, approved, or operator + * @param _from current owner of the token + * @param _to address to receive the ownership of the given token ID + * @param _tokenId uint256 ID of the token to be transferred + */ + function safeTransferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) { + safeTransferFrom(_from, _to, _tokenId, ""); + } + + /** + * @dev Safely transfers the ownership of a given token ID to another address + * @dev If the target address is a contract, it must implement `onERC721Received`, + * which is called upon a safe transfer, and return the magic value + * `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise, + * the transfer is reverted. + * @dev Requires the msg sender to be the owner, approved, or operator + * @param _from current owner of the token + * @param _to address to receive the ownership of the given token ID + * @param _tokenId uint256 ID of the token to be transferred + * @param _data bytes data to send along with a safe transfer check + */ + function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public canTransfer(_tokenId) { + transferFrom(_from, _to, _tokenId); + require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data)); + } + + /** + * @dev Returns whether the given spender can transfer a given token ID + * @param _spender address of the spender to query + * @param _tokenId uint256 ID of the token to be transferred + * @return bool whether the msg.sender is approved for the given token ID, + * is an operator of the owner, or is the owner of the token + */ + function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) { + address owner = ownerOf(_tokenId); + return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender); + } + + /** + * @dev Internal function to mint a new token + * @dev Reverts if the given token ID already exists + * @param _to The address that will own the minted token + * @param _tokenId uint256 ID of the token to be minted by the msg.sender + */ + function _mint(address _to, uint256 _tokenId) internal { + require(_to != address(0)); + addTokenTo(_to, _tokenId); + Transfer(address(0), _to, _tokenId); + } + + /** + * @dev Internal function to burn a specific token + * @dev Reverts if the token does not exist + * @param _tokenId uint256 ID of the token being burned by the msg.sender + */ + function _burn(address _owner, uint256 _tokenId) internal { + clearApproval(_owner, _tokenId); + removeTokenFrom(_owner, _tokenId); + Transfer(_owner, address(0), _tokenId); + } + + /** + * @dev Internal function to clear current approval of a given token ID + * @dev Reverts if the given address is not indeed the owner of the token + * @param _owner owner of the token + * @param _tokenId uint256 ID of the token to be transferred + */ + function clearApproval(address _owner, uint256 _tokenId) internal { + require(ownerOf(_tokenId) == _owner); + if (tokenApprovals[_tokenId] != address(0)) { + tokenApprovals[_tokenId] = address(0); + Approval(_owner, address(0), _tokenId); + } + } + + /** + * @dev Internal function to add a token ID to the list of a given address + * @param _to address representing the new owner of the given token ID + * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address + */ + function addTokenTo(address _to, uint256 _tokenId) internal { + require(tokenOwner[_tokenId] == address(0)); + tokenOwner[_tokenId] = _to; + ownedTokensCount[_to] = ownedTokensCount[_to].add(1); + } + + /** + * @dev Internal function to remove a token ID from the list of a given address + * @param _from address representing the previous owner of the given token ID + * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address + */ + function removeTokenFrom(address _from, uint256 _tokenId) internal { + require(ownerOf(_tokenId) == _from); + ownedTokensCount[_from] = ownedTokensCount[_from].sub(1); + tokenOwner[_tokenId] = address(0); + } + + /** + * @dev Internal function to invoke `onERC721Received` on a target address + * @dev The call is not executed if the target address is not a contract + * @param _from address representing the previous owner of the given token ID + * @param _to target address that will receive the tokens + * @param _tokenId uint256 ID of the token to be transferred + * @param _data bytes optional data to send along with the call + * @return whether the call correctly returned the expected magic value + */ + function checkAndCallSafeTransfer(address _from, address _to, uint256 _tokenId, bytes _data) internal returns (bool) { + if (!_to.isContract()) { + return true; + } + bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data); + return (retval == ERC721_RECEIVED); + } +} diff --git a/contracts/token/ERC721/ERC721Holder.sol b/contracts/token/ERC721/ERC721Holder.sol new file mode 100644 index 00000000000..4bd4b0c7c0e --- /dev/null +++ b/contracts/token/ERC721/ERC721Holder.sol @@ -0,0 +1,9 @@ +pragma solidity ^0.4.18; + +import "./ERC721Receiver.sol"; + +contract ERC721Holder is ERC721Receiver { + function onERC721Received(address, uint256, bytes) public returns(bytes4) { + return ERC721_RECEIVED; + } +} diff --git a/contracts/token/ERC721/ERC721Receiver.sol b/contracts/token/ERC721/ERC721Receiver.sol new file mode 100644 index 00000000000..81154d379e9 --- /dev/null +++ b/contracts/token/ERC721/ERC721Receiver.sol @@ -0,0 +1,29 @@ +pragma solidity ^0.4.18; + +/** + * @title ERC721 token receiver interface + * @dev Interface for any contract that wants to support safeTransfers + * from ERC721 asset contracts. + */ +contract ERC721Receiver { + /** + * @dev Magic value to be returned upon successful reception of an NFT + * Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`, + * which can be also obtained as `ERC721Receiver(0).onERC721Received.selector` + */ + bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba; + + /** + * @notice Handle the receipt of an NFT + * @dev The ERC721 smart contract calls this function on the recipient + * after a `safetransfer`. This function MAY throw to revert and reject the + * transfer. This function MUST use 50,000 gas or less. Return of other + * than the magic value MUST result in the transaction being reverted. + * Note: the contract address is always the message sender. + * @param _from The sending address + * @param _tokenId The NFT identifier which is being transfered + * @param _data Additional data with no specified format + * @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))` + */ + function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4); +} diff --git a/contracts/token/ERC721/ERC721Token.sol b/contracts/token/ERC721/ERC721Token.sol index 4f8f268c3ba..495a071014f 100644 --- a/contracts/token/ERC721/ERC721Token.sol +++ b/contracts/token/ERC721/ERC721Token.sol @@ -1,176 +1,111 @@ pragma solidity ^0.4.18; import "./ERC721.sol"; -import "../../math/SafeMath.sol"; +import "./DeprecatedERC721.sol"; +import "./ERC721BasicToken.sol"; + /** - * @title ERC721Token - * Generic implementation for the required functionality of the ERC721 standard + * @title Full ERC721 Token + * This implementation includes all the required and some optional functionality of the ERC721 standard + * Moreover, it includes approve all functionality using operator terminology + * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ -contract ERC721Token is ERC721 { - using SafeMath for uint256; - - // Total amount of tokens - uint256 private totalTokens; +contract ERC721Token is ERC721, ERC721BasicToken { + // Token name + string internal name_; - // Mapping from token ID to owner - mapping (uint256 => address) private tokenOwner; - - // Mapping from token ID to approved address - mapping (uint256 => address) private tokenApprovals; + // Token symbol + string internal symbol_; // Mapping from owner to list of owned token IDs - mapping (address => uint256[]) private ownedTokens; + mapping (address => uint256[]) internal ownedTokens; // Mapping from token ID to index of the owner tokens list - mapping(uint256 => uint256) private ownedTokensIndex; + mapping(uint256 => uint256) internal ownedTokensIndex; - /** - * @dev Guarantees msg.sender is owner of the given token - * @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender - */ - modifier onlyOwnerOf(uint256 _tokenId) { - require(ownerOf(_tokenId) == msg.sender); - _; - } + // Array with all token ids, used for enumeration + uint256[] internal allTokens; - /** - * @dev Gets the total amount of tokens stored by the contract - * @return uint256 representing the total amount of tokens - */ - function totalSupply() public view returns (uint256) { - return totalTokens; - } + // Mapping from token id to position in the allTokens array + mapping(uint256 => uint256) internal allTokensIndex; - /** - * @dev Gets the balance of the specified address - * @param _owner address to query the balance of - * @return uint256 representing the amount owned by the passed address - */ - function balanceOf(address _owner) public view returns (uint256) { - return ownedTokens[_owner].length; - } - - /** - * @dev Gets the list of tokens owned by a given address - * @param _owner address to query the tokens of - * @return uint256[] representing the list of tokens owned by the passed address - */ - function tokensOf(address _owner) public view returns (uint256[]) { - return ownedTokens[_owner]; - } + // Optional mapping for token URIs + mapping(uint256 => string) internal tokenURIs; /** - * @dev Gets the owner of the specified token ID - * @param _tokenId uint256 ID of the token to query the owner of - * @return owner address currently marked as the owner of the given token ID + * @dev Constructor function */ - function ownerOf(uint256 _tokenId) public view returns (address) { - address owner = tokenOwner[_tokenId]; - require(owner != address(0)); - return owner; + function ERC721Token(string _name, string _symbol) public { + name_ = _name; + symbol_ = _symbol; } /** - * @dev Gets the approved address to take ownership of a given token ID - * @param _tokenId uint256 ID of the token to query the approval of - * @return address currently approved to take ownership of the given token ID - */ - function approvedFor(uint256 _tokenId) public view returns (address) { - return tokenApprovals[_tokenId]; - } - - /** - * @dev Transfers the ownership of a given token ID to another address - * @param _to address to receive the ownership of the given token ID - * @param _tokenId uint256 ID of the token to be transferred + * @dev Gets the token name + * @return string representing the token name */ - function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) { - clearApprovalAndTransfer(msg.sender, _to, _tokenId); + function name() public view returns (string) { + return name_; } /** - * @dev Approves another address to claim for the ownership of the given token ID - * @param _to address to be approved for the given token ID - * @param _tokenId uint256 ID of the token to be approved + * @dev Gets the token symbol + * @return string representing the token symbol */ - function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) { - address owner = ownerOf(_tokenId); - require(_to != owner); - if (approvedFor(_tokenId) != 0 || _to != 0) { - tokenApprovals[_tokenId] = _to; - Approval(owner, _to, _tokenId); - } + function symbol() public view returns (string) { + return symbol_; } /** - * @dev Claims the ownership of a given token ID - * @param _tokenId uint256 ID of the token being claimed by the msg.sender + * @dev Returns an URI for a given token ID + * @dev Throws if the token ID does not exist. May return an empty string. + * @param _tokenId uint256 ID of the token to query */ - function takeOwnership(uint256 _tokenId) public { - require(isApprovedFor(msg.sender, _tokenId)); - clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId); + function tokenURI(uint256 _tokenId) public view returns (string) { + require(exists(_tokenId)); + return tokenURIs[_tokenId]; } /** - * @dev Mint token function - * @param _to The address that will own the minted token - * @param _tokenId uint256 ID of the token to be minted by the msg.sender + * @dev Internal function to set the token URI for a given token + * @dev Reverts if the token ID does not exist + * @param _tokenId uint256 ID of the token to set its URI + * @param _uri string URI to assign */ - function _mint(address _to, uint256 _tokenId) internal { - require(_to != address(0)); - addToken(_to, _tokenId); - Transfer(0x0, _to, _tokenId); + function _setTokenURI(uint256 _tokenId, string _uri) internal { + require(exists(_tokenId)); + tokenURIs[_tokenId] = _uri; } /** - * @dev Burns a specific token - * @param _tokenId uint256 ID of the token being burned by the msg.sender + * @dev Gets the token ID at a given index of the tokens list of the requested owner + * @param _owner address owning the tokens list to be accessed + * @param _index uint256 representing the index to be accessed of the requested tokens list + * @return uint256 token ID at the given index of the tokens list owned by the requested address */ - function _burn(uint256 _tokenId) onlyOwnerOf(_tokenId) internal { - if (approvedFor(_tokenId) != 0) { - clearApproval(msg.sender, _tokenId); - } - removeToken(msg.sender, _tokenId); - Transfer(msg.sender, 0x0, _tokenId); + function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) { + require(_index < balanceOf(_owner)); + return ownedTokens[_owner][_index]; } /** - * @dev Tells whether the msg.sender is approved for the given token ID or not - * This function is not private so it can be extended in further implementations like the operatable ERC721 - * @param _owner address of the owner to query the approval of - * @param _tokenId uint256 ID of the token to query the approval of - * @return bool whether the msg.sender is approved for the given token ID or not - */ - function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) { - return approvedFor(_tokenId) == _owner; - } - - /** - * @dev Internal function to clear current approval and transfer the ownership of a given token ID - * @param _from address which you want to send tokens from - * @param _to address which you want to transfer the token to - * @param _tokenId uint256 ID of the token to be transferred + * @dev Gets the total amount of tokens stored by the contract + * @return uint256 representing the total amount of tokens */ - function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal { - require(_to != address(0)); - require(_to != ownerOf(_tokenId)); - require(ownerOf(_tokenId) == _from); - - clearApproval(_from, _tokenId); - removeToken(_from, _tokenId); - addToken(_to, _tokenId); - Transfer(_from, _to, _tokenId); + function totalSupply() public view returns (uint256) { + return allTokens.length; } /** - * @dev Internal function to clear current approval of a given token ID - * @param _tokenId uint256 ID of the token to be transferred + * @dev Gets the token ID at a given index of all the tokens in this contract + * @dev Reverts if the index is greater or equal to the total number of tokens + * @param _index uint256 representing the index to be accessed of the tokens list + * @return uint256 token ID at the given index of the tokens list */ - function clearApproval(address _owner, uint256 _tokenId) private { - require(ownerOf(_tokenId) == _owner); - tokenApprovals[_tokenId] = 0; - Approval(_owner, 0, _tokenId); + function tokenByIndex(uint256 _index) public view returns (uint256) { + require(_index < totalSupply()); + return allTokens[_index]; } /** @@ -178,13 +113,11 @@ contract ERC721Token is ERC721 { * @param _to address representing the new owner of the given token ID * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address */ - function addToken(address _to, uint256 _tokenId) private { - require(tokenOwner[_tokenId] == address(0)); - tokenOwner[_tokenId] = _to; - uint256 length = balanceOf(_to); + function addTokenTo(address _to, uint256 _tokenId) internal { + super.addTokenTo(_to, _tokenId); + uint256 length = ownedTokens[_to].length; ownedTokens[_to].push(_tokenId); ownedTokensIndex[_tokenId] = length; - totalTokens = totalTokens.add(1); } /** @@ -192,14 +125,13 @@ contract ERC721Token is ERC721 { * @param _from address representing the previous owner of the given token ID * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address */ - function removeToken(address _from, uint256 _tokenId) private { - require(ownerOf(_tokenId) == _from); + function removeTokenFrom(address _from, uint256 _tokenId) internal { + super.removeTokenFrom(_from, _tokenId); uint256 tokenIndex = ownedTokensIndex[_tokenId]; - uint256 lastTokenIndex = balanceOf(_from).sub(1); + uint256 lastTokenIndex = ownedTokens[_from].length.sub(1); uint256 lastToken = ownedTokens[_from][lastTokenIndex]; - tokenOwner[_tokenId] = 0; ownedTokens[_from][tokenIndex] = lastToken; ownedTokens[_from][lastTokenIndex] = 0; // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to @@ -209,6 +141,46 @@ contract ERC721Token is ERC721 { ownedTokens[_from].length--; ownedTokensIndex[_tokenId] = 0; ownedTokensIndex[lastToken] = tokenIndex; - totalTokens = totalTokens.sub(1); } + + /** + * @dev Internal function to mint a new token + * @dev Reverts if the given token ID already exists + * @param _to address the beneficiary that will own the minted token + * @param _tokenId uint256 ID of the token to be minted by the msg.sender + */ + function _mint(address _to, uint256 _tokenId) internal { + super._mint(_to, _tokenId); + + allTokensIndex[_tokenId] = allTokens.length; + allTokens.push(_tokenId); + } + + /** + * @dev Internal function to burn a specific token + * @dev Reverts if the token does not exist + * @param _owner owner of the token to burn + * @param _tokenId uint256 ID of the token being burned by the msg.sender + */ + function _burn(address _owner, uint256 _tokenId) internal { + super._burn(_owner, _tokenId); + + // Clear metadata (if any) + if (bytes(tokenURIs[_tokenId]).length != 0) { + delete tokenURIs[_tokenId]; + } + + // Reorg all tokens array + uint256 tokenIndex = allTokensIndex[_tokenId]; + uint256 lastTokenIndex = allTokens.length.sub(1); + uint256 lastToken = allTokens[lastTokenIndex]; + + allTokens[tokenIndex] = lastToken; + allTokens[lastTokenIndex] = 0; + + allTokens.length--; + allTokensIndex[_tokenId] = 0; + allTokensIndex[lastToken] = tokenIndex; + } + } diff --git a/test/helpers/sendTransaction.js b/test/helpers/sendTransaction.js new file mode 100644 index 00000000000..3d28117466b --- /dev/null +++ b/test/helpers/sendTransaction.js @@ -0,0 +1,17 @@ +const _ = require('lodash'); +const ethjsABI = require('ethjs-abi'); + +export function findMethod (abi, name, args) { + for (var i = 0; i < abi.length; i++) { + const methodArgs = _.map(abi[i].inputs, 'type').join(','); + if ((abi[i].name === name) && (methodArgs === args)) { + return abi[i]; + } + } +} + +export default function sendTransaction (target, name, argsTypes, argsValues, opts) { + const abiMethod = findMethod(target.abi, name, argsTypes); + const encodedData = ethjsABI.encodeMethod(abiMethod, argsValues); + return target.sendTransaction(Object.assign({ data: encodedData }, opts)); +} diff --git a/test/token/ERC721/ERC721BasicToken.behaviour.js b/test/token/ERC721/ERC721BasicToken.behaviour.js new file mode 100644 index 00000000000..82df925424d --- /dev/null +++ b/test/token/ERC721/ERC721BasicToken.behaviour.js @@ -0,0 +1,541 @@ +import assertRevert from '../../helpers/assertRevert'; +import decodeLogs from '../../helpers/decodeLogs'; +import sendTransaction from '../../helpers/sendTransaction'; +import _ from 'lodash'; + +const ERC721Receiver = artifacts.require('ERC721ReceiverMock.sol'); +const BigNumber = web3.BigNumber; + +require('chai') + .use(require('chai-as-promised')) + .use(require('chai-bignumber')(BigNumber)) + .should(); + +export default function shouldBehaveLikeERC721BasicToken (accounts) { + const firstTokenId = 1; + const secondTokenId = 2; + const unknownTokenId = 3; + const creator = accounts[0]; + const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'; + const RECEIVER_MAGIC_VALUE = '0xf0b9e5ba'; + + describe('like a ERC721BasicToken', function () { + beforeEach(async function () { + await this.token.mint(creator, firstTokenId, { from: creator }); + await this.token.mint(creator, secondTokenId, { from: creator }); + }); + + describe('balanceOf', function () { + describe('when the given address owns some tokens', function () { + it('returns the amount of tokens owned by the given address', async function () { + const balance = await this.token.balanceOf(creator); + balance.should.be.bignumber.equal(2); + }); + }); + + describe('when the given address does not own any tokens', function () { + it('returns 0', async function () { + const balance = await this.token.balanceOf(accounts[1]); + balance.should.be.bignumber.equal(0); + }); + }); + + describe('when querying the zero address', function () { + it('throws', async function () { + await assertRevert(this.token.balanceOf(0)); + }); + }); + }); + + describe('exists', function () { + describe('when the token exists', function () { + const tokenId = firstTokenId; + + it('should return true', async function () { + const result = await this.token.exists(tokenId); + result.should.be.true; + }); + }); + + describe('when the token does not exist', function () { + const tokenId = unknownTokenId; + + it('should return false', async function () { + const result = await this.token.exists(tokenId); + result.should.be.false; + }); + }); + }); + + describe('ownerOf', function () { + describe('when the given token ID was tracked by this token', function () { + const tokenId = firstTokenId; + + it('returns the owner of the given token ID', async function () { + const owner = await this.token.ownerOf(tokenId); + owner.should.be.equal(creator); + }); + }); + + describe('when the given token ID was not tracked by this token', function () { + const tokenId = unknownTokenId; + + it('reverts', async function () { + await assertRevert(this.token.ownerOf(tokenId)); + }); + }); + }); + + describe('transfers', function () { + const owner = accounts[0]; + const approved = accounts[2]; + const operator = accounts[3]; + const unauthorized = accounts[4]; + const tokenId = firstTokenId; + const data = '0x42'; + + let logs = null; + + beforeEach(async function () { + this.to = accounts[1]; + await this.token.approve(approved, tokenId, { from: owner }); + await this.token.setApprovalForAll(operator, true, { from: owner }); + }); + + const transferWasSuccessful = function ({ owner, tokenId, approved }) { + it('transfers the ownership of the given token ID to the given address', async function () { + const newOwner = await this.token.ownerOf(tokenId); + newOwner.should.be.equal(this.to); + }); + + it('clears the approval for the token ID', async function () { + const approvedAccount = await this.token.getApproved(tokenId); + approvedAccount.should.be.equal(ZERO_ADDRESS); + }); + + if (approved) { + it('emits an approval and transfer events', async function () { + logs.length.should.be.equal(2); + logs[0].event.should.be.eq('Approval'); + logs[0].args._owner.should.be.equal(owner); + logs[0].args._approved.should.be.equal(ZERO_ADDRESS); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + + logs[1].event.should.be.eq('Transfer'); + logs[1].args._from.should.be.equal(owner); + logs[1].args._to.should.be.equal(this.to); + logs[1].args._tokenId.should.be.bignumber.equal(tokenId); + }); + } else { + it('emits only a transfer event', async function () { + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('Transfer'); + logs[0].args._from.should.be.equal(owner); + logs[0].args._to.should.be.equal(this.to); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + }); + } + + it('adjusts owners balances', async function () { + const newOwnerBalance = await this.token.balanceOf(this.to); + newOwnerBalance.should.be.bignumber.equal(1); + + const previousOwnerBalance = await this.token.balanceOf(owner); + previousOwnerBalance.should.be.bignumber.equal(1); + }); + + it('adjusts owners tokens by index', async function () { + if (!this.token.tokenOfOwnerByIndex) return; + + const newOwnerToken = await this.token.tokenOfOwnerByIndex(this.to, 0); + newOwnerToken.toNumber().should.be.equal(tokenId); + + const previousOwnerToken = await this.token.tokenOfOwnerByIndex(owner, 0); + previousOwnerToken.toNumber().should.not.be.equal(tokenId); + }); + }; + + const shouldTransferTokensByUsers = function (transferFunction) { + describe('when called by the owner', function () { + beforeEach(async function () { + ({ logs } = await transferFunction.call(this, owner, this.to, tokenId, { from: owner })); + }); + transferWasSuccessful({ owner, tokenId, approved }); + }); + + describe('when called by the approved individual', function () { + beforeEach(async function () { + ({ logs } = await transferFunction.call(this, owner, this.to, tokenId, { from: approved })); + }); + transferWasSuccessful({ owner, tokenId, approved }); + }); + + describe('when called by the operator', function () { + beforeEach(async function () { + ({ logs } = await transferFunction.call(this, owner, this.to, tokenId, { from: operator })); + }); + transferWasSuccessful({ owner, tokenId, approved }); + }); + + describe('when called by the owner without an approved user', function () { + beforeEach(async function () { + await this.token.approve(ZERO_ADDRESS, tokenId, { from: owner }); + ({ logs } = await transferFunction.call(this, owner, this.to, tokenId, { from: operator })); + }); + transferWasSuccessful({ owner, tokenId, approved: null }); + }); + + describe('when sent to the owner', function () { + beforeEach(async function () { + ({ logs } = await transferFunction.call(this, owner, owner, tokenId, { from: owner })); + }); + + it('keeps ownership of the token', async function () { + const newOwner = await this.token.ownerOf(tokenId); + newOwner.should.be.equal(owner); + }); + + it('clears the approval for the token ID', async function () { + const approvedAccount = await this.token.getApproved(tokenId); + approvedAccount.should.be.equal(ZERO_ADDRESS); + }); + + it('emits an approval and transfer events', async function () { + logs.length.should.be.equal(2); + logs[0].event.should.be.eq('Approval'); + logs[0].args._owner.should.be.equal(owner); + logs[0].args._approved.should.be.equal(ZERO_ADDRESS); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + + logs[1].event.should.be.eq('Transfer'); + logs[1].args._from.should.be.equal(owner); + logs[1].args._to.should.be.equal(owner); + logs[1].args._tokenId.should.be.bignumber.equal(tokenId); + }); + + it('keeps the owner balance', async function () { + const ownerBalance = await this.token.balanceOf(owner); + ownerBalance.should.be.bignumber.equal(2); + }); + + it('keeps same tokens by index', async function () { + if (!this.token.tokenOfOwnerByIndex) return; + const tokensListed = await Promise.all(_.range(2).map(i => this.token.tokenOfOwnerByIndex(owner, i))); + tokensListed.map(t => t.toNumber()).should.have.members([firstTokenId, secondTokenId]); + }); + }); + + describe('when the address of the previous owner is incorrect', function () { + it('reverts', async function () { + await assertRevert(transferFunction.call(this, unauthorized, this.to, tokenId, { from: owner })); + }); + }); + + describe('when the sender is not authorized for the token id', function () { + it('reverts', async function () { + await assertRevert(transferFunction.call(this, owner, this.to, tokenId, { from: unauthorized })); + }); + }); + + describe('when the given token ID does not exist', function () { + it('reverts', async function () { + await assertRevert(transferFunction.call(this, owner, this.to, unknownTokenId, { from: owner })); + }); + }); + + describe('when the address to transfer the token to is the zero address', function () { + it('reverts', async function () { + await assertRevert(transferFunction.call(this, owner, ZERO_ADDRESS, tokenId, { from: owner })); + }); + }); + }; + + describe('via transferFrom', function () { + shouldTransferTokensByUsers(function (from, to, tokenId, opts) { + return this.token.transferFrom(from, to, tokenId, opts); + }); + }); + + describe('via safeTransferFrom', function () { + const safeTransferFromWithData = function (from, to, tokenId, opts) { + return sendTransaction( + this.token, + 'safeTransferFrom', + 'address,address,uint256,bytes', + [from, to, tokenId, data], + opts + ); + }; + + const safeTransferFromWithoutData = function (from, to, tokenId, opts) { + return this.token.safeTransferFrom(from, to, tokenId, opts); + }; + + const shouldTransferSafely = function (transferFun, data) { + describe('to a user account', function () { + shouldTransferTokensByUsers(transferFun); + }); + + describe('to a valid receiver contract', function () { + beforeEach(async function () { + this.receiver = await ERC721Receiver.new(RECEIVER_MAGIC_VALUE, false); + this.to = this.receiver.address; + }); + + shouldTransferTokensByUsers(transferFun); + + it('should call onERC721Received', async function () { + const result = await transferFun.call(this, owner, this.to, tokenId, { from: owner }); + result.receipt.logs.length.should.be.equal(3); + const [log] = decodeLogs([result.receipt.logs[2]], ERC721Receiver, this.receiver.address); + log.event.should.be.eq('Received'); + log.args._address.should.be.equal(owner); + log.args._tokenId.toNumber().should.be.equal(tokenId); + log.args._data.should.be.equal(data); + }); + }); + }; + + describe('with data', function () { + shouldTransferSafely(safeTransferFromWithData, data); + }); + + describe('without data', function () { + shouldTransferSafely(safeTransferFromWithoutData, '0x'); + }); + + describe('to a receiver contract returning unexpected value', function () { + it('reverts', async function () { + const invalidReceiver = await ERC721Receiver.new('0x42', false); + await assertRevert(this.token.safeTransferFrom(owner, invalidReceiver.address, tokenId, { from: owner })); + }); + }); + + describe('to a receiver contract that throws', function () { + it('reverts', async function () { + const invalidReceiver = await ERC721Receiver.new(RECEIVER_MAGIC_VALUE, true); + await assertRevert(this.token.safeTransferFrom(owner, invalidReceiver.address, tokenId, { from: owner })); + }); + }); + + describe('to a contract that does not implement the required function', function () { + it('reverts', async function () { + const invalidReceiver = this.token; + await assertRevert(this.token.safeTransferFrom(owner, invalidReceiver.address, tokenId, { from: owner })); + }); + }); + }); + }); + + describe('approve', function () { + const tokenId = firstTokenId; + const sender = creator; + const to = accounts[1]; + + let logs = null; + + const itClearsApproval = function () { + it('clears approval for the token', async function () { + const approvedAccount = await this.token.getApproved(tokenId); + approvedAccount.should.be.equal(ZERO_ADDRESS); + }); + }; + + const itApproves = function (address) { + it('sets the approval for the target address', async function () { + const approvedAccount = await this.token.getApproved(tokenId); + approvedAccount.should.be.equal(address); + }); + }; + + const itEmitsApprovalEvent = function (address) { + it('emits an approval event', async function () { + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('Approval'); + logs[0].args._owner.should.be.equal(sender); + logs[0].args._approved.should.be.equal(address); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + }); + }; + + describe('when clearing approval', function () { + describe('when there was no prior approval', function () { + beforeEach(async function () { + ({ logs } = await this.token.approve(ZERO_ADDRESS, tokenId, { from: sender })); + }); + + itClearsApproval(); + + it('does not emit an approval event', async function () { + logs.length.should.be.equal(0); + }); + }); + + describe('when there was a prior approval', function () { + beforeEach(async function () { + await this.token.approve(to, tokenId, { from: sender }); + ({ logs } = await this.token.approve(ZERO_ADDRESS, tokenId, { from: sender })); + }); + + itClearsApproval(); + itEmitsApprovalEvent(ZERO_ADDRESS); + }); + }); + + describe('when approving a non-zero address', function () { + describe('when there was no prior approval', function () { + beforeEach(async function () { + ({ logs } = await this.token.approve(to, tokenId, { from: sender })); + }); + + itApproves(to); + itEmitsApprovalEvent(to); + }); + + describe('when there was a prior approval to the same address', function () { + beforeEach(async function () { + await this.token.approve(to, tokenId, { from: sender }); + ({ logs } = await this.token.approve(to, tokenId, { from: sender })); + }); + + itApproves(to); + itEmitsApprovalEvent(to); + }); + + describe('when there was a prior approval to a different address', function () { + beforeEach(async function () { + await this.token.approve(accounts[2], tokenId, { from: sender }); + ({ logs } = await this.token.approve(to, tokenId, { from: sender })); + }); + + itApproves(to); + itEmitsApprovalEvent(to); + }); + }); + + describe('when the address that receives the approval is the owner', function () { + it('reverts', async function () { + await assertRevert(this.token.approve(sender, tokenId, { from: sender })); + }); + }); + + describe('when the sender does not own the given token ID', function () { + it('reverts', async function () { + await assertRevert(this.token.approve(to, tokenId, { from: accounts[2] })); + }); + }); + + describe('when the sender is approved for the given token ID', function () { + it('reverts', async function () { + await this.token.approve(accounts[2], tokenId, { from: sender }); + await assertRevert(this.token.approve(to, tokenId, { from: accounts[2] })); + }); + }); + + describe('when the sender is an operator', function () { + const operator = accounts[2]; + beforeEach(async function () { + await this.token.setApprovalForAll(operator, true, { from: sender }); + ({ logs } = await this.token.approve(to, tokenId, { from: operator })); + }); + + itApproves(to); + itEmitsApprovalEvent(to); + }); + + describe('when the given token ID does not exist', function () { + it('reverts', async function () { + await assertRevert(this.token.approve(to, unknownTokenId, { from: sender })); + }); + }); + }); + + describe('setApprovalForAll', function () { + const sender = creator; + + describe('when the operator willing to approve is not the owner', function () { + const operator = accounts[1]; + + describe('when there is no operator approval set by the sender', function () { + it('approves the operator', async function () { + await this.token.setApprovalForAll(operator, true, { from: sender }); + + const isApproved = await this.token.isApprovedForAll(sender, operator); + isApproved.should.be.true; + }); + + it('emits an approval event', async function () { + const { logs } = await this.token.setApprovalForAll(operator, true, { from: sender }); + + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('ApprovalForAll'); + logs[0].args._owner.should.be.equal(sender); + logs[0].args._operator.should.be.equal(operator); + logs[0].args._approved.should.be.true; + }); + }); + + describe('when the operator was set as not approved', function () { + beforeEach(async function () { + await this.token.setApprovalForAll(operator, false, { from: sender }); + }); + + it('approves the operator', async function () { + await this.token.setApprovalForAll(operator, true, { from: sender }); + + const isApproved = await this.token.isApprovedForAll(sender, operator); + isApproved.should.be.true; + }); + + it('emits an approval event', async function () { + const { logs } = await this.token.setApprovalForAll(operator, true, { from: sender }); + + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('ApprovalForAll'); + logs[0].args._owner.should.be.equal(sender); + logs[0].args._operator.should.be.equal(operator); + logs[0].args._approved.should.be.true; + }); + + it('can unset the operator approval', async function () { + await this.token.setApprovalForAll(operator, false, { from: sender }); + + const isApproved = await this.token.isApprovedForAll(sender, operator); + isApproved.should.be.false; + }); + }); + + describe('when the operator was already approved', function () { + beforeEach(async function () { + await this.token.setApprovalForAll(operator, true, { from: sender }); + }); + + it('keeps the approval to the given address', async function () { + await this.token.setApprovalForAll(operator, true, { from: sender }); + + const isApproved = await this.token.isApprovedForAll(sender, operator); + isApproved.should.be.true; + }); + + it('emits an approval event', async function () { + const { logs } = await this.token.setApprovalForAll(operator, true, { from: sender }); + + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('ApprovalForAll'); + logs[0].args._owner.should.be.equal(sender); + logs[0].args._operator.should.be.equal(operator); + logs[0].args._approved.should.be.true; + }); + }); + }); + + describe('when the operator is the owner', function () { + const operator = creator; + + it('reverts', async function () { + await assertRevert(this.token.setApprovalForAll(operator, true, { from: sender })); + }); + }); + }); + }); +}; diff --git a/test/token/ERC721/ERC721BasicToken.test.js b/test/token/ERC721/ERC721BasicToken.test.js new file mode 100644 index 00000000000..05666f5aa27 --- /dev/null +++ b/test/token/ERC721/ERC721BasicToken.test.js @@ -0,0 +1,19 @@ +import shouldBehaveLikeERC721BasicToken from './ERC721BasicToken.behaviour'; +import shouldMintAndBurnERC721Token from './ERC721MintBurn.behaviour'; + +const BigNumber = web3.BigNumber; +const ERC721BasicToken = artifacts.require('ERC721BasicTokenMock.sol'); + +require('chai') + .use(require('chai-as-promised')) + .use(require('chai-bignumber')(BigNumber)) + .should(); + +contract('ERC721BasicToken', function (accounts) { + beforeEach(async function () { + this.token = await ERC721BasicToken.new({ from: accounts[0] }); + }); + + shouldBehaveLikeERC721BasicToken(accounts); + shouldMintAndBurnERC721Token(accounts); +}); diff --git a/test/token/ERC721/ERC721MintBurn.behaviour.js b/test/token/ERC721/ERC721MintBurn.behaviour.js new file mode 100644 index 00000000000..e0a033d5061 --- /dev/null +++ b/test/token/ERC721/ERC721MintBurn.behaviour.js @@ -0,0 +1,122 @@ +import assertRevert from '../../helpers/assertRevert'; +const BigNumber = web3.BigNumber; + +require('chai') + .use(require('chai-as-promised')) + .use(require('chai-bignumber')(BigNumber)) + .should(); + +export default function shouldMintAndBurnERC721Token (accounts) { + const firstTokenId = 1; + const secondTokenId = 2; + const unknownTokenId = 3; + const creator = accounts[0]; + const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'; + + describe('like a mintable and burnable ERC721Token', function () { + beforeEach(async function () { + await this.token.mint(creator, firstTokenId, { from: creator }); + await this.token.mint(creator, secondTokenId, { from: creator }); + }); + + describe('mint', function () { + const to = accounts[1]; + const tokenId = unknownTokenId; + let logs = null; + + describe('when successful', function () { + beforeEach(async function () { + const result = await this.token.mint(to, tokenId); + logs = result.logs; + }); + + it('assigns the token to the new owner', async function () { + const owner = await this.token.ownerOf(tokenId); + owner.should.be.equal(to); + }); + + it('increases the balance of its owner', async function () { + const balance = await this.token.balanceOf(to); + balance.should.be.bignumber.equal(1); + }); + + it('emits a transfer event', async function () { + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('Transfer'); + logs[0].args._from.should.be.equal(ZERO_ADDRESS); + logs[0].args._to.should.be.equal(to); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + }); + }); + + describe('when the given owner address is the zero address', function () { + it('reverts', async function () { + await assertRevert(this.token.mint(ZERO_ADDRESS, tokenId)); + }); + }); + + describe('when the given token ID was already tracked by this contract', function () { + it('reverts', async function () { + await assertRevert(this.token.mint(accounts[1], firstTokenId)); + }); + }); + }); + + describe('burn', function () { + const tokenId = firstTokenId; + const sender = creator; + let logs = null; + + describe('when successful', function () { + beforeEach(async function () { + const result = await this.token.burn(tokenId, { from: sender }); + logs = result.logs; + }); + + it('burns the given token ID and adjusts the balance of the owner', async function () { + await assertRevert(this.token.ownerOf(tokenId)); + const balance = await this.token.balanceOf(sender); + balance.should.be.bignumber.equal(1); + }); + + it('emits a burn event', async function () { + logs.length.should.be.equal(1); + logs[0].event.should.be.eq('Transfer'); + logs[0].args._from.should.be.equal(sender); + logs[0].args._to.should.be.equal(ZERO_ADDRESS); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + }); + }); + + describe('when there is a previous approval', function () { + beforeEach(async function () { + await this.token.approve(accounts[1], tokenId, { from: sender }); + const result = await this.token.burn(tokenId, { from: sender }); + logs = result.logs; + }); + + it('clears the approval', async function () { + const approvedAccount = await this.token.getApproved(tokenId); + approvedAccount.should.be.equal(ZERO_ADDRESS); + }); + + it('emits an approval event', async function () { + logs.length.should.be.equal(2); + + logs[0].event.should.be.eq('Approval'); + logs[0].args._owner.should.be.equal(sender); + logs[0].args._approved.should.be.equal(ZERO_ADDRESS); + logs[0].args._tokenId.should.be.bignumber.equal(tokenId); + + logs[1].event.should.be.eq('Transfer'); + }); + }); + + describe('when the given token ID was not tracked by this contract', function () { + it('reverts', async function () { + await assertRevert(this.token.burn(unknownTokenId, { from: creator })); + }); + }); + }); + }); +}; diff --git a/test/token/ERC721/ERC721Token.test.js b/test/token/ERC721/ERC721Token.test.js index cb6546f4246..a1aabc24141 100644 --- a/test/token/ERC721/ERC721Token.test.js +++ b/test/token/ERC721/ERC721Token.test.js @@ -1,4 +1,8 @@ import assertRevert from '../../helpers/assertRevert'; +import shouldBehaveLikeERC721BasicToken from './ERC721BasicToken.behaviour'; +import shouldMintAndBurnERC721Token from './ERC721MintBurn.behaviour'; +import _ from 'lodash'; + const BigNumber = web3.BigNumber; const ERC721Token = artifacts.require('ERC721TokenMock.sol'); @@ -7,527 +11,188 @@ require('chai') .use(require('chai-bignumber')(BigNumber)) .should(); -contract('ERC721Token', accounts => { - let token = null; - const _firstTokenId = 1; - const _secondTokenId = 2; - const _unknownTokenId = 3; - const _creator = accounts[0]; - const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'; +contract('ERC721Token', function (accounts) { + const name = 'Non Fungible Token'; + const symbol = 'NFT'; + const firstTokenId = 100; + const secondTokenId = 200; + const creator = accounts[0]; beforeEach(async function () { - token = await ERC721Token.new({ from: _creator }); - await token.mint(_creator, _firstTokenId, { from: _creator }); - await token.mint(_creator, _secondTokenId, { from: _creator }); + this.token = await ERC721Token.new(name, symbol, { from: creator }); }); - describe('totalSupply', function () { - it('has a total supply equivalent to the inital supply', async function () { - const totalSupply = await token.totalSupply(); - totalSupply.should.be.bignumber.equal(2); - }); - }); - - describe('balanceOf', function () { - describe('when the given address owns some tokens', function () { - it('returns the amount of tokens owned by the given address', async function () { - const balance = await token.balanceOf(_creator); - balance.should.be.bignumber.equal(2); - }); - }); + shouldBehaveLikeERC721BasicToken(accounts); + shouldMintAndBurnERC721Token(accounts); - describe('when the given address does not own any tokens', function () { - it('returns 0', async function () { - const balance = await token.balanceOf(accounts[1]); - balance.should.be.bignumber.equal(0); - }); + describe('like a full ERC721', function () { + beforeEach(async function () { + await this.token.mint(creator, firstTokenId, { from: creator }); + await this.token.mint(creator, secondTokenId, { from: creator }); }); - }); - describe('ownerOf', function () { - describe('when the given token ID was tracked by this token', function () { - const tokenId = _firstTokenId; + describe('mint', function () { + const to = accounts[1]; + const tokenId = 3; - it('returns the owner of the given token ID', async function () { - const owner = await token.ownerOf(tokenId); - owner.should.be.equal(_creator); + beforeEach(async function () { + await this.token.mint(to, tokenId); }); - }); - describe('when the given token ID was not tracked by this token', function () { - const tokenId = _unknownTokenId; + it('adjusts owner tokens by index', async function () { + const token = await this.token.tokenOfOwnerByIndex(to, 0); + token.toNumber().should.be.equal(tokenId); + }); - it('reverts', async function () { - await assertRevert(token.ownerOf(tokenId)); + it('adjusts all tokens list', async function () { + const newToken = await this.token.tokenByIndex(2); + newToken.toNumber().should.be.equal(tokenId); }); }); - }); - - describe('mint', function () { - describe('when the given token ID was not tracked by this contract', function () { - const tokenId = _unknownTokenId; - - describe('when the given address is not the zero address', function () { - const to = accounts[1]; - - it('mints the given token ID to the given address', async function () { - const previousBalance = await token.balanceOf(to); - - await token.mint(to, tokenId); - - const owner = await token.ownerOf(tokenId); - owner.should.be.equal(to); - - const balance = await token.balanceOf(to); - balance.should.be.bignumber.equal(previousBalance + 1); - }); - it('adds that token to the token list of the owner', async function () { - await token.mint(to, tokenId); + describe('burn', function () { + const tokenId = firstTokenId; + const sender = creator; - const tokens = await token.tokensOf(to); - tokens.length.should.be.equal(1); - tokens[0].should.be.bignumber.equal(tokenId); - }); - - it('emits a transfer event', async function () { - const { logs } = await token.mint(to, tokenId); - - logs.length.should.be.equal(1); - logs[0].event.should.be.eq('Transfer'); - logs[0].args._from.should.be.equal(ZERO_ADDRESS); - logs[0].args._to.should.be.equal(to); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); + beforeEach(async function () { + await this.token.burn(tokenId, { from: sender }); }); - describe('when the given address is the zero address', function () { - const to = ZERO_ADDRESS; - - it('reverts', async function () { - await assertRevert(token.mint(to, tokenId)); - }); + it('removes that token from the token list of the owner', async function () { + const token = await this.token.tokenOfOwnerByIndex(sender, 0); + token.toNumber().should.be.equal(secondTokenId); }); - }); - describe('when the given token ID was already tracked by this contract', function () { - const tokenId = _firstTokenId; + it('adjusts all tokens list', async function () { + const token = await this.token.tokenByIndex(0); + token.toNumber().should.be.equal(secondTokenId); + }); - it('reverts', async function () { - await assertRevert(token.mint(accounts[1], tokenId)); + it('burns all tokens', async function () { + await this.token.burn(secondTokenId, { from: sender }); + const total = await this.token.totalSupply(); + total.toNumber().should.be.equal(0); + await assertRevert(this.token.tokenByIndex(0)); }); }); - }); - - describe('burn', function () { - describe('when the given token ID was tracked by this contract', function () { - const tokenId = _firstTokenId; - - describe('when the msg.sender owns given token', function () { - const sender = _creator; - - it('burns the given token ID and adjusts the balance of the owner', async function () { - const previousBalance = await token.balanceOf(sender); - - await token.burn(tokenId, { from: sender }); + + describe('metadata', function () { + const sampleUri = 'mock://mytoken'; - await assertRevert(token.ownerOf(tokenId)); - const balance = await token.balanceOf(sender); - balance.should.be.bignumber.equal(previousBalance - 1); - }); - - it('removes that token from the token list of the owner', async function () { - await token.burn(tokenId, { from: sender }); - - const tokens = await token.tokensOf(sender); - tokens.length.should.be.equal(1); - tokens[0].should.be.bignumber.equal(_secondTokenId); - }); - - it('emits a burn event', async function () { - const { logs } = await token.burn(tokenId, { from: sender }); - - logs.length.should.be.equal(1); - logs[0].event.should.be.eq('Transfer'); - logs[0].args._from.should.be.equal(sender); - logs[0].args._to.should.be.equal(ZERO_ADDRESS); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); - - describe('when there is an approval for the given token ID', function () { - beforeEach(async function () { - await token.approve(accounts[1], tokenId, { from: sender }); - }); - - it('clears the approval', async function () { - await token.burn(tokenId, { from: sender }); - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(ZERO_ADDRESS); - }); - - it('emits an approval event', async function () { - const { logs } = await token.burn(tokenId, { from: sender }); - - logs.length.should.be.equal(2); - - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(sender); - logs[0].args._approved.should.be.equal(ZERO_ADDRESS); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); - }); + it('has a name', async function () { + const name = await this.token.name(); + name.should.be.equal(name); }); - describe('when the msg.sender does not own given token', function () { - const sender = accounts[1]; - - it('reverts', async function () { - await assertRevert(token.burn(tokenId, { from: sender })); - }); + it('has a symbol', async function () { + const symbol = await this.token.symbol(); + symbol.should.be.equal(symbol); }); - }); - - describe('when the given token ID was not tracked by this contract', function () { - const tokenID = _unknownTokenId; - it('reverts', async function () { - await assertRevert(token.burn(tokenID, { from: _creator })); + it('sets and returns metadata for a token id', async function () { + await this.token.setTokenURI(firstTokenId, sampleUri); + const uri = await this.token.tokenURI(firstTokenId); + uri.should.be.equal(sampleUri); }); - }); - }); - - describe('transfer', function () { - describe('when the address to transfer the token to is not the zero address', function () { - const to = accounts[1]; - - describe('when the given token ID was tracked by this token', function () { - const tokenId = _firstTokenId; - - describe('when the msg.sender is the owner of the given token ID', function () { - const sender = _creator; - - it('transfers the ownership of the given token ID to the given address', async function () { - await token.transfer(to, tokenId, { from: sender }); - - const newOwner = await token.ownerOf(tokenId); - newOwner.should.be.equal(to); - }); - - it('clears the approval for the token ID', async function () { - await token.approve(accounts[2], tokenId, { from: sender }); - - await token.transfer(to, tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(ZERO_ADDRESS); - }); - - it('emits an approval and transfer events', async function () { - const { logs } = await token.transfer(to, tokenId, { from: sender }); - - logs.length.should.be.equal(2); - - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(sender); - logs[0].args._approved.should.be.equal(ZERO_ADDRESS); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - - logs[1].event.should.be.eq('Transfer'); - logs[1].args._from.should.be.equal(sender); - logs[1].args._to.should.be.equal(to); - logs[1].args._tokenId.should.be.bignumber.equal(tokenId); - }); - - it('adjusts owners balances', async function () { - const previousBalance = await token.balanceOf(sender); - await token.transfer(to, tokenId, { from: sender }); - - const newOwnerBalance = await token.balanceOf(to); - newOwnerBalance.should.be.bignumber.equal(1); - - const previousOwnerBalance = await token.balanceOf(_creator); - previousOwnerBalance.should.be.bignumber.equal(previousBalance - 1); - }); - - it('adds the token to the tokens list of the new owner', async function () { - await token.transfer(to, tokenId, { from: sender }); - - const tokenIDs = await token.tokensOf(to); - tokenIDs.length.should.be.equal(1); - tokenIDs[0].should.be.bignumber.equal(tokenId); - }); - }); - - describe('when the msg.sender is not the owner of the given token ID', function () { - const sender = accounts[2]; - it('reverts', async function () { - await assertRevert(token.transfer(to, tokenId, { from: sender })); - }); - }); + it('can burn token with metadata', async function () { + await this.token.setTokenURI(firstTokenId, sampleUri); + await this.token.burn(firstTokenId); + const exists = await this.token.exists(firstTokenId); + exists.should.be.false; }); - describe('when the given token ID was not tracked by this token', function () { - let tokenId = _unknownTokenId; + it('returns empty metadata for token', async function () { + const uri = await this.token.tokenURI(firstTokenId); + uri.should.be.equal(''); + }); - it('reverts', async function () { - await assertRevert(token.transfer(to, tokenId, { from: _creator })); - }); + it('reverts when querying metadata for non existant token id', async function () { + await assertRevert(this.token.tokenURI(500)); }); }); - describe('when the address to transfer the token to is the zero address', function () { - const to = ZERO_ADDRESS; - - it('reverts', async function () { - await assertRevert(token.transfer(to, 0, { from: _creator })); + describe('totalSupply', function () { + it('returns total token supply', async function () { + const totalSupply = await this.token.totalSupply(); + totalSupply.should.be.bignumber.equal(2); }); }); - }); - - describe('approve', function () { - describe('when the given token ID was already tracked by this contract', function () { - const tokenId = _firstTokenId; - - describe('when the sender owns the given token ID', function () { - const sender = _creator; - - describe('when the address that receives the approval is the 0 address', function () { - const to = ZERO_ADDRESS; - - describe('when there was no approval for the given token ID before', function () { - it('clears the approval for that token', async function () { - await token.approve(to, tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(to); - }); - - it('does not emit an approval event', async function () { - const { logs } = await token.approve(to, tokenId, { from: sender }); - - logs.length.should.be.equal(0); - }); - }); - - describe('when the given token ID was approved for another account', function () { - beforeEach(async function () { - await token.approve(accounts[2], tokenId, { from: sender }); - }); - - it('clears the approval for the token ID', async function () { - await token.approve(to, tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(to); - }); - - it('emits an approval event', async function () { - const { logs } = await token.approve(to, tokenId, { from: sender }); - - logs.length.should.be.equal(1); - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(sender); - logs[0].args._approved.should.be.equal(to); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); - }); - }); - - describe('when the address that receives the approval is not the 0 address', function () { - describe('when the address that receives the approval is different than the owner', function () { - const to = accounts[1]; - - describe('when there was no approval for the given token ID before', function () { - it('approves the token ID to the given address', async function () { - await token.approve(to, tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(to); - }); - - it('emits an approval event', async function () { - const { logs } = await token.approve(to, tokenId, { from: sender }); - - logs.length.should.be.equal(1); - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(sender); - logs[0].args._approved.should.be.equal(to); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); - }); - - describe('when the given token ID was approved for the same account', function () { - beforeEach(async function () { - await token.approve(to, tokenId, { from: sender }); - }); - - it('keeps the approval to the given address', async function () { - await token.approve(to, tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(to); - }); - - it('emits an approval event', async function () { - const { logs } = await token.approve(to, tokenId, { from: sender }); - - logs.length.should.be.equal(1); - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(sender); - logs[0].args._approved.should.be.equal(to); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); - }); - - describe('when the given token ID was approved for another account', function () { - beforeEach(async function () { - await token.approve(accounts[2], tokenId, { from: sender }); - }); - - it('changes the approval to the given address', async function () { - await token.approve(to, tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(to); - }); - - it('emits an approval event', async function () { - const { logs } = await token.approve(to, tokenId, { from: sender }); - - logs.length.should.be.equal(1); - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(sender); - logs[0].args._approved.should.be.equal(to); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - }); - }); - }); - - describe('when the address that receives the approval is the owner', function () { - const to = _creator; - - describe('when there was no approval for the given token ID before', function () { - it('reverts', async function () { - await assertRevert(token.approve(to, tokenId, { from: sender })); - }); - }); - - describe('when the given token ID was approved for another account', function () { - beforeEach(async function () { - await token.approve(accounts[2], tokenId, { from: sender }); - }); - it('reverts', async function () { - await assertRevert(token.approve(to, tokenId, { from: sender })); - }); - }); - }); + describe('tokenOfOwnerByIndex', function () { + const owner = creator; + const another = accounts[1]; + + describe('when the given index is lower than the amount of tokens owned by the given address', function () { + it('returns the token ID placed at the given index', async function () { + const tokenId = await this.token.tokenOfOwnerByIndex(owner, 0); + tokenId.should.be.bignumber.equal(firstTokenId); }); }); - describe('when the sender does not own the given token ID', function () { - const sender = accounts[1]; - + describe('when the index is greater than or equal to the total tokens owned by the given address', function () { it('reverts', async function () { - await assertRevert(token.approve(accounts[2], tokenId, { from: sender })); + await assertRevert(this.token.tokenOfOwnerByIndex(owner, 2)); }); }); - }); - - describe('when the given token ID was not tracked by the contract before', function () { - const tokenId = _unknownTokenId; - it('reverts', async function () { - await assertRevert(token.approve(accounts[1], tokenId, { from: _creator })); + describe('when the given address does not own any token', function () { + it('reverts', async function () { + await assertRevert(this.token.tokenOfOwnerByIndex(another, 0)); + }); }); - }); - }); - - describe('takeOwnership', function () { - describe('when the given token ID was already tracked by this contract', function () { - const tokenId = _firstTokenId; - - describe('when the sender has the approval for the token ID', function () { - const sender = accounts[1]; + describe('after transferring all tokens to another user', function () { beforeEach(async function () { - await token.approve(sender, tokenId, { from: _creator }); - }); - - it('transfers the ownership of the given token ID to the given address', async function () { - await token.takeOwnership(tokenId, { from: sender }); - - const newOwner = await token.ownerOf(tokenId); - newOwner.should.be.equal(sender); - }); - - it('clears the approval for the token ID', async function () { - await token.takeOwnership(tokenId, { from: sender }); - - const approvedAccount = await token.approvedFor(tokenId); - approvedAccount.should.be.equal(ZERO_ADDRESS); - }); - - it('emits an approval and transfer events', async function () { - const { logs } = await token.takeOwnership(tokenId, { from: sender }); - - logs.length.should.be.equal(2); - - logs[0].event.should.be.eq('Approval'); - logs[0].args._owner.should.be.equal(_creator); - logs[0].args._approved.should.be.equal(ZERO_ADDRESS); - logs[0].args._tokenId.should.be.bignumber.equal(tokenId); - - logs[1].event.should.be.eq('Transfer'); - logs[1].args._from.should.be.equal(_creator); - logs[1].args._to.should.be.equal(sender); - logs[1].args._tokenId.should.be.bignumber.equal(tokenId); - }); - - it('adjusts owners balances', async function () { - const previousBalance = await token.balanceOf(_creator); - - await token.takeOwnership(tokenId, { from: sender }); - - const newOwnerBalance = await token.balanceOf(sender); - newOwnerBalance.should.be.bignumber.equal(1); - - const previousOwnerBalance = await token.balanceOf(_creator); - previousOwnerBalance.should.be.bignumber.equal(previousBalance - 1); - }); - - it('adds the token to the tokens list of the new owner', async function () { - await token.takeOwnership(tokenId, { from: sender }); - - const tokenIDs = await token.tokensOf(sender); - tokenIDs.length.should.be.equal(1); - tokenIDs[0].should.be.bignumber.equal(tokenId); + await this.token.transferFrom(owner, another, firstTokenId, { from: owner }); + await this.token.transferFrom(owner, another, secondTokenId, { from: owner }); }); - }); - - describe('when the sender does not have an approval for the token ID', function () { - const sender = accounts[1]; - it('reverts', async function () { - await assertRevert(token.takeOwnership(tokenId, { from: sender })); + it('returns correct token IDs for target', async function () { + const count = await this.token.balanceOf(another); + count.toNumber().should.be.equal(2); + const tokensListed = await Promise.all(_.range(2).map(i => this.token.tokenOfOwnerByIndex(another, i))); + tokensListed.map(t => t.toNumber()).should.have.members([firstTokenId, secondTokenId]); }); - }); - describe('when the sender is already the owner of the token', function () { - const sender = _creator; - - it('reverts', async function () { - await assertRevert(token.takeOwnership(tokenId, { from: sender })); + it('returns empty collection for original owner', async function () { + const count = await this.token.balanceOf(owner); + count.toNumber().should.be.equal(0); + await assertRevert(this.token.tokenOfOwnerByIndex(owner, 0)); }); }); }); - describe('when the given token ID was not tracked by the contract before', function () { - const tokenId = _unknownTokenId; - - it('reverts', async function () { - await assertRevert(token.takeOwnership(tokenId, { from: _creator })); + describe('tokenByIndex', function () { + it('should return all tokens', async function () { + const tokensListed = await Promise.all(_.range(2).map(i => this.token.tokenByIndex(i))); + tokensListed.map(t => t.toNumber()).should.have.members([firstTokenId, secondTokenId]); + }); + + it('should revert if index is greater than supply', async function () { + await assertRevert(this.token.tokenByIndex(2)); + }); + + [firstTokenId, secondTokenId].forEach(function (tokenId) { + it(`should return all tokens after burning token ${tokenId} and minting new tokens`, async function () { + const owner = accounts[0]; + const newTokenId = 300; + const anotherNewTokenId = 400; + + await this.token.burn(tokenId, { from: owner }); + await this.token.mint(owner, newTokenId, { from: owner }); + await this.token.mint(owner, anotherNewTokenId, { from: owner }); + + const count = await this.token.totalSupply(); + count.toNumber().should.be.equal(3); + + const tokensListed = await Promise.all(_.range(3).map(i => this.token.tokenByIndex(i))); + const expectedTokens = _.filter( + [firstTokenId, secondTokenId, newTokenId, anotherNewTokenId], + x => (x !== tokenId) + ); + tokensListed.map(t => t.toNumber()).should.have.members(expectedTokens); + }); }); }); });