difftreelog
chore require refungible pallet
in: master
1 file changed
tests/src/eth/reFungible.test.tsdiffbeforeafterboth1// 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 {754 const ownerCross = helper.ethCrossAccount.fromAddress(owner);755 await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;756 }757 });758759 itEth('[negative] Cant perform transfer without approval', async ({helper}) => {760 const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});761 const owner = await helper.eth.createAccountWithBalance(donor, 100n);762 const receiver = alice;763764 const spender = await helper.eth.createAccountWithBalance(donor, 100n);765766 const token = await collection.mintToken(minter, 100n, {Ethereum: owner});767768 const address = helper.ethAddress.fromCollectionId(collection.collectionId);769 const contract = helper.ethNativeContract.collection(address, 'rft');770771 {772 const ownerCross = helper.ethCrossAccount.fromAddress(owner);773 const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);774 await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;775 }776 });777});