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

222      await collection.mintToken(222      await collection.mintToken(
223        donor,223        donor,
224        {Substrate: susbstrateReceiver.address},224        {Substrate: susbstrateReceiver.address},
225        PROPERTIES.slice(0, setup.propertiesNumber).map((p) => {225        PROPERTIES.slice(0, setup.propertiesNumber).map((p) => ({key: p.key, value: Buffer.from(p.value).toString()})),
226          return {key: p.key, value: Buffer.from(p.value).toString()};
227        }),
228      );226      );
229    },227    },

379  res['setCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(379  res['setCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(
380    {Substrate: donor.address},380    {Substrate: donor.address},
381    () => collection.setProperties(donor, PROPERTIES.slice(0, 1)381    () => collection.setProperties(donor, PROPERTIES.slice(0, 1)
382      .map(p => { return {key: p.key, value: p.value.toString()}; })),382      .map(p => ({key: p.key, value: p.value.toString()}))),
383  )));383  )));
384384
385  res['deleteCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(385  res['deleteCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(
755  res['setCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(755  res['setCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(
756    {Substrate: donor.address},756    {Substrate: donor.address},
757    () => collection.setProperties(donor, PROPERTIES.slice(0, 1)757    () => collection.setProperties(donor, PROPERTIES.slice(0, 1)
758      .map(p => { return {key: p.key, value: p.value.toString()}; })),758      .map(p => ({key: p.key, value: p.value.toString()}))),
759  )));759  )));
760760
761  res['deleteCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(761  res['deleteCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(

55
6export const PROPERTIES = Array(40)6export const PROPERTIES = Array(40)
7  .fill(0)7  .fill(0)
8  .map((_, i) => {8  .map((_, i) => ({
9    return {
10      key: `key_${i}`,9    key: `key_${i}`,
11      value: Uint8Array.from(Buffer.from(`value_${i}`)),10    value: Uint8Array.from(Buffer.from(`value_${i}`)),
12    };
13  });11  }));
1412
15export const SUBS_PROPERTIES = Array(40)13export const SUBS_PROPERTIES = Array(40)
16  .fill(0)14  .fill(0)
17  .map((_, i) => {15  .map((_, i) => ({
18    return {
19      key: `key_${i}`,16    key: `key_${i}`,
20      value: `value_${i}`,17    value: `value_${i}`,
21    };
22  });18  }));
2319
24export const PERMISSIONS: ITokenPropertyPermission[] = PROPERTIES.map((p) => {20export const PERMISSIONS: ITokenPropertyPermission[] = PROPERTIES.map((p) => ({
25  return {
26    key: p.key,21  key: p.key,
27    permission: {22  permission: {
28      tokenOwner: true,23    tokenOwner: true,
29      collectionAdmin: true,24    collectionAdmin: true,
30      mutable: true,25    mutable: true,
31    },26  },
32  };
33});27}));
3428
35export function convertToTokens(value: bigint, nominal = 1000_000_000_000_000_000n): number {29export function convertToTokens(value: bigint, nominal = 1000_000_000_000_000_000n): number {
36  return Number((value * 1000n) / nominal) / 1000;30  return Number((value * 1000n) / nominal) / 1000;

7676
77      // 2. Expect methods.collectionAdmins == api.rpc.unique.adminlist77      // 2. Expect methods.collectionAdmins == api.rpc.unique.adminlist
78      let adminListEth = await collectionEvm.methods.collectionAdmins().call();78      let adminListEth = await collectionEvm.methods.collectionAdmins().call();
79      adminListEth = adminListEth.map((element: IEthCrossAccountId) => {79      adminListEth = adminListEth.map((element: IEthCrossAccountId) => helper.address.convertCrossAccountFromEthCrossAccount(element));
80        return helper.address.convertCrossAccountFromEthCrossAccount(element);
81      });
82      expect(adminListRpc).to.be.like(adminListEth);80      expect(adminListRpc).to.be.like(adminListEth);
8381
84      // 3. check isOwnerOrAdminCross returns true:82      // 3. check isOwnerOrAdminCross returns true:

181      const propertyPermissions = data2?.raw.tokenPropertyPermissions;181      const propertyPermissions = data2?.raw.tokenPropertyPermissions;
182      expect(propertyPermissions?.length).to.equal(2);182      expect(propertyPermissions?.length).to.equal(2);
183183
184      expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => {184      expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => tpp.key === 'URI' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner)).to.be.not.null;
185        return tpp.key === 'URI' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner;
186      })).to.be.not.null;
187185
188      expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => {186      expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => tpp.key === 'URISuffix' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner)).to.be.not.null;
189        return tpp.key === 'URISuffix' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner;
190      })).to.be.not.null;
191187
192      expect(data2?.raw.properties?.find((property: IProperty) => {188      expect(data2?.raw.properties?.find((property: IProperty) => property.key === 'baseURI' && property.value === BASE_URI)).to.be.not.null;
193        return property.key === 'baseURI' && property.value === BASE_URI;
194      })).to.be.not.null;
195189
196      const token1Result = await contract.methods.mint(bruh).send();190      const token1Result = await contract.methods.mint(bruh).send();
197      const tokenId1 = token1Result.events.Transfer.returnValues.tokenId;191      const tokenId1 = token1Result.events.Transfer.returnValues.tokenId;

