difftreelog
tests: refactor and adapt some tests for asynchronicity
in: master
14 files changed
tests/src/app-promotion.test.tsdiffbeforeafterboth--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -37,7 +37,7 @@
before(async function () {
await usingPlaygrounds(async (helper, privateKey) => {
requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);
- alice = await privateKey({filename: __filename});
+ alice = await privateKey('//Alice');
[palletAdmin] = await helper.arrange.createAccounts([100n], alice);
const api = helper.getApi();
await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
@@ -557,7 +557,7 @@
// caller payed for call
expect(1000n * nominal > callerBalance).to.be.true;
- expect(contractBalanceAfter).to.be.equal(1000n * nominal);
+ expect(contractBalanceAfter).to.be.equal(100n * nominal);
});
itEth('can not be called by non-admin', async ({helper}) => {
@@ -613,7 +613,7 @@
await helper.staking.stake(staker, 200n * nominal);
// wait rewards are available:
- const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+ const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));
const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;
tests/src/confirmSponsorship.test.tsdiffbeforeafterboth--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -109,7 +109,9 @@
});
itSub('NFT: Sponsoring of transfers is rate limited', async ({helper}) => {
- const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL', limits: {
+ sponsorTransferTimeout: 1000,
+ }});
await collection.setSponsor(alice, bob.address);
await collection.confirmSponsorship(bob);
@@ -125,7 +127,9 @@
});
itSub('Fungible: Sponsoring is rate limited', async ({helper}) => {
- const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL', limits: {
+ sponsorTransferTimeout: 1000,
+ }});
await collection.setSponsor(alice, bob.address);
await collection.confirmSponsorship(bob);
@@ -141,7 +145,9 @@
});
itSub.ifWithPallets('ReFungible: Sponsoring is rate limited', [Pallets.ReFungible], async ({helper}) => {
- const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL', limits: {
+ sponsorTransferTimeout: 1000,
+ }});
await collection.setSponsor(alice, bob.address);
await collection.confirmSponsorship(bob);
tests/src/creditFeesToTreasury.seqtest.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/creditFeesToTreasury.seqtest.ts
@@ -0,0 +1,165 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import './interfaces/augment-api-consts';
+import {IKeyringPair} from '@polkadot/types/types';
+import {ApiPromise} from '@polkadot/api';
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
+
+const TREASURY = '5EYCAe5ijiYfyeZ2JJCGq56LmPyNRAKzpG4QkoQkkQNB5e6Z';
+const saneMinimumFee = 0.05;
+const saneMaximumFee = 0.5;
+const createCollectionDeposit = 100;
+
+// Skip the inflation block pauses if the block is close to inflation block
+// until the inflation happens
+/*eslint no-async-promise-executor: "off"*/
+function skipInflationBlock(api: ApiPromise): Promise<void> {
+ const promise = new Promise<void>(async (resolve) => {
+ const blockInterval = api.consts.inflation.inflationBlockInterval.toNumber();
+ const unsubscribe = await api.rpc.chain.subscribeNewHeads(head => {
+ const currentBlock = head.number.toNumber();
+ if (currentBlock % blockInterval < blockInterval - 10) {
+ unsubscribe();
+ resolve();
+ } else {
+ console.log(`Skipping inflation block, current block: ${currentBlock}`);
+ }
+ });
+ });
+
+ return promise;
+}
+
+describe('integration test: Fees must be credited to Treasury:', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+ });
+ });
+
+ itSub('Total issuance does not change', async ({helper}) => {
+ const api = helper.getApi();
+ await skipInflationBlock(api);
+ await helper.wait.newBlocks(1);
+
+ const totalBefore = (await helper.callRpc('api.query.balances.totalIssuance', [])).toBigInt();
+
+ await helper.balance.transferToSubstrate(alice, bob.address, 1n);
+
+ const totalAfter = (await helper.callRpc('api.query.balances.totalIssuance', [])).toBigInt();
+
+ expect(totalAfter).to.be.equal(totalBefore);
+ });
+
+ itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {
+ await skipInflationBlock(helper.getApi());
+ await helper.wait.newBlocks(1);
+
+ const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
+
+ const amount = 1n;
+ await helper.balance.transferToSubstrate(alice, bob.address, amount);
+
+ const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+
+ const fee = aliceBalanceBefore - aliceBalanceAfter - amount;
+ const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+
+ expect(treasuryIncrease).to.be.equal(fee);
+ });
+
+ itSub('Treasury balance increased by failed tx fee', async ({helper}) => {
+ const api = helper.getApi();
+ await helper.wait.newBlocks(1);
+
+ const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+
+ await expect(helper.signTransaction(bob, api.tx.balances.setBalance(alice.address, 0, 0))).to.be.rejected;
+
+ const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+
+ const fee = bobBalanceBefore - bobBalanceAfter;
+ const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+
+ expect(treasuryIncrease).to.be.equal(fee);
+ });
+
+ itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {
+ await skipInflationBlock(helper.getApi());
+ await helper.wait.newBlocks(1);
+
+ const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
+
+ await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+
+ const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+ const fee = aliceBalanceBefore - aliceBalanceAfter;
+ const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+
+ expect(treasuryIncrease).to.be.equal(fee);
+ });
+
+ itSub('Fees are sane', async ({helper}) => {
+ const unique = helper.balance.getOneTokenNominal();
+ await skipInflationBlock(helper.getApi());
+ await helper.wait.newBlocks(1);
+
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
+
+ await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+ const fee = aliceBalanceBefore - aliceBalanceAfter;
+
+ expect(fee / unique < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
+ expect(fee / unique < BigInt(Math.ceil(saneMinimumFee + createCollectionDeposit))).to.be.true;
+ });
+
+ itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {
+ await skipInflationBlock(helper.getApi());
+ await helper.wait.newBlocks(1);
+
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
+ const token = await collection.mintToken(alice, {Substrate: alice.address});
+
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
+ await token.transfer(alice, {Substrate: bob.address});
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+
+ const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal());
+ const expectedTransferFee = 0.1;
+ // fee drifts because of NextFeeMultiplier
+ const tolerance = 0.001;
+
+ expect(Math.abs(fee - expectedTransferFee)).to.be.lessThan(tolerance);
+ });
+});
tests/src/creditFeesToTreasury.test.tsdiffbeforeafterboth--- a/tests/src/creditFeesToTreasury.test.ts
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-import './interfaces/augment-api-consts';
-import {IKeyringPair} from '@polkadot/types/types';
-import {ApiPromise} from '@polkadot/api';
-import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
-
-const TREASURY = '5EYCAe5ijiYfyeZ2JJCGq56LmPyNRAKzpG4QkoQkkQNB5e6Z';
-const saneMinimumFee = 0.05;
-const saneMaximumFee = 0.5;
-const createCollectionDeposit = 100;
-
-// Skip the inflation block pauses if the block is close to inflation block
-// until the inflation happens
-/*eslint no-async-promise-executor: "off"*/
-function skipInflationBlock(api: ApiPromise): Promise<void> {
- const promise = new Promise<void>(async (resolve) => {
- const blockInterval = api.consts.inflation.inflationBlockInterval.toNumber();
- const unsubscribe = await api.rpc.chain.subscribeNewHeads(head => {
- const currentBlock = head.number.toNumber();
- if (currentBlock % blockInterval < blockInterval - 10) {
- unsubscribe();
- resolve();
- } else {
- console.log(`Skipping inflation block, current block: ${currentBlock}`);
- }
- });
- });
-
- return promise;
-}
-
-describe('integration test: Fees must be credited to Treasury:', () => {
- let alice: IKeyringPair;
- let bob: IKeyringPair;
-
- before(async () => {
- await usingPlaygrounds(async (helper, privateKey) => {
- const donor = await privateKey({filename: __filename});
- [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
- });
- });
-
- itSub('Total issuance does not change', async ({helper}) => {
- const api = helper.getApi();
- await skipInflationBlock(api);
- await helper.wait.newBlocks(1);
-
- const totalBefore = (await helper.callRpc('api.query.balances.totalIssuance', [])).toBigInt();
-
- await helper.balance.transferToSubstrate(alice, bob.address, 1n);
-
- const totalAfter = (await helper.callRpc('api.query.balances.totalIssuance', [])).toBigInt();
-
- expect(totalAfter).to.be.equal(totalBefore);
- });
-
- itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {
- await skipInflationBlock(helper.getApi());
- await helper.wait.newBlocks(1);
-
- const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
- const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
-
- const amount = 1n;
- await helper.balance.transferToSubstrate(alice, bob.address, amount);
-
- const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
- const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
-
- const fee = aliceBalanceBefore - aliceBalanceAfter - amount;
- const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
-
- expect(treasuryIncrease).to.be.equal(fee);
- });
-
- itSub('Treasury balance increased by failed tx fee', async ({helper}) => {
- const api = helper.getApi();
- await helper.wait.newBlocks(1);
-
- const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
- const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-
- await expect(helper.signTransaction(bob, api.tx.balances.setBalance(alice.address, 0, 0))).to.be.rejected;
-
- const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
- const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-
- const fee = bobBalanceBefore - bobBalanceAfter;
- const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
-
- expect(treasuryIncrease).to.be.equal(fee);
- });
-
- itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {
- await skipInflationBlock(helper.getApi());
- await helper.wait.newBlocks(1);
-
- const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
- const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
-
- await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-
- const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
- const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
- const fee = aliceBalanceBefore - aliceBalanceAfter;
- const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
-
- expect(treasuryIncrease).to.be.equal(fee);
- });
-
- itSub('Fees are sane', async ({helper}) => {
- const unique = helper.balance.getOneTokenNominal();
- await skipInflationBlock(helper.getApi());
- await helper.wait.newBlocks(1);
-
- const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
-
- await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-
- const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
- const fee = aliceBalanceBefore - aliceBalanceAfter;
-
- expect(fee / unique < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
- expect(fee / unique < BigInt(Math.ceil(saneMinimumFee + createCollectionDeposit))).to.be.true;
- });
-
- itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {
- await skipInflationBlock(helper.getApi());
- await helper.wait.newBlocks(1);
-
- const collection = await helper.nft.mintCollection(alice, {
- name: 'test',
- description: 'test',
- tokenPrefix: 'test',
- });
- // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
- const token = await collection.mintToken(alice, {Substrate: alice.address});
-
- const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
- await token.transfer(alice, {Substrate: bob.address});
- const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
-
- const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal());
- const expectedTransferFee = 0.1;
- // fee drifts because of NextFeeMultiplier
- const tolerance = 0.001;
-
- expect(Math.abs(fee - expectedTransferFee)).to.be.lessThan(tolerance);
- });
-});
tests/src/eth/collectionSponsoring.test.tsdiffbeforeafterboth--- a/tests/src/eth/collectionSponsoring.test.ts
+++ b/tests/src/eth/collectionSponsoring.test.ts
@@ -9,17 +9,12 @@
before(async () => {
await usingPlaygrounds(async (helper, privateKey) => {
- donor = privateKey('//Alice');
+ donor = await privateKey({filename: __filename});
+ [alice] = await helper.arrange.createAccounts([100n], donor);
nominal = helper.balance.getOneTokenNominal();
});
});
-
- beforeEach(async () => {
- await usingPlaygrounds(async (helper) => {
- [alice] = await helper.arrange.createAccounts([1000n], donor);
- });
- });
-
+
itEth('sponsors mint transactions', async ({helper}) => {
const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'spnr', permissions: {mintMode: true}});
await collection.setSponsor(alice, alice.address);
tests/src/eth/contractSponsoring.test.tsdiffbeforeafterboth--- a/tests/src/eth/contractSponsoring.test.ts
+++ b/tests/src/eth/contractSponsoring.test.ts
@@ -26,11 +26,11 @@
before(async () => {
await usingPlaygrounds(async (_helper, privateKey) => {
- donor = privateKey('//Alice');
+ donor = await privateKey({filename: __filename});
});
});
- itEth('Self sponsored can be set by the address that deployed the contract', async ({helper, privateKey}) => {
+ itEth('Self sponsored can be set by the address that deployed the contract', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
const flipper = await helper.eth.deployFlipper(owner);
const helpers = helper.ethNativeContract.contractHelpers(owner);
@@ -517,20 +517,13 @@
before(async () => {
await usingEthPlaygrounds(async (helper, privateKey) => {
- donor = privateKey('//Alice');
+ donor = await privateKey({filename: __filename});
+ [alice] = await helper.arrange.createAccounts([100n], donor);
DEFAULT_GAS = helper.eth.DEFAULT_GAS;
});
});
- beforeEach(async () => {
- await usingPlaygrounds(async (helper) => {
- [alice] = await helper.arrange.createAccounts([1000n], donor);
- });
- });
-
let testContract: CompiledContract;
-
-
itEth('Default fee limit', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
@@ -584,7 +577,7 @@
expect(await helper.balance.getEthereum(user)).to.not.be.equal(originalUserBalance);
});
- itEth('Negative test - check that evm.call transactions exceeding fee limit are not executed', async ({helper, privateKey}) => {
+ itEth('Negative test - check that evm.call transactions exceeding fee limit are not executed', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
const sponsor = await helper.eth.createAccountWithBalance(donor);
const helpers = helper.ethNativeContract.contractHelpers(owner);
tests/src/eth/createNFTCollection.test.tsdiffbeforeafterboth--- a/tests/src/eth/createNFTCollection.test.ts
+++ b/tests/src/eth/createNFTCollection.test.ts
@@ -35,24 +35,17 @@
const description = 'Some description';
const prefix = 'token prefix';
- // todo:playgrounds this might fail when in async environment.
- const collectionCountBefore = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
const {collectionId} = await helper.eth.createNonfungibleCollection(owner, name, description, prefix);
- const collectionCountAfter = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
-
- const collection = helper.nft.getCollectionObject(collectionId);
- const data = (await collection.getData())!;
+ const data = (await helper.rft.getData(collectionId))!;
- expect(collectionCountAfter - collectionCountBefore).to.be.eq(1);
- expect(collectionId).to.be.eq(collectionCountAfter);
expect(data.name).to.be.eq(name);
expect(data.description).to.be.eq(description);
expect(data.raw.tokenPrefix).to.be.eq(prefix);
expect(data.raw.mode).to.be.eq('NFT');
});
- // todo:playgrounds this test will fail when in async environment.
- itEth('Check collection address exist', async ({helper}) => {
+ // this test will occasionally fail when in async environment.
+ itEth.skip('Check collection address exist', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
const expectedCollectionId = +(await helper.callRpc('api.rpc.unique.collectionStats')).created + 1;
tests/src/eth/createRFTCollection.test.tsdiffbeforeafterboth--- a/tests/src/eth/createRFTCollection.test.ts
+++ b/tests/src/eth/createRFTCollection.test.ts
@@ -37,23 +37,17 @@
const description = 'Some description';
const prefix = 'token prefix';
- // todo:playgrounds this might fail when in async environment.
- const collectionCountBefore = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
const {collectionId} = await helper.eth.createRefungibleCollection(owner, name, description, prefix);
- const collectionCountAfter = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
-
const data = (await helper.rft.getData(collectionId))!;
- expect(collectionCountAfter - collectionCountBefore).to.be.eq(1);
- expect(collectionId).to.be.eq(collectionCountAfter);
expect(data.name).to.be.eq(name);
expect(data.description).to.be.eq(description);
expect(data.raw.tokenPrefix).to.be.eq(prefix);
expect(data.raw.mode).to.be.eq('ReFungible');
});
-
- // todo:playgrounds this test will fail when in async environment.
- itEth('Check collection address exist', async ({helper}) => {
+
+ // this test will occasionally fail when in async environment.
+ itEth.skip('Check collection address exist', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
const expectedCollectionId = +(await helper.callRpc('api.rpc.unique.collectionStats')).created + 1;
tests/src/eth/marketplace/marketplace.test.tsdiffbeforeafterboth--- a/tests/src/eth/marketplace/marketplace.test.ts
+++ b/tests/src/eth/marketplace/marketplace.test.ts
@@ -14,10 +14,9 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import {usingPlaygrounds} from './../../util/playgrounds/index';
import {IKeyringPair} from '@polkadot/types/types';
import {readFile} from 'fs/promises';
-import {itEth, expect, SponsoringMode} from '../util/playgrounds';
+import {itEth, usingEthPlaygrounds, expect, SponsoringMode} from '../util/playgrounds';
describe('Matcher contract usage', () => {
const PRICE = 2000n;
@@ -29,17 +28,17 @@
let sellerMirror: string;
before(async () => {
- await usingPlaygrounds(async (_helper, privateKey) => {
- donor = privateKey('//Alice');
+ await usingEthPlaygrounds(async (_helper, privateKey) => {
+ donor = await privateKey({filename: __filename});
});
});
beforeEach(async () => {
- await usingPlaygrounds(async (helper, privateKey) => {
- [alice] = await helper.arrange.createAccounts([10000n], donor);
+ await usingEthPlaygrounds(async (helper, privateKey) => {
+ [alice] = await helper.arrange.createAccounts([1000n], donor);
aliceMirror = helper.address.substrateToEth(alice.address).toLowerCase();
aliceDoubleMirror = helper.address.ethToSubstrate(aliceMirror);
- seller = privateKey(`//Seller/${Date.now()}`);
+ seller = await privateKey(`//Seller/${Date.now()}`);
sellerMirror = helper.address.substrateToEth(seller.address).toLowerCase();
await helper.balance.transferToSubstrate(donor, aliceDoubleMirror, 10_000_000_000_000_000_000n);
tests/src/eth/sponsoring.test.tsdiffbeforeafterboth--- a/tests/src/eth/sponsoring.test.ts
+++ b/tests/src/eth/sponsoring.test.ts
@@ -22,8 +22,8 @@
let donor: IKeyringPair;
before(async () => {
- await usingPlaygrounds(async (helper, privateKey) => {
- donor = privateKey('//Alice');
+ await usingPlaygrounds(async (_helper, privateKey) => {
+ donor = await privateKey({filename: __filename});
});
});
tests/src/nesting/collectionProperties.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/nesting/collectionProperties.test.ts
@@ -0,0 +1,261 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, Pallets, usingPlaygrounds, expect} from '../util/playgrounds';
+import {UniqueBaseCollection} from '../util/playgrounds/unique';
+
+describe('Integration Test: Collection Properties', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);
+ });
+ });
+
+ itSub('Properties are initially empty', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice);
+ expect(await collection.getProperties()).to.be.empty;
+ });
+
+ async function testSetsPropertiesForCollection(collection: UniqueBaseCollection) {
+ // As owner
+ await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled;
+
+ await collection.addAdmin(alice, {Substrate: bob.address});
+
+ // As administrator
+ await expect(collection.setProperties(bob, [{key: 'black_hole'}])).to.be.fulfilled;
+
+ const properties = await collection.getProperties();
+ expect(properties).to.include.deep.members([
+ {key: 'electron', value: 'come bond'},
+ {key: 'black_hole', value: ''},
+ ]);
+ }
+
+ itSub('Sets properties for a NFT collection', async ({helper}) => {
+ await testSetsPropertiesForCollection(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Sets properties for a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice));
+ });
+
+ async function testCheckValidNames(collection: UniqueBaseCollection) {
+ // alpha symbols
+ await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled;
+
+ // numeric symbols
+ await expect(collection.setProperties(alice, [{key: '451'}])).to.be.fulfilled;
+
+ // underscore symbol
+ await expect(collection.setProperties(alice, [{key: 'black_hole'}])).to.be.fulfilled;
+
+ // dash symbol
+ await expect(collection.setProperties(alice, [{key: '-'}])).to.be.fulfilled;
+
+ // dot symbol
+ await expect(collection.setProperties(alice, [{key: 'once.in.a.long.long.while...', value: 'you get a little lost'}])).to.be.fulfilled;
+
+ const properties = await collection.getProperties();
+ expect(properties).to.include.deep.members([
+ {key: 'answer', value: ''},
+ {key: '451', value: ''},
+ {key: 'black_hole', value: ''},
+ {key: '-', value: ''},
+ {key: 'once.in.a.long.long.while...', value: 'you get a little lost'},
+ ]);
+ }
+
+ itSub('Check valid names for NFT collection properties keys', async ({helper}) => {
+ await testCheckValidNames(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Check valid names for ReFungible collection properties keys', [Pallets.ReFungible], async ({helper}) => {
+ await testCheckValidNames(await helper.rft.mintCollection(alice));
+ });
+
+ async function testChangesProperties(collection: UniqueBaseCollection) {
+ await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled;
+
+ // Mutate the properties
+ await expect(collection.setProperties(alice, [{key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
+
+ const properties = await collection.getProperties();
+ expect(properties).to.include.deep.members([
+ {key: 'electron', value: 'come bond'},
+ {key: 'black_hole', value: 'LIGO'},
+ ]);
+ }
+
+ itSub('Changes properties of a NFT collection', async ({helper}) => {
+ await testChangesProperties(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Changes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ await testChangesProperties(await helper.rft.mintCollection(alice));
+ });
+
+ async function testDeleteProperties(collection: UniqueBaseCollection) {
+ await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
+
+ await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled;
+
+ const properties = await collection.getProperties(['black_hole', 'electron']);
+ expect(properties).to.be.deep.equal([
+ {key: 'black_hole', value: 'LIGO'},
+ ]);
+ }
+
+ itSub('Deletes properties of a NFT collection', async ({helper}) => {
+ await testDeleteProperties(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Deletes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ await testDeleteProperties(await helper.rft.mintCollection(alice));
+ });
+});
+
+describe('Negative Integration Test: Collection Properties', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
+ });
+ });
+
+ async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: UniqueBaseCollection) {
+ await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]))
+ .to.be.rejectedWith(/common\.NoPermission/);
+
+ expect(await collection.getProperties()).to.be.empty;
+ }
+
+ itSub('Fails to set properties in a NFT collection if not its onwer/administrator', async ({helper}) => {
+ await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Fails to set properties in a ReFungible collection if not its onwer/administrator', [Pallets.ReFungible], async ({helper}) => {
+ await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice));
+ });
+
+ async function testFailsSetPropertiesThatExeedLimits(collection: UniqueBaseCollection) {
+ const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber();
+
+ // Mute the general tx parsing error, too many bytes to process
+ {
+ console.error = () => {};
+ await expect(collection.setProperties(alice, [
+ {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))},
+ ])).to.be.rejected;
+ }
+
+ expect(await collection.getProperties(['electron'])).to.be.empty;
+
+ await expect(collection.setProperties(alice, [
+ {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))},
+ {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))},
+ ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);
+
+ expect(await collection.getProperties(['electron', 'black_hole'])).to.be.empty;
+ }
+
+ itSub('Fails to set properties that exceed the limits (NFT)', async ({helper}) => {
+ await testFailsSetPropertiesThatExeedLimits(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Fails to set properties that exceed the limits (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice));
+ });
+
+ async function testFailsSetMorePropertiesThanAllowed(collection: UniqueBaseCollection) {
+ const propertiesToBeSet = [];
+ for (let i = 0; i < 65; i++) {
+ propertiesToBeSet.push({
+ key: 'electron_' + i,
+ value: Math.random() > 0.5 ? 'high' : 'low',
+ });
+ }
+
+ await expect(collection.setProperties(alice, propertiesToBeSet)).
+ to.be.rejectedWith(/common\.PropertyLimitReached/);
+
+ expect(await collection.getProperties()).to.be.empty;
+ }
+
+ itSub('Fails to set more properties than it is allowed (NFT)', async ({helper}) => {
+ await testFailsSetMorePropertiesThanAllowed(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Fails to set more properties than it is allowed (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice));
+ });
+
+ async function testFailsSetPropertiesWithInvalidNames(collection: UniqueBaseCollection) {
+ const invalidProperties = [
+ [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],
+ [{key: 'Mr/Sandman', value: 'Bring me a gene'}],
+ [{key: 'déjà vu', value: 'hmm...'}],
+ ];
+
+ for (let i = 0; i < invalidProperties.length; i++) {
+ await expect(
+ collection.setProperties(alice, invalidProperties[i]),
+ `on rejecting the new badly-named property #${i}`,
+ ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
+ }
+
+ await expect(
+ collection.setProperties(alice, [{key: '', value: 'nothing must not exist'}]),
+ 'on rejecting an unnamed property',
+ ).to.be.rejectedWith(/common\.EmptyPropertyKey/);
+
+ await expect(
+ collection.setProperties(alice, [{key: 'CRISPR-Cas9', value: 'rewriting nature!'}]),
+ 'on setting the correctly-but-still-badly-named property',
+ ).to.be.fulfilled;
+
+ const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');
+
+ const properties = await collection.getProperties(keys);
+ expect(properties).to.be.deep.equal([
+ {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
+ ]);
+
+ for (let i = 0; i < invalidProperties.length; i++) {
+ await expect(
+ collection.deleteProperties(alice, invalidProperties[i].map(propertySet => propertySet.key)),
+ `on trying to delete the non-existent badly-named property #${i}`,
+ ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
+ }
+ }
+
+ itSub('Fails to set properties with invalid names (NFT)', async ({helper}) => {
+ await testFailsSetPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Fails to set properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testFailsSetPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));
+ });
+});
+
\ No newline at end of file
tests/src/nesting/properties.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 {IKeyringPair} from '@polkadot/types/types';18import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from '../util/playgrounds';19import {UniqueHelper, UniqueBaseCollection, UniqueNFTCollection, UniqueNFToken, UniqueRFTCollection, UniqueRFToken} from '../util/playgrounds/unique';2021// ---------- COLLECTION PROPERTIES2223describe('Integration Test: Collection Properties', () => {24 let alice: IKeyringPair;25 let bob: IKeyringPair;2627 before(async () => {28 await usingPlaygrounds(async (helper, privateKey) => {29 const donor = await privateKey({filename: __filename});30 [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);31 });32 });3334 itSub('Properties are initially empty', async ({helper}) => {35 const collection = await helper.nft.mintCollection(alice);36 expect(await collection.getProperties()).to.be.empty;37 });3839 async function testSetsPropertiesForCollection(collection: UniqueBaseCollection) {40 // As owner41 await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled;4243 await collection.addAdmin(alice, {Substrate: bob.address});4445 // As administrator46 await expect(collection.setProperties(bob, [{key: 'black_hole'}])).to.be.fulfilled;4748 const properties = await collection.getProperties();49 expect(properties).to.include.deep.members([50 {key: 'electron', value: 'come bond'},51 {key: 'black_hole', value: ''},52 ]);53 }5455 itSub('Sets properties for a NFT collection', async ({helper}) => {56 await testSetsPropertiesForCollection(await helper.nft.mintCollection(alice));57 });5859 itSub.ifWithPallets('Sets properties for a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {60 await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice));61 });6263 async function testCheckValidNames(collection: UniqueBaseCollection) {64 // alpha symbols65 await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled;6667 // numeric symbols68 await expect(collection.setProperties(alice, [{key: '451'}])).to.be.fulfilled;6970 // underscore symbol71 await expect(collection.setProperties(alice, [{key: 'black_hole'}])).to.be.fulfilled;7273 // dash symbol74 await expect(collection.setProperties(alice, [{key: '-'}])).to.be.fulfilled;7576 // dot symbol77 await expect(collection.setProperties(alice, [{key: 'once.in.a.long.long.while...', value: 'you get a little lost'}])).to.be.fulfilled;7879 const properties = await collection.getProperties();80 expect(properties).to.include.deep.members([81 {key: 'answer', value: ''},82 {key: '451', value: ''},83 {key: 'black_hole', value: ''},84 {key: '-', value: ''},85 {key: 'once.in.a.long.long.while...', value: 'you get a little lost'},86 ]);87 }8889 itSub('Check valid names for NFT collection properties keys', async ({helper}) => {90 await testCheckValidNames(await helper.nft.mintCollection(alice));91 });9293 itSub.ifWithPallets('Check valid names for ReFungible collection properties keys', [Pallets.ReFungible], async ({helper}) => {94 await testCheckValidNames(await helper.rft.mintCollection(alice));95 });9697 async function testChangesProperties(collection: UniqueBaseCollection) {98 await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled;99100 // Mutate the properties101 await expect(collection.setProperties(alice, [{key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;102103 const properties = await collection.getProperties();104 expect(properties).to.include.deep.members([105 {key: 'electron', value: 'come bond'},106 {key: 'black_hole', value: 'LIGO'},107 ]);108 }109110 itSub('Changes properties of a NFT collection', async ({helper}) => {111 await testChangesProperties(await helper.nft.mintCollection(alice));112 });113114 itSub.ifWithPallets('Changes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {115 await testChangesProperties(await helper.rft.mintCollection(alice));116 });117118 async function testDeleteProperties(collection: UniqueBaseCollection) {119 await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;120121 await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled;122123 const properties = await collection.getProperties(['black_hole', 'electron']);124 expect(properties).to.be.deep.equal([125 {key: 'black_hole', value: 'LIGO'},126 ]);127 }128129 itSub('Deletes properties of a NFT collection', async ({helper}) => {130 await testDeleteProperties(await helper.nft.mintCollection(alice));131 });132133 itSub.ifWithPallets('Deletes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {134 await testDeleteProperties(await helper.rft.mintCollection(alice));135 });136});137138describe('Negative Integration Test: Collection Properties', () => {139 let alice: IKeyringPair;140 let bob: IKeyringPair;141142 before(async () => {143 await usingPlaygrounds(async (helper, privateKey) => {144 const donor = await privateKey({filename: __filename});145 [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);146 });147 });148 149 async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: UniqueBaseCollection) { 150 await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]))151 .to.be.rejectedWith(/common\.NoPermission/);152153 expect(await collection.getProperties()).to.be.empty;154 }155156 itSub('Fails to set properties in a NFT collection if not its onwer/administrator', async ({helper}) => {157 await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.nft.mintCollection(alice));158 });159160 itSub.ifWithPallets('Fails to set properties in a ReFungible collection if not its onwer/administrator', [Pallets.ReFungible], async ({helper}) => {161 await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice));162 });163 164 async function testFailsSetPropertiesThatExeedLimits(collection: UniqueBaseCollection) {165 const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber();166 167 // Mute the general tx parsing error, too many bytes to process168 {169 console.error = () => {};170 await expect(collection.setProperties(alice, [171 {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))},172 ])).to.be.rejected;173 }174175 expect(await collection.getProperties(['electron'])).to.be.empty;176177 await expect(collection.setProperties(alice, [178 {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 179 {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 180 ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);181182 expect(await collection.getProperties(['electron', 'black_hole'])).to.be.empty;183 }184185 itSub('Fails to set properties that exceed the limits (NFT)', async ({helper}) => {186 await testFailsSetPropertiesThatExeedLimits(await helper.nft.mintCollection(alice));187 });188189 itSub.ifWithPallets('Fails to set properties that exceed the limits (ReFungible)', [Pallets.ReFungible], async ({helper}) => {190 await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice));191 });192 193 async function testFailsSetMorePropertiesThanAllowed(collection: UniqueBaseCollection) {194 const propertiesToBeSet = [];195 for (let i = 0; i < 65; i++) {196 propertiesToBeSet.push({197 key: 'electron_' + i,198 value: Math.random() > 0.5 ? 'high' : 'low',199 });200 }201202 await expect(collection.setProperties(alice, propertiesToBeSet)).203 to.be.rejectedWith(/common\.PropertyLimitReached/);204205 expect(await collection.getProperties()).to.be.empty;206 }207208 itSub('Fails to set more properties than it is allowed (NFT)', async ({helper}) => {209 await testFailsSetMorePropertiesThanAllowed(await helper.nft.mintCollection(alice));210 });211212 itSub.ifWithPallets('Fails to set more properties than it is allowed (ReFungible)', [Pallets.ReFungible], async ({helper}) => {213 await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice));214 });215 216 async function testFailsSetPropertiesWithInvalidNames(collection: UniqueBaseCollection) {217 const invalidProperties = [218 [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],219 [{key: 'Mr/Sandman', value: 'Bring me a gene'}],220 [{key: 'déjà vu', value: 'hmm...'}],221 ];222223 for (let i = 0; i < invalidProperties.length; i++) {224 await expect(225 collection.setProperties(alice, invalidProperties[i]), 226 `on rejecting the new badly-named property #${i}`,227 ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);228 }229230 await expect(231 collection.setProperties(alice, [{key: '', value: 'nothing must not exist'}]), 232 'on rejecting an unnamed property',233 ).to.be.rejectedWith(/common\.EmptyPropertyKey/);234235 await expect(236 collection.setProperties(alice, [{key: 'CRISPR-Cas9', value: 'rewriting nature!'}]), 237 'on setting the correctly-but-still-badly-named property',238 ).to.be.fulfilled;239240 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');241242 const properties = await collection.getProperties(keys);243 expect(properties).to.be.deep.equal([244 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},245 ]);246247 for (let i = 0; i < invalidProperties.length; i++) {248 await expect(249 collection.deleteProperties(alice, invalidProperties[i].map(propertySet => propertySet.key)), 250 `on trying to delete the non-existent badly-named property #${i}`,251 ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);252 }253 }254255 itSub('Fails to set properties with invalid names (NFT)', async ({helper}) => {256 await testFailsSetPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));257 });258259 itSub.ifWithPallets('Fails to set properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {260 await testFailsSetPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));261 });262});263264// ---------- ACCESS RIGHTS265266describe('Integration Test: Access Rights to Token Properties', () => {267 let alice: IKeyringPair;268 let bob: IKeyringPair;269270 before(async () => {271 await usingPlaygrounds(async (helper, privateKey) => {272 const donor = await privateKey({filename: __filename});273 [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);274 });275 });276 277 itSub('Reads access rights to properties of a collection', async ({helper}) => {278 const collection = await helper.nft.mintCollection(alice);279 const propertyRights = (await helper.callRpc('api.query.common.collectionPropertyPermissions', [collection.collectionId])).toJSON();280 expect(propertyRights).to.be.empty;281 });282 283 async function testSetsAccessRightsToProperties(collection: UniqueNFTCollection | UniqueRFTCollection) { 284 await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true}}]))285 .to.be.fulfilled;286287 await collection.addAdmin(alice, {Substrate: bob.address});288289 await expect(collection.setTokenPropertyPermissions(bob, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]))290 .to.be.fulfilled;291292 const propertyRights = await collection.getPropertyPermissions(['skullduggery', 'mindgame']);293 expect(propertyRights).to.include.deep.members([294 {key: 'skullduggery', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}},295 {key: 'mindgame', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},296 ]);297 }298299 itSub('Sets access rights to properties of a collection (NFT)', async ({helper}) => {300 await testSetsAccessRightsToProperties(await helper.nft.mintCollection(alice));301 });302303 itSub.ifWithPallets('Sets access rights to properties of a collection (ReFungible)', [Pallets.ReFungible], async ({helper}) => {304 await testSetsAccessRightsToProperties(await helper.rft.mintCollection(alice));305 });306 307 async function testChangesAccessRightsToProperty(collection: UniqueNFTCollection | UniqueRFTCollection) {308 await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]))309 .to.be.fulfilled;310311 await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))312 .to.be.fulfilled;313314 const propertyRights = await collection.getPropertyPermissions();315 expect(propertyRights).to.be.deep.equal([316 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},317 ]);318 }319320 itSub('Changes access rights to properties of a NFT collection', async ({helper}) => {321 await testChangesAccessRightsToProperty(await helper.nft.mintCollection(alice));322 });323324 itSub.ifWithPallets('Changes access rights to properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {325 await testChangesAccessRightsToProperty(await helper.rft.mintCollection(alice));326 });327});328329describe('Negative Integration Test: Access Rights to Token Properties', () => {330 let alice: IKeyringPair;331 let bob: IKeyringPair;332333 before(async () => {334 await usingPlaygrounds(async (helper, privateKey) => {335 const donor = await privateKey({filename: __filename});336 [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);337 });338 });339340 async function testPreventsFromSettingAccessRightsNotAdminOrOwner(collection: UniqueNFTCollection | UniqueRFTCollection) {341 await expect(collection.setTokenPropertyPermissions(bob, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]))342 .to.be.rejectedWith(/common\.NoPermission/);343344 const propertyRights = await collection.getPropertyPermissions(['skullduggery']);345 expect(propertyRights).to.be.empty;346 }347348 itSub('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async ({helper}) => {349 await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.nft.mintCollection(alice));350 });351352 itSub.ifWithPallets('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', [Pallets.ReFungible], async ({helper}) => {353 await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.rft.mintCollection(alice));354 });355356 async function testPreventFromAddingTooManyPossibleProperties(collection: UniqueNFTCollection | UniqueRFTCollection) { 357 const constitution = [];358 for (let i = 0; i < 65; i++) {359 constitution.push({360 key: 'property_' + i,361 permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},362 });363 }364365 await expect(collection.setTokenPropertyPermissions(alice, constitution))366 .to.be.rejectedWith(/common\.PropertyLimitReached/);367368 const propertyRights = await collection.getPropertyPermissions();369 expect(propertyRights).to.be.empty;370 }371372 itSub('Prevents from adding too many possible properties (NFT)', async ({helper}) => {373 await testPreventFromAddingTooManyPossibleProperties(await helper.nft.mintCollection(alice));374 });375376 itSub.ifWithPallets('Prevents from adding too many possible properties (ReFungible)', [Pallets.ReFungible], async ({helper}) => {377 await testPreventFromAddingTooManyPossibleProperties(await helper.rft.mintCollection(alice));378 });379380 async function testPreventAccessRightsModifiedIfConstant(collection: UniqueNFTCollection | UniqueRFTCollection) {381 await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))382 .to.be.fulfilled;383384 await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {collectionAdmin: true}}]))385 .to.be.rejectedWith(/common\.NoPermission/);386387 const propertyRights = await collection.getPropertyPermissions(['skullduggery']);388 expect(propertyRights).to.deep.equal([389 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},390 ]);391 }392393 itSub('Prevents access rights to be modified if constant (NFT)', async ({helper}) => {394 await testPreventAccessRightsModifiedIfConstant(await helper.nft.mintCollection(alice));395 });396397 itSub.ifWithPallets('Prevents access rights to be modified if constant (ReFungible)', [Pallets.ReFungible], async ({helper}) => {398 await testPreventAccessRightsModifiedIfConstant(await helper.rft.mintCollection(alice));399 });400401 async function testPreventsAddingPropertiesWithInvalidNames(collection: UniqueNFTCollection | UniqueRFTCollection) {402 const invalidProperties = [403 [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],404 [{key: 'G#4', permission: {tokenOwner: true}}],405 [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],406 ];407408 for (let i = 0; i < invalidProperties.length; i++) {409 await expect(410 collection.setTokenPropertyPermissions(alice, invalidProperties[i]), 411 `on setting the new badly-named property #${i}`,412 ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);413 }414415 await expect(416 collection.setTokenPropertyPermissions(alice, [{key: '', permission: {}}]), 417 'on rejecting an unnamed property',418 ).to.be.rejectedWith(/common\.EmptyPropertyKey/);419420 const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string421 await expect(422 collection.setTokenPropertyPermissions(alice, [423 {key: correctKey, permission: {collectionAdmin: true}},424 ]), 425 'on setting the correctly-but-still-badly-named property',426 ).to.be.fulfilled;427428 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');429430 const propertyRights = await collection.getPropertyPermissions(keys);431 expect(propertyRights).to.be.deep.equal([432 {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},433 ]);434 }435436 itSub('Prevents adding properties with invalid names (NFT)', async ({helper}) => {437 await testPreventsAddingPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));438 });439440 itSub.ifWithPallets('Prevents adding properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {441 await testPreventsAddingPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));442 });443});444445// ---------- TOKEN PROPERTIES446447describe('Integration Test: Token Properties', () => {448 let alice: IKeyringPair; // collection owner449 let bob: IKeyringPair; // collection admin450 let charlie: IKeyringPair; // token owner451452 let permissions: {permission: any, signers: IKeyringPair[]}[];453454 before(async () => {455 await usingPlaygrounds(async (helper, privateKey) => {456 const donor = await privateKey({filename: __filename});457 [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);458 });459460 // todo:playgrounds probably separate these tests later461 permissions = [462 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},463 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},464 {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},465 {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},466 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},467 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},468 ];469 });470 471 async function testReadsYetEmptyProperties(token: UniqueNFToken | UniqueRFToken) {472 const properties = await token.getProperties();473 expect(properties).to.be.empty;474475 const tokenData = await token.getData();476 expect(tokenData!.properties).to.be.empty;477 }478479 itSub('Reads yet empty properties of a token (NFT)', async ({helper}) => {480 const collection = await helper.nft.mintCollection(alice);481 const token = await collection.mintToken(alice);482 await testReadsYetEmptyProperties(token);483 });484485 itSub.ifWithPallets('Reads yet empty properties of a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {486 const collection = await helper.rft.mintCollection(alice);487 const token = await collection.mintToken(alice);488 await testReadsYetEmptyProperties(token);489 });490491 async function testAssignPropertiesAccordingToPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {492 await token.collection.addAdmin(alice, {Substrate: bob.address});493 await token.transfer(alice, {Substrate: charlie.address}, pieces);494495 const propertyKeys: string[] = [];496 let i = 0;497 for (const permission of permissions) {498 i++;499 let j = 0;500 for (const signer of permission.signers) {501 j++;502 const key = i + '_' + signer.address;503 propertyKeys.push(key);504505 await expect(506 token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 507 `on setting permission #${i} by alice`,508 ).to.be.fulfilled;509510 await expect(511 token.setProperties(signer, [{key: key, value: 'Serotonin increase'}]), 512 `on adding property #${i} by signer #${j}`,513 ).to.be.fulfilled;514 }515 }516517 const properties = await token.getProperties(propertyKeys);518 const tokenData = await token.getData();519 for (let i = 0; i < properties.length; i++) {520 expect(properties[i].value).to.be.equal('Serotonin increase');521 expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');522 }523 }524525 itSub('Assigns properties to a token according to permissions (NFT)', async ({helper}) => {526 const collection = await helper.nft.mintCollection(alice);527 const token = await collection.mintToken(alice);528 await testAssignPropertiesAccordingToPermissions(token, 1n);529 });530531 itSub.ifWithPallets('Assigns properties to a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {532 const collection = await helper.rft.mintCollection(alice);533 const token = await collection.mintToken(alice, 100n);534 await testAssignPropertiesAccordingToPermissions(token, 100n);535 });536537 async function testChangesPropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {538 await token.collection.addAdmin(alice, {Substrate: bob.address});539 await token.transfer(alice, {Substrate: charlie.address}, pieces);540541 const propertyKeys: string[] = [];542 let i = 0;543 for (const permission of permissions) {544 i++;545 if (!permission.permission.mutable) continue;546 547 let j = 0;548 for (const signer of permission.signers) {549 j++;550 const key = i + '_' + signer.address;551 propertyKeys.push(key);552553 await expect(554 token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 555 `on setting permission #${i} by alice`,556 ).to.be.fulfilled;557558 await expect(559 token.setProperties(signer, [{key, value: 'Serotonin increase'}]), 560 `on adding property #${i} by signer #${j}`,561 ).to.be.fulfilled;562563 await expect(564 token.setProperties(signer, [{key, value: 'Serotonin stable'}]), 565 `on changing property #${i} by signer #${j}`,566 ).to.be.fulfilled;567 }568 }569570 const properties = await token.getProperties(propertyKeys);571 const tokenData = await token.getData();572 for (let i = 0; i < properties.length; i++) {573 expect(properties[i].value).to.be.equal('Serotonin stable');574 expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');575 }576 }577578 itSub('Changes properties of a token according to permissions (NFT)', async ({helper}) => {579 const collection = await helper.nft.mintCollection(alice);580 const token = await collection.mintToken(alice);581 await testChangesPropertiesAccordingPermission(token, 1n);582 });583584 itSub.ifWithPallets('Changes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {585 const collection = await helper.rft.mintCollection(alice);586 const token = await collection.mintToken(alice, 100n);587 await testChangesPropertiesAccordingPermission(token, 100n);588 });589590 async function testDeletePropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {591 await token.collection.addAdmin(alice, {Substrate: bob.address});592 await token.transfer(alice, {Substrate: charlie.address}, pieces);593594 const propertyKeys: string[] = [];595 let i = 0;596597 for (const permission of permissions) {598 i++;599 if (!permission.permission.mutable) continue;600 601 let j = 0;602 for (const signer of permission.signers) {603 j++;604 const key = i + '_' + signer.address;605 propertyKeys.push(key);606607 await expect(608 token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 609 `on setting permission #${i} by alice`,610 ).to.be.fulfilled;611612 await expect(613 token.setProperties(signer, [{key, value: 'Serotonin increase'}]), 614 `on adding property #${i} by signer #${j}`,615 ).to.be.fulfilled;616617 await expect(618 token.deleteProperties(signer, [key]), 619 `on deleting property #${i} by signer #${j}`,620 ).to.be.fulfilled;621 }622 }623624 expect(await token.getProperties(propertyKeys)).to.be.empty;625 expect((await token.getData())!.properties).to.be.empty;626 }627 628 itSub('Deletes properties of a token according to permissions (NFT)', async ({helper}) => {629 const collection = await helper.nft.mintCollection(alice);630 const token = await collection.mintToken(alice);631 await testDeletePropertiesAccordingPermission(token, 1n);632 });633634 itSub.ifWithPallets('Deletes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {635 const collection = await helper.rft.mintCollection(alice);636 const token = await collection.mintToken(alice, 100n);637 await testDeletePropertiesAccordingPermission(token, 100n);638 });639640 itSub('Assigns properties to a nested token according to permissions', async ({helper}) => {641 const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});642 const collectionB = await helper.nft.mintCollection(alice);643 const targetToken = await collectionA.mintToken(alice);644 const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());645646 await collectionB.addAdmin(alice, {Substrate: bob.address});647 await targetToken.transfer(alice, {Substrate: charlie.address});648649 const propertyKeys: string[] = [];650 let i = 0;651 for (const permission of permissions) {652 i++;653 let j = 0;654 for (const signer of permission.signers) {655 j++;656 const key = i + '_' + signer.address;657 propertyKeys.push(key);658 659 await expect(660 nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 661 `on setting permission #${i} by alice`,662 ).to.be.fulfilled;663664 await expect(665 nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 666 `on adding property #${i} by signer #${j}`,667 ).to.be.fulfilled;668 }669 }670671 const properties = await nestedToken.getProperties(propertyKeys);672 const tokenData = await nestedToken.getData();673 for (let i = 0; i < properties.length; i++) {674 expect(properties[i].value).to.be.equal('Serotonin increase');675 expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');676 }677 expect(await targetToken.getProperties()).to.be.empty;678 });679680 itSub('Changes properties of a nested token according to permissions', async ({helper}) => {681 const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});682 const collectionB = await helper.nft.mintCollection(alice);683 const targetToken = await collectionA.mintToken(alice);684 const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());685686 await collectionB.addAdmin(alice, {Substrate: bob.address});687 await targetToken.transfer(alice, {Substrate: charlie.address});688689 const propertyKeys: string[] = [];690 let i = 0;691 for (const permission of permissions) {692 i++;693 if (!permission.permission.mutable) continue;694 695 let j = 0;696 for (const signer of permission.signers) {697 j++;698 const key = i + '_' + signer.address;699 propertyKeys.push(key);700701 await expect(702 nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 703 `on setting permission #${i} by alice`,704 ).to.be.fulfilled;705706 await expect(707 nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 708 `on adding property #${i} by signer #${j}`,709 ).to.be.fulfilled;710711 await expect(712 nestedToken.setProperties(signer, [{key, value: 'Serotonin stable'}]), 713 `on changing property #${i} by signer #${j}`,714 ).to.be.fulfilled;715 }716 }717718 const properties = await nestedToken.getProperties(propertyKeys);719 const tokenData = await nestedToken.getData();720 for (let i = 0; i < properties.length; i++) {721 expect(properties[i].value).to.be.equal('Serotonin stable');722 expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');723 }724 expect(await targetToken.getProperties()).to.be.empty;725 });726727 itSub('Deletes properties of a nested token according to permissions', async ({helper}) => {728 const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});729 const collectionB = await helper.nft.mintCollection(alice);730 const targetToken = await collectionA.mintToken(alice);731 const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());732733 await collectionB.addAdmin(alice, {Substrate: bob.address});734 await targetToken.transfer(alice, {Substrate: charlie.address});735736 const propertyKeys: string[] = [];737 let i = 0;738 for (const permission of permissions) {739 i++;740 if (!permission.permission.mutable) continue;741 742 let j = 0;743 for (const signer of permission.signers) {744 j++;745 const key = i + '_' + signer.address;746 propertyKeys.push(key);747748 await expect(749 nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 750 `on setting permission #${i} by alice`,751 ).to.be.fulfilled;752753 await expect(754 nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 755 `on adding property #${i} by signer #${j}`,756 ).to.be.fulfilled;757758 await expect(759 nestedToken.deleteProperties(signer, [key]), 760 `on deleting property #${i} by signer #${j}`,761 ).to.be.fulfilled;762 }763 }764765 expect(await nestedToken.getProperties(propertyKeys)).to.be.empty;766 expect((await nestedToken.getData())!.properties).to.be.empty;767 expect(await targetToken.getProperties()).to.be.empty;768 });769});770771describe('Negative Integration Test: Token Properties', () => {772 let alice: IKeyringPair; // collection owner773 let bob: IKeyringPair; // collection admin774 let charlie: IKeyringPair; // token owner775776 let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];777778 before(async () => {779 await usingPlaygrounds(async (helper, privateKey) => {780 const donor = await privateKey({filename: __filename});781 let dave: IKeyringPair;782 [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor);783784 // todo:playgrounds probably separate these tests later785 constitution = [786 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},787 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},788 {permission: {mutable: true, tokenOwner: true}, signers: [charlie], sinner: alice},789 {permission: {mutable: false, tokenOwner: true}, signers: [charlie], sinner: alice},790 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},791 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},792 ];793 });794 });795796 async function getConsumedSpace(api: any, collectionId: number, tokenId: number, mode: 'NFT' | 'RFT'): Promise<number> {797 return (await (mode == 'NFT' ? api.query.nonfungible : api.query.refungible).tokenProperties(collectionId, tokenId)).toJSON().consumedSpace;798 }799800 async function prepare(token: UniqueNFToken | UniqueRFToken, pieces: bigint): Promise<number> {801 await token.collection.addAdmin(alice, {Substrate: bob.address});802 await token.transfer(alice, {Substrate: charlie.address}, pieces);803804 let i = 0;805 for (const passage of constitution) {806 i++;807 const signer = passage.signers[0];808 809 await expect(810 token.collection.setTokenPropertyPermissions(alice, [{key: `${i}`, permission: passage.permission}]), 811 `on setting permission ${i} by alice`,812 ).to.be.fulfilled;813814 await expect(815 token.setProperties(signer, [{key: `${i}`, value: 'Serotonin increase'}]), 816 `on adding property ${i} by ${signer.address}`,817 ).to.be.fulfilled;818 }819820 const originalSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 821 return originalSpace;822 }823824 async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {825 const originalSpace = await prepare(token, pieces);826827 let i = 0;828 for (const forbiddance of constitution) {829 i++;830 if (!forbiddance.permission.mutable) continue;831832 await expect(833 token.setProperties(forbiddance.sinner, [{key: `${i}`, value: 'Serotonin down'}]), 834 `on failing to change property ${i} by the malefactor`,835 ).to.be.rejectedWith(/common\.NoPermission/);836837 await expect(838 token.deleteProperties(forbiddance.sinner, [`${i}`]), 839 `on failing to delete property ${i} by the malefactor`,840 ).to.be.rejectedWith(/common\.NoPermission/);841 }842843 const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 844 expect(consumedSpace).to.be.equal(originalSpace);845 }846847 itSub('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async ({helper}) => {848 const collection = await helper.nft.mintCollection(alice);849 const token = await collection.mintToken(alice);850 await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 1n);851 });852853 itSub.ifWithPallets('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {854 const collection = await helper.rft.mintCollection(alice);855 const token = await collection.mintToken(alice, 100n);856 await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 100n);857 });858859 async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {860 const originalSpace = await prepare(token, pieces);861862 let i = 0;863 for (const permission of constitution) {864 i++;865 if (permission.permission.mutable) continue;866867 await expect(868 token.setProperties(permission.signers[0], [{key: `${i}`, value: 'Serotonin down'}]), 869 `on failing to change property ${i} by signer #0`,870 ).to.be.rejectedWith(/common\.NoPermission/);871872 await expect(873 token.deleteProperties(permission.signers[0], [i.toString()]), 874 `on failing to delete property ${i} by signer #0`,875 ).to.be.rejectedWith(/common\.NoPermission/);876 }877 878 const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 879 expect(consumedSpace).to.be.equal(originalSpace);880 }881882 itSub('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async ({helper}) => {883 const collection = await helper.nft.mintCollection(alice);884 const token = await collection.mintToken(alice);885 await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 1n);886 });887888 itSub.ifWithPallets('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', [Pallets.ReFungible], async ({helper}) => {889 const collection = await helper.rft.mintCollection(alice);890 const token = await collection.mintToken(alice, 100n);891 await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 100n);892 });893894 async function testForbidsAddingPropertiesIfPropertyNotDeclared(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {895 const originalSpace = await prepare(token, pieces);896897 await expect(898 token.setProperties(alice, [{key: 'non-existent', value: 'I exist!'}]), 899 'on failing to add a previously non-existent property',900 ).to.be.rejectedWith(/common\.NoPermission/);901 902 await expect(903 token.collection.setTokenPropertyPermissions(alice, [{key: 'now-existent', permission: {}}]), 904 'on setting a new non-permitted property',905 ).to.be.fulfilled;906907 await expect(908 token.setProperties(alice, [{key: 'now-existent', value: 'I exist!'}]), 909 'on failing to add a property forbidden by the \'None\' permission',910 ).to.be.rejectedWith(/common\.NoPermission/);911912 expect(await token.getProperties(['non-existent', 'now-existent'])).to.be.empty;913 914 const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 915 expect(consumedSpace).to.be.equal(originalSpace);916 }917918 itSub('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async ({helper}) => {919 const collection = await helper.nft.mintCollection(alice);920 const token = await collection.mintToken(alice);921 await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 1n);922 });923924 itSub.ifWithPallets('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', [Pallets.ReFungible], async ({helper}) => {925 const collection = await helper.rft.mintCollection(alice);926 const token = await collection.mintToken(alice, 100n);927 await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 100n);928 });929930 async function testForbidsAddingTooManyProperties(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {931 const originalSpace = await prepare(token, pieces);932933 await expect(934 token.collection.setTokenPropertyPermissions(alice, [935 {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 936 {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},937 ]), 938 'on setting new permissions for properties',939 ).to.be.fulfilled;940941 // Mute the general tx parsing error942 {943 console.error = () => {};944 await expect(token.setProperties(alice, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]))945 .to.be.rejected;946 }947948 await expect(token.setProperties(alice, [949 {key: 'a_holy_book', value: 'word '.repeat(3277)}, 950 {key: 'young_years', value: 'neverending'.repeat(1490)},951 ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);952 953 expect(await token.getProperties(['a_holy_book', 'young_years'])).to.be.empty;954 const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 955 expect(consumedSpace).to.be.equal(originalSpace);956 }957958 itSub('Forbids adding too many properties to a token (NFT)', async ({helper}) => {959 const collection = await helper.nft.mintCollection(alice);960 const token = await collection.mintToken(alice);961 await testForbidsAddingTooManyProperties(token, 1n);962 });963964 itSub.ifWithPallets('Forbids adding too many properties to a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {965 const collection = await helper.rft.mintCollection(alice);966 const token = await collection.mintToken(alice, 100n);967 await testForbidsAddingTooManyProperties(token, 100n);968 });969});970971describe('ReFungible token properties permissions tests', () => {972 let alice: IKeyringPair;973 let bob: IKeyringPair;974 let charlie: IKeyringPair;975976 before(async function() {977 await usingPlaygrounds(async (helper, privateKey) => {978 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);979980 const donor = await privateKey({filename: __filename});981 [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);982 });983 });984985 async function prepare(helper: UniqueHelper): Promise<UniqueRFToken> {986 const collection = await helper.rft.mintCollection(alice);987 const token = await collection.mintToken(alice, 100n);988 989 await collection.addAdmin(alice, {Substrate: bob.address});990 await collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable: true, tokenOwner: true}}]);991 992 return token;993 }994995 itSub('Forbids adding token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) => {996 const token = await prepare(helper);997998 await token.transfer(alice, {Substrate: charlie.address}, 33n);9991000 await expect(token.setProperties(alice, [1001 {key: 'fractals', value: 'multiverse'}, 1002 ])).to.be.rejectedWith(/common\.NoPermission/);1003 });10041005 itSub('Forbids mutating token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) => {1006 const token = await prepare(helper);10071008 await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, tokenOwner: true}}]))1009 .to.be.fulfilled;10101011 await expect(token.setProperties(alice, [1012 {key: 'fractals', value: 'multiverse'}, 1013 ])).to.be.fulfilled;10141015 await token.transfer(alice, {Substrate: charlie.address}, 33n);10161017 await expect(token.setProperties(alice, [1018 {key: 'fractals', value: 'want to rule the world'}, 1019 ])).to.be.rejectedWith(/common\.NoPermission/);1020 });10211022 itSub('Forbids deleting token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) => {1023 const token = await prepare(helper);10241025 await expect(token.setProperties(alice, [1026 {key: 'fractals', value: 'one headline - why believe it'}, 1027 ])).to.be.fulfilled;10281029 await token.transfer(alice, {Substrate: charlie.address}, 33n);10301031 await expect(token.deleteProperties(alice, ['fractals'])).1032 to.be.rejectedWith(/common\.NoPermission/);1033 });10341035 itSub('Allows token property mutation with collectionOwner==true when admin doesn\'t have all pieces', async ({helper}) => {1036 const token = await prepare(helper);10371038 await token.transfer(alice, {Substrate: charlie.address}, 33n);10391040 await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, collectionAdmin: true}}]))1041 .to.be.fulfilled;10421043 await expect(token.setProperties(alice, [1044 {key: 'fractals', value: 'multiverse'}, 1045 ])).to.be.fulfilled;1046 });1047});tests/src/nesting/propertyPermissions.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/nesting/propertyPermissions.test.ts
@@ -0,0 +1,198 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, Pallets, usingPlaygrounds, expect} from '../util/playgrounds';
+import {UniqueNFTCollection, UniqueRFTCollection} from '../util/playgrounds/unique';
+
+describe('Integration Test: Access Rights to Token Properties', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
+ });
+ });
+
+ itSub('Reads access rights to properties of a collection', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice);
+ const propertyRights = (await helper.callRpc('api.query.common.collectionPropertyPermissions', [collection.collectionId])).toJSON();
+ expect(propertyRights).to.be.empty;
+ });
+
+ async function testSetsAccessRightsToProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {
+ await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true}}]))
+ .to.be.fulfilled;
+
+ await collection.addAdmin(alice, {Substrate: bob.address});
+
+ await expect(collection.setTokenPropertyPermissions(bob, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]))
+ .to.be.fulfilled;
+
+ const propertyRights = await collection.getPropertyPermissions(['skullduggery', 'mindgame']);
+ expect(propertyRights).to.include.deep.members([
+ {key: 'skullduggery', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}},
+ {key: 'mindgame', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
+ ]);
+ }
+
+ itSub('Sets access rights to properties of a collection (NFT)', async ({helper}) => {
+ await testSetsAccessRightsToProperties(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Sets access rights to properties of a collection (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testSetsAccessRightsToProperties(await helper.rft.mintCollection(alice));
+ });
+
+ async function testChangesAccessRightsToProperty(collection: UniqueNFTCollection | UniqueRFTCollection) {
+ await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]))
+ .to.be.fulfilled;
+
+ await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
+ .to.be.fulfilled;
+
+ const propertyRights = await collection.getPropertyPermissions();
+ expect(propertyRights).to.be.deep.equal([
+ {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
+ ]);
+ }
+
+ itSub('Changes access rights to properties of a NFT collection', async ({helper}) => {
+ await testChangesAccessRightsToProperty(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Changes access rights to properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ await testChangesAccessRightsToProperty(await helper.rft.mintCollection(alice));
+ });
+});
+
+describe('Negative Integration Test: Access Rights to Token Properties', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);
+ });
+ });
+
+ async function testPreventsFromSettingAccessRightsNotAdminOrOwner(collection: UniqueNFTCollection | UniqueRFTCollection) {
+ await expect(collection.setTokenPropertyPermissions(bob, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]))
+ .to.be.rejectedWith(/common\.NoPermission/);
+
+ const propertyRights = await collection.getPropertyPermissions(['skullduggery']);
+ expect(propertyRights).to.be.empty;
+ }
+
+ itSub('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async ({helper}) => {
+ await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', [Pallets.ReFungible], async ({helper}) => {
+ await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.rft.mintCollection(alice));
+ });
+
+ async function testPreventFromAddingTooManyPossibleProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {
+ const constitution = [];
+ for (let i = 0; i < 65; i++) {
+ constitution.push({
+ key: 'property_' + i,
+ permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},
+ });
+ }
+
+ await expect(collection.setTokenPropertyPermissions(alice, constitution))
+ .to.be.rejectedWith(/common\.PropertyLimitReached/);
+
+ const propertyRights = await collection.getPropertyPermissions();
+ expect(propertyRights).to.be.empty;
+ }
+
+ itSub('Prevents from adding too many possible properties (NFT)', async ({helper}) => {
+ await testPreventFromAddingTooManyPossibleProperties(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Prevents from adding too many possible properties (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testPreventFromAddingTooManyPossibleProperties(await helper.rft.mintCollection(alice));
+ });
+
+ async function testPreventAccessRightsModifiedIfConstant(collection: UniqueNFTCollection | UniqueRFTCollection) {
+ await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
+ .to.be.fulfilled;
+
+ await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {collectionAdmin: true}}]))
+ .to.be.rejectedWith(/common\.NoPermission/);
+
+ const propertyRights = await collection.getPropertyPermissions(['skullduggery']);
+ expect(propertyRights).to.deep.equal([
+ {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
+ ]);
+ }
+
+ itSub('Prevents access rights to be modified if constant (NFT)', async ({helper}) => {
+ await testPreventAccessRightsModifiedIfConstant(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Prevents access rights to be modified if constant (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testPreventAccessRightsModifiedIfConstant(await helper.rft.mintCollection(alice));
+ });
+
+ async function testPreventsAddingPropertiesWithInvalidNames(collection: UniqueNFTCollection | UniqueRFTCollection) {
+ const invalidProperties = [
+ [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],
+ [{key: 'G#4', permission: {tokenOwner: true}}],
+ [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],
+ ];
+
+ for (let i = 0; i < invalidProperties.length; i++) {
+ await expect(
+ collection.setTokenPropertyPermissions(alice, invalidProperties[i]),
+ `on setting the new badly-named property #${i}`,
+ ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
+ }
+
+ await expect(
+ collection.setTokenPropertyPermissions(alice, [{key: '', permission: {}}]),
+ 'on rejecting an unnamed property',
+ ).to.be.rejectedWith(/common\.EmptyPropertyKey/);
+
+ const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string
+ await expect(
+ collection.setTokenPropertyPermissions(alice, [
+ {key: correctKey, permission: {collectionAdmin: true}},
+ ]),
+ 'on setting the correctly-but-still-badly-named property',
+ ).to.be.fulfilled;
+
+ const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');
+
+ const propertyRights = await collection.getPropertyPermissions(keys);
+ expect(propertyRights).to.be.deep.equal([
+ {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
+ ]);
+ }
+
+ itSub('Prevents adding properties with invalid names (NFT)', async ({helper}) => {
+ await testPreventsAddingPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));
+ });
+
+ itSub.ifWithPallets('Prevents adding properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ await testPreventsAddingPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));
+ });
+});
\ No newline at end of file
tests/src/nesting/tokenProperties.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/nesting/tokenProperties.test.ts
@@ -0,0 +1,594 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from '../util/playgrounds';
+import {UniqueHelper, UniqueNFToken, UniqueRFToken} from '../util/playgrounds/unique';
+
+describe('Integration Test: Token Properties', () => {
+ let alice: IKeyringPair; // collection owner
+ let bob: IKeyringPair; // collection admin
+ let charlie: IKeyringPair; // token owner
+
+ let permissions: {permission: any, signers: IKeyringPair[]}[];
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+ });
+
+ permissions = [
+ {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},
+ {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},
+ {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},
+ {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},
+ {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
+ {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
+ ];
+ });
+
+ async function mintCollectionWithAllPermissionsAndToken(helper: UniqueHelper, mode: 'NFT' | 'RFT'): Promise<[UniqueNFToken | UniqueRFToken, bigint]> {
+ const collection = await (mode == 'NFT' ? helper.nft : helper.rft).mintCollection(alice, {
+ tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
+ signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),
+ });
+ return mode == 'NFT' ? [await collection.mintToken(alice), 1n] : [await collection.mintToken(alice, 100n), 100n];
+ }
+
+ async function testReadsYetEmptyProperties(token: UniqueNFToken | UniqueRFToken) {
+ const properties = await token.getProperties();
+ expect(properties).to.be.empty;
+
+ const tokenData = await token.getData();
+ expect(tokenData!.properties).to.be.empty;
+ }
+
+ itSub('Reads yet empty properties of a token (NFT)', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice);
+ const token = await collection.mintToken(alice);
+ await testReadsYetEmptyProperties(token);
+ });
+
+ itSub.ifWithPallets('Reads yet empty properties of a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice);
+ const token = await collection.mintToken(alice);
+ await testReadsYetEmptyProperties(token);
+ });
+
+ async function testAssignPropertiesAccordingToPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ await token.collection.addAdmin(alice, {Substrate: bob.address});
+ await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+ const propertyKeys: string[] = [];
+ let i = 0;
+ for (const permission of permissions) {
+ i++;
+ let j = 0;
+ for (const signer of permission.signers) {
+ j++;
+ const key = i + '_' + signer.address;
+ propertyKeys.push(key);
+
+ await expect(
+ token.setProperties(signer, [{key: key, value: 'Serotonin increase'}]),
+ `on adding property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+ }
+ }
+
+ const properties = await token.getProperties(propertyKeys);
+ const tokenData = await token.getData();
+ for (let i = 0; i < properties.length; i++) {
+ expect(properties[i].value).to.be.equal('Serotonin increase');
+ expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');
+ }
+ }
+
+ itSub('Assigns properties to a token according to permissions (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testAssignPropertiesAccordingToPermissions(token, amount);
+ });
+
+ itSub.ifWithPallets('Assigns properties to a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testAssignPropertiesAccordingToPermissions(token, amount);
+ });
+
+ async function testChangesPropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ await token.collection.addAdmin(alice, {Substrate: bob.address});
+ await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+ const propertyKeys: string[] = [];
+ let i = 0;
+ for (const permission of permissions) {
+ i++;
+ if (!permission.permission.mutable) continue;
+
+ let j = 0;
+ for (const signer of permission.signers) {
+ j++;
+ const key = i + '_' + signer.address;
+ propertyKeys.push(key);
+
+ await expect(
+ token.setProperties(signer, [{key, value: 'Serotonin increase'}]),
+ `on adding property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+
+ await expect(
+ token.setProperties(signer, [{key, value: 'Serotonin stable'}]),
+ `on changing property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+ }
+ }
+
+ const properties = await token.getProperties(propertyKeys);
+ const tokenData = await token.getData();
+ for (let i = 0; i < properties.length; i++) {
+ expect(properties[i].value).to.be.equal('Serotonin stable');
+ expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');
+ }
+ }
+
+ itSub('Changes properties of a token according to permissions (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testChangesPropertiesAccordingPermission(token, amount);
+ });
+
+ itSub.ifWithPallets('Changes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testChangesPropertiesAccordingPermission(token, amount);
+ });
+
+ async function testDeletePropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ await token.collection.addAdmin(alice, {Substrate: bob.address});
+ await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+ const propertyKeys: string[] = [];
+ let i = 0;
+
+ for (const permission of permissions) {
+ i++;
+ if (!permission.permission.mutable) continue;
+
+ let j = 0;
+ for (const signer of permission.signers) {
+ j++;
+ const key = i + '_' + signer.address;
+ propertyKeys.push(key);
+
+ await expect(
+ token.setProperties(signer, [{key, value: 'Serotonin increase'}]),
+ `on adding property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+
+ await expect(
+ token.deleteProperties(signer, [key]),
+ `on deleting property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+ }
+ }
+
+ expect(await token.getProperties(propertyKeys)).to.be.empty;
+ expect((await token.getData())!.properties).to.be.empty;
+ }
+
+ itSub('Deletes properties of a token according to permissions (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testDeletePropertiesAccordingPermission(token, amount);
+ });
+
+ itSub.ifWithPallets('Deletes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testDeletePropertiesAccordingPermission(token, amount);
+ });
+
+ itSub('Assigns properties to a nested token according to permissions', async ({helper}) => {
+ const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+ const collectionB = await helper.nft.mintCollection(alice, {
+ tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
+ signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),
+ });
+ const targetToken = await collectionA.mintToken(alice);
+ const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
+
+ await collectionB.addAdmin(alice, {Substrate: bob.address});
+ await targetToken.transfer(alice, {Substrate: charlie.address});
+
+ const propertyKeys: string[] = [];
+ let i = 0;
+ for (const permission of permissions) {
+ i++;
+ let j = 0;
+ for (const signer of permission.signers) {
+ j++;
+ const key = i + '_' + signer.address;
+ propertyKeys.push(key);
+
+ await expect(
+ nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]),
+ `on adding property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+ }
+ }
+
+ const properties = await nestedToken.getProperties(propertyKeys);
+ const tokenData = await nestedToken.getData();
+ for (let i = 0; i < properties.length; i++) {
+ expect(properties[i].value).to.be.equal('Serotonin increase');
+ expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');
+ }
+ expect(await targetToken.getProperties()).to.be.empty;
+ });
+
+ itSub('Changes properties of a nested token according to permissions', async ({helper}) => {
+ const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+ const collectionB = await helper.nft.mintCollection(alice, {
+ tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
+ signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),
+ });
+ const targetToken = await collectionA.mintToken(alice);
+ const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
+
+ await collectionB.addAdmin(alice, {Substrate: bob.address});
+ await targetToken.transfer(alice, {Substrate: charlie.address});
+
+ const propertyKeys: string[] = [];
+ let i = 0;
+ for (const permission of permissions) {
+ i++;
+ if (!permission.permission.mutable) continue;
+
+ let j = 0;
+ for (const signer of permission.signers) {
+ j++;
+ const key = i + '_' + signer.address;
+ propertyKeys.push(key);
+
+ await expect(
+ nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]),
+ `on adding property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+
+ await expect(
+ nestedToken.setProperties(signer, [{key, value: 'Serotonin stable'}]),
+ `on changing property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+ }
+ }
+
+ const properties = await nestedToken.getProperties(propertyKeys);
+ const tokenData = await nestedToken.getData();
+ for (let i = 0; i < properties.length; i++) {
+ expect(properties[i].value).to.be.equal('Serotonin stable');
+ expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');
+ }
+ expect(await targetToken.getProperties()).to.be.empty;
+ });
+
+ itSub('Deletes properties of a nested token according to permissions', async ({helper}) => {
+ const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+ const collectionB = await helper.nft.mintCollection(alice, {
+ tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
+ signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),
+ });
+ const targetToken = await collectionA.mintToken(alice);
+ const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
+
+ await collectionB.addAdmin(alice, {Substrate: bob.address});
+ await targetToken.transfer(alice, {Substrate: charlie.address});
+
+ const propertyKeys: string[] = [];
+ let i = 0;
+ for (const permission of permissions) {
+ i++;
+ if (!permission.permission.mutable) continue;
+
+ let j = 0;
+ for (const signer of permission.signers) {
+ j++;
+ const key = i + '_' + signer.address;
+ propertyKeys.push(key);
+
+ await expect(
+ nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]),
+ `on adding property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+
+ await expect(
+ nestedToken.deleteProperties(signer, [key]),
+ `on deleting property #${i} by signer #${j}`,
+ ).to.be.fulfilled;
+ }
+ }
+
+ expect(await nestedToken.getProperties(propertyKeys)).to.be.empty;
+ expect((await nestedToken.getData())!.properties).to.be.empty;
+ expect(await targetToken.getProperties()).to.be.empty;
+ });
+});
+
+describe('Negative Integration Test: Token Properties', () => {
+ let alice: IKeyringPair; // collection owner
+ let bob: IKeyringPair; // collection admin
+ let charlie: IKeyringPair; // token owner
+
+ let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ let dave: IKeyringPair;
+ [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor);
+
+ // todo:playgrounds probably separate these tests later
+ constitution = [
+ {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},
+ {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},
+ {permission: {mutable: true, tokenOwner: true}, signers: [charlie], sinner: alice},
+ {permission: {mutable: false, tokenOwner: true}, signers: [charlie], sinner: alice},
+ {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},
+ {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},
+ ];
+ });
+ });
+
+ async function mintCollectionWithAllPermissionsAndToken(helper: UniqueHelper, mode: 'NFT' | 'RFT'): Promise<[UniqueNFToken | UniqueRFToken, bigint]> {
+ const collection = await (mode == 'NFT' ? helper.nft : helper.rft).mintCollection(alice, {
+ tokenPropertyPermissions: constitution.map(({permission}, i) => {return {key: `${i+1}`, permission};}),
+ });
+ return mode == 'NFT' ? [await collection.mintToken(alice), 1n] : [await collection.mintToken(alice, 100n), 100n];
+ }
+
+ async function getConsumedSpace(api: any, collectionId: number, tokenId: number, mode: 'NFT' | 'RFT'): Promise<number> {
+ return (await (mode == 'NFT' ? api.query.nonfungible : api.query.refungible).tokenProperties(collectionId, tokenId)).toJSON().consumedSpace;
+ }
+
+ async function prepare(token: UniqueNFToken | UniqueRFToken, pieces: bigint): Promise<number> {
+ await token.collection.addAdmin(alice, {Substrate: bob.address});
+ await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+ let i = 0;
+ for (const passage of constitution) {
+ i++;
+ const signer = passage.signers[0];
+ await expect(
+ token.setProperties(signer, [{key: `${i}`, value: 'Serotonin increase'}]),
+ `on adding property ${i} by ${signer.address}`,
+ ).to.be.fulfilled;
+ }
+
+ const originalSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT');
+ return originalSpace;
+ }
+
+ async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ const originalSpace = await prepare(token, pieces);
+
+ let i = 0;
+ for (const forbiddance of constitution) {
+ i++;
+ if (!forbiddance.permission.mutable) continue;
+
+ await expect(
+ token.setProperties(forbiddance.sinner, [{key: `${i}`, value: 'Serotonin down'}]),
+ `on failing to change property ${i} by the malefactor`,
+ ).to.be.rejectedWith(/common\.NoPermission/);
+
+ await expect(
+ token.deleteProperties(forbiddance.sinner, [`${i}`]),
+ `on failing to delete property ${i} by the malefactor`,
+ ).to.be.rejectedWith(/common\.NoPermission/);
+ }
+
+ const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT');
+ expect(consumedSpace).to.be.equal(originalSpace);
+ }
+
+ itSub('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, amount);
+ });
+
+ itSub.ifWithPallets('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, amount);
+ });
+
+ async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ const originalSpace = await prepare(token, pieces);
+
+ let i = 0;
+ for (const permission of constitution) {
+ i++;
+ if (permission.permission.mutable) continue;
+
+ await expect(
+ token.setProperties(permission.signers[0], [{key: `${i}`, value: 'Serotonin down'}]),
+ `on failing to change property ${i} by signer #0`,
+ ).to.be.rejectedWith(/common\.NoPermission/);
+
+ await expect(
+ token.deleteProperties(permission.signers[0], [i.toString()]),
+ `on failing to delete property ${i} by signer #0`,
+ ).to.be.rejectedWith(/common\.NoPermission/);
+ }
+
+ const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT');
+ expect(consumedSpace).to.be.equal(originalSpace);
+ }
+
+ itSub('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, amount);
+ });
+
+ itSub.ifWithPallets('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, amount);
+ });
+
+ async function testForbidsAddingPropertiesIfPropertyNotDeclared(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ const originalSpace = await prepare(token, pieces);
+
+ await expect(
+ token.setProperties(alice, [{key: 'non-existent', value: 'I exist!'}]),
+ 'on failing to add a previously non-existent property',
+ ).to.be.rejectedWith(/common\.NoPermission/);
+
+ await expect(
+ token.collection.setTokenPropertyPermissions(alice, [{key: 'now-existent', permission: {}}]),
+ 'on setting a new non-permitted property',
+ ).to.be.fulfilled;
+
+ await expect(
+ token.setProperties(alice, [{key: 'now-existent', value: 'I exist!'}]),
+ 'on failing to add a property forbidden by the \'None\' permission',
+ ).to.be.rejectedWith(/common\.NoPermission/);
+
+ expect(await token.getProperties(['non-existent', 'now-existent'])).to.be.empty;
+
+ const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT');
+ expect(consumedSpace).to.be.equal(originalSpace);
+ }
+
+ itSub('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testForbidsAddingPropertiesIfPropertyNotDeclared(token, amount);
+ });
+
+ itSub.ifWithPallets('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testForbidsAddingPropertiesIfPropertyNotDeclared(token, amount);
+ });
+
+ async function testForbidsAddingTooManyProperties(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
+ const originalSpace = await prepare(token, pieces);
+
+ await expect(
+ token.collection.setTokenPropertyPermissions(alice, [
+ {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}},
+ {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},
+ ]),
+ 'on setting new permissions for properties',
+ ).to.be.fulfilled;
+
+ // Mute the general tx parsing error
+ {
+ console.error = () => {};
+ await expect(token.setProperties(alice, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]))
+ .to.be.rejected;
+ }
+
+ await expect(token.setProperties(alice, [
+ {key: 'a_holy_book', value: 'word '.repeat(3277)},
+ {key: 'young_years', value: 'neverending'.repeat(1490)},
+ ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);
+
+ expect(await token.getProperties(['a_holy_book', 'young_years'])).to.be.empty;
+ const consumedSpace = await getConsumedSpace(token.collection.helper.getApi(), token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT');
+ expect(consumedSpace).to.be.equal(originalSpace);
+ }
+
+ itSub('Forbids adding too many properties to a token (NFT)', async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'NFT');
+ await testForbidsAddingTooManyProperties(token, amount);
+ });
+
+ itSub.ifWithPallets('Forbids adding too many properties to a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+ const [token, amount] = await mintCollectionWithAllPermissionsAndToken(helper, 'RFT');
+ await testForbidsAddingTooManyProperties(token, amount);
+ });
+});
+
+describe('ReFungible token properties permissions tests', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
+
+ before(async function() {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
+
+ const donor = await privateKey({filename: __filename});
+ [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+ });
+ });
+
+ async function prepare(helper: UniqueHelper): Promise<UniqueRFToken> {
+ const collection = await helper.rft.mintCollection(alice);
+ const token = await collection.mintToken(alice, 100n);
+
+ await collection.addAdmin(alice, {Substrate: bob.address});
+ await collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable: true, tokenOwner: true}}]);
+
+ return token;
+ }
+
+ itSub('Forbids adding token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) => {
+ const token = await prepare(helper);
+
+ await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+ await expect(token.setProperties(alice, [
+ {key: 'fractals', value: 'multiverse'},
+ ])).to.be.rejectedWith(/common\.NoPermission/);
+ });
+
+ itSub('Forbids mutating token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) => {
+ const token = await prepare(helper);
+
+ await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, tokenOwner: true}}]))
+ .to.be.fulfilled;
+
+ await expect(token.setProperties(alice, [
+ {key: 'fractals', value: 'multiverse'},
+ ])).to.be.fulfilled;
+
+ await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+ await expect(token.setProperties(alice, [
+ {key: 'fractals', value: 'want to rule the world'},
+ ])).to.be.rejectedWith(/common\.NoPermission/);
+ });
+
+ itSub('Forbids deleting token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) => {
+ const token = await prepare(helper);
+
+ await expect(token.setProperties(alice, [
+ {key: 'fractals', value: 'one headline - why believe it'},
+ ])).to.be.fulfilled;
+
+ await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+ await expect(token.deleteProperties(alice, ['fractals'])).
+ to.be.rejectedWith(/common\.NoPermission/);
+ });
+
+ itSub('Allows token property mutation with collectionOwner==true when admin doesn\'t have all pieces', async ({helper}) => {
+ const token = await prepare(helper);
+
+ await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+ await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, collectionAdmin: true}}]))
+ .to.be.fulfilled;
+
+ await expect(token.setProperties(alice, [
+ {key: 'fractals', value: 'multiverse'},
+ ])).to.be.fulfilled;
+ });
+});