git.delta.rocks / unique-network / refs/commits / 67600317b934

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 spenderCross = helper.ethCrossAccount.fromAddress(spender);167168    const collection = await helper.rft.mintCollection(alice);169    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});170171    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);172    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);173174    {175      const result = await contract.methods.approveCross(spenderCross, 100).send({from: owner});176      const event = result.events.Approval;177      expect(event.address).to.be.equal(tokenAddress);178      expect(event.returnValues.owner).to.be.equal(owner);179      expect(event.returnValues.spender).to.be.equal(spender);180      expect(event.returnValues.value).to.be.equal('100');181    }182183    {184      const allowance = await contract.methods.allowance(owner, spender).call();185      expect(+allowance).to.equal(100);186    }187  });188  189  itEth('Can perform transferFrom()', async ({helper}) => {190    const owner = await helper.eth.createAccountWithBalance(donor);191    const spender = await helper.eth.createAccountWithBalance(donor);192    const receiver = helper.eth.createAccount();193    const collection = await helper.rft.mintCollection(alice);194    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});195196    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);197    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);198199    await contract.methods.approve(spender, 100).send();200201    {202      const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});203      let event = result.events.Transfer;204      expect(event.address).to.be.equal(tokenAddress);205      expect(event.returnValues.from).to.be.equal(owner);206      expect(event.returnValues.to).to.be.equal(receiver);207      expect(event.returnValues.value).to.be.equal('49');208209      event = result.events.Approval;210      expect(event.address).to.be.equal(tokenAddress);211      expect(event.returnValues.owner).to.be.equal(owner);212      expect(event.returnValues.spender).to.be.equal(spender);213      expect(event.returnValues.value).to.be.equal('51');214    }215216    {217      const balance = await contract.methods.balanceOf(receiver).call();218      expect(+balance).to.equal(49);219    }220221    {222      const balance = await contract.methods.balanceOf(owner).call();223      expect(+balance).to.equal(151);224    }225  });226  227  itEth('Can perform transferFromCross()', async ({helper}) => {228    const owner = await helper.eth.createAccountWithBalance(donor);229    const ownerCross = helper.ethCrossAccount.fromAddress(owner);230    const spender = await helper.eth.createAccountWithBalance(donor);231    const receiver = helper.eth.createAccount();232    const receiverCross = helper.ethCrossAccount.fromAddress(receiver);233    const collection = await helper.rft.mintCollection(alice);234    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});235236    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);237    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);238239    await contract.methods.approve(spender, 100).send();240241    {242      const result = await contract.methods.transferFromCross(ownerCross, receiverCross, 49).send({from: spender});243      let event = result.events.Transfer;244      expect(event.address).to.be.equal(tokenAddress);245      expect(event.returnValues.from).to.be.equal(owner);246      expect(event.returnValues.to).to.be.equal(receiver);247      expect(event.returnValues.value).to.be.equal('49');248249      event = result.events.Approval;250      expect(event.address).to.be.equal(tokenAddress);251      expect(event.returnValues.owner).to.be.equal(owner);252      expect(event.returnValues.spender).to.be.equal(spender);253      expect(event.returnValues.value).to.be.equal('51');254    }255256    {257      const balance = await contract.methods.balanceOf(receiver).call();258      expect(+balance).to.equal(49);259    }260261    {262      const balance = await contract.methods.balanceOf(owner).call();263      expect(+balance).to.equal(151);264    }265  });266267  itEth('Can perform transfer()', async ({helper}) => {268    const owner = await helper.eth.createAccountWithBalance(donor);269    const receiver = helper.eth.createAccount();270    const collection = await helper.rft.mintCollection(alice);271    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});272273    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);274    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);275276    {277      const result = await contract.methods.transfer(receiver, 50).send({from: owner});278      const event = result.events.Transfer;279      expect(event.address).to.be.equal(tokenAddress);280      expect(event.returnValues.from).to.be.equal(owner);281      expect(event.returnValues.to).to.be.equal(receiver);282      expect(event.returnValues.value).to.be.equal('50');283    }284285    {286      const balance = await contract.methods.balanceOf(owner).call();287      expect(+balance).to.equal(150);288    }289290    {291      const balance = await contract.methods.balanceOf(receiver).call();292      expect(+balance).to.equal(50);293    }294  });295  296  [297    'transfer',298    // 'transferCross', // TODO299  ].map(testCase => 300    itEth(`Cannot ${testCase}() non-owned token`, async ({helper}) => {301      const owner = await helper.eth.createAccountWithBalance(donor);302      const receiver = await helper.eth.createAccountWithBalance(donor);303      const collection = await helper.rft.mintCollection(alice);304      const rftOwner = await collection.mintToken(alice, 10n, {Ethereum: owner});305      const rftReceiver = await collection.mintToken(alice, 10n, {Ethereum: receiver});306      const tokenIdNonExist = 9999999;307  308      const tokenAddress1 = helper.ethAddress.fromTokenId(collection.collectionId, rftOwner.tokenId);309      const tokenAddress2 = helper.ethAddress.fromTokenId(collection.collectionId, rftReceiver.tokenId);310      const tokenAddressNonExist = helper.ethAddress.fromTokenId(collection.collectionId, tokenIdNonExist);311      const tokenEvmOwner = helper.ethNativeContract.rftToken(tokenAddress1, owner);312      const tokenEvmReceiver = helper.ethNativeContract.rftToken(tokenAddress2, owner);313      const tokenEvmNonExist = helper.ethNativeContract.rftToken(tokenAddressNonExist, owner);314      315      // 1. Can transfer zero amount (EIP-20):316      await tokenEvmOwner.methods[testCase](receiver, 0).send({from: owner});317      // 2. Cannot transfer non-owned token:318      await expect(tokenEvmReceiver.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;319      await expect(tokenEvmReceiver.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;320      // 3. Cannot transfer non-existing token:321      await expect(tokenEvmNonExist.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;322      await expect(tokenEvmNonExist.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;323324      // 4. Storage is not corrupted:325      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);326      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);327      expect(await helper.rft.getTokenTop10Owners(collection.collectionId, tokenIdNonExist)).to.deep.eq([]); // TODO328329      // 4.1 Tokens can be transferred:330      await tokenEvmOwner.methods[testCase](receiver, 10).send({from: owner});331      await tokenEvmReceiver.methods[testCase](owner, 10).send({from: receiver});332      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);333      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);334    }));335336  itEth('Can perform transferCross()', async ({helper}) => {337    const owner = await helper.eth.createAccountWithBalance(donor);338    const receiver = helper.eth.createAccount();339    const receiverCross = helper.ethCrossAccount.fromAddress(receiver);340    const collection = await helper.rft.mintCollection(alice);341    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});342343    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);344    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);345346    {347      const result = await contract.methods.transferCross(receiverCross, 50).send({from: owner});348      const event = result.events.Transfer;349      expect(event.address).to.be.equal(tokenAddress);350      expect(event.returnValues.from).to.be.equal(owner);351      expect(event.returnValues.to).to.be.equal(receiver);352      expect(event.returnValues.value).to.be.equal('50');353    }354355    {356      const balance = await contract.methods.balanceOf(owner).call();357      expect(+balance).to.equal(150);358    }359360    {361      const balance = await contract.methods.balanceOf(receiver).call();362      expect(+balance).to.equal(50);363    }364  });365  itEth('Can perform repartition()', async ({helper}) => {366    const owner = await helper.eth.createAccountWithBalance(donor);367    const receiver = await helper.eth.createAccountWithBalance(donor);368    const collection = await helper.rft.mintCollection(alice);369    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});370371    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);372    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);373374    await contract.methods.repartition(200).send({from: owner});375    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);376    await contract.methods.transfer(receiver, 110).send({from: owner});377    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);378    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);379380    await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; // Transaction is reverted381382    await contract.methods.transfer(receiver, 90).send({from: owner});383    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);384    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);385386    await contract.methods.repartition(150).send({from: receiver});387    await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected; // Transaction is reverted388    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);389  });390391  itEth('Can repartition with increased amount', async ({helper}) => {392    const owner = await helper.eth.createAccountWithBalance(donor);393    const collection = await helper.rft.mintCollection(alice);394    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});395396    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);397    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);398399    const result = await contract.methods.repartition(200).send();400401    const event = result.events.Transfer;402    expect(event.address).to.be.equal(tokenAddress);403    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');404    expect(event.returnValues.to).to.be.equal(owner);405    expect(event.returnValues.value).to.be.equal('100');406  });407408  itEth('Can repartition with decreased amount', async ({helper}) => {409    const owner = await helper.eth.createAccountWithBalance(donor);410    const collection = await helper.rft.mintCollection(alice);411    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});412413    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);414    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);415416    const result = await contract.methods.repartition(50).send();417    const event = result.events.Transfer;418    expect(event.address).to.be.equal(tokenAddress);419    expect(event.returnValues.from).to.be.equal(owner);420    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');421    expect(event.returnValues.value).to.be.equal('50');422  });423424  itEth('Receiving Transfer event on burning into full ownership', async ({helper}) => {425    const caller = await helper.eth.createAccountWithBalance(donor);426    const receiver = await helper.eth.createAccountWithBalance(donor);427    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Devastation', '6', '6');428    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);429430    const result = await contract.methods.mint(caller).send();431    const tokenId = result.events.Transfer.returnValues.tokenId;432    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);433    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);434435    await tokenContract.methods.repartition(2).send();436    await tokenContract.methods.transfer(receiver, 1).send();437438    const events: any = [];439    contract.events.allEvents((_: any, event: any) => {440      events.push(event);441    });442    await tokenContract.methods.burnFrom(caller, 1).send();443444    if (events.length == 0) await helper.wait.newBlocks(1);445    const event = events[0];446    expect(event.address).to.be.equal(collectionAddress);447    expect(event.returnValues.from).to.be.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');448    expect(event.returnValues.to).to.be.equal(receiver);449    expect(event.returnValues.tokenId).to.be.equal(tokenId);450  });451  452  itEth('Can perform burnFromCross()', async ({helper}) => {453    const owner = await helper.eth.createAccountWithBalance(donor);454    const ownerCross = helper.ethCrossAccount.fromAddress(owner);455    const spender = await helper.eth.createAccountWithBalance(donor);456    const spenderCross = helper.ethCrossAccount.fromAddress(spender);457458    const collection = await helper.rft.mintCollection(alice);459    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});460461    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);462    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);463464    await contract.methods.approveCross(spenderCross, 100).send({from: owner});465    466    await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;467    await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;468    expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');469  });470});471472describe('Refungible: Fees', () => {473  let donor: IKeyringPair;474  let alice: IKeyringPair;475476  before(async function() {477    await usingEthPlaygrounds(async (helper, privateKey) => {478      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);479480      donor = await privateKey({filename: __filename});481      [alice] = await helper.arrange.createAccounts([50n], donor);482    });483  });484485  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {486    const owner = await helper.eth.createAccountWithBalance(donor);487    const spender = helper.eth.createAccount();488    const collection = await helper.rft.mintCollection(alice);489    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});490491    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);492    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);493494    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));495    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));496  });497498  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {499    const owner = await helper.eth.createAccountWithBalance(donor);500    const spender = await helper.eth.createAccountWithBalance(donor);501    const collection = await helper.rft.mintCollection(alice);502    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});503504    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);505    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);506507    await contract.methods.approve(spender, 100).send({from: owner});508509    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));510    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));511  });512513  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {514    const owner = await helper.eth.createAccountWithBalance(donor);515    const receiver = helper.eth.createAccount();516    const collection = await helper.rft.mintCollection(alice);517    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});518519    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);520    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);521522    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));523    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));524  });525});526527describe('Refungible: Substrate calls', () => {528  let donor: IKeyringPair;529  let alice: IKeyringPair;530531  before(async function() {532    await usingEthPlaygrounds(async (helper, privateKey) => {533      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);534535      donor = await privateKey({filename: __filename});536      [alice] = await helper.arrange.createAccounts([50n], donor);537    });538  });539540  itEth('Events emitted for approve()', async ({helper}) => {541    const receiver = helper.eth.createAccount();542    const collection = await helper.rft.mintCollection(alice);543    const token = await collection.mintToken(alice, 200n);544545    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);546    const contract = helper.ethNativeContract.rftToken(tokenAddress);547548    const events: any = [];549    contract.events.allEvents((_: any, event: any) => {550      events.push(event);551    });552553    expect(await token.approve(alice, {Ethereum: receiver}, 100n)).to.be.true;554    if (events.length == 0) await helper.wait.newBlocks(1);555    const event = events[0];556557    expect(event.event).to.be.equal('Approval');558    expect(event.address).to.be.equal(tokenAddress);559    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));560    expect(event.returnValues.spender).to.be.equal(receiver);561    expect(event.returnValues.value).to.be.equal('100');562  });563564  itEth('Events emitted for transferFrom()', async ({helper}) => {565    const [bob] = await helper.arrange.createAccounts([10n], donor);566    const receiver = helper.eth.createAccount();567    const collection = await helper.rft.mintCollection(alice);568    const token = await collection.mintToken(alice, 200n);569    await token.approve(alice, {Substrate: bob.address}, 100n);570571    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);572    const contract = helper.ethNativeContract.rftToken(tokenAddress);573574    const events: any = [];575    contract.events.allEvents((_: any, event: any) => {576      events.push(event);577    });578579    expect(await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver},  51n)).to.be.true;580    if (events.length == 0) await helper.wait.newBlocks(1);581582    let event = events[0];583    expect(event.event).to.be.equal('Transfer');584    expect(event.address).to.be.equal(tokenAddress);585    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));586    expect(event.returnValues.to).to.be.equal(receiver);587    expect(event.returnValues.value).to.be.equal('51');588589    event = events[1];590    expect(event.event).to.be.equal('Approval');591    expect(event.address).to.be.equal(tokenAddress);592    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));593    expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));594    expect(event.returnValues.value).to.be.equal('49');595  });596597  itEth('Events emitted for transfer()', async ({helper}) => {598    const receiver = helper.eth.createAccount();599    const collection = await helper.rft.mintCollection(alice);600    const token = await collection.mintToken(alice, 200n);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.transfer(alice, {Ethereum: receiver},  51n)).to.be.true;611    if (events.length == 0) await helper.wait.newBlocks(1);612    const event = events[0];613614    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');619  });620});621622describe('ERC 1633 implementation', () => {623  let donor: IKeyringPair;624625  before(async function() {626    await usingEthPlaygrounds(async (helper, privateKey) => {627      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);628629      donor = await privateKey({filename: __filename});630    });631  });632633  itEth('Default parent token address and id', async ({helper}) => {634    const owner = await helper.eth.createAccountWithBalance(donor);635636    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Sands', '', 'GRAIN');637    const collectionContract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);638639    const result = await collectionContract.methods.mint(owner).send();640    const tokenId = result.events.Transfer.returnValues.tokenId;641642    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);643    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);644645    expect(await tokenContract.methods.parentToken().call()).to.be.equal(collectionAddress);646    expect(await tokenContract.methods.parentTokenId().call()).to.be.equal(tokenId);647  });648});