17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {itEth, expect, usingEthPlaygrounds} from './util';18import {itEth, expect, usingEthPlaygrounds} from './util';
1919
20const getContractSource = (collectionAddress: string, contractAddress: string): string => {20const getContractSource = (collectionAddress: string, contractAddress: string): string => `
21  return `21  // SPDX-License-Identifier: MIT
22  // SPDX-License-Identifier: MIT22  pragma solidity ^0.8.0;
23  pragma solidity ^0.8.0;23  interface ITest {
24  interface ITest {24    function ztestzzzzzzz() external returns (uint256 n);
50      ITest(${collectionAddress}).ztestzzzzzzz();50    }
51    }51  }
52  }52  `;
53  `;
54};
5553
5654
57describe('Evm Coder tests', () => {55describe('Evm Coder tests', () => {

102      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);102      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
103103
104      // const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);104      // const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);
105      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });105      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));
106      const permissions: ITokenPropertyPermission[] = properties106      const permissions: ITokenPropertyPermission[] = properties
107        .map(p => {107        .map(p => ({
108          return {
109            key: p.key, permission: {108          key: p.key, permission: {
110              tokenOwner: false,109            tokenOwner: false,
111              collectionAdmin: true,110            collectionAdmin: true,
112              mutable: false,111            mutable: false,
113            },112          },
114          };
115        });113        }));
116114
117      const collection = await helper.nft.mintCollection(minter, {115      const collection = await helper.nft.mintCollection(minter, {
118        tokenPrefix: 'ethp',116        tokenPrefix: 'ethp',
146      expect(tokenId).to.be.equal(expectedTokenId);144      expect(tokenId).to.be.equal(expectedTokenId);
147145
148      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties146      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
149        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));147        .map(p => helper.ethProperty.property(p.key, p.value.toString())));
150148
151      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))149      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))
152        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});150        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});

46      const receiverSub = bob;46      const receiverSub = bob;
47      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);47      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
4848
49      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });49      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));
50      const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {50      const permissions: ITokenPropertyPermission[] = properties.map(p => ({key: p.key, permission: {
51        tokenOwner: false,51        tokenOwner: false,
52        collectionAdmin: true,52        collectionAdmin: true,
53        mutable: false}};53        mutable: false}}));
54      });
5554
5655
86      expect(tokenId).to.be.equal(expectedTokenId);85      expect(tokenId).to.be.equal(expectedTokenId);
8786
88      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties87      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
89        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));88        .map(p => helper.ethProperty.property(p.key, p.value.toString())));
9089
91      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))90      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))
92        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});91        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});

