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

71    "testRemoveFromContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractAllowList.test.ts",71    "testRemoveFromContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractAllowList.test.ts",
72    "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",72    "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",
73    "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts",73    "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts",
74    "testNextSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/nextSponsoring.test.ts",
74    "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts",75    "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts",
75    "testInflation": "mocha --timeout 9999999 -r ts-node/register ./**/inflation.test.ts",76    "testInflation": "mocha --timeout 9999999 -r ts-node/register ./**/inflation.test.ts",
76    "testScheduler": "mocha --timeout 9999999 -r ts-node/register ./**/scheduler.test.ts",77    "testScheduler": "mocha --timeout 9999999 -r ts-node/register ./**/scheduler.test.ts",
97  "dependencies": {98  "dependencies": {
98    "@polkadot/api": "9.2.2",99    "@polkadot/api": "9.2.2",
99    "@polkadot/api-contract": "9.2.2",100    "@polkadot/api-contract": "9.2.2",
100    "@polkadot/util-crypto": "10.1.1",101    "@polkadot/util-crypto": "10.1.7",
101    "bignumber.js": "^9.0.2",102    "bignumber.js": "^9.0.2",
102    "chai-as-promised": "^7.1.1",103    "chai-as-promised": "^7.1.1",
103    "chai-like": "^1.1.1",104    "chai-like": "^1.1.1",

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import chai from 'chai';
19import chaiAsPromised from 'chai-as-promised';
20import {usingPlaygrounds} from './util/playgrounds';18import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
21
22chai.use(chaiAsPromised);
23const expect = chai.expect;
24
25let donor: IKeyringPair;
26
27before(async () => {
28  await usingPlaygrounds(async (_, privateKeyWrapper) => {
29    donor = privateKeyWrapper('//Alice');
30  });
31});
3219
33describe('Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {20describe('Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {
21  let donor: IKeyringPair;
22
23  before(async () => {
24    await usingPlaygrounds(async (_, privateKeyWrapper) => {
25      donor = privateKeyWrapper('//Alice');
26    });
27  });
28
34  it('Add collection admin.', async () => {29  itSub('Add collection admin.', async ({helper}) => {
35    await usingPlaygrounds(async (helper) => {
36      const [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);30    const [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
37      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});31    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
3832
39      const collection = await helper.collection.getData(collectionId);33    const collection = await helper.collection.getData(collectionId);
40      expect(collection!.normalizedOwner!).to.be.equal(alice.address);34    expect(collection!.normalizedOwner!).to.be.equal(helper.address.normalizeSubstrate(alice.address));
4135
42      await helper.nft.addAdmin(alice, collectionId, {Substrate: bob.address});36    await helper.nft.addAdmin(alice, collectionId, {Substrate: bob.address});
4337
44      const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);38    const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
45      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});39    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
46    });
47  });40  });
48});41});
4942
50describe('Negative Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {43describe('Negative Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {
44  let donor: IKeyringPair;
45
46  before(async () => {
47    await usingPlaygrounds(async (_, privateKeyWrapper) => {
48      donor = privateKeyWrapper('//Alice');
49    });
50  });
51
51  it("Not owner can't add collection admin.", async () => {52  itSub("Not owner can't add collection admin.", async ({helper}) => {
52    await usingPlaygrounds(async (helper) => {
53      const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);53    const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
54      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});54    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
5555
56      const collection = await helper.collection.getData(collectionId);56    const collection = await helper.collection.getData(collectionId);
57      expect(collection?.normalizedOwner).to.be.equal(alice.address);57    expect(collection?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
5858
59      const changeAdminTxBob = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address});59    const changeAdminTxBob = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address});
60      const changeAdminTxCharlie = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address});60    const changeAdminTxCharlie = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address});
61      await expect(changeAdminTxCharlie()).to.be.rejected;61    await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
62      await expect(changeAdminTxBob()).to.be.rejected;62    await expect(changeAdminTxBob()).to.be.rejectedWith(/common\.NoPermission/);
6363
64      const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);64    const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
65      expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: charlie.address});65    expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: charlie.address});
66      expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: bob.address});66    expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: bob.address});
67    });
68  });67  });
6968
70  it("Admin can't add collection admin.", async () => {69  itSub("Admin can't add collection admin.", async ({helper}) => {
71    await usingPlaygrounds(async (helper) => {
72      const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);70    const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
73      const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});71    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
7472
78      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});76    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
7977
80      const changeAdminTxCharlie = async () => collection.addAdmin(bob, {Substrate: charlie.address});78    const changeAdminTxCharlie = async () => collection.addAdmin(bob, {Substrate: charlie.address});
81      await expect(changeAdminTxCharlie()).to.be.rejected;79    await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
8280
83      const adminListAfterAddNewAdmin = await collection.getAdmins();81    const adminListAfterAddNewAdmin = await collection.getAdmins();
84      expect(adminListAfterAddNewAdmin).to.be.deep.contains({Substrate: bob.address});82    expect(adminListAfterAddNewAdmin).to.be.deep.contains({Substrate: bob.address});
85      expect(adminListAfterAddNewAdmin).to.be.not.deep.contains({Substrate: charlie.address});83    expect(adminListAfterAddNewAdmin).to.be.not.deep.contains({Substrate: charlie.address});
86    });
87  });84  });
8885
89  it("Can't add collection admin of not existing collection.", async () => {86  itSub("Can't add collection admin of not existing collection.", async ({helper}) => {
90    await usingPlaygrounds(async (helper) => {
91      const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);87    const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
92      // tslint:disable-next-line: no-bitwise
93      const collectionId = (1 << 32) - 1;88    const collectionId = (1 << 32) - 1;
9489
95      const addAdminTx = async () => helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});90    const addAdminTx = async () => helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
96      await expect(addAdminTx()).to.be.rejected;91    await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
9792
98      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)93    // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
99      await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});94    await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
100    });
101  });95  });
10296
103  it("Can't add an admin to a destroyed collection.", async () => {97  itSub("Can't add an admin to a destroyed collection.", async ({helper}) => {
104    await usingPlaygrounds(async (helper) => {
105      const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);98    const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
106      const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});99    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
107100
108      await collection.burn(alice);101    await collection.burn(alice);
109      const addAdminTx = async () => collection.addAdmin(alice, {Substrate: bob.address});102    const addAdminTx = async () => collection.addAdmin(alice, {Substrate: bob.address});
110      await expect(addAdminTx()).to.be.rejected;103    await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
111104
112      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)105    // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
113      await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});106    await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
114    });
115  });107  });
116108
117  it('Add an admin to a collection that has reached the maximum number of admins limit', async () => {109  itSub('Add an admin to a collection that has reached the maximum number of admins limit', async ({helper}) => {
118    await usingPlaygrounds(async (helper) => {
119      const [alice, ...accounts] = await helper.arrange.createAccounts([10n, 0n, 0n, 0n, 0n, 0n, 0n, 0n], donor);110    const [alice, ...accounts] = await helper.arrange.createAccounts([10n, 0n, 0n, 0n, 0n, 0n, 0n, 0n], donor);
120      const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});111    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
121112
129      }120    }
130121
131      const addExtraAdminTx = async () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});122    const addExtraAdminTx = async () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});
132      await expect(addExtraAdminTx()).to.be.rejected;123    await expect(addExtraAdminTx()).to.be.rejectedWith(/common\.CollectionAdminCountExceeded/);
133    });
134  });124  });
135});125});
136126

