git.delta.rocks / unique-network / refs/commits / 2d2eac8ef8b2

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 {approve, createCollection, createRefungibleToken, transfer, transferFrom, UNIQUE} from '../util/helpers';18import {collectionIdFromAddress, collectionIdToAddress, createEthAccount, createEthAccountWithBalance, createNonfungibleCollection, createRefungibleCollection, evmCollection, evmCollectionHelpers, getCollectionAddressFromResult, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, tokenIdToAddress, transferBalanceToEth, uniqueNFT, uniqueRefungible, uniqueRefungibleToken} from './util/helpers';1920import chai from 'chai';21import chaiAsPromised from 'chai-as-promised';22chai.use(chaiAsPromised);23const expect = chai.expect;2425describe('Refungible token: Information getting', () => {26  itWeb3('totalSupply', async ({api, web3, privateKeyWrapper}) => {27    const alice = privateKeyWrapper('//Alice');2829    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;3031    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);3233    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: caller})).itemId;3435    const address = tokenIdToAddress(collectionId, tokenId);36    const contract = uniqueRefungibleToken(web3, address, caller);37    const totalSupply = await contract.methods.totalSupply().call();3839    expect(totalSupply).to.equal('200');40  });4142  itWeb3('balanceOf', async ({api, web3, privateKeyWrapper}) => {43    const alice = privateKeyWrapper('//Alice');4445    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;4647    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);4849    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: caller})).itemId;5051    const address = tokenIdToAddress(collectionId, tokenId);52    const contract = uniqueRefungibleToken(web3, address, caller);53    const balance = await contract.methods.balanceOf(caller).call();5455    expect(balance).to.equal('200');56  });5758  itWeb3('decimals', async ({api, web3, privateKeyWrapper}) => {59    const alice = privateKeyWrapper('//Alice');6061    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;6263    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);6465    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: caller})).itemId;6667    const address = tokenIdToAddress(collectionId, tokenId);68    const contract = uniqueRefungibleToken(web3, address, caller);69    const decimals = await contract.methods.decimals().call();7071    expect(decimals).to.equal('0');72  });73});7475// FIXME: Need erc721 for ReFubgible.76describe('Check ERC721 token URI for ReFungible', () => {77  itWeb3('Empty tokenURI', async ({web3, api, privateKeyWrapper}) => {78    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);79    const helper = evmCollectionHelpers(web3, owner);80    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', '').send();81    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);82    const receiver = createEthAccount(web3);83    const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'});84    85    const nextTokenId = await contract.methods.nextTokenId().call();86    expect(nextTokenId).to.be.equal('1');87    result = await contract.methods.mint(88      receiver,89      nextTokenId,90    ).send();9192    const events = normalizeEvents(result.events);93    const address = collectionIdToAddress(collectionId);9495    expect(events).to.be.deep.equal([96      {97        address,98        event: 'Transfer',99        args: {100          from: '0x0000000000000000000000000000000000000000',101          to: receiver,102          tokenId: nextTokenId,103        },104      },105    ]);106107    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');108  });109110  itWeb3('TokenURI from url', async ({web3, api, privateKeyWrapper}) => {111    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);112    const helper = evmCollectionHelpers(web3, owner);113    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', 'BaseURI_').send();114    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);115    const receiver = createEthAccount(web3);116    const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'});117    118    const nextTokenId = await contract.methods.nextTokenId().call();119    expect(nextTokenId).to.be.equal('1');120    result = await contract.methods.mint(121      receiver,122      nextTokenId,123    ).send();124    125    // Set URL126    await contract.methods.setProperty(nextTokenId, 'url', Buffer.from('Token URI')).send();127      128    const events = normalizeEvents(result.events);129    const address = collectionIdToAddress(collectionId);130131    expect(events).to.be.deep.equal([132      {133        address,134        event: 'Transfer',135        args: {136          from: '0x0000000000000000000000000000000000000000',137          to: receiver,138          tokenId: nextTokenId,139        },140      },141    ]);142143    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');144  });145146  itWeb3('TokenURI from baseURI + tokenId', async ({web3, api, privateKeyWrapper}) => {147    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);148    const helper = evmCollectionHelpers(web3, owner);149    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', 'BaseURI_').send();150    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);151    const receiver = createEthAccount(web3);152    const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'});153    154    const nextTokenId = await contract.methods.nextTokenId().call();155    expect(nextTokenId).to.be.equal('1');156    result = await contract.methods.mint(157      receiver,158      nextTokenId,159    ).send();160          161    const events = normalizeEvents(result.events);162    const address = collectionIdToAddress(collectionId);163164    expect(events).to.be.deep.equal([165      {166        address,167        event: 'Transfer',168        args: {169          from: '0x0000000000000000000000000000000000000000',170          to: receiver,171          tokenId: nextTokenId,172        },173      },174    ]);175176    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + nextTokenId);177  });178179  itWeb3('TokenURI from baseURI + suffix', async ({web3, api, privateKeyWrapper}) => {180    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);181    const helper = evmCollectionHelpers(web3, owner);182    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', 'BaseURI_').send();183    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);184    const receiver = createEthAccount(web3);185    const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'});186    187    const nextTokenId = await contract.methods.nextTokenId().call();188    expect(nextTokenId).to.be.equal('1');189    result = await contract.methods.mint(190      receiver,191      nextTokenId,192    ).send();193          194    // Set suffix195    const suffix = '/some/suffix';196    await contract.methods.setProperty(nextTokenId, 'suffix', Buffer.from(suffix)).send();197198    const events = normalizeEvents(result.events);199    const address = collectionIdToAddress(collectionId);200201    expect(events).to.be.deep.equal([202      {203        address,204        event: 'Transfer',205        args: {206          from: '0x0000000000000000000000000000000000000000',207          to: receiver,208          tokenId: nextTokenId,209        },210      },211    ]);212213    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);214  });215});216217describe('Refungible: Plain calls', () => {218  itWeb3('Can perform approve()', async ({web3, api, privateKeyWrapper}) => {219    const alice = privateKeyWrapper('//Alice');220221    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;222223    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);224225    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId;226227    const address = tokenIdToAddress(collectionId, tokenId);228229    const spender = createEthAccount(web3);230231    const contract = uniqueRefungibleToken(web3, address, owner);232233    {234      const result = await contract.methods.approve(spender, 100).send({from: owner});235      const events = normalizeEvents(result.events);236237      expect(events).to.be.deep.equal([238        {239          address,240          event: 'Approval',241          args: {242            owner,243            spender,244            value: '100',245          },246        },247      ]);248    }249250    {251      const allowance = await contract.methods.allowance(owner, spender).call();252      expect(+allowance).to.equal(100);253    }254  });255256  itWeb3('Can perform transferFrom()', async ({web3, api, privateKeyWrapper}) => {257    const alice = privateKeyWrapper('//Alice');258259    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;260261    const owner = createEthAccount(web3);262    await transferBalanceToEth(api, alice, owner);263264    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId;265266    const spender = createEthAccount(web3);267    await transferBalanceToEth(api, alice, spender);268269    const receiver = createEthAccount(web3);270271    const address = tokenIdToAddress(collectionId, tokenId);272    const contract = uniqueRefungibleToken(web3, address, owner);273274    await contract.methods.approve(spender, 100).send();275276    {277      const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});278      const events = normalizeEvents(result.events);279      expect(events).to.include.deep.members([280        {281          address,282          event: 'Transfer',283          args: {284            from: owner,285            to: receiver,286            value: '49',287          },288        },289        {290          address,291          event: 'Approval',292          args: {293            owner,294            spender,295            value: '51',296          },297        },298      ]);299    }300301    {302      const balance = await contract.methods.balanceOf(receiver).call();303      expect(+balance).to.equal(49);304    }305306    {307      const balance = await contract.methods.balanceOf(owner).call();308      expect(+balance).to.equal(151);309    }310  });311312  itWeb3('Can perform transfer()', async ({web3, api, privateKeyWrapper}) => {313    const alice = privateKeyWrapper('//Alice');314315    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;316317    const owner = createEthAccount(web3);318    await transferBalanceToEth(api, alice, owner);319320    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId;321322    const receiver = createEthAccount(web3);323    await transferBalanceToEth(api, alice, receiver);324325    const address = tokenIdToAddress(collectionId, tokenId);326    const contract = uniqueRefungibleToken(web3, address, owner);327328    {329      const result = await contract.methods.transfer(receiver, 50).send({from: owner});330      const events = normalizeEvents(result.events);331      expect(events).to.include.deep.members([332        {333          address,334          event: 'Transfer',335          args: {336            from: owner,337            to: receiver,338            value: '50',339          },340        },341      ]);342    }343344    {345      const balance = await contract.methods.balanceOf(owner).call();346      expect(+balance).to.equal(150);347    }348349    {350      const balance = await contract.methods.balanceOf(receiver).call();351      expect(+balance).to.equal(50);352    }353  });354355  itWeb3('Can perform repartition()', async ({web3, api, privateKeyWrapper}) => {356    const alice = privateKeyWrapper('//Alice');357358    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;359360    const owner = createEthAccount(web3);361    await transferBalanceToEth(api, alice, owner);362363    const receiver = createEthAccount(web3);364    await transferBalanceToEth(api, alice, receiver);365366    const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId;367368    const address = tokenIdToAddress(collectionId, tokenId);369    const contract = uniqueRefungibleToken(web3, address, owner);370371    await contract.methods.repartition(200).send({from: owner});372    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);373    await contract.methods.transfer(receiver, 110).send({from: owner});374    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);375    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);376    377    await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected;378379    await contract.methods.transfer(receiver, 90).send({from: owner});380    expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);381    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);382383    await contract.methods.repartition(150).send({from: receiver});384    await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected;385    expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);386  });387388  itWeb3('Can repartition with increased amount', async ({web3, api, privateKeyWrapper}) => {389    const alice = privateKeyWrapper('//Alice');390391    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;392393    const owner = createEthAccount(web3);394    await transferBalanceToEth(api, alice, owner);395396    const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId;397398    const address = tokenIdToAddress(collectionId, tokenId);399    const contract = uniqueRefungibleToken(web3, address, owner);400401    const result = await contract.methods.repartition(200).send();402    const events = normalizeEvents(result.events);403404    expect(events).to.deep.equal([405      {406        address,407        event: 'Transfer',408        args: {409          from: '0x0000000000000000000000000000000000000000',410          to: owner,411          value: '100',412        },413      },414    ]);415  });416417  itWeb3('Can repartition with decreased amount', async ({web3, api, privateKeyWrapper}) => {418    const alice = privateKeyWrapper('//Alice');419420    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;421422    const owner = createEthAccount(web3);423    await transferBalanceToEth(api, alice, owner);424425    const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId;426427    const address = tokenIdToAddress(collectionId, tokenId);428    const contract = uniqueRefungibleToken(web3, address, owner);429430    const result = await contract.methods.repartition(50).send();431    const events = normalizeEvents(result.events);432    expect(events).to.deep.equal([433      {434        address,435        event: 'Transfer',436        args: {437          from: owner,438          to: '0x0000000000000000000000000000000000000000',439          value: '50',440        },441      },442    ]);443  });444445  itWeb3('Receiving Transfer event on burning into full ownership', async ({web3, api, privateKeyWrapper}) => {446    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);447    const receiver = await createEthAccountWithBalance(api, web3, privateKeyWrapper);448    const helper = evmCollectionHelpers(web3, caller);449    const result = await helper.methods.createRefungibleCollection('Mint collection', '6', '6').send();450    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);451    const contract = evmCollection(web3, caller, collectionIdAddress, {type: 'ReFungible'});452453    const tokenId = await contract.methods.nextTokenId().call();454    await contract.methods.mint(caller, tokenId).send();455456    const address = tokenIdToAddress(collectionId, tokenId);457458    const tokenContract =  uniqueRefungibleToken(web3, address, caller);459    await tokenContract.methods.repartition(2).send();460    await tokenContract.methods.transfer(receiver, 1).send();461462    const events =  await recordEvents(contract, async () => 463      await tokenContract.methods.burnFrom(caller, 1).send());464    expect(events).to.deep.equal([465      {466        address: collectionIdAddress,467        event: 'Transfer',468        args: {469          from: '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF',470          to: receiver,471          tokenId,472        },473      },474    ]);475  });476});477478describe('Refungible: Fees', () => {479  itWeb3('approve() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {480    const alice = privateKeyWrapper('//Alice');481482    const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;483484    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);485    const spender = createEthAccount(web3);486487    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId;488489    const address = tokenIdToAddress(collectionId, tokenId);490    const contract = uniqueRefungibleToken(web3, address, owner);491492    const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({from: owner}));493    expect(cost < BigInt(0.2 * Number(UNIQUE)));494  });495496  itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {497    const alice = privateKeyWrapper('//Alice');498499    const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;500501    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);502    const spender = await createEthAccountWithBalance(api, web3, privateKeyWrapper);503504    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId;505506    const address = tokenIdToAddress(collectionId, tokenId);507    const contract = uniqueRefungibleToken(web3, address, owner);508509    await contract.methods.approve(spender, 100).send({from: owner});510511    const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));512    expect(cost < BigInt(0.2 * Number(UNIQUE)));513  });514515  itWeb3('transfer() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {516    const alice = privateKeyWrapper('//Alice');517518    const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;519520    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);521    const receiver = createEthAccount(web3);522523    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId;524525    const address = tokenIdToAddress(collectionId, tokenId);526    const contract = uniqueRefungibleToken(web3, address, owner);527528    const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));529    expect(cost < BigInt(0.2 * Number(UNIQUE)));530  });531});532533describe('Refungible: Substrate calls', () => {534  itWeb3('Events emitted for approve()', async ({web3, api, privateKeyWrapper}) => {535    const alice = privateKeyWrapper('//Alice');536537    const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;538539    const receiver = createEthAccount(web3);540541    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n)).itemId;542543    const address = tokenIdToAddress(collectionId, tokenId);544    const contract = uniqueRefungibleToken(web3, address);545546    const events = await recordEvents(contract, async () => {547      expect(await approve(api, collectionId, tokenId, alice, {Ethereum: receiver}, 100n)).to.be.true;548    });549550    expect(events).to.be.deep.equal([551      {552        address,553        event: 'Approval',554        args: {555          owner: subToEth(alice.address),556          spender: receiver,557          value: '100',558        },559      },560    ]);561  });562563  itWeb3('Events emitted for transferFrom()', async ({web3, api, privateKeyWrapper}) => {564    const alice = privateKeyWrapper('//Alice');565566    const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;567    const bob = privateKeyWrapper('//Bob');568569    const receiver = createEthAccount(web3);570571    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n)).itemId;572    expect(await approve(api, collectionId, tokenId, alice, bob.address, 100n)).to.be.true;573574    const address = tokenIdToAddress(collectionId, tokenId);575    const contract = uniqueRefungibleToken(web3, address);576577    const events = await recordEvents(contract, async () => {578      expect(await transferFrom(api, collectionId, tokenId, bob, alice, {Ethereum: receiver},  51n)).to.be.true;579    });580581    expect(events).to.be.deep.equal([582      {583        address,584        event: 'Transfer',585        args: {586          from: subToEth(alice.address),587          to: receiver,588          value: '51',589        },590      },591      {592        address,593        event: 'Approval',594        args: {595          owner: subToEth(alice.address),596          spender: subToEth(bob.address),597          value: '49',598        },599      },600    ]);601  });602603  itWeb3('Events emitted for transfer()', async ({web3, api, privateKeyWrapper}) => {604    const alice = privateKeyWrapper('//Alice');605606    const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;607608    const receiver = createEthAccount(web3);609610    const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n)).itemId;611612    const address = tokenIdToAddress(collectionId, tokenId);613    const contract = uniqueRefungibleToken(web3, address);614615    const events = await recordEvents(contract, async () => {616      expect(await transfer(api, collectionId, tokenId, alice, {Ethereum: receiver},  51n)).to.be.true;617    });618619    expect(events).to.be.deep.equal([620      {621        address,622        event: 'Transfer',623        args: {624          from: subToEth(alice.address),625          to: receiver,626          value: '51',627        },628      },629    ]);630  });631});632633describe('ERC 1633 implementation', () => {634  itWeb3('Parent NFT token address and id', async ({api, web3, privateKeyWrapper}) => {635    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);636637    const {collectionIdAddress:  nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner);638    const nftContract = uniqueNFT(web3, nftCollectionAddress, owner);639    const nftTokenId = await nftContract.methods.nextTokenId().call();640    await nftContract.methods.mint(owner, nftTokenId).send();641    const nftCollectionId = collectionIdFromAddress(nftCollectionAddress);642643    const {collectionIdAddress, collectionId} = await createRefungibleCollection(api, web3, owner);644    const refungibleContract = uniqueRefungible(web3, collectionIdAddress, owner);645    const refungibleTokenId = await refungibleContract.methods.nextTokenId().call();646    await refungibleContract.methods.mint(owner, refungibleTokenId).send();647648    const rftTokenAddress = tokenIdToAddress(collectionId, refungibleTokenId);649    const refungibleTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner);650    await refungibleTokenContract.methods.setParentNFT(nftCollectionAddress, nftTokenId).send();651652    const tokenAddress = await refungibleTokenContract.methods.parentToken().call();653    const tokenId = await refungibleTokenContract.methods.parentTokenId().call();654    const nftTokenAddress = tokenIdToAddress(nftCollectionId, nftTokenId);655    expect(tokenAddress).to.be.equal(nftTokenAddress);656    expect(tokenId).to.be.equal(nftTokenId);657  });658659  itWeb3('Default parent token address and id', async ({api, web3, privateKeyWrapper}) => {660    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);661662    const {collectionIdAddress, collectionId} = await createRefungibleCollection(api, web3, owner);663    const refungibleContract = uniqueRefungible(web3, collectionIdAddress, owner);664    const refungibleTokenId = await refungibleContract.methods.nextTokenId().call();665    await refungibleContract.methods.mint(owner, refungibleTokenId).send();666667    const rftTokenAddress = tokenIdToAddress(collectionId, refungibleTokenId);668    const refungibleTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner);669670    const tokenAddress = await refungibleTokenContract.methods.parentToken().call();671    const tokenId = await refungibleTokenContract.methods.parentTokenId().call();672    expect(tokenAddress).to.be.equal(rftTokenAddress);673    expect(tokenId).to.be.equal(refungibleTokenId);674  });675});676