241    itEth.ifWithPallets(`Can be multiple set/read for ${testCase.mode}`, testCase.requiredPallets, async({helper}) => {241    itEth.ifWithPallets(`Can be multiple set/read for ${testCase.mode}`, testCase.requiredPallets, async({helper}) => {
242      const caller = await helper.eth.createAccountWithBalance(donor);242      const caller = await helper.eth.createAccountWithBalance(donor);
243243
244      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });244      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));
245      const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {tokenOwner: true,245      const permissions: ITokenPropertyPermission[] = properties.map(p => ({key: p.key, permission: {tokenOwner: true,
246        collectionAdmin: true,246        collectionAdmin: true,
247        mutable: true}}; });247        mutable: true}}));
248248
249      const collection = await helper[testCase.mode].mintCollection(alice, {249      const collection = await helper[testCase.mode].mintCollection(alice, {
250        tokenPrefix: 'ethp',250        tokenPrefix: 'ethp',
267      await contract.methods.setProperties(token.tokenId, properties).send({from: caller});267      await contract.methods.setProperties(token.tokenId, properties).send({from: caller});
268268
269      const values = await token.getProperties(properties.map(p => p.key));269      const values = await token.getProperties(properties.map(p => p.key));
270      expect(values).to.be.deep.equal(properties.map(p => { return {key: p.key, value: p.value.toString()}; }));270      expect(values).to.be.deep.equal(properties.map(p => ({key: p.key, value: p.value.toString()})));
271271
272      expect(await contract.methods.properties(token.tokenId, []).call()).to.be.like(properties272      expect(await contract.methods.properties(token.tokenId, []).call()).to.be.like(properties
273        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));273        .map(p => helper.ethProperty.property(p.key, p.value.toString())));
274274
275      expect(await contract.methods.properties(token.tokenId, [properties[0].key]).call())275      expect(await contract.methods.properties(token.tokenId, [properties[0].key]).call())
276        .to.be.like([helper.ethProperty.property(properties[0].key, properties[0].value.toString())]);276        .to.be.like([helper.ethProperty.property(properties[0].key, properties[0].value.toString())]);

4646
47  itSub('RPC method tokenOnewrs for fungible collection and token', async ({helper}) => {47  itSub('RPC method tokenOnewrs for fungible collection and token', async ({helper}) => {
48    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};48    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
49    const facelessCrowd = (await helper.arrange.createAccounts(Array(7).fill(0n), donor)).map(keyring => {return {Substrate: keyring.address};});49    const facelessCrowd = (await helper.arrange.createAccounts(Array(7).fill(0n), donor)).map(keyring => ({Substrate: keyring.address}));
5050
51    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});51    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
5252

48describe('query properties RPC', () => {48describe('query properties RPC', () => {
49  let alice: IKeyringPair;49  let alice: IKeyringPair;
5050
51  const mintCollection = async (helper: UniqueHelper) => {51  const mintCollection = async (helper: UniqueHelper) => await helper.nft.mintCollection(alice, {
52    return await helper.nft.mintCollection(alice, {
53      tokenPrefix: 'prps',52    tokenPrefix: 'prps',
54      properties: collectionProps,53    properties: collectionProps,
55      tokenPropertyPermissions: tokenPropPermissions,54    tokenPropertyPermissions: tokenPropPermissions,
56    });55  });
57  };
5856
59  const mintToken = async (collection: UniqueNFTCollection) => {57  const mintToken = async (collection: UniqueNFTCollection) => await collection.mintToken(alice, {Substrate: alice.address}, tokenProps);
60    return await collection.mintToken(alice, {Substrate: alice.address}, tokenProps);
61  };
6258
6359
64  before(async () => {60  before(async () => {

44  async function mintCollectionWithAllPermissionsAndToken(helper: UniqueHelper, mode: 'NFT' | 'RFT'): Promise<[UniqueNFToken | UniqueRFToken, bigint]> {44  async function mintCollectionWithAllPermissionsAndToken(helper: UniqueHelper, mode: 'NFT' | 'RFT'): Promise<[UniqueNFToken | UniqueRFToken, bigint]> {
45    const collection = await (mode == 'NFT' ? helper.nft : helper.rft).mintCollection(alice, {45    const collection = await (mode == 'NFT' ? helper.nft : helper.rft).mintCollection(alice, {
46      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>46      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
47        signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),47        signers.map(signer => ({key: `${i+1}_${signer.address}`, permission}))),
48    });48    });
49    return mode == 'NFT' ? [await collection.mintToken(alice), 1n] : [await collection.mintToken(alice, 100n as any), 100n];49    return mode == 'NFT' ? [await collection.mintToken(alice), 1n] : [await collection.mintToken(alice, 100n as any), 100n];
50  }50  }
201    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});201    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
202    const collectionB = await helper.nft.mintCollection(alice, {202    const collectionB = await helper.nft.mintCollection(alice, {
203      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>203      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
204        signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),204        signers.map(signer => ({key: `${i+1}_${signer.address}`, permission}))),
205    });205    });
206    const targetToken = await collectionA.mintToken(alice);206    const targetToken = await collectionA.mintToken(alice);
207    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());207    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
239    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});239    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
240    const collectionB = await helper.nft.mintCollection(alice, {240    const collectionB = await helper.nft.mintCollection(alice, {
241      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>241      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
242        signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),242        signers.map(signer => ({key: `${i+1}_${signer.address}`, permission}))),
243    });243    });
244    const targetToken = await collectionA.mintToken(alice);244    const targetToken = await collectionA.mintToken(alice);
245    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());245    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
284    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});284    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
285    const collectionB = await helper.nft.mintCollection(alice, {285    const collectionB = await helper.nft.mintCollection(alice, {
286      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>286      tokenPropertyPermissions: permissions.flatMap(({permission, signers}, i) =>
287        signers.map(signer => {return {key: `${i+1}_${signer.address}`, permission};})),287        signers.map(signer => ({key: `${i+1}_${signer.address}`, permission}))),
288    });288    });
289    const targetToken = await collectionA.mintToken(alice);289    const targetToken = await collectionA.mintToken(alice);
290    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());290    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
477477
478  async function mintCollectionWithAllPermissionsAndToken(helper: UniqueHelper, mode: 'NFT' | 'RFT'): Promise<[UniqueNFToken | UniqueRFToken, bigint]> {478  async function mintCollectionWithAllPermissionsAndToken(helper: UniqueHelper, mode: 'NFT' | 'RFT'): Promise<[UniqueNFToken | UniqueRFToken, bigint]> {
479    const collection = await (mode == 'NFT' ? helper.nft : helper.rft).mintCollection(alice, {479    const collection = await (mode == 'NFT' ? helper.nft : helper.rft).mintCollection(alice, {
480      tokenPropertyPermissions: constitution.map(({permission}, i) => {return {key: `${i+1}`, permission};}),480      tokenPropertyPermissions: constitution.map(({permission}, i) => ({key: `${i+1}`, permission})),
481    });481    });
482    return mode == 'NFT' ? [await collection.mintToken(alice), 1n] : [await collection.mintToken(alice, 100n as any), 100n];482    return mode == 'NFT' ? [await collection.mintToken(alice), 1n] : [await collection.mintToken(alice, 100n as any), 100n];
483  }483  }

