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

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 {expect, itEth, usingEthPlaygrounds} from './util';19import {IKeyringPair} from '@polkadot/types/types';2021describe('Refungible: Information getting', () => {22  let donor: IKeyringPair;2324  before(async function() {25    await usingEthPlaygrounds(async (helper, privateKey) => {26      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);2728      donor = await privateKey({filename: __filename});29    });30  });3132  itEth('totalSupply', async ({helper}) => {33    const caller = await helper.eth.createAccountWithBalance(donor);34    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'TotalSupply', '6', '6');35    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);3637    await contract.methods.mint(caller).send();3839    const totalSupply = await contract.methods.totalSupply().call();40    expect(totalSupply).to.equal('1');41  });4243  itEth('balanceOf', async ({helper}) => {44    const caller = await helper.eth.createAccountWithBalance(donor);45    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'BalanceOf', '6', '6');46    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);4748    await contract.methods.mint(caller).send();49    await contract.methods.mint(caller).send();50    await contract.methods.mint(caller).send();5152    const balance = await contract.methods.balanceOf(caller).call();53    expect(balance).to.equal('3');54  });5556  itEth('ownerOf', async ({helper}) => {57    const caller = await helper.eth.createAccountWithBalance(donor);58    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'OwnerOf', '6', '6');59    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);6061    const result = await contract.methods.mint(caller).send();62    const tokenId = result.events.Transfer.returnValues.tokenId;6364    const owner = await contract.methods.ownerOf(tokenId).call();65    expect(owner).to.equal(caller);66  });6768  itEth('ownerOf after burn', async ({helper}) => {69    const caller = await helper.eth.createAccountWithBalance(donor);70    const receiver = helper.eth.createAccount();71    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'OwnerOf-AfterBurn', '6', '6');72    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);7374    const result = await contract.methods.mint(caller).send();75    const tokenId = result.events.Transfer.returnValues.tokenId;76    const tokenContract = helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);7778    await tokenContract.methods.repartition(2).send();79    await tokenContract.methods.transfer(receiver, 1).send();8081    await tokenContract.methods.burnFrom(caller, 1).send();8283    const owner = await contract.methods.ownerOf(tokenId).call();84    expect(owner).to.equal(receiver);85  });8687  itEth('ownerOf for partial ownership', async ({helper}) => {88    const caller = await helper.eth.createAccountWithBalance(donor);89    const receiver = helper.eth.createAccount();90    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Partial-OwnerOf', '6', '6');91    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);9293    const result = await contract.methods.mint(caller).send();94    const tokenId = result.events.Transfer.returnValues.tokenId;95    const tokenContract = helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);9697    await tokenContract.methods.repartition(2).send();98    await tokenContract.methods.transfer(receiver, 1).send();99100    const owner = await contract.methods.ownerOf(tokenId).call();101    expect(owner).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');102  });103});104105describe('Refungible: Plain calls', () => {106  let donor: IKeyringPair;107  let minter: IKeyringPair;108  let bob: IKeyringPair;109  let charlie: IKeyringPair;110111  before(async function() {112    await usingEthPlaygrounds(async (helper, privateKey) => {113      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);114115      donor = await privateKey({filename: __filename});116      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);117    });118  });119120  itEth('Can perform mint() & crossOwnerOf()', async ({helper}) => {121    const owner = await helper.eth.createAccountWithBalance(donor);122    const receiver = helper.eth.createAccount();123    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'Minty', '6', '6', '');124    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);125126    const result = await contract.methods.mintWithTokenURI(receiver, 'Test URI').send();127128    const event = result.events.Transfer;129    expect(event.address).to.equal(collectionAddress);130    expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');131    expect(event.returnValues.to).to.equal(receiver);132    const tokenId = event.returnValues.tokenId;133    expect(tokenId).to.be.equal('1');134135    expect(await contract.methods.crossOwnerOf(tokenId).call()).to.be.like([receiver, '0']);136    expect(await contract.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');137  });138139  itEth.skip('Can perform mintBulk()', async ({helper}) => {140    const owner = await helper.eth.createAccountWithBalance(donor);141    const receiver = helper.eth.createAccount();142    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'MintBulky', '6', '6', '');143    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);144145    {146      const nextTokenId = await contract.methods.nextTokenId().call();147      expect(nextTokenId).to.be.equal('1');148      const result = await contract.methods.mintBulkWithTokenURI(149        receiver,150        [151          [nextTokenId, 'Test URI 0'],152          [+nextTokenId + 1, 'Test URI 1'],153          [+nextTokenId + 2, 'Test URI 2'],154        ],155      ).send();156157      const events = result.events.Transfer;158      for (let i = 0; i < 2; i++) {159        const event = events[i];160        expect(event.address).to.equal(collectionAddress);161        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');162        expect(event.returnValues.to).to.equal(receiver);163        expect(event.returnValues.tokenId).to.equal(String(+nextTokenId + i));164      }165166      expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI 0');167      expect(await contract.methods.tokenURI(+nextTokenId + 1).call()).to.be.equal('Test URI 1');168      expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');169    }170  });171172  itEth('Can perform setApprovalForAll()', async ({helper}) => {173    const owner = await helper.eth.createAccountWithBalance(donor);174    const operator = helper.eth.createAccount();175176    const collection = await helper.rft.mintCollection(minter, {});177178    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);179    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);180181    const approvedBefore = await contract.methods.isApprovedForAll(owner, operator).call();182    expect(approvedBefore).to.be.equal(false);183184    {185      const result = await contract.methods.setApprovalForAll(operator, true).send({from: owner});186187      expect(result.events.ApprovalForAll).to.be.like({188        address: collectionAddress,189        event: 'ApprovalForAll',190        returnValues: {191          owner,192          operator,193          approved: true,194        },195      });196197      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();198      expect(approvedAfter).to.be.equal(true);199    }200201    {202      const result = await contract.methods.setApprovalForAll(operator, false).send({from: owner});203204      expect(result.events.ApprovalForAll).to.be.like({205        address: collectionAddress,206        event: 'ApprovalForAll',207        returnValues: {208          owner,209          operator,210          approved: false,211        },212      });213214      const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();215      expect(approvedAfter).to.be.equal(false);216    }217  });218219  itEth('Can perform burn with ApprovalForAll', async ({helper}) => {220    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});221222    const owner = await helper.eth.createAccountWithBalance(donor);223    const operator = await helper.eth.createAccountWithBalance(donor, 100n);224225    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});226227    const address = helper.ethAddress.fromCollectionId(collection.collectionId);228    const contract = helper.ethNativeContract.collection(address, 'rft');229230    {231      await contract.methods.setApprovalForAll(operator, true).send({from: owner});232      const ownerCross = helper.ethCrossAccount.fromAddress(owner);233      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: operator});234      const events = result.events.Transfer;235236      expect(events).to.be.like({237        address,238        event: 'Transfer',239        returnValues: {240          from: owner,241          to: '0x0000000000000000000000000000000000000000',242          tokenId: token.tokenId.toString(),243        },244      });245    }246  });247248  itEth('Can perform burn with approve and approvalForAll', async ({helper}) => {249    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});250251    const owner = await helper.eth.createAccountWithBalance(donor);252    const operator = await helper.eth.createAccountWithBalance(donor, 100n);253254    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});255256    const address = helper.ethAddress.fromCollectionId(collection.collectionId);257    const contract = helper.ethNativeContract.collection(address, 'rft');258259    const rftToken = helper.ethNativeContract.rftTokenById(token.collectionId, token.tokenId, owner);260261    {262      await rftToken.methods.approve(operator, 15n).send({from: owner});263      await contract.methods.setApprovalForAll(operator, true).send({from: owner});264      await rftToken.methods.burnFrom(owner, 10n).send({from: operator});265      const allowance = await rftToken.methods.allowance(owner, operator).call();266      expect(allowance).to.be.equal('5');267    }268  });269  270  itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {271    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});272273    const owner = await helper.eth.createAccountWithBalance(donor);274    const operator = await helper.eth.createAccountWithBalance(donor);275    const receiver = charlie;276277    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});278279    const address = helper.ethAddress.fromCollectionId(collection.collectionId);280    const contract = helper.ethNativeContract.collection(address, 'rft');281282    {283      await contract.methods.setApprovalForAll(operator, true).send({from: owner});284      const ownerCross = helper.ethCrossAccount.fromAddress(owner);285      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);286      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: operator});287      const event = result.events.Transfer;288      expect(event).to.be.like({289        address: helper.ethAddress.fromCollectionId(collection.collectionId),290        event: 'Transfer',291        returnValues: {292          from: owner,293          to: helper.address.substrateToEth(receiver.address),294          tokenId: token.tokenId.toString(),295        },296      });297    }298299    expect(await token.getTop10Owners()).to.be.like([{Substrate: receiver.address}]);300  });301302  itEth('Can perform burn()', async ({helper}) => {303    const caller = await helper.eth.createAccountWithBalance(donor);304    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Burny', '6', '6');305    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);306307    const result = await contract.methods.mint(caller).send();308    const tokenId = result.events.Transfer.returnValues.tokenId;309    {310      const result = await contract.methods.burn(tokenId).send();311      const event = result.events.Transfer;312      expect(event.address).to.equal(collectionAddress);313      expect(event.returnValues.from).to.equal(caller);314      expect(event.returnValues.to).to.equal('0x0000000000000000000000000000000000000000');315      expect(event.returnValues.tokenId).to.equal(tokenId.toString());316    }317  });318319  itEth('Can perform transferFrom()', async ({helper}) => {320    const caller = await helper.eth.createAccountWithBalance(donor);321    const receiver = helper.eth.createAccount();322    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'TransferFromy', '6', '6');323    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);324325    const result = await contract.methods.mint(caller).send();326    const tokenId = result.events.Transfer.returnValues.tokenId;327328    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);329330    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);331    await tokenContract.methods.repartition(15).send();332333    {334      const tokenEvents: any = [];335      tokenContract.events.allEvents((_: any, event: any) => {336        tokenEvents.push(event);337      });338      const result = await contract.methods.transferFrom(caller, receiver, tokenId).send();339      if (tokenEvents.length == 0) await helper.wait.newBlocks(1);340341      let event = result.events.Transfer;342      expect(event.address).to.equal(collectionAddress);343      expect(event.returnValues.from).to.equal(caller);344      expect(event.returnValues.to).to.equal(receiver);345      expect(event.returnValues.tokenId).to.equal(tokenId.toString());346347      event = tokenEvents[0];348      expect(event.address).to.equal(tokenAddress);349      expect(event.returnValues.from).to.equal(caller);350      expect(event.returnValues.to).to.equal(receiver);351      expect(event.returnValues.value).to.equal('15');352    }353354    {355      const balance = await contract.methods.balanceOf(receiver).call();356      expect(+balance).to.equal(1);357    }358359    {360      const balance = await contract.methods.balanceOf(caller).call();361      expect(+balance).to.equal(0);362    }363  });364365  // Soft-deprecated366  itEth('Can perform burnFrom()', async ({helper}) => {367    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});368369    const owner = await helper.eth.createAccountWithBalance(donor, 100n);370    const spender = await helper.eth.createAccountWithBalance(donor, 100n);371372    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});373374    const address = helper.ethAddress.fromCollectionId(collection.collectionId);375    const contract = helper.ethNativeContract.collection(address, 'rft', spender, true);376377    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);378    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);379    await tokenContract.methods.repartition(15).send();380    await tokenContract.methods.approve(spender, 15).send();381382    {383      const result = await contract.methods.burnFrom(owner, token.tokenId).send();384      const event = result.events.Transfer;385      expect(event).to.be.like({386        address: helper.ethAddress.fromCollectionId(collection.collectionId),387        event: 'Transfer',388        returnValues: {389          from: owner,390          to: '0x0000000000000000000000000000000000000000',391          tokenId: token.tokenId.toString(),392        },393      });394    }395396    expect(await collection.getTokenBalance(token.tokenId, {Ethereum: owner})).to.be.eq(0n);397  });398399  itEth('Can perform burnFromCross()', async ({helper}) => {400    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});401    402    const owner = bob;403    const spender = await helper.eth.createAccountWithBalance(donor, 100n);404405    const token = await collection.mintToken(minter, 100n, {Substrate: owner.address});406407    const address = helper.ethAddress.fromCollectionId(collection.collectionId);408    const contract = helper.ethNativeContract.collection(address, 'rft');409410    await token.repartition(owner, 15n);411    await token.approve(owner, {Ethereum: spender}, 15n);412413    {414      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);415      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender});416      const event = result.events.Transfer;417      expect(event).to.be.like({418        address: helper.ethAddress.fromCollectionId(collection.collectionId),419        event: 'Transfer',420        returnValues: {421          from: helper.address.substrateToEth(owner.address),422          to: '0x0000000000000000000000000000000000000000',423          tokenId: token.tokenId.toString(),424        },425      });426    }427428    expect(await collection.getTokenBalance(token.tokenId, {Substrate: owner.address})).to.be.eq(0n);429  });430431  itEth('Can perform transferFromCross()', async ({helper}) => {432    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});433434    const owner = bob;435    const spender = await helper.eth.createAccountWithBalance(donor, 100n);436    const receiver = charlie;437438    const token = await collection.mintToken(minter, 100n, {Substrate: owner.address});439440    const address = helper.ethAddress.fromCollectionId(collection.collectionId);441    const contract = helper.ethNativeContract.collection(address, 'rft');442443    await token.repartition(owner, 15n);444    await token.approve(owner, {Ethereum: spender}, 15n);445446    {447      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);448      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);449      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});450      const event = result.events.Transfer;451      expect(event).to.be.like({452        address: helper.ethAddress.fromCollectionId(collection.collectionId),453        event: 'Transfer',454        returnValues: {455          from: helper.address.substrateToEth(owner.address),456          to: helper.address.substrateToEth(receiver.address),457          tokenId: token.tokenId.toString(),458        },459      });460    }461462    expect(await token.getTop10Owners()).to.be.like([{Substrate: receiver.address}]);463  });464465  itEth('Can perform transfer()', async ({helper}) => {466    const caller = await helper.eth.createAccountWithBalance(donor);467    const receiver = helper.eth.createAccount();468    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry', '6', '6');469    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);470471    const result = await contract.methods.mint(caller).send();472    const tokenId = result.events.Transfer.returnValues.tokenId;473474    {475      const result = await contract.methods.transfer(receiver, tokenId).send();476477      const event = result.events.Transfer;478      expect(event.address).to.equal(collectionAddress);479      expect(event.returnValues.from).to.equal(caller);480      expect(event.returnValues.to).to.equal(receiver);481      expect(event.returnValues.tokenId).to.equal(tokenId.toString());482    }483484    {485      const balance = await contract.methods.balanceOf(caller).call();486      expect(+balance).to.equal(0);487    }488489    {490      const balance = await contract.methods.balanceOf(receiver).call();491      expect(+balance).to.equal(1);492    }493  });494  495  itEth('Can perform transferCross()', async ({helper}) => {496    const sender = await helper.eth.createAccountWithBalance(donor);497    const receiverEth = await helper.eth.createAccountWithBalance(donor);498    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);499    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);500501    const collection = await helper.rft.mintCollection(minter, {});502    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);503    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'rft', sender);504505    const token = await collection.mintToken(minter, 50n, {Ethereum: sender});506507    {508      // Can transferCross to ethereum address:509      const result = await collectionEvm.methods.transferCross(receiverCrossEth, token.tokenId).send({from: sender});510      // Check events:511      const event = result.events.Transfer;512      expect(event.address).to.equal(collectionAddress);513      expect(event.returnValues.from).to.equal(sender);514      expect(event.returnValues.to).to.equal(receiverEth);515      expect(event.returnValues.tokenId).to.equal(token.tokenId.toString());516      // Sender's balance decreased:517      const senderBalance = await collectionEvm.methods.balanceOf(sender).call();518      expect(+senderBalance).to.equal(0);519      expect(await token.getBalance({Ethereum: sender})).to.eq(0n);520      // Receiver's balance increased:521      const receiverBalance = await collectionEvm.methods.balanceOf(receiverEth).call();522      expect(+receiverBalance).to.equal(1);523      expect(await token.getBalance({Ethereum: receiverEth})).to.eq(50n);524    }525    526    {527      // Can transferCross to substrate address:528      const substrateResult = await collectionEvm.methods.transferCross(receiverCrossSub, token.tokenId).send({from: receiverEth});529      // Check events:530      const event = substrateResult.events.Transfer;531      expect(event.address).to.be.equal(collectionAddress);532      expect(event.returnValues.from).to.be.equal(receiverEth);533      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(minter.address));534      expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);535      // Sender's balance decreased:536      const senderBalance = await collectionEvm.methods.balanceOf(receiverEth).call();537      expect(+senderBalance).to.equal(0);538      expect(await token.getBalance({Ethereum: receiverEth})).to.eq(0n);539      // Receiver's balance increased:540      const receiverBalance = await helper.nft.getTokensByAddress(collection.collectionId, {Substrate: minter.address});541      expect(receiverBalance).to.contain(token.tokenId);542      expect(await token.getBalance({Substrate: minter.address})).to.eq(50n);543    }544  });545546  ['transfer', 'transferCross'].map(testCase => itEth(`Cannot ${testCase} non-owned token`, async ({helper}) => {547    const sender = await helper.eth.createAccountWithBalance(donor);548    const tokenOwner = await helper.eth.createAccountWithBalance(donor);549    const receiverSub = minter;550    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(minter);551552    const collection = await helper.rft.mintCollection(minter, {});553    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);554    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'rft', sender);555556    await collection.mintToken(minter, 50n, {Ethereum: sender});557    const nonSendersToken = await collection.mintToken(minter, 50n, {Ethereum: tokenOwner});558559    // Cannot transferCross someone else's token:560    const receiver = testCase === 'transfer' ? helper.address.substrateToEth(receiverSub.address) : receiverCrossSub;561    await expect(collectionEvm.methods[testCase](receiver, nonSendersToken.tokenId).send({from: sender})).to.be.rejected;562    // Cannot transfer token if it does not exist:563    await expect(collectionEvm.methods[testCase](receiver, 999999).send({from: sender})).to.be.rejected;564  }));565566  itEth('transfer event on transfer from partial ownership to full ownership', async ({helper}) => {567    const caller = await helper.eth.createAccountWithBalance(donor);568    const receiver = helper.eth.createAccount();569    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry-Partial-to-Full', '6', '6');570    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);571572    const result = await contract.methods.mint(caller).send();573    const tokenId = result.events.Transfer.returnValues.tokenId;574575    const tokenContract = helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);576577    await tokenContract.methods.repartition(2).send();578    await tokenContract.methods.transfer(receiver, 1).send();579580    const events: any = [];581    contract.events.allEvents((_: any, event: any) => {582      events.push(event);583    });584585    await tokenContract.methods.transfer(receiver, 1).send();586    if (events.length == 0) await helper.wait.newBlocks(1);587    const event = events[0];588589    expect(event.address).to.equal(collectionAddress);590    expect(event.returnValues.from).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');591    expect(event.returnValues.to).to.equal(receiver);592    expect(event.returnValues.tokenId).to.equal(tokenId.toString());593  });594595  itEth('transfer event on transfer from full ownership to partial ownership', async ({helper}) => {596    const caller = await helper.eth.createAccountWithBalance(donor);597    const receiver = helper.eth.createAccount();598    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry-Full-to-Partial', '6', '6');599    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);600601    const result = await contract.methods.mint(caller).send();602    const tokenId = result.events.Transfer.returnValues.tokenId;603604    const tokenContract = helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);605606    await tokenContract.methods.repartition(2).send();607608    const events: any = [];609    contract.events.allEvents((_: any, event: any) => {610      events.push(event);611    });612613    await tokenContract.methods.transfer(receiver, 1).send();614    if (events.length == 0) await helper.wait.newBlocks(1);615    const event = events[0];616617    expect(event.address).to.equal(collectionAddress);618    expect(event.returnValues.from).to.equal(caller);619    expect(event.returnValues.to).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');620    expect(event.returnValues.tokenId).to.equal(tokenId.toString());621  });622});623624describe('RFT: Fees', () => {625  let donor: IKeyringPair;626627  before(async function() {628    await usingEthPlaygrounds(async (helper, privateKey) => {629      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);630631      donor = await privateKey({filename: __filename});632    });633  });634635  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {636    const caller = await helper.eth.createAccountWithBalance(donor);637    const receiver = helper.eth.createAccount();638    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Feeful-Transfer-From', '6', '6');639    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);640641    const result = await contract.methods.mint(caller).send();642    const tokenId = result.events.Transfer.returnValues.tokenId;643644    const cost = await helper.eth.recordCallFee(caller, () => contract.methods.transferFrom(caller, receiver, tokenId).send());645    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));646    expect(cost > 0n);647  });648649  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {650    const caller = await helper.eth.createAccountWithBalance(donor);651    const receiver = helper.eth.createAccount();652    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Feeful-Transfer', '6', '6');653    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);654655    const result = await contract.methods.mint(caller).send();656    const tokenId = result.events.Transfer.returnValues.tokenId;657658    const cost = await helper.eth.recordCallFee(caller, () => contract.methods.transfer(receiver, tokenId).send());659    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));660    expect(cost > 0n);661  });662});663664describe('Common metadata', () => {665  let donor: IKeyringPair;666  let alice: IKeyringPair;667668  before(async function() {669    await usingEthPlaygrounds(async (helper, privateKey) => {670      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);671672      donor = await privateKey({filename: __filename});673      [alice] = await helper.arrange.createAccounts([20n], donor);674    });675  });676677  itEth('Returns collection name', async ({helper}) => {678    const caller = helper.eth.createAccount();679    const tokenPropertyPermissions = [{680      key: 'URI',681      permission: {682        mutable: true,683        collectionAdmin: true,684        tokenOwner: false,685      },686    }];687    const collection = await helper.rft.mintCollection(688      alice,689      {690        name: 'Leviathan',691        tokenPrefix: '11',692        properties: [{key: 'ERC721Metadata', value: '1'}],693        tokenPropertyPermissions,694      },695    );696697    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'rft', caller);698    const name = await contract.methods.name().call();699    expect(name).to.equal('Leviathan');700  });701702  itEth('Returns symbol name', async ({helper}) => {703    const caller = await helper.eth.createAccountWithBalance(donor);704    const tokenPropertyPermissions = [{705      key: 'URI',706      permission: {707        mutable: true,708        collectionAdmin: true,709        tokenOwner: false,710      },711    }];712    const {collectionId} = await helper.rft.mintCollection(713      alice,714      {715        name: 'Leviathan',716        tokenPrefix: '12',717        properties: [{key: 'ERC721Metadata', value: '1'}],718        tokenPropertyPermissions,719      },720    );721722    const contract = helper.ethNativeContract.collectionById(collectionId, 'rft', caller);723    const symbol = await contract.methods.symbol().call();724    expect(symbol).to.equal('12');725  });726});727728describe('Negative tests', () => {729  let donor: IKeyringPair;730  let minter: IKeyringPair;731  let alice: IKeyringPair;732733  before(async function() {734    await usingEthPlaygrounds(async (helper, privateKey) => {735      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);736      737      donor = await privateKey({filename: __filename});738      [minter, alice] = await helper.arrange.createAccounts([100n, 100n], donor);739    });740  });741742  itEth('[negative] Cant perform burn without approval', async ({helper}) => {743    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});744745    const owner = await helper.eth.createAccountWithBalance(donor, 100n);746    const spender = await helper.eth.createAccountWithBalance(donor, 100n);747748    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});749750    const address = helper.ethAddress.fromCollectionId(collection.collectionId);751    const contract = helper.ethNativeContract.collection(address, 'rft');752753    const ownerCross = helper.ethCrossAccount.fromAddress(owner);754755    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;756757    await contract.methods.setApprovalForAll(spender, true).send({from: owner});758    await contract.methods.setApprovalForAll(spender, false).send({from: owner});759760    await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;761  });762763  itEth('[negative] Cant perform transfer without approval', async ({helper}) => {764    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});765    const owner = await helper.eth.createAccountWithBalance(donor, 100n);766    const receiver = alice;767768    const spender = await helper.eth.createAccountWithBalance(donor, 100n);769770    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});771772    const address = helper.ethAddress.fromCollectionId(collection.collectionId);773    const contract = helper.ethNativeContract.collection(address, 'rft');774775    const ownerCross = helper.ethCrossAccount.fromAddress(owner);776    const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);777    778    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;779780    await contract.methods.setApprovalForAll(spender, true).send({from: owner});781    await contract.methods.setApprovalForAll(spender, false).send({from: owner});782    783    await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;784  });785});