no syntactic changes

20  let donor: IKeyringPair;20  let donor: IKeyringPair;
2121
22  before(async function() {22  before(async function() {
23    await usingEthPlaygrounds(async (helper, privateKey) => {23    await usingEthPlaygrounds(async (_, privateKey) => {
24      donor = privateKey('//Alice');24      donor = privateKey('//Alice');
25    });25    });
26  });26  });

22  let donor: IKeyringPair;22  let donor: IKeyringPair;
2323
24  before(async function() {24  before(async function() {
25    await usingEthPlaygrounds(async (helper, privateKey) => {25    await usingEthPlaygrounds(async (_, privateKey) => {
26      donor = privateKey('//Alice');26      donor = privateKey('//Alice');
27    });27    });
28  });28  });

2// SPDX-License-Identifier: Apache-2.02// SPDX-License-Identifier: Apache-2.0
33
4/* eslint-disable function-call-argument-newline */4/* eslint-disable function-call-argument-newline */
5// eslint-disable-next-line @typescript-eslint/triple-slash-reference
6/// <reference path="unique.dev.d.ts" />
57
6import {readFile} from 'fs/promises';8import {readFile} from 'fs/promises';
79

17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {U128_MAX} from './util/helpers';18import {U128_MAX} from './util/helpers';
19
20import {usingPlaygrounds} from './util/playgrounds';19import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
2120
22import chai from 'chai';21// todo:playgrounds get rid of globals
23import chaiAsPromised from 'chai-as-promised';
24chai.use(chaiAsPromised);
25const expect = chai.expect;
26
27let alice: IKeyringPair;22let alice: IKeyringPair;
28let bob: IKeyringPair;23let bob: IKeyringPair;
35    });30    });
36  });31  });
3732
38  it('Create fungible collection and token', async () => {33  itSub('Create fungible collection and token', async ({helper}) => {
39    await usingPlaygrounds(async helper => {
40      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'trest'});34    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'trest'});
41      const defaultTokenId = await collection.getLastTokenId();35    const defaultTokenId = await collection.getLastTokenId();
42      expect(defaultTokenId).to.be.equal(0);36    expect(defaultTokenId).to.be.equal(0);
4337
44      await collection.mint(alice, {Substrate: alice.address}, U128_MAX);38    await collection.mint(alice, U128_MAX);
45      const aliceBalance = await collection.getBalance({Substrate: alice.address});39    const aliceBalance = await collection.getBalance({Substrate: alice.address});
46      const itemCountAfter = await collection.getLastTokenId();40    const itemCountAfter = await collection.getLastTokenId();
4741
48      expect(itemCountAfter).to.be.equal(defaultTokenId);42    expect(itemCountAfter).to.be.equal(defaultTokenId);
49      expect(aliceBalance).to.be.equal(U128_MAX);43    expect(aliceBalance).to.be.equal(U128_MAX);
50    });
51  });44  });
52  45  
53  it('RPC method tokenOnewrs for fungible collection and token', async () => {46  itSub('RPC method tokenOnewrs for fungible collection and token', async ({helper, privateKey}) => {
54    await usingPlaygrounds(async (helper, privateKey) => {
55      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};47    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
56      const facelessCrowd = Array(7).fill(0).map((_, i) => ({Substrate: privateKey(`//Alice+${i}`).address}));48    const facelessCrowd = Array(7).fill(0).map((_, i) => ({Substrate: privateKey(`//Alice+${i}`).address}));
5749
58      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});50    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
5951
60      await collection.mint(alice, {Substrate: alice.address}, U128_MAX);52    await collection.mint(alice, U128_MAX);
6153
62      await collection.transfer(alice, {Substrate: bob.address}, 1000n);54    await collection.transfer(alice, {Substrate: bob.address}, 1000n);
63      await collection.transfer(alice, ethAcc, 900n);55    await collection.transfer(alice, ethAcc, 900n);
75      const eleven = privateKey('//ALice+11');67    const eleven = privateKey('//ALice+11');
76      expect(await collection.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;68    expect(await collection.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;
77      expect((await collection.getTop10Owners()).length).to.be.equal(10);69    expect((await collection.getTop10Owners()).length).to.be.equal(10);
78    });
79  });70  });
80  71  
81  it('Transfer token', async () => {72  itSub('Transfer token', async ({helper}) => {
82    await usingPlaygrounds(async helper => {
83      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};73    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
84      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});74    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
85      await collection.mint(alice, {Substrate: alice.address}, 500n);75    await collection.mint(alice, 500n);
8676
87      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);77    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
88      expect(await collection.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;78    expect(await collection.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
93      expect(await collection.getBalance(ethAcc)).to.be.equal(140n);83    expect(await collection.getBalance(ethAcc)).to.be.equal(140n);
9484
95      await expect(collection.transfer(alice, {Substrate: bob.address}, 350n)).to.eventually.be.rejected;85    await expect(collection.transfer(alice, {Substrate: bob.address}, 350n)).to.eventually.be.rejected;
96    });
97  });86  });
9887
99  it('Tokens multiple creation', async () => {88  itSub('Tokens multiple creation', async ({helper}) => {
100    await usingPlaygrounds(async helper => {
101      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});89    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
10290
103      await collection.mintWithOneOwner(alice, {Substrate: alice.address}, [91    await collection.mintWithOneOwner(alice, [
104        {value: 500n},92      {value: 500n},
105        {value: 400n},93      {value: 400n},
106        {value: 300n},94      {value: 300n},
107      ]);95    ]);
10896
109      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1200n);97    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1200n);
110    });
111  });98  });
11299
113  it('Burn some tokens ', async () => {100  itSub('Burn some tokens ', async ({helper}) => {
114    await usingPlaygrounds(async helper => {
115      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});101    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
116      await collection.mint(alice, {Substrate: alice.address}, 500n);102    await collection.mint(alice, 500n);
117103
118      expect(await collection.isTokenExists(0)).to.be.true;104    expect(await collection.isTokenExists(0)).to.be.true;
119      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);105    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
120      expect(await collection.burnTokens(alice, 499n)).to.be.true;106    expect(await collection.burnTokens(alice, 499n)).to.be.true;
121      expect(await collection.isTokenExists(0)).to.be.true;107    expect(await collection.isTokenExists(0)).to.be.true;
122      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);108    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);
123    });
124  });109  });
125  110  
126  it('Burn all tokens ', async () => {111  itSub('Burn all tokens ', async ({helper}) => {
127    await usingPlaygrounds(async helper => {
128      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});112    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
129      await collection.mint(alice, {Substrate: alice.address}, 500n);113    await collection.mint(alice, 500n);
130114
131      expect(await collection.isTokenExists(0)).to.be.true;115    expect(await collection.isTokenExists(0)).to.be.true;
132      expect(await collection.burnTokens(alice, 500n)).to.be.true;116    expect(await collection.burnTokens(alice, 500n)).to.be.true;
133      expect(await collection.isTokenExists(0)).to.be.true;117    expect(await collection.isTokenExists(0)).to.be.true;
134118
135      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);119    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);
136      expect(await collection.getTotalPieces()).to.be.equal(0n);120    expect(await collection.getTotalPieces()).to.be.equal(0n);
137    });
138  });121  });
139122
140  it('Set allowance for token', async () => {123  itSub('Set allowance for token', async ({helper}) => {
141    await usingPlaygrounds(async helper => {
142      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});124    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
143      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};125    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
144      await collection.mint(alice, {Substrate: alice.address}, 100n);126    await collection.mint(alice, 100n);
145127
146      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(100n);128    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(100n);
147      129    
160      expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(30n);142    expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(30n);
161      expect(await collection.transferFrom(bob, {Substrate: alice.address}, ethAcc, 10n)).to.be.true;143    expect(await collection.transferFrom(bob, {Substrate: alice.address}, ethAcc, 10n)).to.be.true;
162      expect(await collection.getBalance(ethAcc)).to.be.equal(10n);144    expect(await collection.getBalance(ethAcc)).to.be.equal(10n);
163    });
164  });145  });
165});146});
166147

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import usingApi from './substrate/substrate-api';18import {expect, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util/playgrounds';
19import {
20  createCollectionExpectSuccess,
21  destroyCollectionExpectSuccess,
22  setCollectionLimitsExpectSuccess,
23  setCollectionSponsorExpectSuccess,
24  confirmSponsorshipExpectSuccess,
25  createItemExpectSuccess,
26  createItemExpectFailure,
27  transferExpectSuccess,
28  getFreeBalance,
29  waitNewBlocks, burnItemExpectSuccess,
30  requirePallets,
31  Pallets,
32} from './util/helpers';
33import {expect} from 'chai';
3419
35describe('Number of tokens per address (NFT)', () => {20describe('Number of tokens per address (NFT)', () => {
36  let alice: IKeyringPair;21  let alice: IKeyringPair;
3722
38  before(async () => {23  before(async () => {
39    await usingApi(async (api, privateKeyWrapper) => {24    await usingPlaygrounds(async (helper, privateKey) => {
40      alice = privateKeyWrapper('//Alice');25      const donor = privateKey('//Alice');
26      [alice] = await helper.arrange.createAccounts([10n], donor);
41    });27    });
42  });28  });
4329
44  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {30  itSub.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async ({helper}) => {
45
46    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});31    const collection = await helper.nft.mintCollection(alice, {});
47    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});32    await collection.setLimits(alice, {accountTokenOwnershipLimit: 20});
33    
48    for(let i = 0; i < 10; i++){34    for(let i = 0; i < 10; i++){
49      await createItemExpectSuccess(alice, collectionId, 'NFT');35      await expect(collection.mintToken(alice)).to.be.not.rejected;
50    }36    }
51    await createItemExpectFailure(alice, collectionId, 'NFT');37    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
52    for(let i = 1; i < 11; i++) {38    for(let i = 1; i < 11; i++) {
53      await burnItemExpectSuccess(alice, collectionId, i);39      await expect(collection.burnToken(alice, i)).to.be.not.rejected;
54    }40    }
55    await destroyCollectionExpectSuccess(collectionId);41    await collection.burn(alice);
56  });42  });
43  
44  itSub('Collection limits allow lower number than chain limits, collection limits are enforced', async ({helper}) => {
45    const collection = await helper.nft.mintCollection(alice, {});
46    await collection.setLimits(alice, {accountTokenOwnershipLimit: 1});
5747
58  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {48    await collection.mintToken(alice);
59
60    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
61    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});49    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
62    await createItemExpectSuccess(alice, collectionId, 'NFT');
63    await createItemExpectFailure(alice, collectionId, 'NFT');50    
64    await burnItemExpectSuccess(alice, collectionId, 1);51    await collection.burnToken(alice, 1);
65    await destroyCollectionExpectSuccess(collectionId);52    await expect(collection.burn(alice)).to.be.not.rejected;
66  });53  });
67});54});
6855
69describe('Number of tokens per address (ReFungible)', () => {56describe('Number of tokens per address (ReFungible)', () => {
70  let alice: IKeyringPair;57  let alice: IKeyringPair;
7158
72  before(async function() {59  before(async function() {
73    await requirePallets(this, [Pallets.ReFungible]);60    await usingPlaygrounds(async (helper, privateKey) => {
61      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
7462
75    await usingApi(async (api, privateKeyWrapper) => {63      const donor = privateKey('//Alice');
76      alice = privateKeyWrapper('//Alice');64      [alice] = await helper.arrange.createAccounts([10n], donor);
77    });65    });
78  });66  });
7967
80  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {68  itSub.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async ({helper}) => {
81    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});69    const collection = await helper.rft.mintCollection(alice, {});
82    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});70    await collection.setLimits(alice, {accountTokenOwnershipLimit: 20});
71    
83    for(let i = 0; i < 10; i++){72    for(let i = 0; i < 10; i++){
84      await createItemExpectSuccess(alice, collectionId, 'ReFungible');73      await expect(collection.mintToken(alice, 10n)).to.be.not.rejected;
85    }74    }
86    await createItemExpectFailure(alice, collectionId, 'ReFungible');75    await expect(collection.mintToken(alice, 10n)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
87    for(let i = 1; i < 11; i++) {76    for(let i = 1; i < 11; i++) {
88      await burnItemExpectSuccess(alice, collectionId, i, 100);77      await expect(collection.burnToken(alice, i, 10n)).to.be.not.rejected;
89    }78    }
90    await destroyCollectionExpectSuccess(collectionId);79    await collection.burn(alice);
91  });80  });
9281
93  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {82  itSub('Collection limits allow lower number than chain limits, collection limits are enforced', async ({helper}) => {
94    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});83    const collection = await helper.rft.mintCollection(alice, {});
95    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});84    await collection.setLimits(alice, {accountTokenOwnershipLimit: 1});
85
96    await createItemExpectSuccess(alice, collectionId, 'ReFungible');86    await collection.mintToken(alice);
97    await createItemExpectFailure(alice, collectionId, 'ReFungible');87    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
98    await burnItemExpectSuccess(alice, collectionId, 1, 100);88    
89    await collection.burnToken(alice, 1);
99    await destroyCollectionExpectSuccess(collectionId);90    await expect(collection.burn(alice)).to.be.not.rejected;
100  });91  });
101});92});
10293
94// todo:playgrounds skipped ~ postponed
103describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {95describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {
104  let alice: IKeyringPair;96  /*let alice: IKeyringPair;
105  let bob: IKeyringPair;97  let bob: IKeyringPair;
106  let charlie: IKeyringPair;98  let charlie: IKeyringPair;
10799
113    });105    });
114  });106  });
115107
116  it.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {108  itSub.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
117    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});109    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
118    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});110    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
119    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');111    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
137    await destroyCollectionExpectSuccess(collectionId);129    await destroyCollectionExpectSuccess(collectionId);
138  });130  });
139131
140  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {132  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
141133
142    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});134    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
143    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});135    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
176    });168    });
177  });169  });
178170
179  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {171  itSub('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
180    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});172    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
181    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});173    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
182    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');174    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');
202    await destroyCollectionExpectSuccess(collectionId);194    await destroyCollectionExpectSuccess(collectionId);
203  });195  });
204196
205  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {197  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
206198
207    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});199    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
208    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});200    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
243    });235    });
244  });236  });
245237
246  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {238  itSub('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
247    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});239    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
248    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});240    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
249    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');241    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');
267    await destroyCollectionExpectSuccess(collectionId);259    await destroyCollectionExpectSuccess(collectionId);
268  });260  });
269261
270  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {262  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
271263
272    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});264    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
273    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});265    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
290    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;282    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;
291    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);283    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
292    await destroyCollectionExpectSuccess(collectionId);284    await destroyCollectionExpectSuccess(collectionId);
293  });285  });*/
294});286});
295287
296describe('Collection zero limits (NFT)', () => {288describe('Collection zero limits (NFT)', () => {
299  let charlie: IKeyringPair;291  let charlie: IKeyringPair;
300292
301  before(async () => {293  before(async () => {
302    await usingApi(async (api, privateKeyWrapper) => {294    await usingPlaygrounds(async (helper, privateKey) => {
303      alice = privateKeyWrapper('//Alice');295      const donor = privateKey('//Alice');
304      bob = privateKeyWrapper('//Bob');296      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
305      charlie = privateKeyWrapper('//Charlie');
306    });297    });
307  });298  });
308299
309  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {300  itSub.skip('Limits have 0 in tokens per address field, the chain limits are applied', async ({helper}) => {
310    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});301    const collection = await helper.nft.mintCollection(alice, {});
311    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});302    await collection.setLimits(alice, {accountTokenOwnershipLimit: 0});
303
312    for(let i = 0; i < 10; i++){304    for(let i = 0; i < 10; i++){
313      await createItemExpectSuccess(alice, collectionId, 'NFT');305      await collection.mintToken(alice);
314    }306    }
315    await createItemExpectFailure(alice, collectionId, 'NFT');307    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
316  });308  });
317309
318  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {310  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
311    const collection = await helper.nft.mintCollection(alice, {});
312    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
313    const token = await collection.mintToken(alice);
319314
320    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});315    await collection.setSponsor(alice, alice.address);
321    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
322    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
323    await setCollectionSponsorExpectSuccess(collectionId, alice.address);316    await collection.confirmSponsorship(alice);
324    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');317    
325    await transferExpectSuccess(collectionId, tokenId, alice, bob);318    await token.transfer(alice, {Substrate: bob.address});
326    const aliceBalanceBefore = await getFreeBalance(alice);319    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
327320
328    // check setting SponsorTimeout = 0, success with next block321    // check setting SponsorTimeout = 0, success with next block
329    await waitNewBlocks(1);322    await helper.wait.newBlocks(1);
330    await transferExpectSuccess(collectionId, tokenId, bob, charlie);323    await token.transfer(bob, {Substrate: charlie.address});
331    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);324    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
332    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;325    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
333    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
334  });326  });
335});327});
336328
340  let charlie: IKeyringPair;332  let charlie: IKeyringPair;
341333
342  before(async () => {334  before(async () => {
343    await usingApi(async (api, privateKeyWrapper) => {335    await usingPlaygrounds(async (helper, privateKey) => {
344      alice = privateKeyWrapper('//Alice');336      const donor = privateKey('//Alice');
345      bob = privateKeyWrapper('//Bob');337      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
346      charlie = privateKeyWrapper('//Charlie');
347    });338    });
348  });339  });
349340
350  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {341  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
351    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});342    const collection = await helper.ft.mintCollection(alice, {});
352    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});343    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
353    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');344    await collection.mint(alice, 3n);
354    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
355    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
356    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');
357    const aliceBalanceBefore = await getFreeBalance(alice);
358    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');
359345
346    await collection.setSponsor(alice, alice.address);
347    await collection.confirmSponsorship(alice);
348    
349    await collection.transfer(alice, {Substrate: bob.address}, 2n);
350    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
351
360    // check setting SponsorTimeout = 0, success with next block352    // check setting SponsorTimeout = 0, success with next block
361    await waitNewBlocks(1);353    await helper.wait.newBlocks(1);
362    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');354    await collection.transfer(bob, {Substrate: charlie.address});
363    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);355    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
364    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;356    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
365    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
366  });357  });
367});358});
368359
372  let charlie: IKeyringPair;363  let charlie: IKeyringPair;
373364
374  before(async function() {365  before(async function() {
375    await requirePallets(this, [Pallets.ReFungible]);366    await usingPlaygrounds(async (helper, privateKey) => {
367      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
376368
377    await usingApi(async (api, privateKeyWrapper) => {369      const donor = privateKey('//Alice');
378      alice = privateKeyWrapper('//Alice');
379      bob = privateKeyWrapper('//Bob');370      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
380      charlie = privateKeyWrapper('//Charlie');
381    });371    });
382  });372  });
383373
384  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {374  itSub.skip('Limits have 0 in tokens per address field, the chain limits are applied', async ({helper}) => {
385    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});375    const collection = await helper.rft.mintCollection(alice, {});
386    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});376    await collection.setLimits(alice, {accountTokenOwnershipLimit: 0});
387    for(let i = 0; i < 10; i++){377    for(let i = 0; i < 10; i++){
388      await createItemExpectSuccess(alice, collectionId, 'ReFungible');378      await collection.mintToken(alice);
389    }379    }
390    await createItemExpectFailure(alice, collectionId, 'ReFungible');380    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
391  });381  });
392382
393  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {383  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
384    const collection = await helper.rft.mintCollection(alice, {});
385    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
386    const token = await collection.mintToken(alice, 3n);
394387
395    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});388    await collection.setSponsor(alice, alice.address);
396    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
397    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');
398    await setCollectionSponsorExpectSuccess(collectionId, alice.address);389    await collection.confirmSponsorship(alice);
399    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');390    
400    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');391    await token.transfer(alice, {Substrate: bob.address}, 2n);
401    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');
402    const aliceBalanceBefore = await getFreeBalance(alice);392    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
403393
404    // check setting SponsorTimeout = 0, success with next block394    // check setting SponsorTimeout = 0, success with next block
405    await waitNewBlocks(1);395    await helper.wait.newBlocks(1);
406    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');396    await token.transfer(bob, {Substrate: charlie.address});
407    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);397    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
408    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;398    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
409    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
410  });399  });
411  
412  it('Effective collection limits', async () => {
413    await usingApi(async (api) => {
414      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});400});
415      await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true});
416      
417      { // Check that limits is undefined
418        const collection = await api.rpc.unique.collectionById(collectionId);
419        expect(collection.isSome).to.be.true;
420        const limits = collection.unwrap().limits;
421        expect(limits).to.be.any;
422        
423        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.null;
424        expect(limits.sponsoredDataSize.toHuman()).to.be.null;
425        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.null;
426        expect(limits.tokenLimit.toHuman()).to.be.null;
427        expect(limits.sponsorTransferTimeout.toHuman()).to.be.null;
428        expect(limits.sponsorApproveTimeout.toHuman()).to.be.null;
429        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
430        expect(limits.ownerCanDestroy.toHuman()).to.be.null;
431        expect(limits.transfersEnabled.toHuman()).to.be.null;
432      }
433  
434      { // Check that limits is undefined for non-existent collection
435        const limits = await api.rpc.unique.effectiveCollectionLimits(11111);
436        expect(limits.toHuman()).to.be.null;
437      }
438  
439      { // Check that default values defined for collection limits
440        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);
441        expect(limitsOpt.isNone).to.be.false;
442        const limits = limitsOpt.unwrap();
443  
444        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('100,000');
445        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('2,048');
446        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');
447        expect(limits.tokenLimit.toHuman()).to.be.eq('4,294,967,295');
448        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');
449        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');
450        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
451        expect(limits.ownerCanDestroy.toHuman()).to.be.true;
452        expect(limits.transfersEnabled.toHuman()).to.be.true;
453      }
454401
455      { //Check the values for collection limits402describe('Effective collection limits (NFT)', () => {
456        await setCollectionLimitsExpectSuccess(alice, collectionId, {
457          accountTokenOwnershipLimit: 99_999,403  let alice: IKeyringPair;
458          sponsoredDataSize: 1024,
459          tokenLimit: 123,
460          transfersEnabled: false,
461        });
462404
463        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);405  before(async () => {
464        expect(limitsOpt.isNone).to.be.false;
465        const limits = limitsOpt.unwrap();
466  406    await usingPlaygrounds(async (helper, privateKey) => {
467        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('99,999');
468        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('1,024');
469        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');
470        expect(limits.tokenLimit.toHuman()).to.be.eq('123');
471        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');407      const donor = privateKey('//Alice');
472        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');
473        expect(limits.ownerCanTransfer.toHuman()).to.be.true;408      [alice] = await helper.arrange.createAccounts([10n], donor);
474        expect(limits.ownerCanDestroy.toHuman()).to.be.true;
475        expect(limits.transfersEnabled.toHuman()).to.be.false;
476      }
477    });409    });
478  });410  });
411  
479});412  itSub('Effective collection limits', async ({helper}) => {
413    const collection = await helper.nft.mintCollection(alice, {});
414    await collection.setLimits(alice, {ownerCanTransfer: true});    
415    
416    { 
417      // Check that limits are undefined
418      const collectionInfo = await collection.getData();
419      const limits = collectionInfo?.raw.limits;
420      expect(limits).to.be.any;
421      
422      expect(limits.accountTokenOwnershipLimit).to.be.null;
423      expect(limits.sponsoredDataSize).to.be.null;
424      expect(limits.sponsoredDataRateLimit).to.be.null;
425      expect(limits.tokenLimit).to.be.null;
426      expect(limits.sponsorTransferTimeout).to.be.null;
427      expect(limits.sponsorApproveTimeout).to.be.null;
428      expect(limits.ownerCanTransfer).to.be.true;
429      expect(limits.ownerCanDestroy).to.be.null;
430      expect(limits.transfersEnabled).to.be.null;
431    }
480432
433    { // Check that limits is undefined for non-existent collection
434      const limits = await helper.collection.getEffectiveLimits(999999);
435      expect(limits).to.be.null;
436    }
481437
438    { // Check that default values defined for collection limits
439      const limits = await collection.getEffectiveLimits();
440
441      expect(limits.accountTokenOwnershipLimit).to.be.eq(100000);
442      expect(limits.sponsoredDataSize).to.be.eq(2048);
443      expect(limits.sponsoredDataRateLimit).to.be.deep.eq({sponsoringDisabled: null});
444      expect(limits.tokenLimit).to.be.eq(4294967295);
445      expect(limits.sponsorTransferTimeout).to.be.eq(5);
446      expect(limits.sponsorApproveTimeout).to.be.eq(5);
447      expect(limits.ownerCanTransfer).to.be.true;
448      expect(limits.ownerCanDestroy).to.be.true;
449      expect(limits.transfersEnabled).to.be.true;
450    }
451
452    { 
453      // Check the values for collection limits
454      await collection.setLimits(alice, {
455        accountTokenOwnershipLimit: 99_999,
456        sponsoredDataSize: 1024,
457        tokenLimit: 123,
458        transfersEnabled: false,
459      });
460
461      const limits = await collection.getEffectiveLimits();
462
463      expect(limits.accountTokenOwnershipLimit).to.be.eq(99999);
464      expect(limits.sponsoredDataSize).to.be.eq(1024);
465      expect(limits.sponsoredDataRateLimit).to.be.deep.eq({sponsoringDisabled: null});
466      expect(limits.tokenLimit).to.be.eq(123);
467      expect(limits.sponsorTransferTimeout).to.be.eq(5);
468      expect(limits.sponsorApproveTimeout).to.be.eq(5);
469      expect(limits.ownerCanTransfer).to.be.true;
470      expect(limits.ownerCanDestroy).to.be.true;
471      expect(limits.transfersEnabled).to.be.false;
472    }
473  });
474});
482475