6464
65  itSub('RPC method tokenOwners for refungible collection and token', async ({helper}) => {65  itSub('RPC method tokenOwners for refungible collection and token', async ({helper}) => {
66    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};66    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
67    const facelessCrowd = (await helper.arrange.createAccounts(Array(7).fill(0n), donor)).map(keyring => {return {Substrate: keyring.address};});67    const facelessCrowd = (await helper.arrange.createAccounts(Array(7).fill(0n), donor)).map(keyring => ({Substrate: keyring.address}));
6868
69    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});69    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
7070

40    // Set-up a few token owners of all stripes40    // Set-up a few token owners of all stripes
41    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};41    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
42    const facelessCrowd = (await helper.arrange.createAccounts([0n, 0n, 0n, 0n, 0n, 0n, 0n], donor))42    const facelessCrowd = (await helper.arrange.createAccounts([0n, 0n, 0n, 0n, 0n, 0n, 0n], donor))
43      .map(i => {return {Substrate: i.address};});43      .map(i => ({Substrate: i.address}));
4444
45    const collection = await helper.ft.mintCollection(alice, {name: 'RPC-2', tokenPrefix: 'RPC'});45    const collection = await helper.ft.mintCollection(alice, {name: 'RPC-2', tokenPrefix: 'RPC'});
46    // mint some maximum (u128) amounts of tokens possible46    // mint some maximum (u128) amounts of tokens possible

357        const stakers = await getAccounts(3);357        const stakers = await getAccounts(3);
358358
359        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));359        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));
360        await Promise.all(stakers.map(staker => {360        await Promise.all(stakers.map(staker => testCase.method === 'unstakeAll'
361          return testCase.method === 'unstakeAll'
362            ? helper.staking.unstakeAll(staker)361          ? helper.staking.unstakeAll(staker)
363            : helper.staking.unstakePartial(staker, 100n * nominal);362          : helper.staking.unstakePartial(staker, 100n * nominal)));
364        }));
365363
366        await Promise.all(stakers.map(async (staker) => {364        await Promise.all(stakers.map(async (staker) => {
367          expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);365          expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);
375        const stakers = await getAccounts(10);373        const stakers = await getAccounts(10);
376374
377        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));375        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));
378        const unstakingResults = await Promise.allSettled(stakers.map((staker, i) => {376        const unstakingResults = await Promise.allSettled(stakers.map((staker, i) => i % 2 === 0
379          return i % 2 === 0
380            ? helper.staking.unstakeAll(staker)377          ? helper.staking.unstakeAll(staker)
381            : helper.staking.unstakePartial(staker, 100n * nominal);378          : helper.staking.unstakePartial(staker, 100n * nominal)));
382        }));
383379
384        const successfulUnstakes = unstakingResults.filter(result => result.status === 'fulfilled');380        const successfulUnstakes = unstakingResults.filter(result => result.status === 'fulfilled');
385        expect(successfulUnstakes).to.have.length(3);381        expect(successfulUnstakes).to.have.length(3);

