git.delta.rocks / unique-network / refs/commits / 534b1e6a235d

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  [212    'transferFrom',213    'transferFromCross',214  ].map(testCase => 215    itEth(`Can perform ${testCase}`, async ({helper}) => {216      const isCross = testCase === 'transferFromCross';217      const owner = await helper.eth.createAccountWithBalance(donor);218      const ownerCross = helper.ethCrossAccount.fromAddress(owner);219      const spender = await helper.eth.createAccountWithBalance(donor);220      const receiverEth = helper.eth.createAccount();221      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);222      const [receiverSub] = await helper.arrange.createAccounts([1n], donor);223      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);224    225      const collection = await helper.rft.mintCollection(alice);226      const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});227228      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);229      const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);230231      await contract.methods.approve(spender, 100).send({from: owner});232    233      // 1. Can transfer from234      // 1.1 Plain ethereum or cross address:235      {236        const result = await contract.methods[testCase](237          isCross ? ownerCross : owner,238          isCross ? receiverCrossEth : receiverEth, 239          49,240        ).send({from: spender});241242        // Check events:243        const transferEvent = result.events.Transfer;244        expect(transferEvent.address).to.be.equal(tokenAddress);245        expect(transferEvent.returnValues.from).to.be.equal(owner);246        expect(transferEvent.returnValues.to).to.be.equal(receiverEth);247        expect(transferEvent.returnValues.value).to.be.equal('49');248249        const approvalEvent = result.events.Approval;250        expect(approvalEvent.address).to.be.equal(tokenAddress);251        expect(approvalEvent.returnValues.owner).to.be.equal(owner);252        expect(approvalEvent.returnValues.spender).to.be.equal(spender);253        expect(approvalEvent.returnValues.value).to.be.equal('51');254255        // Check balances:256        const receiverBalance = await contract.methods.balanceOf(receiverEth).call();257        const ownerBalance = await contract.methods.balanceOf(owner).call();258259        expect(+receiverBalance).to.equal(49);260        expect(+ownerBalance).to.equal(151);261      }262    263      // 1.2 Cross substrate address:264      if (testCase === 'transferFromCross') {265        const result = await contract.methods.transferFromCross(ownerCross, receiverCrossSub, 51).send({from: spender});266        // Check events:267        const transferEvent = result.events.Transfer;268        expect(transferEvent.address).to.be.equal(tokenAddress);269        expect(transferEvent.returnValues.from).to.be.equal(owner);270        expect(transferEvent.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));271        expect(transferEvent.returnValues.value).to.be.equal('51');272273        const approvalEvent = result.events.Approval;274        expect(approvalEvent.address).to.be.equal(tokenAddress);275        expect(approvalEvent.returnValues.owner).to.be.equal(owner);276        expect(approvalEvent.returnValues.spender).to.be.equal(spender);277        expect(approvalEvent.returnValues.value).to.be.equal('0');278279        // Check balances:280        const receiverBalance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});281        const ownerBalance = await contract.methods.balanceOf(owner).call();282        expect(receiverBalance).to.equal(51n);283        expect(+ownerBalance).to.equal(100);284      }285    }));286287  [288    'transfer',289    'transferCross',290  ].map(testCase => 291    itEth(`Can perform ${testCase}()`, async ({helper}) => {292      const isCross = testCase === 'transferCross';293      const owner = await helper.eth.createAccountWithBalance(donor);294      const receiverEth = helper.eth.createAccount();295      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);296      const [receiverSub] = await helper.arrange.createAccounts([1n], donor);297      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);298      const collection = await helper.rft.mintCollection(alice);299      const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});300301      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);302      const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);303304      // 1. Can transfer to plain ethereum or cross-ethereum account:305      {306        const result = await contract.methods[testCase](isCross ? receiverCrossEth : receiverEth, 50).send({from: owner});307        // Check events308        const transferEvent = result.events.Transfer;309        expect(transferEvent.address).to.be.equal(tokenAddress);310        expect(transferEvent.returnValues.from).to.be.equal(owner);311        expect(transferEvent.returnValues.to).to.be.equal(receiverEth);312        expect(transferEvent.returnValues.value).to.be.equal('50');313        // Check balances:314        const ownerBalance = await contract.methods.balanceOf(owner).call();315        const receiverBalance = await contract.methods.balanceOf(receiverEth).call();316        expect(+ownerBalance).to.equal(150);317        expect(+receiverBalance).to.equal(50);318      }319    320      // 2. Can transfer to cross-substrate account: 321      if(isCross) {322        const result = await contract.methods.transferCross(receiverCrossSub, 50).send({from: owner});323        // Check events:324        const event = result.events.Transfer;325        expect(event.address).to.be.equal(tokenAddress);326        expect(event.returnValues.from).to.be.equal(owner);327        expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));328        expect(event.returnValues.value).to.be.equal('50');329        // Check balances:330        const ownerBalance = await contract.methods.balanceOf(owner).call();331        const receiverBalance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});332        expect(+ownerBalance).to.equal(100);333        expect(receiverBalance).to.equal(50n);334      }335    }));336337  [338    'transfer',339    'transferCross',340  ].map(testCase => 341    itEth(`Cannot ${testCase}() non-owned token`, async ({helper}) => {342      const isCross = testCase === 'transferCross';343      const owner = await helper.eth.createAccountWithBalance(donor);344      const ownerCross = helper.ethCrossAccount.fromAddress(owner);345      const receiverEth = await helper.eth.createAccountWithBalance(donor);346      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);347      const collection = await helper.rft.mintCollection(alice);348      const rftOwner = await collection.mintToken(alice, 10n, {Ethereum: owner});349      const rftReceiver = await collection.mintToken(alice, 10n, {Ethereum: receiverEth});350      const tokenIdNonExist = 9999999;351  352      const tokenAddress1 = helper.ethAddress.fromTokenId(collection.collectionId, rftOwner.tokenId);353      const tokenAddress2 = helper.ethAddress.fromTokenId(collection.collectionId, rftReceiver.tokenId);354      const tokenAddressNonExist = helper.ethAddress.fromTokenId(collection.collectionId, tokenIdNonExist);355      const tokenEvmOwner = helper.ethNativeContract.rftToken(tokenAddress1, owner);356      const tokenEvmReceiver = helper.ethNativeContract.rftToken(tokenAddress2, owner);357      const tokenEvmNonExist = helper.ethNativeContract.rftToken(tokenAddressNonExist, owner);358      359      // 1. Can transfer zero amount (EIP-20):360      await tokenEvmOwner.methods[testCase](isCross ? receiverCrossEth : receiverEth, 0).send({from: owner});361      // 2. Cannot transfer non-owned token:362      await expect(tokenEvmReceiver.methods[testCase](isCross ? ownerCross : owner, 0).send({from: owner})).to.be.rejected;363      await expect(tokenEvmReceiver.methods[testCase](isCross ? ownerCross : owner, 5).send({from: owner})).to.be.rejected;364      // 3. Cannot transfer non-existing token:365      await expect(tokenEvmNonExist.methods[testCase](isCross ? ownerCross : owner, 0).send({from: owner})).to.be.rejected;366      await expect(tokenEvmNonExist.methods[testCase](isCross ? ownerCross : owner, 5).send({from: owner})).to.be.rejected;367368      // 4. Storage is not corrupted:369      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);370      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: receiverEth.toLowerCase()}]);371      expect(await helper.rft.getTokenTop10Owners(collection.collectionId, tokenIdNonExist)).to.deep.eq([]);372373      // 4.1 Tokens can be transferred:374      await tokenEvmOwner.methods[testCase](isCross ? receiverCrossEth : receiverEth, 10).send({from: owner});375      await tokenEvmReceiver.methods[testCase](isCross ? ownerCross : owner, 10).send({from: receiverEth});376      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: receiverEth.toLowerCase()}]);377      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);378    }));379380  itEth('Can perform repartition()', async ({helper}) => {381    const owner = await helper.eth.createAccountWithBalance(donor);382    const receiver = await helper.eth.createAccountWithBalance(donor);383    const collection = await helper.rft.mintCollection(alice);384    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});385386    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);387    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);388389    await contract.methods.repartition(200).send({from: owner});390    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);391    await contract.methods.transfer(receiver, 110).send({from: owner});392    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);393    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);394395    await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; // Transaction is reverted396397    await contract.methods.transfer(receiver, 90).send({from: owner});398    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);399    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);400401    await contract.methods.repartition(150).send({from: receiver});402    await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected; // Transaction is reverted403    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);404  });405406  itEth('Can repartition with increased amount', async ({helper}) => {407    const owner = await helper.eth.createAccountWithBalance(donor);408    const collection = await helper.rft.mintCollection(alice);409    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});410411    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);412    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);413414    const result = await contract.methods.repartition(200).send();415416    const event = result.events.Transfer;417    expect(event.address).to.be.equal(tokenAddress);418    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');419    expect(event.returnValues.to).to.be.equal(owner);420    expect(event.returnValues.value).to.be.equal('100');421  });422423  itEth('Can repartition with decreased amount', async ({helper}) => {424    const owner = await helper.eth.createAccountWithBalance(donor);425    const collection = await helper.rft.mintCollection(alice);426    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});427428    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);429    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);430431    const result = await contract.methods.repartition(50).send();432    const event = result.events.Transfer;433    expect(event.address).to.be.equal(tokenAddress);434    expect(event.returnValues.from).to.be.equal(owner);435    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');436    expect(event.returnValues.value).to.be.equal('50');437  });438439  itEth('Receiving Transfer event on burning into full ownership', async ({helper}) => {440    const caller = await helper.eth.createAccountWithBalance(donor);441    const receiver = await helper.eth.createAccountWithBalance(donor);442    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Devastation', '6', '6');443    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);444445    const result = await contract.methods.mint(caller).send();446    const tokenId = result.events.Transfer.returnValues.tokenId;447    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);448    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);449450    await tokenContract.methods.repartition(2).send();451    await tokenContract.methods.transfer(receiver, 1).send();452453    const events: any = [];454    contract.events.allEvents((_: any, event: any) => {455      events.push(event);456    });457    await tokenContract.methods.burnFrom(caller, 1).send();458459    if (events.length == 0) await helper.wait.newBlocks(1);460    const event = events[0];461    expect(event.address).to.be.equal(collectionAddress);462    expect(event.returnValues.from).to.be.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');463    expect(event.returnValues.to).to.be.equal(receiver);464    expect(event.returnValues.tokenId).to.be.equal(tokenId);465  });466  467  itEth('Can perform burnFromCross()', async ({helper}) => {468    const owner = await helper.eth.createAccountWithBalance(donor);469    const ownerSub = (await helper.arrange.createAccounts([10n], donor))[0];470    const ownerCross = helper.ethCrossAccount.fromAddress(owner);471    const spender = await helper.eth.createAccountWithBalance(donor);472   473    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);474    const ownerSubCross = helper.ethCrossAccount.fromKeyringPair(ownerSub);475476    const collection = await helper.rft.mintCollection(alice);477    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});478    479480    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);481    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);482483    {484      await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});485    486      await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;487      await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;488      expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');489    }490    {491      const {tokenId} = await collection.mintToken(alice, 200n, {Substrate: ownerSub.address});492      await collection.approveToken(ownerSub, tokenId, {Ethereum: spender}, 100n);493      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);494      const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);495    496      await expect(contract.methods.burnFromCross(ownerSubCross, 50).send({from: spender})).to.be.fulfilled;497      await expect(contract.methods.burnFromCross(ownerSubCross, 100).send({from: spender})).to.be.rejected;498      expect(await collection.getTokenBalance(tokenId, {Substrate: ownerSub.address})).to.be.equal(150n);499    }500  });501});502503describe('Refungible: Fees', () => {504  let donor: IKeyringPair;505  let alice: IKeyringPair;506507  before(async function() {508    await usingEthPlaygrounds(async (helper, privateKey) => {509      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);510511      donor = await privateKey({filename: __filename});512      [alice] = await helper.arrange.createAccounts([50n], donor);513    });514  });515516  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {517    const owner = await helper.eth.createAccountWithBalance(donor);518    const spender = helper.eth.createAccount();519    const collection = await helper.rft.mintCollection(alice);520    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});521522    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);523    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);524525    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));526    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));527  });528529  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {530    const owner = await helper.eth.createAccountWithBalance(donor);531    const spender = await helper.eth.createAccountWithBalance(donor);532    const collection = await helper.rft.mintCollection(alice);533    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});534535    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);536    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);537538    await contract.methods.approve(spender, 100).send({from: owner});539540    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));541    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));542  });543544  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {545    const owner = await helper.eth.createAccountWithBalance(donor);546    const receiver = helper.eth.createAccount();547    const collection = await helper.rft.mintCollection(alice);548    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});549550    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);551    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);552553    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));554    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));555  });556});557558describe('Refungible: Substrate calls', () => {559  let donor: IKeyringPair;560  let alice: IKeyringPair;561562  before(async function() {563    await usingEthPlaygrounds(async (helper, privateKey) => {564      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);565566      donor = await privateKey({filename: __filename});567      [alice] = await helper.arrange.createAccounts([50n], donor);568    });569  });570571  itEth('Events emitted for approve()', async ({helper}) => {572    const receiver = helper.eth.createAccount();573    const collection = await helper.rft.mintCollection(alice);574    const token = await collection.mintToken(alice, 200n);575576    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);577    const contract = helper.ethNativeContract.rftToken(tokenAddress);578579    const events: any = [];580    contract.events.allEvents((_: any, event: any) => {581      events.push(event);582    });583584    expect(await token.approve(alice, {Ethereum: receiver}, 100n)).to.be.true;585    if (events.length == 0) await helper.wait.newBlocks(1);586    const event = events[0];587588    expect(event.event).to.be.equal('Approval');589    expect(event.address).to.be.equal(tokenAddress);590    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));591    expect(event.returnValues.spender).to.be.equal(receiver);592    expect(event.returnValues.value).to.be.equal('100');593  });594595  itEth('Events emitted for transferFrom()', async ({helper}) => {596    const [bob] = await helper.arrange.createAccounts([10n], donor);597    const receiver = helper.eth.createAccount();598    const collection = await helper.rft.mintCollection(alice);599    const token = await collection.mintToken(alice, 200n);600    await token.approve(alice, {Substrate: bob.address}, 100n);601602    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);603    const contract = helper.ethNativeContract.rftToken(tokenAddress);604605    const events: any = [];606    contract.events.allEvents((_: any, event: any) => {607      events.push(event);608    });609610    expect(await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver},  51n)).to.be.true;611    if (events.length == 0) await helper.wait.newBlocks(1);612613    let event = events[0];614    expect(event.event).to.be.equal('Transfer');615    expect(event.address).to.be.equal(tokenAddress);616    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));617    expect(event.returnValues.to).to.be.equal(receiver);618    expect(event.returnValues.value).to.be.equal('51');619620    event = events[1];621    expect(event.event).to.be.equal('Approval');622    expect(event.address).to.be.equal(tokenAddress);623    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));624    expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));625    expect(event.returnValues.value).to.be.equal('49');626  });627628  itEth('Events emitted for transfer()', async ({helper}) => {629    const receiver = helper.eth.createAccount();630    const collection = await helper.rft.mintCollection(alice);631    const token = await collection.mintToken(alice, 200n);632633    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);634    const contract = helper.ethNativeContract.rftToken(tokenAddress);635636    const events: any = [];637    contract.events.allEvents((_: any, event: any) => {638      events.push(event);639    });640641    expect(await token.transfer(alice, {Ethereum: receiver},  51n)).to.be.true;642    if (events.length == 0) await helper.wait.newBlocks(1);643    const event = events[0];644645    expect(event.event).to.be.equal('Transfer');646    expect(event.address).to.be.equal(tokenAddress);647    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));648    expect(event.returnValues.to).to.be.equal(receiver);649    expect(event.returnValues.value).to.be.equal('51');650  });651});652653describe('ERC 1633 implementation', () => {654  let donor: IKeyringPair;655656  before(async function() {657    await usingEthPlaygrounds(async (helper, privateKey) => {658      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);659660      donor = await privateKey({filename: __filename});661    });662  });663664  itEth('Default parent token address and id', async ({helper}) => {665    const owner = await helper.eth.createAccountWithBalance(donor);666667    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Sands', '', 'GRAIN');668    const collectionContract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);669670    const result = await collectionContract.methods.mint(owner).send();671    const tokenId = result.events.Transfer.returnValues.tokenId;672673    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);674    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);675676    expect(await tokenContract.methods.parentToken().call()).to.be.equal(collectionAddress);677    expect(await tokenContract.methods.parentTokenId().call()).to.be.equal(tokenId);678  });679});