git.delta.rocks / unique-network / refs/commits / a3eb5c564fa0

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';20import {ITokenPropertyPermission} from '../util/playgrounds/types';2122describe('Check ERC721 token URI for NFT', () => {23  let donor: IKeyringPair;2425  before(async function() {26    await usingEthPlaygrounds(async (_helper, privateKey) => {27      donor = await privateKey({url: import.meta.url});28    });29  });3031  async function setup(helper: EthUniqueHelper, baseUri: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {32    const owner = await helper.eth.createAccountWithBalance(donor);33    const receiver = helper.eth.createAccount();3435    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Mint collection', 'a', 'b', baseUri);36    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);3738    const result = await contract.methods.mint(receiver).send();39    const tokenId = result.events.Transfer.returnValues.tokenId;40    expect(tokenId).to.be.equal('1');4142    if(propertyKey && propertyValue) {43      // Set URL or suffix44      await contract.methods.setProperties(tokenId, [{key: propertyKey, value: Buffer.from(propertyValue)}]).send();45    }4647    const event = result.events.Transfer;48    expect(event.address).to.be.equal(collectionAddress);49    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');50    expect(event.returnValues.to).to.be.equal(receiver);51    expect(event.returnValues.tokenId).to.be.equal(tokenId);5253    return {contract, nextTokenId: tokenId};54  }5556  itEth('Empty tokenURI', async ({helper}) => {57    const {contract, nextTokenId} = await setup(helper, '');58    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');59  });6061  itEth('TokenURI from url', async ({helper}) => {62    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URI', 'Token URI');63    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');64  });6566  itEth('TokenURI from baseURI', async ({helper}) => {67    const {contract, nextTokenId} = await setup(helper, 'BaseURI_');68    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_');69  });7071  itEth('TokenURI from baseURI + suffix', async ({helper}) => {72    const suffix = '/some/suffix';73    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URISuffix', suffix);74    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);75  });76});7778describe('NFT: Plain calls', () => {79  let donor: IKeyringPair;80  let minter: IKeyringPair;81  let bob: IKeyringPair;82  let charlie: IKeyringPair;8384  before(async function() {85    await usingEthPlaygrounds(async (helper, privateKey) => {86      donor = await privateKey({url: import.meta.url});87      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);88    });89  });9091  // TODO combine all minting tests in one place92  [93    'substrate' as const,94    'ethereum' as const,95  ].map(testCase => {96    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {97      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);9899      const receiverEth = helper.eth.createAccount();100      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);101      const receiverSub = bob;102      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);103104      // const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);105      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));106      const permissions: ITokenPropertyPermission[] = properties107        .map(p => ({108          key: p.key, permission: {109            tokenOwner: false,110            collectionAdmin: true,111            mutable: false,112          },113        }));114115      const collection = await helper.nft.mintCollection(minter, {116        tokenPrefix: 'ethp',117        tokenPropertyPermissions: permissions,118      });119      await collection.addAdmin(minter, {Ethereum: collectionAdmin});120121      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);122      const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', collectionAdmin, true);123      let expectedTokenId = await contract.methods.nextTokenId().call();124      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();125      let tokenId = result.events.Transfer.returnValues.tokenId;126      expect(tokenId).to.be.equal(expectedTokenId);127128      let event = result.events.Transfer;129      expect(event.address).to.be.equal(collectionAddress);130      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');131      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));132      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);133134      expectedTokenId = await contract.methods.nextTokenId().call();135      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();136      event = result.events.Transfer;137      expect(event.address).to.be.equal(collectionAddress);138      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');139      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));140      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);141142      tokenId = result.events.Transfer.returnValues.tokenId;143144      expect(tokenId).to.be.equal(expectedTokenId);145146      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties147        .map(p => helper.ethProperty.property(p.key, p.value.toString())));148149      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))150        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});151    });152  });153154  itEth('Non-owner and non admin cannot mintCross', async ({helper}) => {155    const nonOwner = await helper.eth.createAccountWithBalance(donor);156    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);157158    const collection = await helper.nft.mintCollection(minter);159    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);160    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft');161162    await expect(collectionEvm.methods.mintCross(nonOwnerCross, []).call({from: nonOwner}))163      .to.be.rejectedWith('PublicMintingNotAllowed');164  });165166  //TODO: CORE-302 add eth methods167  itEth.skip('Can perform mintBulk()', async ({helper}) => {168    const caller = await helper.eth.createAccountWithBalance(donor);169    const receiver = helper.eth.createAccount();170171    const collection = await helper.nft.mintCollection(minter);172    await collection.addAdmin(minter, {Ethereum: caller});173174    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);175    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', caller);176    {177      const bulkSize = 3;178      const nextTokenId = await contract.methods.nextTokenId().call();179      expect(nextTokenId).to.be.equal('1');180      const result = await contract.methods.mintBulkWithTokenURI(181        receiver,182        Array.from({length: bulkSize}, (_, i) => (183          [+nextTokenId + i, `Test URI ${i}`]184        )),185      ).send({from: caller});186187      const events = result.events.Transfer.sort((a: any, b: any) => +a.returnValues.tokenId - b.returnValues.tokenId);188      for(let i = 0; i < bulkSize; i++) {189        const event = events[i];190        expect(event.address).to.equal(collectionAddress);191        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');192        expect(event.returnValues.to).to.equal(receiver);193        expect(event.returnValues.tokenId).to.equal(`${+nextTokenId + i}`);194195        expect(await contract.methods.tokenURI(+nextTokenId + i).call()).to.be.equal(`Test URI ${i}`);196      }197    }198  });199200  itEth('Can perform burn()', async ({helper}) => {201    const caller = await helper.eth.createAccountWithBalance(donor);202203    const collection = await helper.nft.mintCollection(minter, {});204    const {tokenId} = await collection.mintToken(minter, {Ethereum: caller});205206    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);207    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', caller);208209    {210      const result = await contract.methods.burn(tokenId).send({from: caller});211212      const event = result.events.Transfer;213      expect(event.address).to.be.equal(collectionAddress);214      expect(event.returnValues.from).to.be.equal(caller);215      expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');216      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);217    }218  });219220  itEth('Can perform approve()', async ({helper}) => {221    const owner = await helper.eth.createAccountWithBalance(donor);222    const spender = helper.eth.createAccount();223224    const collection = await helper.nft.mintCollection(minter, {});225    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});226227    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);228    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);229230    {231      const badTokenId = await contract.methods.nextTokenId().call() + 1;232      await expect(contract.methods.getApproved(badTokenId).call()).to.be.rejectedWith('revert TokenNotFound');233    }234    {235      const approved = await contract.methods.getApproved(tokenId).call();236      expect(approved).to.be.equal('0x0000000000000000000000000000000000000000');237    }238    {239      const result = await contract.methods.approve(spender, tokenId).send({from: owner});240241      const event = result.events.Approval;242      expect(event.address).to.be.equal(collectionAddress);243      expect(event.returnValues.owner).to.be.equal(owner);244      expect(event.returnValues.approved).to.be.equal(spender);245      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);246    }247    {248      const approved = await contract.methods.getApproved(tokenId).call();249      expect(approved).to.be.equal(spender);250    }251  });252253  itEth('Can perform setApprovalForAll()', async ({helper}) => {254    const owner = await helper.eth.createAccountWithBalance(donor);255    const operator = helper.eth.createAccount();256257    const collection = await helper.nft.mintCollection(minter, {});258259    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);260    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);261262    const approvedBefore = await contract.methods.isApprovedForAll(owner, operator).call();263    expect(approvedBefore).to.be.equal(false);264265    {266      const result = await contract.methods.setApprovalForAll(operator, true).send({from: owner});267268      expect(result.events.ApprovalForAll).to.be.like({269        address: collectionAddress,270        event: 'ApprovalForAll',271        returnValues: {272          owner,273          operator,274          approved: true,275        },276      });277278      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();279      expect(approvedAfter).to.be.equal(true);280    }281282    {283      const result = await contract.methods.setApprovalForAll(operator, false).send({from: owner});284285      expect(result.events.ApprovalForAll).to.be.like({286        address: collectionAddress,287        event: 'ApprovalForAll',288        returnValues: {289          owner,290          operator,291          approved: false,292        },293      });294295      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();296      expect(approvedAfter).to.be.equal(false);297    }298  });299300  itEth('Can perform burn with ApprovalForAll', async ({helper}) => {301    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});302303    const owner = await helper.eth.createAccountWithBalance(donor);304    const operator = await helper.eth.createAccountWithBalance(donor);305306    const token = await collection.mintToken(minter, {Ethereum: owner});307308    const address = helper.ethAddress.fromCollectionId(collection.collectionId);309    const contract = await helper.ethNativeContract.collection(address, 'nft');310311    {312      await contract.methods.setApprovalForAll(operator, true).send({from: owner});313      const ownerCross = helper.ethCrossAccount.fromAddress(owner);314      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: operator});315      const events = result.events.Transfer;316317      expect(events).to.be.like({318        address,319        event: 'Transfer',320        returnValues: {321          from: owner,322          to: '0x0000000000000000000000000000000000000000',323          tokenId: token.tokenId.toString(),324        },325      });326    }327328    expect(await helper.nft.doesTokenExist(collection.collectionId, token.tokenId)).to.be.false;329  });330331  itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {332    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});333334    const owner = await helper.eth.createAccountWithBalance(donor);335    const operator = await helper.eth.createAccountWithBalance(donor);336    const receiver = charlie;337338    const token = await collection.mintToken(minter, {Ethereum: owner});339340    const address = helper.ethAddress.fromCollectionId(collection.collectionId);341    const contract = await helper.ethNativeContract.collection(address, 'nft');342343    {344      await contract.methods.setApprovalForAll(operator, true).send({from: owner});345      const ownerCross = helper.ethCrossAccount.fromAddress(owner);346      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);347      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: operator});348      const event = result.events.Transfer;349      expect(event).to.be.like({350        address: helper.ethAddress.fromCollectionId(collection.collectionId),351        event: 'Transfer',352        returnValues: {353          from: owner,354          to: helper.address.substrateToEth(receiver.address),355          tokenId: token.tokenId.toString(),356        },357      });358    }359360    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});361  });362363  itEth('Can perform burnFromCross()', async ({helper}) => {364    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});365    const ownerSub = bob;366    const ownerCrossSub = helper.ethCrossAccount.fromKeyringPair(ownerSub);367    const ownerEth = await helper.eth.createAccountWithBalance(donor);368    const ownerCrossEth = helper.ethCrossAccount.fromAddress(ownerEth);369370    const burnerEth = await helper.eth.createAccountWithBalance(donor);371    const burnerCrossEth = helper.ethCrossAccount.fromAddress(burnerEth);372373    const token1 = await collection.mintToken(minter, {Substrate: ownerSub.address});374    const token2 = await collection.mintToken(minter, {Ethereum: ownerEth});375376    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);377    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft');378379    // Approve tokens from substrate and ethereum:380    await token1.approve(ownerSub, {Ethereum: burnerEth});381    await collectionEvm.methods.approveCross(burnerCrossEth, token2.tokenId).send({from: ownerEth});382383    // can burnFromCross:384    const result1 = await collectionEvm.methods.burnFromCross(ownerCrossSub, token1.tokenId).send({from: burnerEth});385    const result2 = await collectionEvm.methods.burnFromCross(ownerCrossEth, token2.tokenId).send({from: burnerEth});386    const events1 = result1.events.Transfer;387    const events2 = result2.events.Transfer;388389    // Check events for burnFromCross (substrate and ethereum):390    [391      [events1, token1, helper.address.substrateToEth(ownerSub.address)],392      [events2, token2, ownerEth],393    ].map(burnData => {394      expect(burnData[0]).to.be.like({395        address: collectionAddress,396        event: 'Transfer',397        returnValues: {398          from: burnData[2],399          to: '0x0000000000000000000000000000000000000000',400          tokenId: burnData[1].tokenId.toString(),401        },402      });403    });404405    expect(await token1.doesExist()).to.be.false;406    expect(await token2.doesExist()).to.be.false;407  });408409  // TODO combine all approve tests in one place410  itEth('Can perform approveCross()', async ({helper}) => {411    // arrange: create accounts412    const owner = await helper.eth.createAccountWithBalance(donor);413    const ownerCross = helper.ethCrossAccount.fromAddress(owner);414    const receiverSub = charlie;415    const recieverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);416    const receiverEth = await helper.eth.createAccountWithBalance(donor);417    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);418419    // arrange: create collection and tokens:420    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});421    const token1 = await collection.mintToken(minter, {Ethereum: owner});422    const token2 = await collection.mintToken(minter, {Ethereum: owner});423424    const collectionEvm = await helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');425426    // Can approveCross substrate and ethereum address:427    const resultSub = await collectionEvm.methods.approveCross(recieverCrossSub, token1.tokenId).send({from: owner});428    const resultEth = await collectionEvm.methods.approveCross(receiverCrossEth, token2.tokenId).send({from: owner});429    const eventSub = resultSub.events.Approval;430    const eventEth = resultEth.events.Approval;431    expect(eventSub).to.be.like({432      address: helper.ethAddress.fromCollectionId(collection.collectionId),433      event: 'Approval',434      returnValues: {435        owner,436        approved: helper.address.substrateToEth(receiverSub.address),437        tokenId: token1.tokenId.toString(),438      },439    });440    expect(eventEth).to.be.like({441      address: helper.ethAddress.fromCollectionId(collection.collectionId),442      event: 'Approval',443      returnValues: {444        owner,445        approved: receiverEth,446        tokenId: token2.tokenId.toString(),447      },448    });449450    // Substrate address can transferFrom approved tokens:451    await helper.nft.transferTokenFrom(receiverSub, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiverSub.address});452    expect(await helper.nft.getTokenOwner(collection.collectionId, token1.tokenId)).to.deep.eq({Substrate: receiverSub.address});453    // Ethereum address can transferFromCross approved tokens:454    await collectionEvm.methods.transferFromCross(ownerCross, receiverCrossEth, token2.tokenId).send({from: receiverEth});455    expect(await helper.nft.getTokenOwner(collection.collectionId, token2.tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});456  });457458  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {459    const nonOwner = await helper.eth.createAccountWithBalance(donor);460    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);461    const owner = await helper.eth.createAccountWithBalance(donor);462    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});463    const collectionEvm = await helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');464    const token = await collection.mintToken(minter, {Ethereum: owner});465466    await expect(collectionEvm.methods.approveCross(nonOwnerCross, token.tokenId).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');467  });468469  itEth('Can reaffirm approved address', async ({helper}) => {470    const owner = await helper.eth.createAccountWithBalance(donor);471    const ownerCrossEth = helper.ethCrossAccount.fromAddress(owner);472    const [receiver1, receiver2] = await helper.arrange.createAccounts([100n, 100n], donor);473    const receiver1Cross = helper.ethCrossAccount.fromKeyringPair(receiver1);474    const receiver2Cross = helper.ethCrossAccount.fromKeyringPair(receiver2);475    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});476    const token1 = await collection.mintToken(minter, {Ethereum: owner});477    const token2 = await collection.mintToken(minter, {Ethereum: owner});478    const collectionEvm = await helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');479480    // Can approve and reaffirm approved address:481    await collectionEvm.methods.approveCross(receiver1Cross, token1.tokenId).send({from: owner});482    await collectionEvm.methods.approveCross(receiver2Cross, token1.tokenId).send({from: owner});483484    // receiver1 cannot transferFrom:485    await expect(helper.nft.transferTokenFrom(receiver1, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiver1.address})).to.be.rejected;486    // receiver2 can transferFrom:487    await helper.nft.transferTokenFrom(receiver2, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiver2.address});488489    // can set approved address to self address to remove approval:490    await collectionEvm.methods.approveCross(receiver1Cross, token2.tokenId).send({from: owner});491    await collectionEvm.methods.approveCross(ownerCrossEth, token2.tokenId).send({from: owner});492493    // receiver1 cannot transfer token anymore:494    await expect(helper.nft.transferTokenFrom(receiver1, collection.collectionId, token2.tokenId, {Ethereum: owner}, {Substrate: receiver1.address})).to.be.rejected;495  });496497  itEth('Can perform transferFrom()', async ({helper}) => {498    const owner = await helper.eth.createAccountWithBalance(donor);499    const spender = await helper.eth.createAccountWithBalance(donor);500    const receiver = helper.eth.createAccount();501502    const collection = await helper.nft.mintCollection(minter, {});503    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});504505    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);506    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);507508    await contract.methods.approve(spender, tokenId).send({from: owner});509510    {511      const result = await contract.methods.transferFrom(owner, receiver, tokenId).send({from: spender});512513      const event = result.events.Transfer;514      expect(event.address).to.be.equal(collectionAddress);515      expect(event.returnValues.from).to.be.equal(owner);516      expect(event.returnValues.to).to.be.equal(receiver);517      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);518    }519520    {521      const balance = await contract.methods.balanceOf(receiver).call();522      expect(+balance).to.equal(1);523    }524525    {526      const balance = await contract.methods.balanceOf(owner).call();527      expect(+balance).to.equal(0);528    }529  });530531  itEth('Can perform transferFromCross()', async ({helper}) => {532    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});533534    const [owner, receiver] = await helper.arrange.createAccounts([100n, 100n], donor);535    const spender = await helper.eth.createAccountWithBalance(donor);536537    const token = await collection.mintToken(minter, {Substrate: owner.address});538539    const address = helper.ethAddress.fromCollectionId(collection.collectionId);540    const contract = await helper.ethNativeContract.collection(address, 'nft');541542    await token.approve(owner, {Ethereum: spender});543544    {545      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);546      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);547      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});548      const event = result.events.Transfer;549      expect(event).to.be.like({550        address: helper.ethAddress.fromCollectionId(collection.collectionId),551        event: 'Transfer',552        returnValues: {553          from: helper.address.substrateToEth(owner.address),554          to: helper.address.substrateToEth(receiver.address),555          tokenId: token.tokenId.toString(),556        },557      });558    }559560    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});561  });562563  itEth('Can perform transfer()', async ({helper}) => {564    const collection = await helper.nft.mintCollection(minter, {});565    const owner = await helper.eth.createAccountWithBalance(donor);566    const receiver = helper.eth.createAccount();567568    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});569570    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);571    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);572573    {574      const result = await contract.methods.transfer(receiver, tokenId).send({from: owner});575576      const event = result.events.Transfer;577      expect(event.address).to.be.equal(collectionAddress);578      expect(event.returnValues.from).to.be.equal(owner);579      expect(event.returnValues.to).to.be.equal(receiver);580      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);581    }582583    {584      const balance = await contract.methods.balanceOf(owner).call();585      expect(+balance).to.equal(0);586    }587588    {589      const balance = await contract.methods.balanceOf(receiver).call();590      expect(+balance).to.equal(1);591    }592  });593594  itEth('Can perform transferCross()', async ({helper}) => {595    const collection = await helper.nft.mintCollection(minter, {});596    const owner = await helper.eth.createAccountWithBalance(donor);597    const receiverEth = await helper.eth.createAccountWithBalance(donor);598    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);599    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);600601    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});602603    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);604    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);605606    {607      // Can transferCross to ethereum address:608      const result = await collectionEvm.methods.transferCross(receiverCrossEth, tokenId).send({from: owner});609      // Check events:610      const event = result.events.Transfer;611      expect(event.address).to.be.equal(collectionAddress);612      expect(event.returnValues.from).to.be.equal(owner);613      expect(event.returnValues.to).to.be.equal(receiverEth);614      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);615616      // owner has balance = 0:617      const ownerBalance = await collectionEvm.methods.balanceOf(owner).call();618      expect(+ownerBalance).to.equal(0);619      // receiver owns token:620      const receiverBalance = await collectionEvm.methods.balanceOf(receiverEth).call();621      expect(+receiverBalance).to.equal(1);622      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});623    }624625    {626      // Can transferCross to substrate address:627      const substrateResult = await collectionEvm.methods.transferCross(receiverCrossSub, tokenId).send({from: receiverEth});628      // Check events:629      const event = substrateResult.events.Transfer;630      expect(event.address).to.be.equal(collectionAddress);631      expect(event.returnValues.from).to.be.equal(receiverEth);632      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(minter.address));633      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);634635      // owner has balance = 0:636      const ownerBalance = await collectionEvm.methods.balanceOf(receiverEth).call();637      expect(+ownerBalance).to.equal(0);638      // receiver owns token:639      const receiverBalance = await helper.nft.getTokensByAddress(collection.collectionId, {Substrate: minter.address});640      expect(receiverBalance).to.contain(tokenId);641    }642  });643644  ['transfer', 'transferCross'].map(testCase => itEth(`Cannot ${testCase} non-owned token`, async ({helper}) => {645    const sender = await helper.eth.createAccountWithBalance(donor);646    const tokenOwner = await helper.eth.createAccountWithBalance(donor);647    const receiverSub = minter;648    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);649650    const collection = await helper.nft.mintCollection(minter, {});651    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);652    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', sender);653654    await collection.mintToken(minter, {Ethereum: sender});655    const nonSendersToken = await collection.mintToken(minter, {Ethereum: tokenOwner});656657    // Cannot transferCross someone else's token:658    const receiver = testCase === 'transfer' ? helper.address.substrateToEth(receiverSub.address) : receiverCrossSub;659    await expect(collectionEvm.methods[testCase](receiver, nonSendersToken.tokenId).send({from: sender})).to.be.rejected;660    // Cannot transfer token if it does not exist:661    await expect(collectionEvm.methods[testCase](receiver, 999999).send({from: sender})).to.be.rejected;662  }));663664  itEth('Check balanceOfCross()', async ({helper}) => {665    const collection = await helper.nft.mintCollection(minter, {});666    const owner = await helper.ethCrossAccount.createAccountWithBalance(donor);667    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);668    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner.eth);669670    expect(await collectionEvm.methods.balanceOfCross(owner).call({from: owner.eth})).to.be.eq('0');671672    for(let i = 1; i < 10; i++) {673      await collection.mintToken(minter, {Ethereum: owner.eth});674      expect(await collectionEvm.methods.balanceOfCross(owner).call({from: owner.eth})).to.be.eq(i.toString());675    }676  });677678  itEth('Check ownerOfCross()', async ({helper}) => {679    const collection = await helper.nft.mintCollection(minter, {});680    let owner = await helper.ethCrossAccount.createAccountWithBalance(donor);681    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);682    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner.eth);683    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner.eth});684685    for(let i = 1n; i < 10n; i++) {686      const ownerCross = await collectionEvm.methods.ownerOfCross(tokenId).call({from: owner.eth});687      expect(ownerCross.eth).to.be.eq(owner.eth);688      expect(ownerCross.sub).to.be.eq(owner.sub);689690      const newOwner = await helper.ethCrossAccount.createAccountWithBalance(donor);691      await collectionEvm.methods.transferCross(newOwner, tokenId).send({from: owner.eth});692      owner = newOwner;693    }694  });695});696697describe('NFT: Fees', () => {698  let donor: IKeyringPair;699  let alice: IKeyringPair;700  let bob: IKeyringPair;701  let charlie: IKeyringPair;702703  before(async function() {704    await usingEthPlaygrounds(async (helper, privateKey) => {705      donor = await privateKey({url: import.meta.url});706      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);707    });708  });709710  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {711    const owner = await helper.eth.createAccountWithBalance(donor);712    const spender = helper.eth.createAccount();713714    const collection = await helper.nft.mintCollection(alice, {});715    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});716717    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);718719    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, tokenId).send({from: owner}));720    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));721  });722723  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {724    const owner = await helper.eth.createAccountWithBalance(donor);725    const spender = await helper.eth.createAccountWithBalance(donor);726727    const collection = await helper.nft.mintCollection(alice, {});728    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});729730    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);731732    await contract.methods.approve(spender, tokenId).send({from: owner});733734    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, tokenId).send({from: spender}));735    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));736  });737738  itEth('Can perform transferFromCross()', async ({helper}) => {739    const collectionMinter = alice;740    const owner = bob;741    const receiver = charlie;742    const collection = await helper.nft.mintCollection(collectionMinter, {name: 'A', description: 'B', tokenPrefix: 'C'});743744    const spender = await helper.eth.createAccountWithBalance(donor);745746    const token = await collection.mintToken(collectionMinter, {Substrate: owner.address});747748    const address = helper.ethAddress.fromCollectionId(collection.collectionId);749    const contract = await helper.ethNativeContract.collection(address, 'nft');750751    await token.approve(owner, {Ethereum: spender});752753    {754      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);755      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);756      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});757      const event = result.events.Transfer;758      expect(event).to.be.like({759        address: helper.ethAddress.fromCollectionId(collection.collectionId),760        event: 'Transfer',761        returnValues: {762          from: helper.address.substrateToEth(owner.address),763          to: helper.address.substrateToEth(receiver.address),764          tokenId: token.tokenId.toString(),765        },766      });767    }768769    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});770  });771772  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {773    const owner = await helper.eth.createAccountWithBalance(donor);774    const receiver = helper.eth.createAccount();775776    const collection = await helper.nft.mintCollection(alice, {});777    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});778779    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);780781    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, tokenId).send({from: owner}));782    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));783  });784});785786describe('NFT: Substrate calls', () => {787  let donor: IKeyringPair;788  let alice: IKeyringPair;789790  before(async function() {791    await usingEthPlaygrounds(async (helper, privateKey) => {792      donor = await privateKey({url: import.meta.url});793      [alice] = await helper.arrange.createAccounts([20n], donor);794    });795  });796797  itEth('Events emitted for mint()', async ({helper}) => {798    const collection = await helper.nft.mintCollection(alice, {});799    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);800    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');801802    const events: any = [];803    contract.events.allEvents((_: any, event: any) => {804      events.push(event);805    });806807    const {tokenId} = await collection.mintToken(alice);808    if(events.length == 0) await helper.wait.newBlocks(1);809    const event = events[0];810811    expect(event.event).to.be.equal('Transfer');812    expect(event.address).to.be.equal(collectionAddress);813    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');814    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(alice.address));815    expect(event.returnValues.tokenId).to.be.equal(tokenId.toString());816  });817818  itEth('Events emitted for burn()', async ({helper}) => {819    const collection = await helper.nft.mintCollection(alice, {});820    const token = await collection.mintToken(alice);821822    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);823    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');824825    const events: any = [];826    contract.events.allEvents((_: any, event: any) => {827      events.push(event);828    });829830    await token.burn(alice);831    if(events.length == 0) await helper.wait.newBlocks(1);832    const event = events[0];833834    expect(event.event).to.be.equal('Transfer');835    expect(event.address).to.be.equal(collectionAddress);836    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));837    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');838    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());839  });840841  itEth('Events emitted for approve()', async ({helper}) => {842    const receiver = helper.eth.createAccount();843844    const collection = await helper.nft.mintCollection(alice, {});845    const token = await collection.mintToken(alice);846847    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);848    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');849850    const events: any = [];851    contract.events.allEvents((_: any, event: any) => {852      events.push(event);853    });854855    await token.approve(alice, {Ethereum: receiver});856    if(events.length == 0) await helper.wait.newBlocks(1);857    const event = events[0];858859    expect(event.event).to.be.equal('Approval');860    expect(event.address).to.be.equal(collectionAddress);861    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));862    expect(event.returnValues.approved).to.be.equal(receiver);863    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());864  });865866  itEth('Events emitted for transferFrom()', async ({helper}) => {867    const [bob] = await helper.arrange.createAccounts([10n], donor);868    const receiver = helper.eth.createAccount();869870    const collection = await helper.nft.mintCollection(alice, {});871    const token = await collection.mintToken(alice);872    await token.approve(alice, {Substrate: bob.address});873874    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);875    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');876877    const events: any = [];878    contract.events.allEvents((_: any, event: any) => {879      events.push(event);880    });881882    await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver});883884    if(events.length == 0) await helper.wait.newBlocks(1);885    const event = events[0];886887    expect(event.address).to.be.equal(collectionAddress);888    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));889    expect(event.returnValues.to).to.be.equal(receiver);890    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);891  });892893  itEth('Events emitted for transfer()', async ({helper}) => {894    const receiver = helper.eth.createAccount();895896    const collection = await helper.nft.mintCollection(alice, {});897    const token = await collection.mintToken(alice);898899    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);900    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');901902    const events: any = [];903    contract.events.allEvents((_: any, event: any) => {904      events.push(event);905    });906907    await token.transfer(alice, {Ethereum: receiver});908909    if(events.length == 0) await helper.wait.newBlocks(1);910    const event = events[0];911912    expect(event.address).to.be.equal(collectionAddress);913    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));914    expect(event.returnValues.to).to.be.equal(receiver);915    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);916  });917});918919describe('Common metadata', () => {920  let donor: IKeyringPair;921  let alice: IKeyringPair;922923  before(async function() {924    await usingEthPlaygrounds(async (helper, privateKey) => {925      donor = await privateKey({url: import.meta.url});926      [alice] = await helper.arrange.createAccounts([20n], donor);927    });928  });929930  itEth('Returns collection name', async ({helper}) => {931    const caller = helper.eth.createAccount();932    const tokenPropertyPermissions = [{933      key: 'URI',934      permission: {935        mutable: true,936        collectionAdmin: true,937        tokenOwner: false,938      },939    }];940    const collection = await helper.nft.mintCollection(941      alice,942      {943        name: 'oh River',944        tokenPrefix: 'CHANGE',945        properties: [{key: 'ERC721Metadata', value: '1'}],946        tokenPropertyPermissions,947      },948    );949950    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);951    const name = await contract.methods.name().call();952    expect(name).to.equal('oh River');953  });954955  itEth('Returns symbol name', async ({helper}) => {956    const caller = await helper.eth.createAccountWithBalance(donor);957    const tokenPropertyPermissions = [{958      key: 'URI',959      permission: {960        mutable: true,961        collectionAdmin: true,962        tokenOwner: false,963      },964    }];965    const collection = await helper.nft.mintCollection(966      alice,967      {968        name: 'oh River',969        tokenPrefix: 'CHANGE',970        properties: [{key: 'ERC721Metadata', value: '1'}],971        tokenPropertyPermissions,972      },973    );974975    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);976    const symbol = await contract.methods.symbol().call();977    expect(symbol).to.equal('CHANGE');978  });979});980981describe('Negative tests', () => {982  let donor: IKeyringPair;983  let minter: IKeyringPair;984  let alice: IKeyringPair;985986  before(async function() {987    await usingEthPlaygrounds(async (helper, privateKey) => {988      donor = await privateKey({url: import.meta.url});989      [minter, alice] = await helper.arrange.createAccounts([100n, 100n], donor);990    });991  });992993  itEth('[negative] Cant perform burn without approval', async ({helper}) => {994    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});995996    const owner = await helper.eth.createAccountWithBalance(donor);997    const spender = await helper.eth.createAccountWithBalance(donor);998999    const token = await collection.mintToken(minter, {Ethereum: owner});10001001    const address = helper.ethAddress.fromCollectionId(collection.collectionId);1002    const contract = await helper.ethNativeContract.collection(address, 'nft');10031004    const ownerCross = helper.ethCrossAccount.fromAddress(owner);1005    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;10061007    await contract.methods.setApprovalForAll(spender, true).send({from: owner});1008    await contract.methods.setApprovalForAll(spender, false).send({from: owner});10091010    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;1011  });10121013  itEth('[negative] Cant perform transfer without approval', async ({helper}) => {1014    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});1015    const receiver = alice;10161017    const owner = await helper.eth.createAccountWithBalance(donor);1018    const spender = await helper.eth.createAccountWithBalance(donor);10191020    const token = await collection.mintToken(minter, {Ethereum: owner});10211022    const address = helper.ethAddress.fromCollectionId(collection.collectionId);1023    const contract = await helper.ethNativeContract.collection(address, 'nft');10241025    const ownerCross = helper.ethCrossAccount.fromAddress(owner);1026    const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);10271028    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;10291030    await contract.methods.setApprovalForAll(spender, true).send({from: owner});1031    await contract.methods.setApprovalForAll(spender, false).send({from: owner});10321033    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;1034  });1035});