19chai.use(chaiSubset);19chai.use(chaiSubset);
20export const expect = chai.expect;20export const expect = chai.expect;
2121
22const getTestHash = (filename: string) => {22const getTestHash = (filename: string) => crypto.createHash('md5').update(filename).digest('hex');
23  return crypto.createHash('md5').update(filename).digest('hex');
24};
2523
26export const getTestSeed = (filename: string) => {24export const getTestSeed = (filename: string) => `//Alice+${getTestHash(filename)}`;
27  return `//Alice+${getTestHash(filename)}`;
28};
2925
30async function usingPlaygroundsGeneral<T extends ChainHelperBase>(helperType: new(logger: ILogger) => T, url: string, code: (helper: T, privateKey: (seed: string | {filename?: string, url?: string, ignoreFundsPresence?: boolean}) => Promise<IKeyringPair>) => Promise<void>) {26async function usingPlaygroundsGeneral<T extends ChainHelperBase>(helperType: new(logger: ILogger) => T, url: string, code: (helper: T, privateKey: (seed: string | {filename?: string, url?: string, ignoreFundsPresence?: boolean}) => Promise<IKeyringPair>) => Promise<void>) {
31  const silentConsole = new SilentConsole();27  const silentConsole = new SilentConsole();
65  }61  }
66}62}
6763
68export const usingPlaygrounds = (code: (helper: DevUniqueHelper, privateKey: (seed: string | {filename?: string, url?: string, ignoreFundsPresence?: boolean}) => Promise<IKeyringPair>) => Promise<void>, url: string = config.substrateUrl) => {64export const usingPlaygrounds = (code: (helper: DevUniqueHelper, privateKey: (seed: string | {filename?: string, url?: string, ignoreFundsPresence?: boolean}) => Promise<IKeyringPair>) => Promise<void>, url: string = config.substrateUrl) => usingPlaygroundsGeneral<DevUniqueHelper>(DevUniqueHelper, url, code);
69  return usingPlaygroundsGeneral<DevUniqueHelper>(DevUniqueHelper, url, code);
70};
7165
72export const usingWestmintPlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {66export const usingWestmintPlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevWestmintHelper>(DevWestmintHelper, url, code);
73  return usingPlaygroundsGeneral<DevWestmintHelper>(DevWestmintHelper, url, code);
74};
7567
76export const usingStateminePlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {68export const usingStateminePlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevStatemineHelper>(DevWestmintHelper, url, code);
77  return usingPlaygroundsGeneral<DevStatemineHelper>(DevWestmintHelper, url, code);
78};
7969
80export const usingStatemintPlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {70export const usingStatemintPlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevStatemintHelper>(DevWestmintHelper, url, code);
81  return usingPlaygroundsGeneral<DevStatemintHelper>(DevWestmintHelper, url, code);
82};
8371
84export const usingRelayPlaygrounds = (url: string, code: (helper: DevRelayHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {72export const usingRelayPlaygrounds = (url: string, code: (helper: DevRelayHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevRelayHelper>(DevRelayHelper, url, code);
85  return usingPlaygroundsGeneral<DevRelayHelper>(DevRelayHelper, url, code);
86};
8773
88export const usingAcalaPlaygrounds = (url: string, code: (helper: DevAcalaHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {74export const usingAcalaPlaygrounds = (url: string, code: (helper: DevAcalaHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevAcalaHelper>(DevAcalaHelper, url, code);
89  return usingPlaygroundsGeneral<DevAcalaHelper>(DevAcalaHelper, url, code);
90};
9175
92export const usingKaruraPlaygrounds = (url: string, code: (helper: DevKaruraHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {76export const usingKaruraPlaygrounds = (url: string, code: (helper: DevKaruraHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevKaruraHelper>(DevAcalaHelper, url, code);
93  return usingPlaygroundsGeneral<DevKaruraHelper>(DevAcalaHelper, url, code);
94};
9577
96export const usingMoonbeamPlaygrounds = (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {78export const usingMoonbeamPlaygrounds = (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevMoonbeamHelper>(DevMoonbeamHelper, url, code);
97  return usingPlaygroundsGeneral<DevMoonbeamHelper>(DevMoonbeamHelper, url, code);
98};
9979
100export const usingMoonriverPlaygrounds = (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {80export const usingMoonriverPlaygrounds = (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevMoonriverHelper>(DevMoonriverHelper, url, code);
101  return usingPlaygroundsGeneral<DevMoonriverHelper>(DevMoonriverHelper, url, code);
102};
10381
104export const usingAstarPlaygrounds = (url: string, code: (helper: DevAstarHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {82export const usingAstarPlaygrounds = (url: string, code: (helper: DevAstarHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevAstarHelper>(DevAstarHelper, url, code);
105  return usingPlaygroundsGeneral<DevAstarHelper>(DevAstarHelper, url, code);
106};
10783
108export const usingShidenPlaygrounds = (url: string, code: (helper: DevShidenHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {84export const usingShidenPlaygrounds = (url: string, code: (helper: DevShidenHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevShidenHelper>(DevShidenHelper, url, code);
109  return usingPlaygroundsGeneral<DevShidenHelper>(DevShidenHelper, url, code);
110};
11185
112export const MINIMUM_DONOR_FUND = 100_000n;86export const MINIMUM_DONOR_FUND = 100_000n;
113export const DONOR_FUNDING = 2_000_000n;87export const DONOR_FUNDING = 2_000_000n;

771    // <<< Referendum voting <<<771    // <<< Referendum voting <<<
772772
773    // Wait the proposal to pass773    // Wait the proposal to pass
774    await this.helper.wait.expectEvent(3, Event.Democracy.Passed, event => {774    await this.helper.wait.expectEvent(3, Event.Democracy.Passed, event => event.referendumIndex() == referendumIndex);
775      return event.referendumIndex() == referendumIndex;
776    });
777775
778    await this.helper.wait.newBlocks(1);776    await this.helper.wait.newBlocks(1);
779777
924  event<T extends IEventHelper>(922  event<T extends IEventHelper>(
925    maxBlocksToWait: number,923    maxBlocksToWait: number,
926    eventHelperType: new () => T,924    eventHelperType: new () => T,
927    filter: (_: T) => boolean = () => { return true; },925    filter: (_: T) => boolean = () => true,
928  ) {926  ) {
929    // eslint-disable-next-line no-async-promise-executor927    // eslint-disable-next-line no-async-promise-executor
930    const promise = new Promise<T | null>(async (resolve) => {928    const promise = new Promise<T | null>(async (resolve) => {
970  async expectEvent<T extends IEventHelper>(968  async expectEvent<T extends IEventHelper>(
971    maxBlocksToWait: number,969    maxBlocksToWait: number,
972    eventHelperType: new () => T,970    eventHelperType: new () => T,
973    filter: (e: T) => boolean = () => { return true; },971    filter: (e: T) => boolean = () => true,
974  ) {972  ) {
975    const e = await this.event(maxBlocksToWait, eventHelperType, filter);973    const e = await this.event(maxBlocksToWait, eventHelperType, filter);
976    if (e == null) {974    if (e == null) {
1077  async startCapture() {1075  async startCapture() {
1078    this.stopCapture();1076    this.stopCapture();
1079    this.unsubscribe = (await this.helper.getApi().query.system.events((eventRecords: FrameSystemEventRecord[]) => {1077    this.unsubscribe = (await this.helper.getApi().query.system.events((eventRecords: FrameSystemEventRecord[]) => {
1080      const newEvents = eventRecords.filter(r => {1078      const newEvents = eventRecords.filter(r => r.event.section == this.eventSection && r.event.method == this.eventMethod);
1081        return r.event.section == this.eventSection && r.event.method == this.eventMethod;
1082      });
10831079
1084      this.events.push(...newEvents);1080      this.events.push(...newEvents);
1085    })) as any;1081    })) as any;
11051101
1106  async payoutStakers(signer: IKeyringPair, stakersToPayout: number):  Promise<{staker: string, stake: bigint, payout: bigint}[]> {1102  async payoutStakers(signer: IKeyringPair, stakersToPayout: number):  Promise<{staker: string, stake: bigint, payout: bigint}[]> {
1107    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);1103    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);
1108    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => {1104    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => ({
1109      return {
1110        staker: e.event.data[0].toString(),1105      staker: e.event.data[0].toString(),
1111        stake: e.event.data[1].toBigInt(),1106      stake: e.event.data[1].toBigInt(),
1112        payout: e.event.data[2].toBigInt(),1107      payout: e.event.data[2].toBigInt(),
1113      };
1114    });1108    }));
1115  }1109  }
1116}1110}
11171111