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

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;107108  before(async function() {109    await usingEthPlaygrounds(async (helper, privateKey) => {110      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);111112      donor = await privateKey({filename: __filename});113    });114  });115116  itEth('Can perform mint()', async ({helper}) => {117    const owner = await helper.eth.createAccountWithBalance(donor);118    const receiver = helper.eth.createAccount();119    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'Minty', '6', '6', '');120    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);121122    const result = await contract.methods.mintWithTokenURI(receiver, 'Test URI').send();123124    const event = result.events.Transfer;125    expect(event.address).to.equal(collectionAddress);126    expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');127    expect(event.returnValues.to).to.equal(receiver);128    const tokenId = event.returnValues.tokenId;129    expect(tokenId).to.be.equal('1');130131    expect(await contract.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');132  });133134  itEth.skip('Can perform mintBulk()', async ({helper}) => {135    const owner = await helper.eth.createAccountWithBalance(donor);136    const receiver = helper.eth.createAccount();137    const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'MintBulky', '6', '6', '');138    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);139140    {141      const nextTokenId = await contract.methods.nextTokenId().call();142      expect(nextTokenId).to.be.equal('1');143      const result = await contract.methods.mintBulkWithTokenURI(144        receiver,145        [146          [nextTokenId, 'Test URI 0'],147          [+nextTokenId + 1, 'Test URI 1'],148          [+nextTokenId + 2, 'Test URI 2'],149        ],150      ).send();151152      const events = result.events.Transfer;153      for (let i = 0; i < 2; i++) {154        const event = events[i];155        expect(event.address).to.equal(collectionAddress);156        expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');157        expect(event.returnValues.to).to.equal(receiver);158        expect(event.returnValues.tokenId).to.equal(String(+nextTokenId + i));159      }160161      expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI 0');162      expect(await contract.methods.tokenURI(+nextTokenId + 1).call()).to.be.equal('Test URI 1');163      expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');164    }165  });166167  itEth('Can perform burn()', async ({helper}) => {168    const caller = await helper.eth.createAccountWithBalance(donor);169    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Burny', '6', '6');170    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);171172    const result = await contract.methods.mint(caller).send();173    const tokenId = result.events.Transfer.returnValues.tokenId;174    {175      const result = await contract.methods.burn(tokenId).send();176      const event = result.events.Transfer;177      expect(event.address).to.equal(collectionAddress);178      expect(event.returnValues.from).to.equal(caller);179      expect(event.returnValues.to).to.equal('0x0000000000000000000000000000000000000000');180      expect(event.returnValues.tokenId).to.equal(tokenId.toString());181    }182  });183184  itEth('Can perform transferFrom()', async ({helper}) => {185    const caller = await helper.eth.createAccountWithBalance(donor);186    const receiver = helper.eth.createAccount();187    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'TransferFromy', '6', '6');188    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);189190    const result = await contract.methods.mint(caller).send();191    const tokenId = result.events.Transfer.returnValues.tokenId;192193    const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);194195    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);196    await tokenContract.methods.repartition(15).send();197198    {199      const tokenEvents: any = [];200      tokenContract.events.allEvents((_: any, event: any) => {201        tokenEvents.push(event);202      });203      const result = await contract.methods.transferFrom(caller, receiver, tokenId).send();204      if (tokenEvents.length == 0) await helper.wait.newBlocks(1);205206      let event = result.events.Transfer;207      expect(event.address).to.equal(collectionAddress);208      expect(event.returnValues.from).to.equal(caller);209      expect(event.returnValues.to).to.equal(receiver);210      expect(event.returnValues.tokenId).to.equal(tokenId.toString());211212      event = tokenEvents[0];213      expect(event.address).to.equal(tokenAddress);214      expect(event.returnValues.from).to.equal(caller);215      expect(event.returnValues.to).to.equal(receiver);216      expect(event.returnValues.value).to.equal('15');217    }218219    {220      const balance = await contract.methods.balanceOf(receiver).call();221      expect(+balance).to.equal(1);222    }223224    {225      const balance = await contract.methods.balanceOf(caller).call();226      expect(+balance).to.equal(0);227    }228  });229230  itEth('Can perform burnFrom()', async ({helper, privateKey}) => {231    const alice = privateKey('//Alice');232    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});233234    const owner = await helper.eth.createAccountWithBalance(alice, 100n);235    const spender = await helper.eth.createAccountWithBalance(alice, 100n);236237    const token = await collection.mintToken(alice, 100n, {Ethereum: owner});238239    const address = helper.ethAddress.fromCollectionId(collection.collectionId);240    const contract = helper.ethNativeContract.collection(address, 'rft');241242    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);243    const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);244    await tokenContract.methods.repartition(15).send();245    await tokenContract.methods.approve(spender, 15).send();246247    {248      const result = await contract.methods.burnFrom(owner, token.tokenId).send({from: spender});249      const event = result.events.Transfer;250      expect(event).to.be.like({251        address: helper.ethAddress.fromCollectionId(collection.collectionId),252        event: 'Transfer',253        returnValues: {254          from: owner,255          to: '0x0000000000000000000000000000000000000000',256          tokenId: token.tokenId.toString(),257        },258      });259    }260261    expect(await collection.getTokenBalance(token.tokenId, {Ethereum: owner})).to.be.eq(0n);262  });263264  itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {265    const alice = privateKey('//Alice');266    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});267268    const owner = privateKey('//Bob');269    const spender = await helper.eth.createAccountWithBalance(alice, 100n);270271    const token = await collection.mintToken(alice, 100n, {Substrate: owner.address});272273    const address = helper.ethAddress.fromCollectionId(collection.collectionId);274    const contract = helper.ethNativeContract.collection(address, 'rft');275276    await token.repartition(owner, 15n);277    await token.approve(owner, {Ethereum: spender}, 15n);278279    {280      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);281      const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender});282      const event = result.events.Transfer;283      expect(event).to.be.like({284        address: helper.ethAddress.fromCollectionId(collection.collectionId),285        event: 'Transfer',286        returnValues: {287          from: helper.address.substrateToEth(owner.address),288          to: '0x0000000000000000000000000000000000000000',289          tokenId: token.tokenId.toString(),290        },291      });292    }293294    expect(await collection.getTokenBalance(token.tokenId, {Substrate: owner.address})).to.be.eq(0n);295  });296297  itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {298    const alice = privateKey('//Alice');299    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});300301    const owner = privateKey('//Bob');302    const spender = await helper.eth.createAccountWithBalance(alice, 100n);303    const receiver = privateKey('//Charlie');304305    const token = await collection.mintToken(alice, 100n, {Substrate: owner.address});306307    const address = helper.ethAddress.fromCollectionId(collection.collectionId);308    const contract = helper.ethNativeContract.collection(address, 'rft');309310    await token.repartition(owner, 15n);311    await token.approve(owner, {Ethereum: spender}, 15n);312313    {314      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);315      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);316      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});317      const event = result.events.Transfer;318      expect(event).to.be.like({319        address: helper.ethAddress.fromCollectionId(collection.collectionId),320        event: 'Transfer',321        returnValues: {322          from: helper.address.substrateToEth(owner.address),323          to: helper.address.substrateToEth(receiver.address),324          tokenId: token.tokenId.toString(),325        },326      });327    }328329    expect(await token.getTop10Owners()).to.be.like([{Substrate: receiver.address}]);330  });331332  itEth('Can perform transfer()', async ({helper}) => {333    const caller = await helper.eth.createAccountWithBalance(donor);334    const receiver = helper.eth.createAccount();335    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry', '6', '6');336    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);337338    const result = await contract.methods.mint(caller).send();339    const tokenId = result.events.Transfer.returnValues.tokenId;340341    {342      const result = await contract.methods.transfer(receiver, tokenId).send();343344      const event = result.events.Transfer;345      expect(event.address).to.equal(collectionAddress);346      expect(event.returnValues.from).to.equal(caller);347      expect(event.returnValues.to).to.equal(receiver);348      expect(event.returnValues.tokenId).to.equal(tokenId.toString());349    }350351    {352      const balance = await contract.methods.balanceOf(caller).call();353      expect(+balance).to.equal(0);354    }355356    {357      const balance = await contract.methods.balanceOf(receiver).call();358      expect(+balance).to.equal(1);359    }360  });361362  itEth('transfer event on transfer from partial ownership to full ownership', async ({helper}) => {363    const caller = await helper.eth.createAccountWithBalance(donor);364    const receiver = helper.eth.createAccount();365    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry-Partial-to-Full', '6', '6');366    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);367368    const result = await contract.methods.mint(caller).send();369    const tokenId = result.events.Transfer.returnValues.tokenId;370371    const tokenContract = helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);372373    await tokenContract.methods.repartition(2).send();374    await tokenContract.methods.transfer(receiver, 1).send();375376    const events: any = [];377    contract.events.allEvents((_: any, event: any) => {378      events.push(event);379    });380381    await tokenContract.methods.transfer(receiver, 1).send();382    if (events.length == 0) await helper.wait.newBlocks(1);383    const event = events[0];384385    expect(event.address).to.equal(collectionAddress);386    expect(event.returnValues.from).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');387    expect(event.returnValues.to).to.equal(receiver);388    expect(event.returnValues.tokenId).to.equal(tokenId.toString());389  });390391  itEth('transfer event on transfer from full ownership to partial ownership', async ({helper}) => {392    const caller = await helper.eth.createAccountWithBalance(donor);393    const receiver = helper.eth.createAccount();394    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Transferry-Full-to-Partial', '6', '6');395    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);396397    const result = await contract.methods.mint(caller).send();398    const tokenId = result.events.Transfer.returnValues.tokenId;399400    const tokenContract = helper.ethNativeContract.rftTokenById(collectionId, tokenId, caller);401402    await tokenContract.methods.repartition(2).send();403404    const events: any = [];405    contract.events.allEvents((_: any, event: any) => {406      events.push(event);407    });408409    await tokenContract.methods.transfer(receiver, 1).send();410    if (events.length == 0) await helper.wait.newBlocks(1);411    const event = events[0];412413    expect(event.address).to.equal(collectionAddress);414    expect(event.returnValues.from).to.equal(caller);415    expect(event.returnValues.to).to.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');416    expect(event.returnValues.tokenId).to.equal(tokenId.toString());417  });418});419420describe('RFT: Fees', () => {421  let donor: IKeyringPair;422423  before(async function() {424    await usingEthPlaygrounds(async (helper, privateKey) => {425      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);426427      donor = await privateKey({filename: __filename});428    });429  });430431  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {432    const caller = await helper.eth.createAccountWithBalance(donor);433    const receiver = helper.eth.createAccount();434    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Feeful-Transfer-From', '6', '6');435    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);436437    const result = await contract.methods.mint(caller).send();438    const tokenId = result.events.Transfer.returnValues.tokenId;439440    const cost = await helper.eth.recordCallFee(caller, () => contract.methods.transferFrom(caller, receiver, tokenId).send());441    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));442    expect(cost > 0n);443  });444445  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {446    const caller = await helper.eth.createAccountWithBalance(donor);447    const receiver = helper.eth.createAccount();448    const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Feeful-Transfer', '6', '6');449    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);450451    const result = await contract.methods.mint(caller).send();452    const tokenId = result.events.Transfer.returnValues.tokenId;453454    const cost = await helper.eth.recordCallFee(caller, () => contract.methods.transfer(receiver, tokenId).send());455    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));456    expect(cost > 0n);457  });458});459460describe('Common metadata', () => {461  let donor: IKeyringPair;462  let alice: IKeyringPair;463464  before(async function() {465    await usingEthPlaygrounds(async (helper, privateKey) => {466      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);467468      donor = await privateKey({filename: __filename});469      [alice] = await helper.arrange.createAccounts([20n], donor);470    });471  });472473  itEth('Returns collection name', async ({helper}) => {474    const caller = helper.eth.createAccount();475    const tokenPropertyPermissions = [{476      key: 'URI',477      permission: {478        mutable: true,479        collectionAdmin: true,480        tokenOwner: false,481      },482    }];483    const collection = await helper.rft.mintCollection(484      alice,485      {486        name: 'Leviathan',487        tokenPrefix: '11',488        properties: [{key: 'ERC721Metadata', value: '1'}],489        tokenPropertyPermissions,490      },491    );492493    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'rft', caller);494    const name = await contract.methods.name().call();495    expect(name).to.equal('Leviathan');496  });497498  itEth('Returns symbol name', async ({helper}) => {499    const caller = await helper.eth.createAccountWithBalance(donor);500    const tokenPropertyPermissions = [{501      key: 'URI',502      permission: {503        mutable: true,504        collectionAdmin: true,505        tokenOwner: false,506      },507    }];508    const {collectionId} = await helper.rft.mintCollection(509      alice,510      {511        name: 'Leviathan',512        tokenPrefix: '12',513        properties: [{key: 'ERC721Metadata', value: '1'}],514        tokenPropertyPermissions,515      },516    );517518    const contract = helper.ethNativeContract.collectionById(collectionId, 'rft', caller);519    const symbol = await contract.methods.symbol().call();520    expect(symbol).to.equal('12');521  });522});