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

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';21import {CREATE_COLLECTION_DATA_DEFAULTS, CollectionMode, CreateCollectionData, TokenPermissionField} from './util/playgrounds/types';2223describe('Check ERC721 token URI for NFT', () => {24  let donor: IKeyringPair;2526  before(async function() {27    await usingEthPlaygrounds(async (_helper, privateKey) => {28      donor = await privateKey({url: import.meta.url});29    });30  });3132  async function setup(helper: EthUniqueHelper, baseUri: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {33    const owner = await helper.eth.createAccountWithBalance(donor);34    const receiver = helper.eth.createAccount();3536    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Mint collection', 'a', 'b', baseUri);37    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);3839    const result = await contract.methods.mint(receiver).send();40    const tokenId = result.events.Transfer.returnValues.tokenId;41    expect(tokenId).to.be.equal('1');4243    if(propertyKey && propertyValue) {44      // Set URL or suffix45      await contract.methods.setProperties(tokenId, [{key: propertyKey, value: Buffer.from(propertyValue)}]).send();46    }4748    const event = result.events.Transfer;49    expect(event.address).to.be.equal(collectionAddress);50    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');51    expect(event.returnValues.to).to.be.equal(receiver);52    expect(event.returnValues.tokenId).to.be.equal(tokenId);5354    return {contract, nextTokenId: tokenId};55  }5657  itEth('Empty tokenURI', async ({helper}) => {58    const {contract, nextTokenId} = await setup(helper, '');59    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');60  });6162  itEth('TokenURI from url', async ({helper}) => {63    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URI', 'Token URI');64    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');65  });6667  itEth('TokenURI from baseURI', async ({helper}) => {68    const {contract, nextTokenId} = await setup(helper, 'BaseURI_');69    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_');70  });7172  itEth('TokenURI from baseURI + suffix', async ({helper}) => {73    const suffix = '/some/suffix';74    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URISuffix', suffix);75    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);76  });77});7879describe('NFT: Plain calls', () => {80  let donor: IKeyringPair;81  let minter: IKeyringPair;82  let bob: IKeyringPair;83  let charlie: IKeyringPair;8485  before(async function() {86    await usingEthPlaygrounds(async (helper, privateKey) => {87      donor = await privateKey({url: import.meta.url});88      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);89    });90  });9192  // TODO combine all minting tests in one place93  [94    'substrate' as const,95    'ethereum' as const,96  ].map(testCase => {97    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {98      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);99100      const receiverEth = helper.eth.createAccount();101      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);102      const receiverSub = bob;103      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);104105      // const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);106      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));107      const permissions: ITokenPropertyPermission[] = properties108        .map(p => ({109          key: p.key, permission: {110            tokenOwner: false,111            collectionAdmin: true,112            mutable: false,113          },114        }));115116      const collection = await helper.nft.mintCollection(minter, {117        tokenPrefix: 'ethp',118        tokenPropertyPermissions: permissions,119      });120      await collection.addAdmin(minter, {Ethereum: collectionAdmin});121122      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);123      const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', collectionAdmin, true);124      let expectedTokenId = await contract.methods.nextTokenId().call();125      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();126      let tokenId = result.events.Transfer.returnValues.tokenId;127      expect(tokenId).to.be.equal(expectedTokenId);128129      let event = result.events.Transfer;130      expect(event.address).to.be.equal(collectionAddress);131      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');132      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));133      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);134135      expectedTokenId = await contract.methods.nextTokenId().call();136      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();137      event = result.events.Transfer;138      expect(event.address).to.be.equal(collectionAddress);139      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');140      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));141      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);142143      tokenId = result.events.Transfer.returnValues.tokenId;144145      expect(tokenId).to.be.equal(expectedTokenId);146147      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties148        .map(p => helper.ethProperty.property(p.key, p.value.toString())));149150      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))151        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});152    });153  });154155  itEth('Non-owner and non admin cannot mintCross', async ({helper}) => {156    const nonOwner = await helper.eth.createAccountWithBalance(donor);157    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);158159    const collection = await helper.nft.mintCollection(minter);160    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);161    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft');162163    await expect(collectionEvm.methods.mintCross(nonOwnerCross, []).call({from: nonOwner}))164      .to.be.rejectedWith('PublicMintingNotAllowed');165  });166167  //TODO: CORE-302 add eth methods168  itEth.skip('Can perform mintBulk()', async ({helper}) => {169    const caller = await helper.eth.createAccountWithBalance(donor);170    const receiver = helper.eth.createAccount();171172    const collection = await helper.nft.mintCollection(minter);173    await collection.addAdmin(minter, {Ethereum: caller});174175    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);176    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', caller);177    {178      const bulkSize = 3;179      const nextTokenId = await contract.methods.nextTokenId().call();180      expect(nextTokenId).to.be.equal('1');181      const result = await contract.methods.mintBulkWithTokenURI(182        receiver,183        Array.from({length: bulkSize}, (_, i) => (184          [+nextTokenId + i, `Test URI ${i}`]185        )),186      ).send({from: caller});187188      const events = result.events.Transfer.sort((a: any, b: any) => +a.returnValues.tokenId - b.returnValues.tokenId);189      for(let i = 0; i < bulkSize; i++) {190        const event = events[i];191        expect(event.address).to.equal(collectionAddress);192        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');193        expect(event.returnValues.to).to.equal(receiver);194        expect(event.returnValues.tokenId).to.equal(`${+nextTokenId + i}`);195196        expect(await contract.methods.tokenURI(+nextTokenId + i).call()).to.be.equal(`Test URI ${i}`);197      }198    }199  });200201  itEth('Can perform mintBulkCross()', async ({helper}) => {202    const caller = await helper.eth.createAccountWithBalance(donor);203    const callerCross = helper.ethCrossAccount.fromAddress(caller);204    const receiver = helper.eth.createAccount();205    const receiverCross = helper.ethCrossAccount.fromAddress(receiver);206207    const permissions = [208      {code: TokenPermissionField.Mutable, value: true},209      {code: TokenPermissionField.TokenOwner, value: true},210      {code: TokenPermissionField.CollectionAdmin, value: true},211    ];212    const {collectionAddress} = await helper.eth.createCollection(213      caller,214      {215        ...CREATE_COLLECTION_DATA_DEFAULTS,216        name: 'A',217        description: 'B',218        tokenPrefix: 'C',219        collectionMode: 'rft',220        adminList: [callerCross],221        tokenPropertyPermissions: [222          {key: 'key_0_0', permissions},223          {key: 'key_1_0', permissions},224          {key: 'key_1_1', permissions},225          {key: 'key_2_0', permissions},226          {key: 'key_2_1', permissions},227          {key: 'key_2_2', permissions},228        ],229      },230    ).send();231232    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', caller);233    {234      const nextTokenId = await contract.methods.nextTokenId().call();235      expect(nextTokenId).to.be.equal('1');236      const result = await contract.methods.mintBulkCross([237        {238          owner: receiverCross,239          properties: [240            {key: 'key_0_0', value: Buffer.from('value_0_0')},241          ],242        },243        {244          owner: receiverCross,245          properties: [246            {key: 'key_1_0', value: Buffer.from('value_1_0')},247            {key: 'key_1_1', value: Buffer.from('value_1_1')},248          ],249        },250        {251          owner: receiverCross,252          properties: [253            {key: 'key_2_0', value: Buffer.from('value_2_0')},254            {key: 'key_2_1', value: Buffer.from('value_2_1')},255            {key: 'key_2_2', value: Buffer.from('value_2_2')},256          ],257        },258      ]).send({from: caller});259      const events = result.events.Transfer.sort((a: any, b: any) => +a.returnValues.tokenId - b.returnValues.tokenId);260      const bulkSize = 3;261      for(let i = 0; i < bulkSize; i++) {262        const event = events[i];263        expect(event.address).to.equal(collectionAddress);264        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');265        expect(event.returnValues.to).to.equal(receiver);266        expect(event.returnValues.tokenId).to.equal(`${+nextTokenId + i}`);267      }268269      const properties = [270        await contract.methods.properties(+nextTokenId, []).call(),271        await contract.methods.properties(+nextTokenId + 1, []).call(),272        await contract.methods.properties(+nextTokenId + 2, []).call(),273      ];274      expect(properties).to.be.deep.equal([275        [276          ['key_0_0', helper.getWeb3().utils.toHex('value_0_0')],277        ],278        [279          ['key_1_0', helper.getWeb3().utils.toHex('value_1_0')],280          ['key_1_1', helper.getWeb3().utils.toHex('value_1_1')],281        ],282        [283          ['key_2_0', helper.getWeb3().utils.toHex('value_2_0')],284          ['key_2_1', helper.getWeb3().utils.toHex('value_2_1')],285          ['key_2_2', helper.getWeb3().utils.toHex('value_2_2')],286        ],287      ]);288    }289  });290291  itEth('Can perform burn()', async ({helper}) => {292    const caller = await helper.eth.createAccountWithBalance(donor);293294    const collection = await helper.nft.mintCollection(minter, {});295    const {tokenId} = await collection.mintToken(minter, {Ethereum: caller});296297    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);298    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', caller);299300    {301      const result = await contract.methods.burn(tokenId).send({from: caller});302303      const event = result.events.Transfer;304      expect(event.address).to.be.equal(collectionAddress);305      expect(event.returnValues.from).to.be.equal(caller);306      expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');307      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);308    }309  });310311  itEth('Can perform approve()', async ({helper}) => {312    const owner = await helper.eth.createAccountWithBalance(donor);313    const spender = helper.eth.createAccount();314315    const collection = await helper.nft.mintCollection(minter, {});316    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});317318    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);319    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);320321    {322      const badTokenId = await contract.methods.nextTokenId().call() + 1;323      await expect(contract.methods.getApproved(badTokenId).call()).to.be.rejectedWith('revert TokenNotFound');324    }325    {326      const approved = await contract.methods.getApproved(tokenId).call();327      expect(approved).to.be.equal('0x0000000000000000000000000000000000000000');328    }329    {330      const result = await contract.methods.approve(spender, tokenId).send({from: owner});331332      const event = result.events.Approval;333      expect(event.address).to.be.equal(collectionAddress);334      expect(event.returnValues.owner).to.be.equal(owner);335      expect(event.returnValues.approved).to.be.equal(spender);336      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);337    }338    {339      const approved = await contract.methods.getApproved(tokenId).call();340      expect(approved).to.be.equal(spender);341    }342  });343344  itEth('Can perform setApprovalForAll()', async ({helper}) => {345    const owner = await helper.eth.createAccountWithBalance(donor);346    const operator = helper.eth.createAccount();347348    const collection = await helper.nft.mintCollection(minter, {});349350    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);351    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);352353    const approvedBefore = await contract.methods.isApprovedForAll(owner, operator).call();354    expect(approvedBefore).to.be.equal(false);355356    {357      const result = await contract.methods.setApprovalForAll(operator, true).send({from: owner});358359      expect(result.events.ApprovalForAll).to.be.like({360        address: collectionAddress,361        event: 'ApprovalForAll',362        returnValues: {363          owner,364          operator,365          approved: true,366        },367      });368369      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();370      expect(approvedAfter).to.be.equal(true);371    }372373    {374      const result = await contract.methods.setApprovalForAll(operator, false).send({from: owner});375376      expect(result.events.ApprovalForAll).to.be.like({377        address: collectionAddress,378        event: 'ApprovalForAll',379        returnValues: {380          owner,381          operator,382          approved: false,383        },384      });385386      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();387      expect(approvedAfter).to.be.equal(false);388    }389  });390391  itEth('Can perform burn with ApprovalForAll', async ({helper}) => {392    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});393394    const owner = await helper.eth.createAccountWithBalance(donor);395    const operator = await helper.eth.createAccountWithBalance(donor);396397    const token = await collection.mintToken(minter, {Ethereum: owner});398399    const address = helper.ethAddress.fromCollectionId(collection.collectionId);400    const contract = await helper.ethNativeContract.collection(address, 'nft');401402    {403      await contract.methods.setApprovalForAll(operator, true).send({from: owner});404      const ownerCross = helper.ethCrossAccount.fromAddress(owner);405      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: operator});406      const events = result.events.Transfer;407408      expect(events).to.be.like({409        address,410        event: 'Transfer',411        returnValues: {412          from: owner,413          to: '0x0000000000000000000000000000000000000000',414          tokenId: token.tokenId.toString(),415        },416      });417    }418419    expect(await helper.nft.doesTokenExist(collection.collectionId, token.tokenId)).to.be.false;420  });421422  itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {423    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});424425    const owner = await helper.eth.createAccountWithBalance(donor);426    const operator = await helper.eth.createAccountWithBalance(donor);427    const receiver = charlie;428429    const token = await collection.mintToken(minter, {Ethereum: owner});430431    const address = helper.ethAddress.fromCollectionId(collection.collectionId);432    const contract = await helper.ethNativeContract.collection(address, 'nft');433434    {435      await contract.methods.setApprovalForAll(operator, true).send({from: owner});436      const ownerCross = helper.ethCrossAccount.fromAddress(owner);437      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);438      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: operator});439      const event = result.events.Transfer;440      expect(event).to.be.like({441        address: helper.ethAddress.fromCollectionId(collection.collectionId),442        event: 'Transfer',443        returnValues: {444          from: owner,445          to: helper.address.substrateToEth(receiver.address),446          tokenId: token.tokenId.toString(),447        },448      });449    }450451    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});452  });453454  itEth('Can perform burnFromCross()', async ({helper}) => {455    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});456    const ownerSub = bob;457    const ownerCrossSub = helper.ethCrossAccount.fromKeyringPair(ownerSub);458    const ownerEth = await helper.eth.createAccountWithBalance(donor);459    const ownerCrossEth = helper.ethCrossAccount.fromAddress(ownerEth);460461    const burnerEth = await helper.eth.createAccountWithBalance(donor);462    const burnerCrossEth = helper.ethCrossAccount.fromAddress(burnerEth);463464    const token1 = await collection.mintToken(minter, {Substrate: ownerSub.address});465    const token2 = await collection.mintToken(minter, {Ethereum: ownerEth});466467    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);468    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft');469470    // Approve tokens from substrate and ethereum:471    await token1.approve(ownerSub, {Ethereum: burnerEth});472    await collectionEvm.methods.approveCross(burnerCrossEth, token2.tokenId).send({from: ownerEth});473474    // can burnFromCross:475    const result1 = await collectionEvm.methods.burnFromCross(ownerCrossSub, token1.tokenId).send({from: burnerEth});476    const result2 = await collectionEvm.methods.burnFromCross(ownerCrossEth, token2.tokenId).send({from: burnerEth});477    const events1 = result1.events.Transfer;478    const events2 = result2.events.Transfer;479480    // Check events for burnFromCross (substrate and ethereum):481    [482      [events1, token1, helper.address.substrateToEth(ownerSub.address)],483      [events2, token2, ownerEth],484    ].map(burnData => {485      expect(burnData[0]).to.be.like({486        address: collectionAddress,487        event: 'Transfer',488        returnValues: {489          from: burnData[2],490          to: '0x0000000000000000000000000000000000000000',491          tokenId: burnData[1].tokenId.toString(),492        },493      });494    });495496    expect(await token1.doesExist()).to.be.false;497    expect(await token2.doesExist()).to.be.false;498  });499500  // TODO combine all approve tests in one place501  itEth('Can perform approveCross()', async ({helper}) => {502    // arrange: create accounts503    const owner = await helper.eth.createAccountWithBalance(donor);504    const ownerCross = helper.ethCrossAccount.fromAddress(owner);505    const receiverSub = charlie;506    const recieverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);507    const receiverEth = await helper.eth.createAccountWithBalance(donor);508    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);509510    // arrange: create collection and tokens:511    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});512    const token1 = await collection.mintToken(minter, {Ethereum: owner});513    const token2 = await collection.mintToken(minter, {Ethereum: owner});514515    const collectionEvm = await helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');516517    // Can approveCross substrate and ethereum address:518    const resultSub = await collectionEvm.methods.approveCross(recieverCrossSub, token1.tokenId).send({from: owner});519    const resultEth = await collectionEvm.methods.approveCross(receiverCrossEth, token2.tokenId).send({from: owner});520    const eventSub = resultSub.events.Approval;521    const eventEth = resultEth.events.Approval;522    expect(eventSub).to.be.like({523      address: helper.ethAddress.fromCollectionId(collection.collectionId),524      event: 'Approval',525      returnValues: {526        owner,527        approved: helper.address.substrateToEth(receiverSub.address),528        tokenId: token1.tokenId.toString(),529      },530    });531    expect(eventEth).to.be.like({532      address: helper.ethAddress.fromCollectionId(collection.collectionId),533      event: 'Approval',534      returnValues: {535        owner,536        approved: receiverEth,537        tokenId: token2.tokenId.toString(),538      },539    });540541    // Substrate address can transferFrom approved tokens:542    await helper.nft.transferTokenFrom(receiverSub, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiverSub.address});543    expect(await helper.nft.getTokenOwner(collection.collectionId, token1.tokenId)).to.deep.eq({Substrate: receiverSub.address});544    // Ethereum address can transferFromCross approved tokens:545    await collectionEvm.methods.transferFromCross(ownerCross, receiverCrossEth, token2.tokenId).send({from: receiverEth});546    expect(await helper.nft.getTokenOwner(collection.collectionId, token2.tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});547  });548549  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {550    const nonOwner = await helper.eth.createAccountWithBalance(donor);551    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);552    const owner = await helper.eth.createAccountWithBalance(donor);553    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});554    const collectionEvm = await helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');555    const token = await collection.mintToken(minter, {Ethereum: owner});556557    await expect(collectionEvm.methods.approveCross(nonOwnerCross, token.tokenId).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');558  });559560  itEth('Can reaffirm approved address', async ({helper}) => {561    const owner = await helper.eth.createAccountWithBalance(donor);562    const ownerCrossEth = helper.ethCrossAccount.fromAddress(owner);563    const [receiver1, receiver2] = await helper.arrange.createAccounts([100n, 100n], donor);564    const receiver1Cross = helper.ethCrossAccount.fromKeyringPair(receiver1);565    const receiver2Cross = helper.ethCrossAccount.fromKeyringPair(receiver2);566    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});567    const token1 = await collection.mintToken(minter, {Ethereum: owner});568    const token2 = await collection.mintToken(minter, {Ethereum: owner});569    const collectionEvm = await helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');570571    // Can approve and reaffirm approved address:572    await collectionEvm.methods.approveCross(receiver1Cross, token1.tokenId).send({from: owner});573    await collectionEvm.methods.approveCross(receiver2Cross, token1.tokenId).send({from: owner});574575    // receiver1 cannot transferFrom:576    await expect(helper.nft.transferTokenFrom(receiver1, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiver1.address})).to.be.rejected;577    // receiver2 can transferFrom:578    await helper.nft.transferTokenFrom(receiver2, collection.collectionId, token1.tokenId, {Ethereum: owner}, {Substrate: receiver2.address});579580    // can set approved address to self address to remove approval:581    await collectionEvm.methods.approveCross(receiver1Cross, token2.tokenId).send({from: owner});582    await collectionEvm.methods.approveCross(ownerCrossEth, token2.tokenId).send({from: owner});583584    // receiver1 cannot transfer token anymore:585    await expect(helper.nft.transferTokenFrom(receiver1, collection.collectionId, token2.tokenId, {Ethereum: owner}, {Substrate: receiver1.address})).to.be.rejected;586  });587588  itEth('Can perform transferFrom()', async ({helper}) => {589    const owner = await helper.eth.createAccountWithBalance(donor);590    const spender = await helper.eth.createAccountWithBalance(donor);591    const receiver = helper.eth.createAccount();592593    const collection = await helper.nft.mintCollection(minter, {});594    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});595596    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);597    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);598599    await contract.methods.approve(spender, tokenId).send({from: owner});600601    {602      const result = await contract.methods.transferFrom(owner, receiver, tokenId).send({from: spender});603604      const event = result.events.Transfer;605      expect(event.address).to.be.equal(collectionAddress);606      expect(event.returnValues.from).to.be.equal(owner);607      expect(event.returnValues.to).to.be.equal(receiver);608      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);609    }610611    {612      const balance = await contract.methods.balanceOf(receiver).call();613      expect(+balance).to.equal(1);614    }615616    {617      const balance = await contract.methods.balanceOf(owner).call();618      expect(+balance).to.equal(0);619    }620  });621622  itEth('Can perform transferFromCross()', async ({helper}) => {623    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});624625    const [owner, receiver] = await helper.arrange.createAccounts([100n, 100n], donor);626    const spender = await helper.eth.createAccountWithBalance(donor);627628    const token = await collection.mintToken(minter, {Substrate: owner.address});629630    const address = helper.ethAddress.fromCollectionId(collection.collectionId);631    const contract = await helper.ethNativeContract.collection(address, 'nft');632633    await token.approve(owner, {Ethereum: spender});634635    {636      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);637      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);638      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});639      const event = result.events.Transfer;640      expect(event).to.be.like({641        address: helper.ethAddress.fromCollectionId(collection.collectionId),642        event: 'Transfer',643        returnValues: {644          from: helper.address.substrateToEth(owner.address),645          to: helper.address.substrateToEth(receiver.address),646          tokenId: token.tokenId.toString(),647        },648      });649    }650651    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});652  });653654  itEth('Can perform transfer()', async ({helper}) => {655    const collection = await helper.nft.mintCollection(minter, {});656    const owner = await helper.eth.createAccountWithBalance(donor);657    const receiver = helper.eth.createAccount();658659    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});660661    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);662    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);663664    {665      const result = await contract.methods.transfer(receiver, tokenId).send({from: owner});666667      const event = result.events.Transfer;668      expect(event.address).to.be.equal(collectionAddress);669      expect(event.returnValues.from).to.be.equal(owner);670      expect(event.returnValues.to).to.be.equal(receiver);671      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);672    }673674    {675      const balance = await contract.methods.balanceOf(owner).call();676      expect(+balance).to.equal(0);677    }678679    {680      const balance = await contract.methods.balanceOf(receiver).call();681      expect(+balance).to.equal(1);682    }683  });684685  itEth('Can perform transferCross()', async ({helper}) => {686    const collection = await helper.nft.mintCollection(minter, {});687    const owner = await helper.eth.createAccountWithBalance(donor);688    const receiverEth = await helper.eth.createAccountWithBalance(donor);689    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);690    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);691692    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});693694    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);695    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);696697    {698      // Can transferCross to ethereum address:699      const result = await collectionEvm.methods.transferCross(receiverCrossEth, tokenId).send({from: owner});700      // Check events:701      const event = result.events.Transfer;702      expect(event.address).to.be.equal(collectionAddress);703      expect(event.returnValues.from).to.be.equal(owner);704      expect(event.returnValues.to).to.be.equal(receiverEth);705      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);706707      // owner has balance = 0:708      const ownerBalance = await collectionEvm.methods.balanceOf(owner).call();709      expect(+ownerBalance).to.equal(0);710      // receiver owns token:711      const receiverBalance = await collectionEvm.methods.balanceOf(receiverEth).call();712      expect(+receiverBalance).to.equal(1);713      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});714    }715716    {717      // Can transferCross to substrate address:718      const substrateResult = await collectionEvm.methods.transferCross(receiverCrossSub, tokenId).send({from: receiverEth});719      // Check events:720      const event = substrateResult.events.Transfer;721      expect(event.address).to.be.equal(collectionAddress);722      expect(event.returnValues.from).to.be.equal(receiverEth);723      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(minter.address));724      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);725726      // owner has balance = 0:727      const ownerBalance = await collectionEvm.methods.balanceOf(receiverEth).call();728      expect(+ownerBalance).to.equal(0);729      // receiver owns token:730      const receiverBalance = await helper.nft.getTokensByAddress(collection.collectionId, {Substrate: minter.address});731      expect(receiverBalance).to.contain(tokenId);732    }733  });734735  ['transfer', 'transferCross'].map(testCase => itEth(`Cannot ${testCase} non-owned token`, async ({helper}) => {736    const sender = await helper.eth.createAccountWithBalance(donor);737    const tokenOwner = await helper.eth.createAccountWithBalance(donor);738    const receiverSub = minter;739    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);740741    const collection = await helper.nft.mintCollection(minter, {});742    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);743    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', sender);744745    await collection.mintToken(minter, {Ethereum: sender});746    const nonSendersToken = await collection.mintToken(minter, {Ethereum: tokenOwner});747748    // Cannot transferCross someone else's token:749    const receiver = testCase === 'transfer' ? helper.address.substrateToEth(receiverSub.address) : receiverCrossSub;750    await expect(collectionEvm.methods[testCase](receiver, nonSendersToken.tokenId).send({from: sender})).to.be.rejected;751    // Cannot transfer token if it does not exist:752    await expect(collectionEvm.methods[testCase](receiver, 999999).send({from: sender})).to.be.rejected;753  }));754755  itEth('Check balanceOfCross()', async ({helper}) => {756    const collection = await helper.nft.mintCollection(minter, {});757    const owner = await helper.ethCrossAccount.createAccountWithBalance(donor);758    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);759    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner.eth);760761    expect(await collectionEvm.methods.balanceOfCross(owner).call({from: owner.eth})).to.be.eq('0');762763    for(let i = 1; i < 10; i++) {764      await collection.mintToken(minter, {Ethereum: owner.eth});765      expect(await collectionEvm.methods.balanceOfCross(owner).call({from: owner.eth})).to.be.eq(i.toString());766    }767  });768769  itEth('Check ownerOfCross()', async ({helper}) => {770    const collection = await helper.nft.mintCollection(minter, {});771    let owner = await helper.ethCrossAccount.createAccountWithBalance(donor);772    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);773    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner.eth);774    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner.eth});775776    for(let i = 1n; i < 10n; i++) {777      const ownerCross = await collectionEvm.methods.ownerOfCross(tokenId).call({from: owner.eth});778      expect(ownerCross.eth).to.be.eq(owner.eth);779      expect(ownerCross.sub).to.be.eq(owner.sub);780781      const newOwner = await helper.ethCrossAccount.createAccountWithBalance(donor);782      await collectionEvm.methods.transferCross(newOwner, tokenId).send({from: owner.eth});783      owner = newOwner;784    }785  });786});787788describe('NFT: Fees', () => {789  let donor: IKeyringPair;790  let alice: IKeyringPair;791  let bob: IKeyringPair;792  let charlie: IKeyringPair;793794  before(async function() {795    await usingEthPlaygrounds(async (helper, privateKey) => {796      donor = await privateKey({url: import.meta.url});797      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);798    });799  });800801  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {802    const owner = await helper.eth.createAccountWithBalance(donor);803    const spender = helper.eth.createAccount();804805    const collection = await helper.nft.mintCollection(alice, {});806    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});807808    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);809810    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, tokenId).send({from: owner}));811    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));812  });813814  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {815    const owner = await helper.eth.createAccountWithBalance(donor);816    const spender = await helper.eth.createAccountWithBalance(donor);817818    const collection = await helper.nft.mintCollection(alice, {});819    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});820821    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);822823    await contract.methods.approve(spender, tokenId).send({from: owner});824825    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, tokenId).send({from: spender}));826    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));827  });828829  itEth('Can perform transferFromCross()', async ({helper}) => {830    const collectionMinter = alice;831    const owner = bob;832    const receiver = charlie;833    const collection = await helper.nft.mintCollection(collectionMinter, {name: 'A', description: 'B', tokenPrefix: 'C'});834835    const spender = await helper.eth.createAccountWithBalance(donor);836837    const token = await collection.mintToken(collectionMinter, {Substrate: owner.address});838839    const address = helper.ethAddress.fromCollectionId(collection.collectionId);840    const contract = await helper.ethNativeContract.collection(address, 'nft');841842    await token.approve(owner, {Ethereum: spender});843844    {845      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);846      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);847      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});848      const event = result.events.Transfer;849      expect(event).to.be.like({850        address: helper.ethAddress.fromCollectionId(collection.collectionId),851        event: 'Transfer',852        returnValues: {853          from: helper.address.substrateToEth(owner.address),854          to: helper.address.substrateToEth(receiver.address),855          tokenId: token.tokenId.toString(),856        },857      });858    }859860    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});861  });862863  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {864    const owner = await helper.eth.createAccountWithBalance(donor);865    const receiver = helper.eth.createAccount();866867    const collection = await helper.nft.mintCollection(alice, {});868    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});869870    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);871872    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, tokenId).send({from: owner}));873    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));874  });875});876877describe('NFT: Substrate calls', () => {878  let donor: IKeyringPair;879  let alice: IKeyringPair;880881  before(async function() {882    await usingEthPlaygrounds(async (helper, privateKey) => {883      donor = await privateKey({url: import.meta.url});884      [alice] = await helper.arrange.createAccounts([20n], donor);885    });886  });887888  itEth('Events emitted for mint()', async ({helper}) => {889    const collection = await helper.nft.mintCollection(alice, {});890    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);891    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');892893    const events: any = [];894    contract.events.allEvents((_: any, event: any) => {895      events.push(event);896    });897898    const {tokenId} = await collection.mintToken(alice);899    if(events.length == 0) await helper.wait.newBlocks(1);900    const event = events[0];901902    expect(event.event).to.be.equal('Transfer');903    expect(event.address).to.be.equal(collectionAddress);904    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');905    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(alice.address));906    expect(event.returnValues.tokenId).to.be.equal(tokenId.toString());907  });908909  itEth('Events emitted for burn()', async ({helper}) => {910    const collection = await helper.nft.mintCollection(alice, {});911    const token = await collection.mintToken(alice);912913    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);914    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');915916    const events: any = [];917    contract.events.allEvents((_: any, event: any) => {918      events.push(event);919    });920921    await token.burn(alice);922    if(events.length == 0) await helper.wait.newBlocks(1);923    const event = events[0];924925    expect(event.event).to.be.equal('Transfer');926    expect(event.address).to.be.equal(collectionAddress);927    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));928    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');929    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());930  });931932  itEth('Events emitted for approve()', async ({helper}) => {933    const receiver = helper.eth.createAccount();934935    const collection = await helper.nft.mintCollection(alice, {});936    const token = await collection.mintToken(alice);937938    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);939    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');940941    const events: any = [];942    contract.events.allEvents((_: any, event: any) => {943      events.push(event);944    });945946    await token.approve(alice, {Ethereum: receiver});947    if(events.length == 0) await helper.wait.newBlocks(1);948    const event = events[0];949950    expect(event.event).to.be.equal('Approval');951    expect(event.address).to.be.equal(collectionAddress);952    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));953    expect(event.returnValues.approved).to.be.equal(receiver);954    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());955  });956957  itEth('Events emitted for transferFrom()', async ({helper}) => {958    const [bob] = await helper.arrange.createAccounts([10n], donor);959    const receiver = helper.eth.createAccount();960961    const collection = await helper.nft.mintCollection(alice, {});962    const token = await collection.mintToken(alice);963    await token.approve(alice, {Substrate: bob.address});964965    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);966    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');967968    const events: any = [];969    contract.events.allEvents((_: any, event: any) => {970      events.push(event);971    });972973    await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver});974975    if(events.length == 0) await helper.wait.newBlocks(1);976    const event = events[0];977978    expect(event.address).to.be.equal(collectionAddress);979    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));980    expect(event.returnValues.to).to.be.equal(receiver);981    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);982  });983984  itEth('Events emitted for transfer()', async ({helper}) => {985    const receiver = helper.eth.createAccount();986987    const collection = await helper.nft.mintCollection(alice, {});988    const token = await collection.mintToken(alice);989990    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);991    const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft');992993    const events: any = [];994    contract.events.allEvents((_: any, event: any) => {995      events.push(event);996    });997998    await token.transfer(alice, {Ethereum: receiver});9991000    if(events.length == 0) await helper.wait.newBlocks(1);1001    const event = events[0];10021003    expect(event.address).to.be.equal(collectionAddress);1004    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));1005    expect(event.returnValues.to).to.be.equal(receiver);1006    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);1007  });1008});10091010describe('Common metadata', () => {1011  let donor: IKeyringPair;1012  let alice: IKeyringPair;10131014  before(async function() {1015    await usingEthPlaygrounds(async (helper, privateKey) => {1016      donor = await privateKey({url: import.meta.url});1017      [alice] = await helper.arrange.createAccounts([20n], donor);1018    });1019  });10201021  itEth('Returns collection name', async ({helper}) => {1022    const caller = helper.eth.createAccount();1023    const tokenPropertyPermissions = [{1024      key: 'URI',1025      permission: {1026        mutable: true,1027        collectionAdmin: true,1028        tokenOwner: false,1029      },1030    }];1031    const collection = await helper.nft.mintCollection(1032      alice,1033      {1034        name: 'oh River',1035        tokenPrefix: 'CHANGE',1036        properties: [{key: 'ERC721Metadata', value: '1'}],1037        tokenPropertyPermissions,1038      },1039    );10401041    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);1042    const name = await contract.methods.name().call();1043    expect(name).to.equal('oh River');1044  });10451046  itEth('Returns symbol name', async ({helper}) => {1047    const caller = await helper.eth.createAccountWithBalance(donor);1048    const tokenPropertyPermissions = [{1049      key: 'URI',1050      permission: {1051        mutable: true,1052        collectionAdmin: true,1053        tokenOwner: false,1054      },1055    }];1056    const collection = await helper.nft.mintCollection(1057      alice,1058      {1059        name: 'oh River',1060        tokenPrefix: 'CHANGE',1061        properties: [{key: 'ERC721Metadata', value: '1'}],1062        tokenPropertyPermissions,1063      },1064    );10651066    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);1067    const symbol = await contract.methods.symbol().call();1068    expect(symbol).to.equal('CHANGE');1069  });1070});10711072describe('Negative tests', () => {1073  let donor: IKeyringPair;1074  let minter: IKeyringPair;1075  let alice: IKeyringPair;10761077  before(async function() {1078    await usingEthPlaygrounds(async (helper, privateKey) => {1079      donor = await privateKey({url: import.meta.url});1080      [minter, alice] = await helper.arrange.createAccounts([100n, 100n], donor);1081    });1082  });10831084  itEth('[negative] Cant perform burn without approval', async ({helper}) => {1085    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});10861087    const owner = await helper.eth.createAccountWithBalance(donor);1088    const spender = await helper.eth.createAccountWithBalance(donor);10891090    const token = await collection.mintToken(minter, {Ethereum: owner});10911092    const address = helper.ethAddress.fromCollectionId(collection.collectionId);1093    const contract = await helper.ethNativeContract.collection(address, 'nft');10941095    const ownerCross = helper.ethCrossAccount.fromAddress(owner);1096    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;10971098    await contract.methods.setApprovalForAll(spender, true).send({from: owner});1099    await contract.methods.setApprovalForAll(spender, false).send({from: owner});11001101    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;1102  });11031104  itEth('[negative] Cant perform transfer without approval', async ({helper}) => {1105    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});1106    const receiver = alice;11071108    const owner = await helper.eth.createAccountWithBalance(donor);1109    const spender = await helper.eth.createAccountWithBalance(donor);11101111    const token = await collection.mintToken(minter, {Ethereum: owner});11121113    const address = helper.ethAddress.fromCollectionId(collection.collectionId);1114    const contract = await helper.ethNativeContract.collection(address, 'nft');11151116    const ownerCross = helper.ethCrossAccount.fromAddress(owner);1117    const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);11181119    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;11201121    await contract.methods.setApprovalForAll(spender, true).send({from: owner});1122    await contract.methods.setApprovalForAll(spender, false).send({from: owner});11231124    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;1125  });1126});