NoBey/openzeppelin-contracts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ERC721 full implementation (#803)

Browse Source 
* Rename current ERC721 implementation to BaseERC721

* Implement ERC721 optional & approveAll functionality

* Support for new ERC721 interface

- Tests for new features are pending
- ERC721 is abstract, since it requires metadata implementation
- Move some methods into DeprecatedERC721 contract
- Reorganise base vs full implementation
- Pending tokenByIndex

* Add more tests for ERC721

* Implement suggestions by @dekz

* Update comments in ERC721 contracts

* Implement tokensByIndex extension

- Remove restrictions from mock mint and burn calls

* Add default implementation for metadata URI

This allows token implementation to be non-abstract

* Allow operators to call approve on a token

* Remove gas stipend restriction in call to 721 receiver

* Remove deprecated implementation

We only want to keep the interface, for interacting with already deployed contracts

* Add notice to isContract helper on constract constructors

* Change natspec delimiters for consistency

* Minor linting fixes

* Add constant modifier to ERC721_RECEIVED magic value

* Use 4-params safeTransferFrom for implementing the 3-params overload

* Minor text changes in natspec comments

* Use address(0) instead of 0 or 0x0

* Use if-statements instead of boolean one-liners for clarity

:-(

* Keep ownedTokensCount state var in sync in full ERC721 implementation

* Fix incorrect comparison when burning ERC721 tokens with metadata

* Use address(0) instead of 0 in one more place in ERC721

* Throw when querying balance for the zero address

Required by the spec

* Update links to approved version of EIP721

* Use explicit size for uint

* Remove unneeded internal function in ERC721

Also rename addToken and removeToken for added clarity

* Use underscore instead of 'do' prefix for internal methods in ERC721

* Fix failing test due to events reordering in ERC721 safe transfer

* Fix bug introduced in 74db03ba06

* Remove do prefix for internal setTokenUri method

* Allow transfers to self in ERC721
This commit is contained in:
Santiago Palladino
2018-03-23 15:11:59 -03:00
committed by Francisco Giordano
parent 9f52e94339
commit e96164feea
16 changed files with 1414 additions and 650 deletions
Download Patch File Download Diff File Expand all files Collapse all files

617
test/token/ERC721/ERC721Token.test.js
View File

@ -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);
});
});
shouldBehaveLikeERC721BasicToken(accounts);
shouldMintAndBurnERC721Token(accounts);
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);
});
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('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('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 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(token.ownerOf(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);
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);
});
});
describe('when the given address is the zero address', function () {
const to = ZERO_ADDRESS;
it('reverts', async function () {
await assertRevert(token.mint(to, tokenId));
});
});
});
describe('when the given token ID was already tracked by this contract', function () {
const tokenId = _firstTokenId;
it('reverts', async function () {
await assertRevert(token.mint(accounts[1], tokenId));
});
});
});
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 });
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);
});
});
});
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 }));
});
});
});
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 }));
});
});
});
describe('transfer', function () {
describe('when the address to transfer the token to is not the zero address', function () {
describe('mint', function () {
const to = accounts[1];
const tokenId = 3;
describe('when the given token ID was tracked by this token', function () {
const tokenId = _firstTokenId;
beforeEach(async function () {
await this.token.mint(to, tokenId);
});
describe('when the msg.sender is the owner of the given token ID', function () {
const sender = _creator;
it('adjusts owner tokens by index', async function () {
const token = await this.token.tokenOfOwnerByIndex(to, 0);
token.toNumber().should.be.equal(tokenId);
});
it('transfers the ownership of the given token ID to the given address', async function () {
await token.transfer(to, tokenId, { from: sender });
it('adjusts all tokens list', async function () {
const newToken = await this.token.tokenByIndex(2);
newToken.toNumber().should.be.equal(tokenId);
});
});
const newOwner = await token.ownerOf(tokenId);
newOwner.should.be.equal(to);
});
describe('burn', function () {
const tokenId = firstTokenId;
const sender = creator;
it('clears the approval for the token ID', async function () {
await token.approve(accounts[2], tokenId, { from: sender });
beforeEach(async function () {
await this.token.burn(tokenId, { from: sender });
});
await token.transfer(to, tokenId, { from: sender });
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);
});
const approvedAccount = await token.approvedFor(tokenId);
approvedAccount.should.be.equal(ZERO_ADDRESS);
});
it('adjusts all tokens list', async function () {
const token = await this.token.tokenByIndex(0);
token.toNumber().should.be.equal(secondTokenId);
});
it('emits an approval and transfer events', async function () {
const { logs } = await token.transfer(to, tokenId, { from: sender });
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('metadata', function () {
const sampleUri = 'mock://mytoken';
logs.length.should.be.equal(2);
it('has a name', async function () {
const name = await this.token.name();
name.should.be.equal(name);
});
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 symbol', async function () {
const symbol = await this.token.symbol();
symbol.should.be.equal(symbol);
});
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('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);
});
it('adjusts owners balances', async function () {
const previousBalance = await token.balanceOf(sender);
await 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;
});
const newOwnerBalance = await token.balanceOf(to);
newOwnerBalance.should.be.bignumber.equal(1);
it('returns empty metadata for token', async function () {
const uri = await this.token.tokenURI(firstTokenId);
uri.should.be.equal('');
});
const previousOwnerBalance = await token.balanceOf(_creator);
previousOwnerBalance.should.be.bignumber.equal(previousBalance - 1);
});
it('reverts when querying metadata for non existant token id', async function () {
await assertRevert(this.token.tokenURI(500));
});
});
it('adds the token to the tokens list of the new owner', async function () {
await token.transfer(to, tokenId, { from: sender });
describe('totalSupply', function () {
it('returns total token supply', async function () {
const totalSupply = await this.token.totalSupply();
totalSupply.should.be.bignumber.equal(2);
});
});
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 }));
});
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 given token ID was not tracked by this token', function () {
let tokenId = _unknownTokenId;
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.transfer(to, tokenId, { from: _creator }));
});
});
});
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('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 }));
});
});
});
await assertRevert(this.token.tokenOfOwnerByIndex(owner, 2));
});
});
describe('when the sender does not own the given token ID', function () {
const sender = accounts[1];
describe('when the given address does not own any token', function () {
it('reverts', async function () {
await assertRevert(token.approve(accounts[2], tokenId, { from: sender }));
await assertRevert(this.token.tokenOfOwnerByIndex(another, 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.approve(accounts[1], tokenId, { from: _creator }));
});
});
});
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 });
await this.token.transferFrom(owner, another, firstTokenId, { from: owner });
await this.token.transferFrom(owner, another, secondTokenId, { from: owner });
});
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('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]);
});
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);
});
});
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 }));
});
});
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;
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('reverts', async function () {
await assertRevert(token.takeOwnership(tokenId, { from: _creator }));
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);
});
});
});
});