git.delta.rocks / unique-network / refs/commits / 313d9317ef02

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 {Pallets, requirePalletsOrSkip} from '../util';18import {expect, itEth, usingEthPlaygrounds} from './util';19import {IKeyringPair} from '@polkadot/types/types';20import {ITokenPropertyPermission} from '../util/playgrounds/types';2122describe('Refungible: Plain calls', () => {23  let donor: IKeyringPair;24  let minter: IKeyringPair;25  let bob: IKeyringPair;26  let charlie: IKeyringPair;2728  before(async function() {29    await usingEthPlaygrounds(async (helper, privateKey) => {30      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);3132      donor = await privateKey({url: import.meta.url});33      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);34    });35  });3637  [38    'substrate' as const,39    'ethereum' as const,40  ].map(testCase => {41    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {42      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);4344      const receiverEth = helper.eth.createAccount();45      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);46      const receiverSub = bob;47      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);4849      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));50      const permissions: ITokenPropertyPermission[] = properties.map(p => ({key: p.key, permission: {51        tokenOwner: false,52        collectionAdmin: true,53        mutable: false}}));545556      const collection = await helper.rft.mintCollection(minter, {57        tokenPrefix: 'ethp',58        tokenPropertyPermissions: permissions,59      });60      await collection.addAdmin(minter, {Ethereum: collectionAdmin});6162      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);63      const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', collectionAdmin, true);64      let expectedTokenId = await contract.methods.nextTokenId().call();65      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();66      let tokenId = result.events.Transfer.returnValues.tokenId;67      expect(tokenId).to.be.equal(expectedTokenId);6869      let event = result.events.Transfer;70      expect(event.address).to.be.equal(collectionAddress);71      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');72      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));73      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);7475      expectedTokenId = await contract.methods.nextTokenId().call();76      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();77      event = result.events.Transfer;78      expect(event.address).to.be.equal(collectionAddress);79      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');80      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));81      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);8283      tokenId = result.events.Transfer.returnValues.tokenId;8485      expect(tokenId).to.be.equal(expectedTokenId);8687      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties88        .map(p => helper.ethProperty.property(p.key, p.value.toString())));8990      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))91        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});92    });93  });9495  itEth.skip('Can perform mintBulk()', async ({helper}) => {96    const owner = await helper.eth.createAccountWithBalance(donor);97    const receiver = helper.eth.createAccount();98    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'MintBulky', '6', '6', '');99    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);100101    {102      const nextTokenId = await contract.methods.nextTokenId().call();103      expect(nextTokenId).to.be.equal('1');104      const result = await contract.methods.mintBulkWithTokenURI(105        receiver,106        [107          [nextTokenId, 'Test URI 0'],108          [+nextTokenId + 1, 'Test URI 1'],109          [+nextTokenId + 2, 'Test URI 2'],110        ],111      ).send();112113      const events = result.events.Transfer;114      for (let i = 0; i < 2; i++) {115        const event = events[i];116        expect(event.address).to.equal(collectionAddress);117        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');118        expect(event.returnValues.to).to.equal(receiver);119        expect(event.returnValues.tokenId).to.equal(String(+nextTokenId + i));120      }121122      expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI 0');123      expect(await contract.methods.tokenURI(+nextTokenId + 1).call()).to.be.equal('Test URI 1');124      expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');125    }126  });127128  itEth('Can perform setApprovalForAll()', async ({helper}) => {129    const owner = await helper.eth.createAccountWithBalance(donor);130    const operator = helper.eth.createAccount();131132    const collection = await helper.rft.mintCollection(minter, {});133134    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);135    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);136137    const approvedBefore = await contract.methods.isApprovedForAll(owner, operator).call();138    expect(approvedBefore).to.be.equal(false);139140    {141      const result = await contract.methods.setApprovalForAll(operator, true).send({from: owner});142143      expect(result.events.ApprovalForAll).to.be.like({144        address: collectionAddress,145        event: 'ApprovalForAll',146        returnValues: {147          owner,148          operator,149          approved: true,150        },151      });152153      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();154      expect(approvedAfter).to.be.equal(true);155    }156157    {158      const result = await contract.methods.setApprovalForAll(operator, false).send({from: owner});159160      expect(result.events.ApprovalForAll).to.be.like({161        address: collectionAddress,162        event: 'ApprovalForAll',163        returnValues: {164          owner,165          operator,166          approved: false,167        },168      });169170      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();171      expect(approvedAfter).to.be.equal(false);172    }173  });174175  itEth('Can perform burn with ApprovalForAll', async ({helper}) => {176    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});177178    const owner = await helper.eth.createAccountWithBalance(donor);179    const operator = await helper.eth.createAccountWithBalance(donor);180181    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});182183    const address = helper.ethAddress.fromCollectionId(collection.collectionId);184    const contract = await helper.ethNativeContract.collection(address, 'rft');185186    {187      await contract.methods.setApprovalForAll(operator, true).send({from: owner});188      const ownerCross = helper.ethCrossAccount.fromAddress(owner);189      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: operator});190      const events = result.events.Transfer;191192      expect(events).to.be.like({193        address,194        event: 'Transfer',195        returnValues: {196          from: owner,197          to: '0x0000000000000000000000000000000000000000',198          tokenId: token.tokenId.toString(),199        },200      });201    }202  });203204  itEth('Can perform burn with approve and approvalForAll', async ({helper}) => {205    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});206207    const owner = await helper.eth.createAccountWithBalance(donor);208    const operator = await helper.eth.createAccountWithBalance(donor);209210    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});211212    const address = helper.ethAddress.fromCollectionId(collection.collectionId);213    const contract = await helper.ethNativeContract.collection(address, 'rft');214215    const rftToken = await helper.ethNativeContract.rftTokenById(token.collectionId, token.tokenId, owner, true);216217    {218      await rftToken.methods.approve(operator, 15n).send({from: owner});219      await contract.methods.setApprovalForAll(operator, true).send({from: owner});220      await rftToken.methods.burnFrom(owner, 10n).send({from: operator});221    }222    {223      const allowance = await rftToken.methods.allowance(owner, operator).call();224      expect(+allowance).to.be.equal(5);225    }226    {227      const ownerCross = helper.ethCrossAccount.fromAddress(owner);228      const operatorCross = helper.ethCrossAccount.fromAddress(operator);229      const allowance = await rftToken.methods.allowanceCross(ownerCross, operatorCross).call();230      expect(+allowance).to.equal(5);231    }232  });233234  itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {235    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});236237    const owner = await helper.eth.createAccountWithBalance(donor);238    const operator = await helper.eth.createAccountWithBalance(donor);239    const receiver = charlie;240241    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});242243    const address = helper.ethAddress.fromCollectionId(collection.collectionId);244    const contract = await helper.ethNativeContract.collection(address, 'rft');245246    {247      await contract.methods.setApprovalForAll(operator, true).send({from: owner});248      const ownerCross = helper.ethCrossAccount.fromAddress(owner);249      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);250      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: operator});251      const event = result.events.Transfer;252      expect(event).to.be.like({253        address: helper.ethAddress.fromCollectionId(collection.collectionId),254        event: 'Transfer',255        returnValues: {256          from: owner,257          to: helper.address.substrateToEth(receiver.address),258          tokenId: token.tokenId.toString(),259        },260      });261    }262263    expect(await token.getTop10Owners()).to.be.like([{Substrate: receiver.address}]);264  });265266  itEth('Can perform burn()', async ({helper}) => {267    const caller = await helper.eth.createAccountWithBalance(donor);268    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Burny', '6', '6');269    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);270271    const result = await contract.methods.mint(caller).send();272    const tokenId = result.events.Transfer.returnValues.tokenId;273    {274      const result = await contract.methods.burn(tokenId).send();275      const event = result.events.Transfer;276      expect(event.address).to.equal(collectionAddress);277      expect(event.returnValues.from).to.equal(caller);278      expect(event.returnValues.to).to.equal('0x0000000000000000000000000000000000000000');279      expect(event.returnValues.tokenId).to.equal(tokenId.toString());280    }281  });282283  itEth('Can perform transferFrom()', async ({helper}) => {284    const caller = await helper.eth.createAccountWithBalance(donor);285    const receiver = helper.eth.createAccount();286    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'TransferFromy', '6', '6');287    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);288289    const result = await contract.methods.mint(caller).send();290    const tokenId = result.events.Transfer.returnValues.tokenId;291292    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);293294    const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, caller);295    await tokenContract.methods.repartition(15).send();296297    {298      const tokenEvents: any = [];299      tokenContract.events.allEvents((_: any, event: any) => {300        tokenEvents.push(event);301      });302      const result = await contract.methods.transferFrom(caller, receiver, tokenId).send();303      if (tokenEvents.length == 0) await helper.wait.newBlocks(1);304305      let event = result.events.Transfer;306      expect(event.address).to.equal(collectionAddress);307      expect(event.returnValues.from).to.equal(caller);308      expect(event.returnValues.to).to.equal(receiver);309      expect(event.returnValues.tokenId).to.equal(tokenId.toString());310311      event = tokenEvents[0];312      expect(event.address).to.equal(tokenAddress);313      expect(event.returnValues.from).to.equal(caller);314      expect(event.returnValues.to).to.equal(receiver);315      expect(event.returnValues.value).to.equal('15');316    }317318    {319      const balance = await contract.methods.balanceOf(receiver).call();320      expect(+balance).to.equal(1);321    }322323    {324      const balance = await contract.methods.balanceOf(caller).call();325      expect(+balance).to.equal(0);326    }327  });328329  // Soft-deprecated330  itEth('Can perform burnFrom()', async ({helper}) => {331    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});332333    const owner = await helper.eth.createAccountWithBalance(donor);334    const spender = await helper.eth.createAccountWithBalance(donor);335336    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});337338    const address = helper.ethAddress.fromCollectionId(collection.collectionId);339    const contract = await helper.ethNativeContract.collection(address, 'rft', spender, true);340341    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);342    const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, owner);343    await tokenContract.methods.repartition(15).send();344    await tokenContract.methods.approve(spender, 15).send();345346    {347      const result = await contract.methods.burnFrom(owner, token.tokenId).send();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: '0x0000000000000000000000000000000000000000',355          tokenId: token.tokenId.toString(),356        },357      });358    }359360    expect(await collection.getTokenBalance(token.tokenId, {Ethereum: owner})).to.be.eq(0n);361  });362363  itEth('Can perform burnFromCross()', async ({helper}) => {364    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});365366    const owner = bob;367    const spender = await helper.eth.createAccountWithBalance(donor);368369    const token = await collection.mintToken(minter, 100n, {Substrate: owner.address});370371    const address = helper.ethAddress.fromCollectionId(collection.collectionId);372    const contract = await helper.ethNativeContract.collection(address, 'rft');373374    await token.repartition(owner, 15n);375    await token.approve(owner, {Ethereum: spender}, 15n);376377    {378      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);379      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender});380      const event = result.events.Transfer;381      expect(event).to.be.like({382        address: helper.ethAddress.fromCollectionId(collection.collectionId),383        event: 'Transfer',384        returnValues: {385          from: helper.address.substrateToEth(owner.address),386          to: '0x0000000000000000000000000000000000000000',387          tokenId: token.tokenId.toString(),388        },389      });390    }391392    expect(await collection.getTokenBalance(token.tokenId, {Substrate: owner.address})).to.be.eq(0n);393  });394395  itEth('Can perform transferFromCross()', async ({helper}) => {396    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});397398    const owner = bob;399    const spender = await helper.eth.createAccountWithBalance(donor);400    const receiver = charlie;401402    const token = await collection.mintToken(minter, 100n, {Substrate: owner.address});403404    const address = helper.ethAddress.fromCollectionId(collection.collectionId);405    const contract = await helper.ethNativeContract.collection(address, 'rft');406407    await token.repartition(owner, 15n);408    await token.approve(owner, {Ethereum: spender}, 15n);409410    {411      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);412      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);413      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});414      const event = result.events.Transfer;415      expect(event).to.be.like({416        address: helper.ethAddress.fromCollectionId(collection.collectionId),417        event: 'Transfer',418        returnValues: {419          from: helper.address.substrateToEth(owner.address),420          to: helper.address.substrateToEth(receiver.address),421          tokenId: token.tokenId.toString(),422        },423      });424    }425426    expect(await token.getTop10Owners()).to.be.like([{Substrate: receiver.address}]);427  });428429  itEth('Can perform transfer()', async ({helper}) => {430    const caller = await helper.eth.createAccountWithBalance(donor);431    const receiver = helper.eth.createAccount();432    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry', '6', '6');433    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);434435    const result = await contract.methods.mint(caller).send();436    const tokenId = result.events.Transfer.returnValues.tokenId;437438    {439      const result = await contract.methods.transfer(receiver, tokenId).send();440441      const event = result.events.Transfer;442      expect(event.address).to.equal(collectionAddress);443      expect(event.returnValues.from).to.equal(caller);444      expect(event.returnValues.to).to.equal(receiver);445      expect(event.returnValues.tokenId).to.equal(tokenId.toString());446    }447448    {449      const balance = await contract.methods.balanceOf(caller).call();450      expect(+balance).to.equal(0);451    }452453    {454      const balance = await contract.methods.balanceOf(receiver).call();455      expect(+balance).to.equal(1);456    }457  });458459  itEth('Can perform transferCross()', async ({helper}) => {460    const sender = await helper.eth.createAccountWithBalance(donor);461    const receiverEth = await helper.eth.createAccountWithBalance(donor);462    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);463    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);464465    const collection = await helper.rft.mintCollection(minter, {});466    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);467    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', sender);468469    const token = await collection.mintToken(minter, 50n, {Ethereum: sender});470471    {472      // Can transferCross to ethereum address:473      const result = await collectionEvm.methods.transferCross(receiverCrossEth, token.tokenId).send({from: sender});474      // Check events:475      const event = result.events.Transfer;476      expect(event.address).to.equal(collectionAddress);477      expect(event.returnValues.from).to.equal(sender);478      expect(event.returnValues.to).to.equal(receiverEth);479      expect(event.returnValues.tokenId).to.equal(token.tokenId.toString());480      // Sender's balance decreased:481      const senderBalance = await collectionEvm.methods.balanceOf(sender).call();482      expect(+senderBalance).to.equal(0);483      expect(await token.getBalance({Ethereum: sender})).to.eq(0n);484      // Receiver's balance increased:485      const receiverBalance = await collectionEvm.methods.balanceOf(receiverEth).call();486      expect(+receiverBalance).to.equal(1);487      expect(await token.getBalance({Ethereum: receiverEth})).to.eq(50n);488    }489490    {491      // Can transferCross to substrate address:492      const substrateResult = await collectionEvm.methods.transferCross(receiverCrossSub, token.tokenId).send({from: receiverEth});493      // Check events:494      const event = substrateResult.events.Transfer;495      expect(event.address).to.be.equal(collectionAddress);496      expect(event.returnValues.from).to.be.equal(receiverEth);497      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(minter.address));498      expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);499      // Sender's balance decreased:500      const senderBalance = await collectionEvm.methods.balanceOf(receiverEth).call();501      expect(+senderBalance).to.equal(0);502      expect(await token.getBalance({Ethereum: receiverEth})).to.eq(0n);503      // Receiver's balance increased:504      const receiverBalance = await helper.nft.getTokensByAddress(collection.collectionId, {Substrate: minter.address});505      expect(receiverBalance).to.contain(token.tokenId);506      expect(await token.getBalance({Substrate: minter.address})).to.eq(50n);507    }508  });509510  ['transfer', 'transferCross'].map(testCase => itEth(`Cannot ${testCase} non-owned token`, async ({helper}) => {511    const sender = await helper.eth.createAccountWithBalance(donor);512    const tokenOwner = await helper.eth.createAccountWithBalance(donor);513    const receiverSub = minter;514    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);515516    const collection = await helper.rft.mintCollection(minter, {});517    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);518    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', sender);519520    await collection.mintToken(minter, 50n, {Ethereum: sender});521    const nonSendersToken = await collection.mintToken(minter, 50n, {Ethereum: tokenOwner});522523    // Cannot transferCross someone else's token:524    const receiver = testCase === 'transfer' ? helper.address.substrateToEth(receiverSub.address) : receiverCrossSub;525    await expect(collectionEvm.methods[testCase](receiver, nonSendersToken.tokenId).send({from: sender})).to.be.rejected;526    // Cannot transfer token if it does not exist:527    await expect(collectionEvm.methods[testCase](receiver, 999999).send({from: sender})).to.be.rejected;528  }));529530  itEth('transfer event on transfer from partial ownership to full ownership', async ({helper}) => {531    const caller = await helper.eth.createAccountWithBalance(donor);532    const receiver = helper.eth.createAccount();533    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry-Partial-to-Full', '6', '6');534    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);535536    const result = await contract.methods.mint(caller).send();537    const tokenId = result.events.Transfer.returnValues.tokenId;538539    const tokenContract = await helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);540541    await tokenContract.methods.repartition(2).send();542    await tokenContract.methods.transfer(receiver, 1).send();543544    const events: any = [];545    contract.events.allEvents((_: any, event: any) => {546      events.push(event);547    });548549    await tokenContract.methods.transfer(receiver, 1).send();550    if (events.length == 0) await helper.wait.newBlocks(1);551    const event = events[0];552553    expect(event.address).to.equal(collectionAddress);554    expect(event.returnValues.from).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');555    expect(event.returnValues.to).to.equal(receiver);556    expect(event.returnValues.tokenId).to.equal(tokenId.toString());557  });558559  itEth('transfer event on transfer from full ownership to partial ownership', async ({helper}) => {560    const caller = await helper.eth.createAccountWithBalance(donor);561    const receiver = helper.eth.createAccount();562    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry-Full-to-Partial', '6', '6');563    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);564565    const result = await contract.methods.mint(caller).send();566    const tokenId = result.events.Transfer.returnValues.tokenId;567568    const tokenContract = await helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);569570    await tokenContract.methods.repartition(2).send();571572    const events: any = [];573    contract.events.allEvents((_: any, event: any) => {574      events.push(event);575    });576577    await tokenContract.methods.transfer(receiver, 1).send();578    if (events.length == 0) await helper.wait.newBlocks(1);579    const event = events[0];580581    expect(event.address).to.equal(collectionAddress);582    expect(event.returnValues.from).to.equal(caller);583    expect(event.returnValues.to).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');584    expect(event.returnValues.tokenId).to.equal(tokenId.toString());585  });586587  itEth('Check balanceOfCross()', async ({helper}) => {588    const collection = await helper.rft.mintCollection(minter, {});589    const owner = await helper.ethCrossAccount.createAccountWithBalance(donor);590    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);591    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner.eth);592593    expect(await collectionEvm.methods.balanceOfCross(owner).call({from: owner.eth})).to.be.eq('0');594595    for (let i = 1n; i < 10n; i++) {596      await collection.mintToken(minter, 100n, {Ethereum: owner.eth});597      expect(await collectionEvm.methods.balanceOfCross(owner).call({from: owner.eth})).to.be.eq(i.toString());598    }599  });600601  itEth('Check ownerOfCross()', async ({helper}) => {602    const collection = await helper.rft.mintCollection(minter, {});603    let owner = await helper.ethCrossAccount.createAccountWithBalance(donor);604    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);605    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner.eth);606    const {tokenId} = await collection.mintToken(minter, 100n,{Ethereum: owner.eth});607608    for (let i = 1n; i < 10n; i++) {609      const ownerCross = await collectionEvm.methods.ownerOfCross(tokenId).call({from: owner.eth});610      expect(ownerCross.eth).to.be.eq(owner.eth);611      expect(ownerCross.sub).to.be.eq(owner.sub);612613      const newOwner = await helper.ethCrossAccount.createAccountWithBalance(donor);614      await collectionEvm.methods.transferCross(newOwner, tokenId).send({from: owner.eth});615      owner = newOwner;616    }617618    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);619    const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, owner.eth, true);620    const newOwner = await helper.ethCrossAccount.createAccountWithBalance(donor);621    await tokenContract.methods.transferCross(newOwner, 50).send({from: owner.eth});622    const ownerCross = await collectionEvm.methods.ownerOfCross(tokenId).call({from: owner.eth});623    expect(ownerCross.eth.toUpperCase()).to.be.eq('0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');624    expect(ownerCross.sub).to.be.eq('0');625  });626});627628describe('RFT: Fees', () => {629  let donor: IKeyringPair;630631  before(async function() {632    await usingEthPlaygrounds(async (helper, privateKey) => {633      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);634635      donor = await privateKey({url: import.meta.url});636    });637  });638639  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {640    const caller = await helper.eth.createAccountWithBalance(donor);641    const receiver = helper.eth.createAccount();642    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Feeful-Transfer-From', '6', '6');643    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);644645    const result = await contract.methods.mint(caller).send();646    const tokenId = result.events.Transfer.returnValues.tokenId;647648    const cost = await helper.eth.recordCallFee(caller, () => contract.methods.transferFrom(caller, receiver, tokenId).send());649    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));650    expect(cost > 0n);651  });652653  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {654    const caller = await helper.eth.createAccountWithBalance(donor);655    const receiver = helper.eth.createAccount();656    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Feeful-Transfer', '6', '6');657    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);658659    const result = await contract.methods.mint(caller).send();660    const tokenId = result.events.Transfer.returnValues.tokenId;661662    const cost = await helper.eth.recordCallFee(caller, () => contract.methods.transfer(receiver, tokenId).send());663    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));664    expect(cost > 0n);665  });666});667668describe('Common metadata', () => {669  let donor: IKeyringPair;670  let alice: IKeyringPair;671672  before(async function() {673    await usingEthPlaygrounds(async (helper, privateKey) => {674      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);675676      donor = await privateKey({url: import.meta.url});677      [alice] = await helper.arrange.createAccounts([20n], donor);678    });679  });680681  itEth('Returns collection name', async ({helper}) => {682    // FIXME: should not have balance to use .call()683    const caller = await helper.eth.createAccountWithBalance(alice);684    const tokenPropertyPermissions = [{685      key: 'URI',686      permission: {687        mutable: true,688        collectionAdmin: true,689        tokenOwner: false,690      },691    }];692    const collection = await helper.rft.mintCollection(693      alice,694      {695        name: 'Leviathan',696        tokenPrefix: '11',697        properties: [{key: 'ERC721Metadata', value: '1'}],698        tokenPropertyPermissions,699      },700    );701702    const contract = await helper.ethNativeContract.collectionById(collection.collectionId, 'rft', caller);703    const name = await contract.methods.name().call();704    expect(name).to.equal('Leviathan');705  });706707  itEth('Returns symbol name', async ({helper}) => {708    const caller = await helper.eth.createAccountWithBalance(donor);709    const tokenPropertyPermissions = [{710      key: 'URI',711      permission: {712        mutable: true,713        collectionAdmin: true,714        tokenOwner: false,715      },716    }];717    const {collectionId} = await helper.rft.mintCollection(718      alice,719      {720        name: 'Leviathan',721        tokenPrefix: '12',722        properties: [{key: 'ERC721Metadata', value: '1'}],723        tokenPropertyPermissions,724      },725    );726727    const contract = await helper.ethNativeContract.collectionById(collectionId, 'rft', caller);728    const symbol = await contract.methods.symbol().call();729    expect(symbol).to.equal('12');730  });731});732733describe('Negative tests', () => {734  let donor: IKeyringPair;735  let minter: IKeyringPair;736  let alice: IKeyringPair;737738  before(async function() {739    await usingEthPlaygrounds(async (helper, privateKey) => {740      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);741742      donor = await privateKey({url: import.meta.url});743      [minter, alice] = await helper.arrange.createAccounts([100n, 100n], donor);744    });745  });746747  itEth('[negative] Cant perform burn without approval', async ({helper}) => {748    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});749750    const owner = await helper.eth.createAccountWithBalance(donor);751    const spender = await helper.eth.createAccountWithBalance(donor);752753    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});754755    const address = helper.ethAddress.fromCollectionId(collection.collectionId);756    const contract = await helper.ethNativeContract.collection(address, 'rft');757758    const ownerCross = helper.ethCrossAccount.fromAddress(owner);759760    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;761762    await contract.methods.setApprovalForAll(spender, true).send({from: owner});763    await contract.methods.setApprovalForAll(spender, false).send({from: owner});764765    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;766  });767768  itEth('[negative] Cant perform transfer without approval', async ({helper}) => {769    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});770    const owner = await helper.eth.createAccountWithBalance(donor);771    const receiver = alice;772773    const spender = await helper.eth.createAccountWithBalance(donor);774775    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});776777    const address = helper.ethAddress.fromCollectionId(collection.collectionId);778    const contract = await helper.ethNativeContract.collection(address, 'rft');779780    const ownerCross = helper.ethCrossAccount.fromAddress(owner);781    const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);782783    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;784785    await contract.methods.setApprovalForAll(spender, true).send({from: owner});786    await contract.methods.setApprovalForAll(spender, false).send({from: owner});787788    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;789  });790});