git.delta.rocks / unique-network / refs/commits / 0f81eccfefee

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {itEth, usingEthPlaygrounds, expect, EthUniqueHelper} from './util';18import {IKeyringPair} from '@polkadot/types/types';19import {Contract} from 'web3-eth-contract';202122describe('NFT: Information getting', () => {23  let donor: IKeyringPair;24  let alice: IKeyringPair;2526  before(async function() {27    await usingEthPlaygrounds(async (helper, privateKey) => {28      donor = await privateKey({filename: __filename});29      [alice] = await helper.arrange.createAccounts([10n], donor);30    });31  });3233  itEth('totalSupply', async ({helper}) => {34    const collection = await helper.nft.mintCollection(alice, {});35    await collection.mintToken(alice);3637    const caller = await helper.eth.createAccountWithBalance(donor);3839    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);40    const totalSupply = await contract.methods.totalSupply().call();4142    expect(totalSupply).to.equal('1');43  });4445  itEth('balanceOf', async ({helper}) => {46    const collection = await helper.nft.mintCollection(alice, {});47    const caller = await helper.eth.createAccountWithBalance(donor);4849    await collection.mintToken(alice, {Ethereum: caller});50    await collection.mintToken(alice, {Ethereum: caller});51    await collection.mintToken(alice, {Ethereum: caller});5253    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);54    const balance = await contract.methods.balanceOf(caller).call();5556    expect(balance).to.equal('3');57  });5859  itEth('ownerOf', async ({helper}) => {60    const collection = await helper.nft.mintCollection(alice, {});61    const caller = await helper.eth.createAccountWithBalance(donor);6263    const token = await collection.mintToken(alice, {Ethereum: caller});6465    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);6667    const owner = await contract.methods.ownerOf(token.tokenId).call();6869    expect(owner).to.equal(caller);70  });7172  itEth('name/symbol is available regardless of ERC721Metadata support', async ({helper}) => {73    const collection = await helper.nft.mintCollection(alice, {name: 'test', tokenPrefix: 'TEST'});74    const caller = helper.eth.createAccount();7576    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);7778    expect(await contract.methods.name().call()).to.equal('test');79    expect(await contract.methods.symbol().call()).to.equal('TEST');80  });81});8283describe('Check ERC721 token URI for NFT', () => {84  let donor: IKeyringPair;8586  before(async function() {87    await usingEthPlaygrounds(async (_helper, privateKey) => {88      donor = await privateKey({filename: __filename});89    });90  });9192  async function setup(helper: EthUniqueHelper, baseUri: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {93    const owner = await helper.eth.createAccountWithBalance(donor);94    const receiver = helper.eth.createAccount();9596    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Mint collection', 'a', 'b', baseUri);97    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);9899    const result = await contract.methods.mint(receiver).send();100    const tokenId = result.events.Transfer.returnValues.tokenId;101    expect(tokenId).to.be.equal('1');102103    if (propertyKey && propertyValue) {104      // Set URL or suffix105      await contract.methods.setProperties(tokenId, [{key: propertyKey, value: Buffer.from(propertyValue)}]).send();106    }107108    const event = result.events.Transfer;109    expect(event.address).to.be.equal(collectionAddress);110    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');111    expect(event.returnValues.to).to.be.equal(receiver);112    expect(event.returnValues.tokenId).to.be.equal(tokenId);113114    return {contract, nextTokenId: tokenId};115  }116117  itEth('Empty tokenURI', async ({helper}) => {118    const {contract, nextTokenId} = await setup(helper, '');119    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');120  });121122  itEth('TokenURI from url', async ({helper}) => {123    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URI', 'Token URI');124    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');125  });126127  itEth('TokenURI from baseURI', async ({helper}) => {128    const {contract, nextTokenId} = await setup(helper, 'BaseURI_');129    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_');130  });131132  itEth('TokenURI from baseURI + suffix', async ({helper}) => {133    const suffix = '/some/suffix';134    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URISuffix', suffix);135    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);136  });137});138139describe('NFT: Plain calls', () => {140  let donor: IKeyringPair;141  let minter: IKeyringPair;142  let bob: IKeyringPair;143  let charlie: IKeyringPair;144145  before(async function() {146    await usingEthPlaygrounds(async (helper, privateKey) => {147      donor = await privateKey({filename: __filename});148      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);149    });150  });151152  itEth('Can perform mint() & get crossOwner()', async ({helper}) => {153    const owner = await helper.eth.createAccountWithBalance(donor);154    const receiver = helper.eth.createAccount();155156    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Mint collection', '6', '6', '');157    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);158159    const result = await contract.methods.mintWithTokenURI(receiver, 'Test URI').send();160    const tokenId = result.events.Transfer.returnValues.tokenId;161    expect(tokenId).to.be.equal('1');162163    const event = result.events.Transfer;164    expect(event.address).to.be.equal(collectionAddress);165    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');166    expect(event.returnValues.to).to.be.equal(receiver);167168    expect(await contract.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');169    console.log(await contract.methods.crossOwnerOf(tokenId).call());170    expect(await contract.methods.crossOwnerOf(tokenId).call()).to.be.like([receiver, '0']);171    // TODO: this wont work right now, need release 919000 first172    // await helper.methods.setOffchainSchema(collectionIdAddress, 'https://offchain-service.local/token-info/{id}').send();173    // const tokenUri = await contract.methods.tokenURI(nextTokenId).call();174    // expect(tokenUri).to.be.equal(`https://offchain-service.local/token-info/${nextTokenId}`);175  });176177  //TODO: CORE-302 add eth methods178  itEth.skip('Can perform mintBulk()', async ({helper}) => {179    const caller = await helper.eth.createAccountWithBalance(donor);180    const receiver = helper.eth.createAccount();181182    const collection = await helper.nft.mintCollection(minter);183    await collection.addAdmin(minter, {Ethereum: caller});184185    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);186    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller);187    {188      const bulkSize = 3;189      const nextTokenId = await contract.methods.nextTokenId().call();190      expect(nextTokenId).to.be.equal('1');191      const result = await contract.methods.mintBulkWithTokenURI(192        receiver,193        Array.from({length: bulkSize}, (_, i) => (194          [+nextTokenId + i, `Test URI ${i}`]195        )),196      ).send({from: caller});197198      const events = result.events.Transfer.sort((a: any, b: any) => +a.returnValues.tokenId - b.returnValues.tokenId);199      for (let i = 0; i < bulkSize; i++) {200        const event = events[i];201        expect(event.address).to.equal(collectionAddress);202        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');203        expect(event.returnValues.to).to.equal(receiver);204        expect(event.returnValues.tokenId).to.equal(`${+nextTokenId + i}`);205206        expect(await contract.methods.tokenURI(+nextTokenId + i).call()).to.be.equal(`Test URI ${i}`);207      }208    }209  });210211  itEth('Can perform burn()', async ({helper}) => {212    const caller = await helper.eth.createAccountWithBalance(donor);213214    const collection = await helper.nft.mintCollection(minter, {});215    const {tokenId} = await collection.mintToken(minter, {Ethereum: caller});216217    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);218    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller);219220    {221      const result = await contract.methods.burn(tokenId).send({from: caller});222223      const event = result.events.Transfer;224      expect(event.address).to.be.equal(collectionAddress);225      expect(event.returnValues.from).to.be.equal(caller);226      expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');227      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);228    }229  });230231  itEth('Can perform approve()', async ({helper}) => {232    const owner = await helper.eth.createAccountWithBalance(donor);233    const spender = helper.eth.createAccount();234235    const collection = await helper.nft.mintCollection(minter, {});236    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});237238    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);239    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);240241    {242      const result = await contract.methods.approve(spender, tokenId).send({from: owner});243244      const event = result.events.Approval;245      expect(event.address).to.be.equal(collectionAddress);246      expect(event.returnValues.owner).to.be.equal(owner);247      expect(event.returnValues.approved).to.be.equal(spender);248      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);249    }250  });251252  itEth('Can perform burnFromCross()', async ({helper}) => {253    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});254    const ownerSub = bob;255    const ownerCrossSub = helper.ethCrossAccount.fromKeyringPair(ownerSub);256    const ownerEth = await helper.eth.createAccountWithBalance(donor, 100n);257    const ownerCrossEth = helper.ethCrossAccount.fromAddress(ownerEth);258259    const burnerEth = await helper.eth.createAccountWithBalance(donor, 100n);260    const burnerCrossEth = helper.ethCrossAccount.fromAddress(burnerEth);261262    const token1 = await collection.mintToken(minter, {Substrate: ownerSub.address});263    const token2 = await collection.mintToken(minter, {Ethereum: ownerEth});264265    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);266    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft');267268    // Approve tokens from substrate and ethereum:269    await token1.approve(ownerSub, {Ethereum: burnerEth});270    await collectionEvm.methods.approveCross(burnerCrossEth, token2.tokenId).send({from: ownerEth});271272    // can burnFromCross:273    const result1 = await collectionEvm.methods.burnFromCross(ownerCrossSub, token1.tokenId).send({from: burnerEth});274    const result2 = await collectionEvm.methods.burnFromCross(ownerCrossEth, token2.tokenId).send({from: burnerEth});275    const events1 = result1.events.Transfer;276    const events2 = result2.events.Transfer;277278    // Check events for burnFromCross (substrate and ethereum):279    [280      [events1, token1, helper.address.substrateToEth(ownerSub.address)], 281      [events2, token2, ownerEth],282    ].map(burnData => {283      expect(burnData[0]).to.be.like({284        address: collectionAddress,285        event: 'Transfer',286        returnValues: {287          from: burnData[2],288          to: '0x0000000000000000000000000000000000000000',289          tokenId: burnData[1].tokenId.toString(),290        },291      });292    });293294    expect(await token1.doesExist()).to.be.false;295    expect(await token2.doesExist()).to.be.false;296  });297298  itEth('Can perform approveCross()', async ({helper}) => {299    // arrange: create accounts300    const owner = await helper.eth.createAccountWithBalance(donor, 100n);301    const ownerCross = helper.ethCrossAccount.fromAddress(owner);302    const receiverSub = charlie;303    const recieverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);304    const receiverEth = await helper.eth.createAccountWithBalance(donor, 100n);305    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);306307    // arrange: create collection and tokens:308    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});309    const token1 = await collection.mintToken(minter, {Ethereum: owner});310    const token2 = await collection.mintToken(minter, {Ethereum: owner});311312    const collectionEvm = helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');313314    // Can approveCross substrate and ethereum address:315    const resultSub = await collectionEvm.methods.approveCross(recieverCrossSub, token1.tokenId).send({from: owner});316    const resultEth = await collectionEvm.methods.approveCross(receiverCrossEth, token2.tokenId).send({from: owner});317    const eventSub = resultSub.events.Approval;318    const eventEth = resultEth.events.Approval;319    expect(eventSub).to.be.like({320      address: helper.ethAddress.fromCollectionId(collection.collectionId),321      event: 'Approval',322      returnValues: {323        owner,324        approved: helper.address.substrateToEth(receiverSub.address),325        tokenId: token1.tokenId.toString(),326      },327    });328    expect(eventEth).to.be.like({329      address: helper.ethAddress.fromCollectionId(collection.collectionId),330      event: 'Approval',331      returnValues: {332        owner,333        approved: receiverEth,334        tokenId: token2.tokenId.toString(),335      },336    });337338    // Substrate address can transferFrom approved tokens:339    await helper.nft.transferTokenFrom(receiverSub, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiverSub.address});340    expect(await helper.nft.getTokenOwner(collection.collectionId, token1.tokenId)).to.deep.eq({Substrate: receiverSub.address});341    // Ethereum address can transferFromCross approved tokens:342    await collectionEvm.methods.transferFromCross(ownerCross, receiverCrossEth, token2.tokenId).send({from: receiverEth});343    expect(await helper.nft.getTokenOwner(collection.collectionId, token2.tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});344  });345346  itEth('Can reaffirm approved address', async ({helper}) => {347    const owner = await helper.eth.createAccountWithBalance(donor, 100n);348    const ownerCrossEth = helper.ethCrossAccount.fromAddress(owner);349    const [receiver1, receiver2] = await helper.arrange.createAccounts([100n, 100n], donor);350    const receiver1Cross = helper.ethCrossAccount.fromKeyringPair(receiver1);351    const receiver2Cross = helper.ethCrossAccount.fromKeyringPair(receiver2);352    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});353    const token1 = await collection.mintToken(minter, {Ethereum: owner});354    const token2 = await collection.mintToken(minter, {Ethereum: owner});355    const collectionEvm = helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');356357    // Can approve and reaffirm approved address:358    await collectionEvm.methods.approveCross(receiver1Cross, token1.tokenId).send({from: owner});359    await collectionEvm.methods.approveCross(receiver2Cross, token1.tokenId).send({from: owner});360361    // receiver1 cannot transferFrom:362    await expect(helper.nft.transferTokenFrom(receiver1, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiver1.address})).to.be.rejected;363    // receiver2 can transferFrom:364    await helper.nft.transferTokenFrom(receiver2, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiver2.address});365366    // can set approved address to self address to remove approval:367    await collectionEvm.methods.approveCross(receiver1Cross, token2.tokenId).send({from: owner});368    await collectionEvm.methods.approveCross(ownerCrossEth, token2.tokenId).send({from: owner});369370    // receiver1 cannot transfer token anymore:371    await expect(helper.nft.transferTokenFrom(receiver1, collection.collectionId, token2.tokenId, {Ethereum: owner}, {Substrate: receiver1.address})).to.be.rejected;372  });373374  itEth('Can perform transferFrom()', async ({helper}) => {375    const owner = await helper.eth.createAccountWithBalance(donor);376    const spender = await helper.eth.createAccountWithBalance(donor);377    const receiver = helper.eth.createAccount();378379    const collection = await helper.nft.mintCollection(minter, {});380    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});381382    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);383    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);384385    await contract.methods.approve(spender, tokenId).send({from: owner});386387    {388      const result = await contract.methods.transferFrom(owner, receiver, tokenId).send({from: spender});389390      const event = result.events.Transfer;391      expect(event.address).to.be.equal(collectionAddress);392      expect(event.returnValues.from).to.be.equal(owner);393      expect(event.returnValues.to).to.be.equal(receiver);394      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);395    }396397    {398      const balance = await contract.methods.balanceOf(receiver).call();399      expect(+balance).to.equal(1);400    }401402    {403      const balance = await contract.methods.balanceOf(owner).call();404      expect(+balance).to.equal(0);405    }406  });407408  itEth('Can perform transferFromCross()', async ({helper}) => {409    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});410411    const [owner, receiver] = await helper.arrange.createAccounts([100n, 100n], donor);412    const spender = await helper.eth.createAccountWithBalance(donor);413414    const token = await collection.mintToken(minter, {Substrate: owner.address});415416    const address = helper.ethAddress.fromCollectionId(collection.collectionId);417    const contract = helper.ethNativeContract.collection(address, 'nft');418419    await token.approve(owner, {Ethereum: spender});420421    {422      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);423      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);424      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});425      const event = result.events.Transfer;426      expect(event).to.be.like({427        address: helper.ethAddress.fromCollectionId(collection.collectionId),428        event: 'Transfer',429        returnValues: {430          from: helper.address.substrateToEth(owner.address),431          to: helper.address.substrateToEth(receiver.address),432          tokenId: token.tokenId.toString(),433        },434      });435    }436437    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});438  });439440  itEth('Can perform transfer()', async ({helper}) => {441    const collection = await helper.nft.mintCollection(minter, {});442    const owner = await helper.eth.createAccountWithBalance(donor);443    const receiver = helper.eth.createAccount();444445    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});446447    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);448    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);449450    {451      const result = await contract.methods.transfer(receiver, tokenId).send({from: owner});452453      const event = result.events.Transfer;454      expect(event.address).to.be.equal(collectionAddress);455      expect(event.returnValues.from).to.be.equal(owner);456      expect(event.returnValues.to).to.be.equal(receiver);457      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);458    }459460    {461      const balance = await contract.methods.balanceOf(owner).call();462      expect(+balance).to.equal(0);463    }464465    {466      const balance = await contract.methods.balanceOf(receiver).call();467      expect(+balance).to.equal(1);468    }469  });470  471  itEth('Can perform transferCross()', async ({helper}) => {472    const collection = await helper.nft.mintCollection(minter, {});473    const owner = await helper.eth.createAccountWithBalance(donor);474    const receiverEth = await helper.eth.createAccountWithBalance(donor);475    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);476    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);477    478    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});479480    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);481    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);482483    {484      // Can transferCross to ethereum address:485      const result = await collectionEvm.methods.transferCross(receiverCrossEth, tokenId).send({from: owner});486      // Check events:487      const event = result.events.Transfer;488      expect(event.address).to.be.equal(collectionAddress);489      expect(event.returnValues.from).to.be.equal(owner);490      expect(event.returnValues.to).to.be.equal(receiverEth);491      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);492      493      // owner has balance = 0:494      const ownerBalance = await collectionEvm.methods.balanceOf(owner).call();495      expect(+ownerBalance).to.equal(0);496      // receiver owns token:497      const receiverBalance = await collectionEvm.methods.balanceOf(receiverEth).call();498      expect(+receiverBalance).to.equal(1);499      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});500    }501    502    {503      // Can transferCross to substrate address:504      const substrateResult = await collectionEvm.methods.transferCross(receiverCrossSub, tokenId).send({from: receiverEth});505      // Check events:506      const event = substrateResult.events.Transfer;507      expect(event.address).to.be.equal(collectionAddress);508      expect(event.returnValues.from).to.be.equal(receiverEth);509      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(minter.address));510      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);511      512      // owner has balance = 0:513      const ownerBalance = await collectionEvm.methods.balanceOf(receiverEth).call();514      expect(+ownerBalance).to.equal(0);515      // receiver owns token:516      const receiverBalance = await helper.nft.getTokensByAddress(collection.collectionId, {Substrate: minter.address});517      expect(receiverBalance).to.contain(tokenId);518    }519  });520521  ['transfer', 'transferCross'].map(testCase => itEth(`Cannot ${testCase} non-owned token`, async ({helper}) => {522    const sender = await helper.eth.createAccountWithBalance(donor);523    const tokenOwner = await helper.eth.createAccountWithBalance(donor);524    const receiverSub = minter;525    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);526527    const collection = await helper.nft.mintCollection(minter, {});528    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);529    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', sender);530531    await collection.mintToken(minter, {Ethereum: sender});532    const nonSendersToken = await collection.mintToken(minter, {Ethereum: tokenOwner});533534    // Cannot transferCross someone else's token:535    const receiver = testCase === 'transfer' ? helper.address.substrateToEth(receiverSub.address) : receiverCrossSub;536    await expect(collectionEvm.methods[testCase](receiver, nonSendersToken.tokenId).send({from: sender})).to.be.rejected;537    // Cannot transfer token if it does not exist:538    await expect(collectionEvm.methods[testCase](receiver, 999999).send({from: sender})).to.be.rejected;539  }));540});541542describe('NFT: Fees', () => {543  let donor: IKeyringPair;544  let alice: IKeyringPair;545  let bob: IKeyringPair;546  let charlie: IKeyringPair;547548  before(async function() {549    await usingEthPlaygrounds(async (helper, privateKey) => {550      donor = await privateKey({filename: __filename});551      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);552    });553  });554555  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {556    const owner = await helper.eth.createAccountWithBalance(donor);557    const spender = helper.eth.createAccount();558559    const collection = await helper.nft.mintCollection(alice, {});560    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});561562    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);563564    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, tokenId).send({from: owner}));565    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));566  });567568  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {569    const owner = await helper.eth.createAccountWithBalance(donor);570    const spender = await helper.eth.createAccountWithBalance(donor);571572    const collection = await helper.nft.mintCollection(alice, {});573    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});574575    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);576577    await contract.methods.approve(spender, tokenId).send({from: owner});578579    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, tokenId).send({from: spender}));580    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));581  });582583  itEth('Can perform transferFromCross()', async ({helper}) => {584    const collectionMinter = alice;585    const owner = bob;586    const receiver = charlie;587    const collection = await helper.nft.mintCollection(collectionMinter, {name: 'A', description: 'B', tokenPrefix: 'C'});588589    const spender = await helper.eth.createAccountWithBalance(donor, 100n);590591    const token = await collection.mintToken(collectionMinter, {Substrate: owner.address});592593    const address = helper.ethAddress.fromCollectionId(collection.collectionId);594    const contract = helper.ethNativeContract.collection(address, 'nft');595596    await token.approve(owner, {Ethereum: spender});597598    {599      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);600      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);601      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});602      const event = result.events.Transfer;603      expect(event).to.be.like({604        address: helper.ethAddress.fromCollectionId(collection.collectionId),605        event: 'Transfer',606        returnValues: {607          from: helper.address.substrateToEth(owner.address),608          to: helper.address.substrateToEth(receiver.address),609          tokenId: token.tokenId.toString(),610        },611      });612    }613614    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});615  });616617  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {618    const owner = await helper.eth.createAccountWithBalance(donor);619    const receiver = helper.eth.createAccount();620621    const collection = await helper.nft.mintCollection(alice, {});622    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});623624    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);625626    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, tokenId).send({from: owner}));627    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));628  });629});630631describe('NFT: Substrate calls', () => {632  let donor: IKeyringPair;633  let alice: IKeyringPair;634635  before(async function() {636    await usingEthPlaygrounds(async (helper, privateKey) => {637      donor = await privateKey({filename: __filename});638      [alice] = await helper.arrange.createAccounts([20n], donor);639    });640  });641642  itEth('Events emitted for mint()', async ({helper}) => {643    const collection = await helper.nft.mintCollection(alice, {});644    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);645    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');646647    const events: any = [];648    contract.events.allEvents((_: any, event: any) => {649      events.push(event);650    });651652    const {tokenId} = await collection.mintToken(alice);653    if (events.length == 0) await helper.wait.newBlocks(1);654    const event = events[0];655656    expect(event.event).to.be.equal('Transfer');657    expect(event.address).to.be.equal(collectionAddress);658    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');659    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(alice.address));660    expect(event.returnValues.tokenId).to.be.equal(tokenId.toString());661  });662663  itEth('Events emitted for burn()', async ({helper}) => {664    const collection = await helper.nft.mintCollection(alice, {});665    const token = await collection.mintToken(alice);666667    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);668    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');669670    const events: any = [];671    contract.events.allEvents((_: any, event: any) => {672      events.push(event);673    });674675    await token.burn(alice);676    if (events.length == 0) await helper.wait.newBlocks(1);677    const event = events[0];678679    expect(event.event).to.be.equal('Transfer');680    expect(event.address).to.be.equal(collectionAddress);681    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));682    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');683    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());684  });685686  itEth('Events emitted for approve()', async ({helper}) => {687    const receiver = helper.eth.createAccount();688689    const collection = await helper.nft.mintCollection(alice, {});690    const token = await collection.mintToken(alice);691692    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);693    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');694695    const events: any = [];696    contract.events.allEvents((_: any, event: any) => {697      events.push(event);698    });699700    await token.approve(alice, {Ethereum: receiver});701    if (events.length == 0) await helper.wait.newBlocks(1);702    const event = events[0];703704    expect(event.event).to.be.equal('Approval');705    expect(event.address).to.be.equal(collectionAddress);706    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));707    expect(event.returnValues.approved).to.be.equal(receiver);708    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());709  });710711  itEth('Events emitted for transferFrom()', async ({helper}) => {712    const [bob] = await helper.arrange.createAccounts([10n], donor);713    const receiver = helper.eth.createAccount();714715    const collection = await helper.nft.mintCollection(alice, {});716    const token = await collection.mintToken(alice);717    await token.approve(alice, {Substrate: bob.address});718719    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);720    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');721722    const events: any = [];723    contract.events.allEvents((_: any, event: any) => {724      events.push(event);725    });726727    await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver});728729    if (events.length == 0) await helper.wait.newBlocks(1);730    const event = events[0];731732    expect(event.address).to.be.equal(collectionAddress);733    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));734    expect(event.returnValues.to).to.be.equal(receiver);735    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);736  });737738  itEth('Events emitted for transfer()', async ({helper}) => {739    const receiver = helper.eth.createAccount();740741    const collection = await helper.nft.mintCollection(alice, {});742    const token = await collection.mintToken(alice);743744    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);745    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');746747    const events: any = [];748    contract.events.allEvents((_: any, event: any) => {749      events.push(event);750    });751752    await token.transfer(alice, {Ethereum: receiver});753754    if (events.length == 0) await helper.wait.newBlocks(1);755    const event = events[0];756757    expect(event.address).to.be.equal(collectionAddress);758    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));759    expect(event.returnValues.to).to.be.equal(receiver);760    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);761  });762});763764describe('Common metadata', () => {765  let donor: IKeyringPair;766  let alice: IKeyringPair;767768  before(async function() {769    await usingEthPlaygrounds(async (helper, privateKey) => {770      donor = await privateKey({filename: __filename});771      [alice] = await helper.arrange.createAccounts([20n], donor);772    });773  });774775  itEth('Returns collection name', async ({helper}) => {776    const caller = await helper.eth.createAccountWithBalance(donor);777    const tokenPropertyPermissions = [{778      key: 'URI',779      permission: {780        mutable: true,781        collectionAdmin: true,782        tokenOwner: false,783      },784    }];785    const collection = await helper.nft.mintCollection(786      alice,787      {788        name: 'oh River',789        tokenPrefix: 'CHANGE',790        properties: [{key: 'ERC721Metadata', value: '1'}],791        tokenPropertyPermissions,792      },793    );794795    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);796    const name = await contract.methods.name().call();797    expect(name).to.equal('oh River');798  });799800  itEth('Returns symbol name', async ({helper}) => {801    const caller = await helper.eth.createAccountWithBalance(donor);802    const tokenPropertyPermissions = [{803      key: 'URI',804      permission: {805        mutable: true,806        collectionAdmin: true,807        tokenOwner: false,808      },809    }];810    const collection = await helper.nft.mintCollection(811      alice,812      {813        name: 'oh River',814        tokenPrefix: 'CHANGE',815        properties: [{key: 'ERC721Metadata', value: '1'}],816        tokenPropertyPermissions,817      },818    );819820    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);821    const symbol = await contract.methods.symbol().call();822    expect(symbol).to.equal('CHANGE');823  });824});