git.delta.rocks / unique-network / refs/commits / d996a74e54de

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 = await 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 = await 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 = await 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 = await 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 = await 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  });162163  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);169170171    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 = await 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    }190191192    {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    }205206    {207      //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()208    }209  });210211  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {212    const nonOwner = await helper.eth.createAccountWithBalance(donor);213    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);214    const owner = await helper.eth.createAccountWithBalance(donor);215    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});216    const token = await collection.mintToken(alice, 100n, {Ethereum: owner});217218    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);219    const tokenEvm = await helper.ethNativeContract.rftToken(tokenAddress, owner);220221    await expect(tokenEvm.methods.approveCross(nonOwnerCross, 20).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');222  });223224  [225    'transferFrom',226    'transferFromCross',227  ].map(testCase =>228    itEth(`Can perform ${testCase}`, async ({helper}) => {229      const isCross = testCase === 'transferFromCross';230      const owner = await helper.eth.createAccountWithBalance(donor);231      const ownerCross = helper.ethCrossAccount.fromAddress(owner);232      const spender = await helper.eth.createAccountWithBalance(donor);233      const receiverEth = helper.eth.createAccount();234      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);235      const [receiverSub] = await helper.arrange.createAccounts([1n], donor);236      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);237238      const collection = await helper.rft.mintCollection(alice);239      const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});240241      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);242      const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);243244      await contract.methods.approve(spender, 100).send({from: owner});245246      // 1. Can transfer from247      // 1.1 Plain ethereum or cross address:248      {249        const result = await contract.methods[testCase](250          isCross ? ownerCross : owner,251          isCross ? receiverCrossEth : receiverEth,252          49,253        ).send({from: spender});254255        // Check events:256        const transferEvent = result.events.Transfer;257        expect(transferEvent.address).to.be.equal(tokenAddress);258        expect(transferEvent.returnValues.from).to.be.equal(owner);259        expect(transferEvent.returnValues.to).to.be.equal(receiverEth);260        expect(transferEvent.returnValues.value).to.be.equal('49');261262        const approvalEvent = result.events.Approval;263        expect(approvalEvent.address).to.be.equal(tokenAddress);264        expect(approvalEvent.returnValues.owner).to.be.equal(owner);265        expect(approvalEvent.returnValues.spender).to.be.equal(spender);266        expect(approvalEvent.returnValues.value).to.be.equal('51');267268        // Check balances:269        const receiverBalance = await contract.methods.balanceOf(receiverEth).call();270        const ownerBalance = await contract.methods.balanceOf(owner).call();271272        expect(+receiverBalance).to.equal(49);273        expect(+ownerBalance).to.equal(151);274      }275276      // 1.2 Cross substrate address:277      if (testCase === 'transferFromCross') {278        const result = await contract.methods.transferFromCross(ownerCross, receiverCrossSub, 51).send({from: spender});279        // Check events:280        const transferEvent = result.events.Transfer;281        expect(transferEvent.address).to.be.equal(tokenAddress);282        expect(transferEvent.returnValues.from).to.be.equal(owner);283        expect(transferEvent.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));284        expect(transferEvent.returnValues.value).to.be.equal('51');285286        const approvalEvent = result.events.Approval;287        expect(approvalEvent.address).to.be.equal(tokenAddress);288        expect(approvalEvent.returnValues.owner).to.be.equal(owner);289        expect(approvalEvent.returnValues.spender).to.be.equal(spender);290        expect(approvalEvent.returnValues.value).to.be.equal('0');291292        // Check balances:293        const receiverBalance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});294        const ownerBalance = await contract.methods.balanceOf(owner).call();295        expect(receiverBalance).to.equal(51n);296        expect(+ownerBalance).to.equal(100);297      }298    }));299300  [301    'transfer',302    'transferCross',303  ].map(testCase =>304    itEth(`Can perform ${testCase}()`, async ({helper}) => {305      const isCross = testCase === 'transferCross';306      const owner = await helper.eth.createAccountWithBalance(donor);307      const receiverEth = helper.eth.createAccount();308      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);309      const [receiverSub] = await helper.arrange.createAccounts([1n], donor);310      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);311      const collection = await helper.rft.mintCollection(alice);312      const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});313314      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);315      const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);316317      // 1. Can transfer to plain ethereum or cross-ethereum account:318      {319        const result = await contract.methods[testCase](isCross ? receiverCrossEth : receiverEth, 50).send({from: owner});320        // Check events321        const transferEvent = result.events.Transfer;322        expect(transferEvent.address).to.be.equal(tokenAddress);323        expect(transferEvent.returnValues.from).to.be.equal(owner);324        expect(transferEvent.returnValues.to).to.be.equal(receiverEth);325        expect(transferEvent.returnValues.value).to.be.equal('50');326        // Check balances:327        const ownerBalance = await contract.methods.balanceOf(owner).call();328        const receiverBalance = await contract.methods.balanceOf(receiverEth).call();329        expect(+ownerBalance).to.equal(150);330        expect(+receiverBalance).to.equal(50);331      }332333      // 2. Can transfer to cross-substrate account:334      if(isCross) {335        const result = await contract.methods.transferCross(receiverCrossSub, 50).send({from: owner});336        // Check events:337        const event = result.events.Transfer;338        expect(event.address).to.be.equal(tokenAddress);339        expect(event.returnValues.from).to.be.equal(owner);340        expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));341        expect(event.returnValues.value).to.be.equal('50');342        // Check balances:343        const ownerBalance = await contract.methods.balanceOf(owner).call();344        const receiverBalance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});345        expect(+ownerBalance).to.equal(100);346        expect(receiverBalance).to.equal(50n);347      }348    }));349350  [351    'transfer',352    'transferCross',353  ].map(testCase =>354    itEth(`Cannot ${testCase}() non-owned token`, async ({helper}) => {355      const isCross = testCase === 'transferCross';356      const owner = await helper.eth.createAccountWithBalance(donor);357      const ownerCross = helper.ethCrossAccount.fromAddress(owner);358      const receiverEth = await helper.eth.createAccountWithBalance(donor);359      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);360      const collection = await helper.rft.mintCollection(alice);361      const rftOwner = await collection.mintToken(alice, 10n, {Ethereum: owner});362      const rftReceiver = await collection.mintToken(alice, 10n, {Ethereum: receiverEth});363      const tokenIdNonExist = 9999999;364365      const tokenAddress1 = helper.ethAddress.fromTokenId(collection.collectionId, rftOwner.tokenId);366      const tokenAddress2 = helper.ethAddress.fromTokenId(collection.collectionId, rftReceiver.tokenId);367      const tokenAddressNonExist = helper.ethAddress.fromTokenId(collection.collectionId, tokenIdNonExist);368      const tokenEvmOwner = await helper.ethNativeContract.rftToken(tokenAddress1, owner);369      const tokenEvmReceiver = await helper.ethNativeContract.rftToken(tokenAddress2, owner);370      const tokenEvmNonExist = await helper.ethNativeContract.rftToken(tokenAddressNonExist, owner);371372      // 1. Can transfer zero amount (EIP-20):373      await tokenEvmOwner.methods[testCase](isCross ? receiverCrossEth : receiverEth, 0).send({from: owner});374      // 2. Cannot transfer non-owned token:375      await expect(tokenEvmReceiver.methods[testCase](isCross ? ownerCross : owner, 0).send({from: owner})).to.be.rejected;376      await expect(tokenEvmReceiver.methods[testCase](isCross ? ownerCross : owner, 5).send({from: owner})).to.be.rejected;377      // 3. Cannot transfer non-existing token:378      await expect(tokenEvmNonExist.methods[testCase](isCross ? ownerCross : owner, 0).send({from: owner})).to.be.rejected;379      await expect(tokenEvmNonExist.methods[testCase](isCross ? ownerCross : owner, 5).send({from: owner})).to.be.rejected;380381      // 4. Storage is not corrupted:382      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);383      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: receiverEth.toLowerCase()}]);384      expect(await helper.rft.getTokenTop10Owners(collection.collectionId, tokenIdNonExist)).to.deep.eq([]);385386      // 4.1 Tokens can be transferred:387      await tokenEvmOwner.methods[testCase](isCross ? receiverCrossEth : receiverEth, 10).send({from: owner});388      await tokenEvmReceiver.methods[testCase](isCross ? ownerCross : owner, 10).send({from: receiverEth});389      expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: receiverEth.toLowerCase()}]);390      expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);391    }));392393  itEth('Can perform repartition()', async ({helper}) => {394    const owner = await helper.eth.createAccountWithBalance(donor);395    const receiver = await helper.eth.createAccountWithBalance(donor);396    const collection = await helper.rft.mintCollection(alice);397    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});398399    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);400    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);401402    await contract.methods.repartition(200).send({from: owner});403    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);404    await contract.methods.transfer(receiver, 110).send({from: owner});405    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);406    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);407408    await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; // Transaction is reverted409410    await contract.methods.transfer(receiver, 90).send({from: owner});411    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);412    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);413414    await contract.methods.repartition(150).send({from: receiver});415    await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected; // Transaction is reverted416    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);417  });418419  itEth('Can repartition with increased amount', async ({helper}) => {420    const owner = await helper.eth.createAccountWithBalance(donor);421    const collection = await helper.rft.mintCollection(alice);422    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});423424    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);425    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);426427    const result = await contract.methods.repartition(200).send();428429    const event = result.events.Transfer;430    expect(event.address).to.be.equal(tokenAddress);431    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');432    expect(event.returnValues.to).to.be.equal(owner);433    expect(event.returnValues.value).to.be.equal('100');434  });435436  itEth('Can repartition with decreased amount', async ({helper}) => {437    const owner = await helper.eth.createAccountWithBalance(donor);438    const collection = await helper.rft.mintCollection(alice);439    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});440441    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);442    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);443444    const result = await contract.methods.repartition(50).send();445    const event = result.events.Transfer;446    expect(event.address).to.be.equal(tokenAddress);447    expect(event.returnValues.from).to.be.equal(owner);448    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');449    expect(event.returnValues.value).to.be.equal('50');450  });451452  itEth('Receiving Transfer event on burning into full ownership', async ({helper}) => {453    const caller = await helper.eth.createAccountWithBalance(donor);454    const receiver = await helper.eth.createAccountWithBalance(donor);455    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Devastation', '6', '6');456    const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', caller);457458    const result = await contract.methods.mint(caller).send();459    const tokenId = result.events.Transfer.returnValues.tokenId;460    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);461    const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, caller, true);462463    await tokenContract.methods.repartition(2).send();464    await tokenContract.methods.transfer(receiver, 1).send();465466    const events: any = [];467    contract.events.allEvents((_: any, event: any) => {468      events.push(event);469    });470    await tokenContract.methods.burnFrom(caller, 1).send();471472    if (events.length == 0) await helper.wait.newBlocks(1);473    const event = events[0];474    expect(event.address).to.be.equal(collectionAddress);475    expect(event.returnValues.from).to.be.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');476    expect(event.returnValues.to).to.be.equal(receiver);477    expect(event.returnValues.tokenId).to.be.equal(tokenId);478  });479480  itEth('Can perform burnFromCross()', async ({helper}) => {481    const owner = await helper.eth.createAccountWithBalance(donor);482    const ownerSub = (await helper.arrange.createAccounts([10n], donor))[0];483    const ownerCross = helper.ethCrossAccount.fromAddress(owner);484    const spender = await helper.eth.createAccountWithBalance(donor);485486    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);487    const ownerSubCross = helper.ethCrossAccount.fromKeyringPair(ownerSub);488489    const collection = await helper.rft.mintCollection(alice);490    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});491492493    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);494    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);495496    {497      await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});498499      await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;500      await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;501      expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');502    }503    {504      const {tokenId} = await collection.mintToken(alice, 200n, {Substrate: ownerSub.address});505      await collection.approveToken(ownerSub, tokenId, {Ethereum: spender}, 100n);506      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);507      const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);508509      await expect(contract.methods.burnFromCross(ownerSubCross, 50).send({from: spender})).to.be.fulfilled;510      await expect(contract.methods.burnFromCross(ownerSubCross, 100).send({from: spender})).to.be.rejected;511      expect(await collection.getTokenBalance(tokenId, {Substrate: ownerSub.address})).to.be.equal(150n);512    }513  });514});515516describe('Refungible: Fees', () => {517  let donor: IKeyringPair;518  let alice: IKeyringPair;519520  before(async function() {521    await usingEthPlaygrounds(async (helper, privateKey) => {522      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);523524      donor = await privateKey({filename: __filename});525      [alice] = await helper.arrange.createAccounts([50n], donor);526    });527  });528529  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {530    const owner = await helper.eth.createAccountWithBalance(donor);531    const spender = helper.eth.createAccount();532    const collection = await helper.rft.mintCollection(alice);533    const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});534535    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);536    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);537538    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));539    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));540  });541542  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {543    const owner = await helper.eth.createAccountWithBalance(donor);544    const spender = await helper.eth.createAccountWithBalance(donor);545    const collection = await helper.rft.mintCollection(alice);546    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});547548    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);549    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);550551    await contract.methods.approve(spender, 100).send({from: owner});552553    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));554    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));555  });556557  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {558    const owner = await helper.eth.createAccountWithBalance(donor);559    const receiver = helper.eth.createAccount();560    const collection = await helper.rft.mintCollection(alice);561    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});562563    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);564    const contract = await helper.ethNativeContract.rftToken(tokenAddress, owner);565566    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));567    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));568  });569});570571describe('Refungible: Substrate calls', () => {572  let donor: IKeyringPair;573  let alice: IKeyringPair;574575  before(async function() {576    await usingEthPlaygrounds(async (helper, privateKey) => {577      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);578579      donor = await privateKey({filename: __filename});580      [alice] = await helper.arrange.createAccounts([50n], donor);581    });582  });583584  itEth('Events emitted for approve()', async ({helper}) => {585    const receiver = helper.eth.createAccount();586    const collection = await helper.rft.mintCollection(alice);587    const token = await collection.mintToken(alice, 200n);588589    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);590    const contract = await helper.ethNativeContract.rftToken(tokenAddress);591592    const events: any = [];593    contract.events.allEvents((_: any, event: any) => {594      events.push(event);595    });596597    expect(await token.approve(alice, {Ethereum: receiver}, 100n)).to.be.true;598    if (events.length == 0) await helper.wait.newBlocks(1);599    const event = events[0];600601    expect(event.event).to.be.equal('Approval');602    expect(event.address).to.be.equal(tokenAddress);603    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));604    expect(event.returnValues.spender).to.be.equal(receiver);605    expect(event.returnValues.value).to.be.equal('100');606  });607608  itEth('Events emitted for transferFrom()', async ({helper}) => {609    const [bob] = await helper.arrange.createAccounts([10n], donor);610    const receiver = helper.eth.createAccount();611    const collection = await helper.rft.mintCollection(alice);612    const token = await collection.mintToken(alice, 200n);613    await token.approve(alice, {Substrate: bob.address}, 100n);614615    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);616    const contract = await helper.ethNativeContract.rftToken(tokenAddress);617618    const events: any = [];619    contract.events.allEvents((_: any, event: any) => {620      events.push(event);621    });622623    expect(await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver},  51n)).to.be.true;624    if (events.length == 0) await helper.wait.newBlocks(1);625626    let event = events[0];627    expect(event.event).to.be.equal('Transfer');628    expect(event.address).to.be.equal(tokenAddress);629    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));630    expect(event.returnValues.to).to.be.equal(receiver);631    expect(event.returnValues.value).to.be.equal('51');632633    event = events[1];634    expect(event.event).to.be.equal('Approval');635    expect(event.address).to.be.equal(tokenAddress);636    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));637    expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));638    expect(event.returnValues.value).to.be.equal('49');639  });640641  itEth('Events emitted for transfer()', async ({helper}) => {642    const receiver = helper.eth.createAccount();643    const collection = await helper.rft.mintCollection(alice);644    const token = await collection.mintToken(alice, 200n);645646    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);647    const contract = await helper.ethNativeContract.rftToken(tokenAddress);648649    const events: any = [];650    contract.events.allEvents((_: any, event: any) => {651      events.push(event);652    });653654    expect(await token.transfer(alice, {Ethereum: receiver},  51n)).to.be.true;655    if (events.length == 0) await helper.wait.newBlocks(1);656    const event = events[0];657658    expect(event.event).to.be.equal('Transfer');659    expect(event.address).to.be.equal(tokenAddress);660    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));661    expect(event.returnValues.to).to.be.equal(receiver);662    expect(event.returnValues.value).to.be.equal('51');663  });664});665666describe('ERC 1633 implementation', () => {667  let donor: IKeyringPair;668669  before(async function() {670    await usingEthPlaygrounds(async (helper, privateKey) => {671      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);672673      donor = await privateKey({filename: __filename});674    });675  });676677  itEth('Default parent token address and id', async ({helper}) => {678    const owner = await helper.eth.createAccountWithBalance(donor);679680    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Sands', '', 'GRAIN');681    const collectionContract = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);682683    const result = await collectionContract.methods.mint(owner).send();684    const tokenId = result.events.Transfer.returnValues.tokenId;685686    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);687    const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, owner);688689    expect(await tokenContract.methods.parentToken().call()).to.be.equal(collectionAddress);690    expect(await tokenContract.methods.parentTokenId().call()).to.be.equal(tokenId);691  });692});