git.delta.rocks / unique-network / refs/commits / 1d1847e4f8dc

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 {EthUniqueHelper, expect, itEth, usingEthPlaygrounds} from './util';19import {IKeyringPair} from '@polkadot/types/types';20import {Contract} from 'web3-eth-contract';212223describe('Refungible token: Information getting', () => {24  let donor: IKeyringPair;25  let alice: IKeyringPair;2627  before(async function() {28    await usingEthPlaygrounds(async (helper, privateKey) => {29      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);3031      donor = await privateKey({filename: __filename});32      [alice] = await helper.arrange.createAccounts([20n], donor);33    });34  });3536  itEth('totalSupply', async ({helper}) => {37    const caller = await helper.eth.createAccountWithBalance(donor);38    const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});39    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});4041    const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);42    const totalSupply = await contract.methods.totalSupply().call();43    expect(totalSupply).to.equal('200');44  });4546  itEth('balanceOf', async ({helper}) => {47    const caller = await helper.eth.createAccountWithBalance(donor);48    const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});49    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});5051    const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);52    const balance = await contract.methods.balanceOf(caller).call();53    expect(balance).to.equal('200');54  });5556  itEth('decimals', async ({helper}) => {57    const caller = await helper.eth.createAccountWithBalance(donor);58    const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});59    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});6061    const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);62    const decimals = await contract.methods.decimals().call();63    expect(decimals).to.equal('0');64  });65});6667// FIXME: Need erc721 for ReFubgible.68describe('Check ERC721 token URI for ReFungible', () => {69  let donor: IKeyringPair;7071  before(async function() {72    await usingEthPlaygrounds(async (helper, privateKey) => {73      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);7475      donor = await privateKey({filename: __filename});76    });77  });7879  async function setup(helper: EthUniqueHelper, baseUri: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {80    const owner = await helper.eth.createAccountWithBalance(donor);81    const receiver = helper.eth.createAccount();8283    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'Mint collection', 'a', 'b', baseUri);84    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);8586    const result = await contract.methods.mint(receiver).send();8788    const event = result.events.Transfer;89    const tokenId = event.returnValues.tokenId;90    expect(tokenId).to.be.equal('1');91    expect(event.address).to.be.equal(collectionAddress);92    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');93    expect(event.returnValues.to).to.be.equal(receiver);9495    if (propertyKey && propertyValue) {96      // Set URL or suffix9798      await contract.methods.setProperties(tokenId, [{key: propertyKey, value: Buffer.from(propertyValue)}]).send();99    }100101    return {contract, nextTokenId: tokenId};102  }103104  itEth('Empty tokenURI', async ({helper}) => {105    const {contract, nextTokenId} = await setup(helper, '');106    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');107  });108109  itEth('TokenURI from url', async ({helper}) => {110    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URI', 'Token URI');111    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');112  });113114  itEth('TokenURI from baseURI', async ({helper}) => {115    const {contract, nextTokenId} = await setup(helper, 'BaseURI_');116    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_');117  });118119  itEth('TokenURI from baseURI + suffix', async ({helper}) => {120    const suffix = '/some/suffix';121    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URISuffix', suffix);122    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);123  });124});125126describe('Refungible: Plain calls', () => {127  let donor: IKeyringPair;128  let alice: IKeyringPair;129130  before(async function() {131    await usingEthPlaygrounds(async (helper, privateKey) => {132      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);133134      donor = await privateKey({filename: __filename});135      [alice] = await helper.arrange.createAccounts([50n], donor);136    });137  });138139  itEth('Can perform approve()', async ({helper}) => {140    const owner = await helper.eth.createAccountWithBalance(donor);141    const spender = helper.eth.createAccount();142    const collection = await helper.rft.mintCollection(alice);143    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});144145    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);146    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);147148    {149      const result = await contract.methods.approve(spender, 100).send({from: owner});150      const event = result.events.Approval;151      expect(event.address).to.be.equal(tokenAddress);152      expect(event.returnValues.owner).to.be.equal(owner);153      expect(event.returnValues.spender).to.be.equal(spender);154      expect(event.returnValues.value).to.be.equal('100');155    }156157    {158      const allowance = await contract.methods.allowance(owner, spender).call();159      expect(+allowance).to.equal(100);160    }161  });162  163  itEth('Can perform approveCross()', async ({helper}) => {164    const owner = await helper.eth.createAccountWithBalance(donor);165    const spender = helper.eth.createAccount();166    const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0];167    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);168    const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub);169    170171    const collection = await helper.rft.mintCollection(alice);172    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});173174    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);175    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);176177    {178      const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});179      const event = result.events.Approval;180      expect(event.address).to.be.equal(tokenAddress);181      expect(event.returnValues.owner).to.be.equal(owner);182      expect(event.returnValues.spender).to.be.equal(spender);183      expect(event.returnValues.value).to.be.equal('100');184    }185186    {187      const allowance = await contract.methods.allowance(owner, spender).call();188      expect(+allowance).to.equal(100);189    }190    191    192    {193      const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner});194      const event = result.events.Approval;195      expect(event.address).to.be.equal(tokenAddress);196      expect(event.returnValues.owner).to.be.equal(owner);197      expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address));198      expect(event.returnValues.value).to.be.equal('100');199    }200201    {202      const allowance = await collection.getTokenApprovedPieces(tokenId, {Ethereum: owner}, {Substrate: spenderSub.address});203      expect(allowance).to.equal(100n);204    }205  206    {207      //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()208    }209  });210  211  itEth('Can perform transferFrom()', async ({helper}) => {212    const owner = await helper.eth.createAccountWithBalance(donor);213    const spender = await helper.eth.createAccountWithBalance(donor);214    const receiver = helper.eth.createAccount();215    const collection = await helper.rft.mintCollection(alice);216    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});217218    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);219    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);220221    await contract.methods.approve(spender, 100).send();222223    {224      const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});225      let event = result.events.Transfer;226      expect(event.address).to.be.equal(tokenAddress);227      expect(event.returnValues.from).to.be.equal(owner);228      expect(event.returnValues.to).to.be.equal(receiver);229      expect(event.returnValues.value).to.be.equal('49');230231      event = result.events.Approval;232      expect(event.address).to.be.equal(tokenAddress);233      expect(event.returnValues.owner).to.be.equal(owner);234      expect(event.returnValues.spender).to.be.equal(spender);235      expect(event.returnValues.value).to.be.equal('51');236    }237238    {239      const balance = await contract.methods.balanceOf(receiver).call();240      expect(+balance).to.equal(49);241    }242243    {244      const balance = await contract.methods.balanceOf(owner).call();245      expect(+balance).to.equal(151);246    }247  });248  249  itEth('Can perform transferFromCross()', async ({helper}) => {250    const owner = await helper.eth.createAccountWithBalance(donor);251    const ownerCross = helper.ethCrossAccount.fromAddress(owner);252    const spender = await helper.eth.createAccountWithBalance(donor);253    const receiver = helper.eth.createAccount();254    const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0];255    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver);256    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);257    258    const collection = await helper.rft.mintCollection(alice);259    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});260261    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);262    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);263264    await contract.methods.approve(spender, 100).send({from: owner});265    266    {267      const result = await contract.methods.transferFromCross(ownerCross, receiverCrossEth, 49).send({from: spender});268      let event = result.events.Transfer;269      expect(event.address).to.be.equal(tokenAddress);270      expect(event.returnValues.from).to.be.equal(owner);271      expect(event.returnValues.to).to.be.equal(receiver);272      expect(event.returnValues.value).to.be.equal('49');273274      event = result.events.Approval;275      expect(event.address).to.be.equal(tokenAddress);276      expect(event.returnValues.owner).to.be.equal(owner);277      expect(event.returnValues.spender).to.be.equal(spender);278      expect(event.returnValues.value).to.be.equal('51');279    }280281    {282      const balance = await contract.methods.balanceOf(receiver).call();283      expect(+balance).to.equal(49);284    }285286    {287      const balance = await contract.methods.balanceOf(owner).call();288      expect(+balance).to.equal(151);289    }290    291    {292      const result = await contract.methods.transferFromCross(ownerCross, receiverCrossSub, 51).send({from: spender});293      let event = result.events.Transfer;294      expect(event.address).to.be.equal(tokenAddress);295      expect(event.returnValues.from).to.be.equal(owner);296      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));297      expect(event.returnValues.value).to.be.equal('51');298299      event = result.events.Approval;300      expect(event.address).to.be.equal(tokenAddress);301      expect(event.returnValues.owner).to.be.equal(owner);302      expect(event.returnValues.spender).to.be.equal(spender);303      expect(event.returnValues.value).to.be.equal('0');304    }305306    {307      const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});308      expect(balance).to.equal(51n);309    }310311    {312      const balance = await contract.methods.balanceOf(owner).call();313      expect(+balance).to.equal(100);314    }315  });316317  itEth('Can perform transfer()', async ({helper}) => {318    const owner = await helper.eth.createAccountWithBalance(donor);319    const receiver = helper.eth.createAccount();320    const collection = await helper.rft.mintCollection(alice);321    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});322323    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);324    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);325326    {327      const result = await contract.methods.transfer(receiver, 50).send({from: owner});328      const event = result.events.Transfer;329      expect(event.address).to.be.equal(tokenAddress);330      expect(event.returnValues.from).to.be.equal(owner);331      expect(event.returnValues.to).to.be.equal(receiver);332      expect(event.returnValues.value).to.be.equal('50');333    }334335    {336      const balance = await contract.methods.balanceOf(owner).call();337      expect(+balance).to.equal(150);338    }339340    {341      const balance = await contract.methods.balanceOf(receiver).call();342      expect(+balance).to.equal(50);343    }344  });345  346  [347    'transfer',348    // 'transferCross', // TODO349  ].map(testCase => 350    itEth(`Cannot ${testCase}() non-owned token`, async ({helper}) => {351      const owner = await helper.eth.createAccountWithBalance(donor);352      const receiver = await helper.eth.createAccountWithBalance(donor);353      const collection = await helper.rft.mintCollection(alice);354      const rftOwner = await collection.mintToken(alice, 10n, {Ethereum: owner});355      const rftReceiver = await collection.mintToken(alice, 10n, {Ethereum: receiver});356      const tokenIdNonExist = 9999999;357  358      const tokenAddress1 = helper.ethAddress.fromTokenId(collection.collectionId, rftOwner.tokenId);359      const tokenAddress2 = helper.ethAddress.fromTokenId(collection.collectionId, rftReceiver.tokenId);360      const tokenAddressNonExist = helper.ethAddress.fromTokenId(collection.collectionId, tokenIdNonExist);361      const tokenEvmOwner = helper.ethNativeContract.rftToken(tokenAddress1, owner);362      const tokenEvmReceiver = helper.ethNativeContract.rftToken(tokenAddress2, owner);363      const tokenEvmNonExist = helper.ethNativeContract.rftToken(tokenAddressNonExist, owner);364      365      // 1. Can transfer zero amount (EIP-20):366      await tokenEvmOwner.methods[testCase](receiver, 0).send({from: owner});367      // 2. Cannot transfer non-owned token:368      await expect(tokenEvmReceiver.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;369      await expect(tokenEvmReceiver.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;370      // 3. Cannot transfer non-existing token:371      await expect(tokenEvmNonExist.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;372      await expect(tokenEvmNonExist.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;373374      // 4. Storage is not corrupted:375      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);376      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);377      expect(await helper.rft.getTokenTop10Owners(collection.collectionId, tokenIdNonExist)).to.deep.eq([]); // TODO378379      // 4.1 Tokens can be transferred:380      await tokenEvmOwner.methods[testCase](receiver, 10).send({from: owner});381      await tokenEvmReceiver.methods[testCase](owner, 10).send({from: receiver});382      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);383      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);384    }));385386  itEth('Can perform transferCross()', async ({helper}) => {387    const owner = await helper.eth.createAccountWithBalance(donor);388    const receiver = helper.eth.createAccount();389    const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0];390    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver);391    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);392    const collection = await helper.rft.mintCollection(alice);393    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});394395    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);396    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);397398    {399      const result = await contract.methods.transferCross(receiverCrossEth, 50).send({from: owner});400      const event = result.events.Transfer;401      expect(event.address).to.be.equal(tokenAddress);402      expect(event.returnValues.from).to.be.equal(owner);403      expect(event.returnValues.to).to.be.equal(receiver);404      expect(event.returnValues.value).to.be.equal('50');405    }406407    {408      const balance = await contract.methods.balanceOf(owner).call();409      expect(+balance).to.equal(150);410    }411412    {413      const balance = await contract.methods.balanceOf(receiver).call();414      expect(+balance).to.equal(50);415    }416    417    {418      const result = await contract.methods.transferCross(receiverCrossSub, 50).send({from: owner});419      const event = result.events.Transfer;420      expect(event.address).to.be.equal(tokenAddress);421      expect(event.returnValues.from).to.be.equal(owner);422      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));423      expect(event.returnValues.value).to.be.equal('50');424    }425426    {427      const balance = await contract.methods.balanceOf(owner).call();428      expect(+balance).to.equal(100);429    }430431    {432      const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});433      expect(balance).to.equal(50n);434    }435  });436  itEth('Can perform repartition()', async ({helper}) => {437    const owner = await helper.eth.createAccountWithBalance(donor);438    const receiver = await helper.eth.createAccountWithBalance(donor);439    const collection = await helper.rft.mintCollection(alice);440    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});441442    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);443    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);444445    await contract.methods.repartition(200).send({from: owner});446    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);447    await contract.methods.transfer(receiver, 110).send({from: owner});448    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);449    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);450451    await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; // Transaction is reverted452453    await contract.methods.transfer(receiver, 90).send({from: owner});454    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);455    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);456457    await contract.methods.repartition(150).send({from: receiver});458    await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected; // Transaction is reverted459    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);460  });461462  itEth('Can repartition with increased amount', async ({helper}) => {463    const owner = await helper.eth.createAccountWithBalance(donor);464    const collection = await helper.rft.mintCollection(alice);465    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});466467    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);468    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);469470    const result = await contract.methods.repartition(200).send();471472    const event = result.events.Transfer;473    expect(event.address).to.be.equal(tokenAddress);474    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');475    expect(event.returnValues.to).to.be.equal(owner);476    expect(event.returnValues.value).to.be.equal('100');477  });478479  itEth('Can repartition with decreased amount', async ({helper}) => {480    const owner = await helper.eth.createAccountWithBalance(donor);481    const collection = await helper.rft.mintCollection(alice);482    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});483484    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);485    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);486487    const result = await contract.methods.repartition(50).send();488    const event = result.events.Transfer;489    expect(event.address).to.be.equal(tokenAddress);490    expect(event.returnValues.from).to.be.equal(owner);491    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');492    expect(event.returnValues.value).to.be.equal('50');493  });494495  itEth('Receiving Transfer event on burning into full ownership', async ({helper}) => {496    const caller = await helper.eth.createAccountWithBalance(donor);497    const receiver = await helper.eth.createAccountWithBalance(donor);498    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Devastation', '6', '6');499    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);500501    const result = await contract.methods.mint(caller).send();502    const tokenId = result.events.Transfer.returnValues.tokenId;503    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);504    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);505506    await tokenContract.methods.repartition(2).send();507    await tokenContract.methods.transfer(receiver, 1).send();508509    const events: any = [];510    contract.events.allEvents((_: any, event: any) => {511      events.push(event);512    });513    await tokenContract.methods.burnFrom(caller, 1).send();514515    if (events.length == 0) await helper.wait.newBlocks(1);516    const event = events[0];517    expect(event.address).to.be.equal(collectionAddress);518    expect(event.returnValues.from).to.be.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');519    expect(event.returnValues.to).to.be.equal(receiver);520    expect(event.returnValues.tokenId).to.be.equal(tokenId);521  });522  523  itEth('Can perform burnFromCross()', async ({helper}) => {524    const owner = await helper.eth.createAccountWithBalance(donor);525    const ownerSub = (await helper.arrange.createAccounts([10n], donor))[0];526    const ownerCross = helper.ethCrossAccount.fromAddress(owner);527    const spender = await helper.eth.createAccountWithBalance(donor);528   529    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);530    const ownerSubCross = helper.ethCrossAccount.fromKeyringPair(ownerSub);531532    const collection = await helper.rft.mintCollection(alice);533    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});534    535536    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);537    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);538539    {540      await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});541    542      await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;543      await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;544      expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');545    }546    {547      const {tokenId} = await collection.mintToken(alice, 200n, {Substrate: ownerSub.address});548      await collection.approveToken(ownerSub, tokenId, {Ethereum: spender}, 100n);549      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);550      const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);551    552      await expect(contract.methods.burnFromCross(ownerSubCross, 50).send({from: spender})).to.be.fulfilled;553      await expect(contract.methods.burnFromCross(ownerSubCross, 100).send({from: spender})).to.be.rejected;554      expect(await collection.getTokenBalance(tokenId, {Substrate: ownerSub.address})).to.be.equal(150n);555    }556  });557});558559describe('Refungible: Fees', () => {560  let donor: IKeyringPair;561  let alice: IKeyringPair;562563  before(async function() {564    await usingEthPlaygrounds(async (helper, privateKey) => {565      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);566567      donor = await privateKey({filename: __filename});568      [alice] = await helper.arrange.createAccounts([50n], donor);569    });570  });571572  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {573    const owner = await helper.eth.createAccountWithBalance(donor);574    const spender = helper.eth.createAccount();575    const collection = await helper.rft.mintCollection(alice);576    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});577578    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);579    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);580581    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));582    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));583  });584585  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {586    const owner = await helper.eth.createAccountWithBalance(donor);587    const spender = await helper.eth.createAccountWithBalance(donor);588    const collection = await helper.rft.mintCollection(alice);589    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});590591    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);592    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);593594    await contract.methods.approve(spender, 100).send({from: owner});595596    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));597    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));598  });599600  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {601    const owner = await helper.eth.createAccountWithBalance(donor);602    const receiver = helper.eth.createAccount();603    const collection = await helper.rft.mintCollection(alice);604    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});605606    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);607    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);608609    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));610    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));611  });612});613614describe('Refungible: Substrate calls', () => {615  let donor: IKeyringPair;616  let alice: IKeyringPair;617618  before(async function() {619    await usingEthPlaygrounds(async (helper, privateKey) => {620      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);621622      donor = await privateKey({filename: __filename});623      [alice] = await helper.arrange.createAccounts([50n], donor);624    });625  });626627  itEth('Events emitted for approve()', async ({helper}) => {628    const receiver = helper.eth.createAccount();629    const collection = await helper.rft.mintCollection(alice);630    const token = await collection.mintToken(alice, 200n);631632    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);633    const contract = helper.ethNativeContract.rftToken(tokenAddress);634635    const events: any = [];636    contract.events.allEvents((_: any, event: any) => {637      events.push(event);638    });639640    expect(await token.approve(alice, {Ethereum: receiver}, 100n)).to.be.true;641    if (events.length == 0) await helper.wait.newBlocks(1);642    const event = events[0];643644    expect(event.event).to.be.equal('Approval');645    expect(event.address).to.be.equal(tokenAddress);646    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));647    expect(event.returnValues.spender).to.be.equal(receiver);648    expect(event.returnValues.value).to.be.equal('100');649  });650651  itEth('Events emitted for transferFrom()', async ({helper}) => {652    const [bob] = await helper.arrange.createAccounts([10n], donor);653    const receiver = helper.eth.createAccount();654    const collection = await helper.rft.mintCollection(alice);655    const token = await collection.mintToken(alice, 200n);656    await token.approve(alice, {Substrate: bob.address}, 100n);657658    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);659    const contract = helper.ethNativeContract.rftToken(tokenAddress);660661    const events: any = [];662    contract.events.allEvents((_: any, event: any) => {663      events.push(event);664    });665666    expect(await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver},  51n)).to.be.true;667    if (events.length == 0) await helper.wait.newBlocks(1);668669    let event = events[0];670    expect(event.event).to.be.equal('Transfer');671    expect(event.address).to.be.equal(tokenAddress);672    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));673    expect(event.returnValues.to).to.be.equal(receiver);674    expect(event.returnValues.value).to.be.equal('51');675676    event = events[1];677    expect(event.event).to.be.equal('Approval');678    expect(event.address).to.be.equal(tokenAddress);679    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));680    expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));681    expect(event.returnValues.value).to.be.equal('49');682  });683684  itEth('Events emitted for transfer()', async ({helper}) => {685    const receiver = helper.eth.createAccount();686    const collection = await helper.rft.mintCollection(alice);687    const token = await collection.mintToken(alice, 200n);688689    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);690    const contract = helper.ethNativeContract.rftToken(tokenAddress);691692    const events: any = [];693    contract.events.allEvents((_: any, event: any) => {694      events.push(event);695    });696697    expect(await token.transfer(alice, {Ethereum: receiver},  51n)).to.be.true;698    if (events.length == 0) await helper.wait.newBlocks(1);699    const event = events[0];700701    expect(event.event).to.be.equal('Transfer');702    expect(event.address).to.be.equal(tokenAddress);703    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));704    expect(event.returnValues.to).to.be.equal(receiver);705    expect(event.returnValues.value).to.be.equal('51');706  });707});708709describe('ERC 1633 implementation', () => {710  let donor: IKeyringPair;711712  before(async function() {713    await usingEthPlaygrounds(async (helper, privateKey) => {714      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);715716      donor = await privateKey({filename: __filename});717    });718  });719720  itEth('Default parent token address and id', async ({helper}) => {721    const owner = await helper.eth.createAccountWithBalance(donor);722723    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Sands', '', 'GRAIN');724    const collectionContract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);725726    const result = await collectionContract.methods.mint(owner).send();727    const tokenId = result.events.Transfer.returnValues.tokenId;728729    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);730    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);731732    expect(await tokenContract.methods.parentToken().call()).to.be.equal(collectionAddress);733    expect(await tokenContract.methods.parentTokenId().call()).to.be.equal(tokenId);734  });735});