git.delta.rocks / unique-network / refs/commits / 56575de5acb6

--- a/primitives/app_promotion_rpc/src/lib.rs
+++ b/primitives/app_promotion_rpc/src/lib.rs
@@ -16,11 +16,6 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use up_data_structs::{
-	CollectionId, TokenId, RpcCollection, CollectionStats, CollectionLimits, Property,
-	PropertyKeyPermission, TokenData, TokenChild,
-};
-
 use sp_std::vec::Vec;
 use codec::Decode;
 use sp_runtime::{

--- a/runtime/common/construct_runtime/mod.rs
+++ b/runtime/common/construct_runtime/mod.rs
@@ -78,7 +78,7 @@
                 RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,
 
                 #[runtimes(opal)]
-                Promotion: pallet_app_promotion::{Pallet, Call, Storage, Event<T>} = 73,
+                AppPromotion: pallet_app_promotion::{Pallet, Call, Storage, Event<T>} = 73,
 
                 // Frontier
                 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,

38const palletAddress = calculatePalleteAddress('appstake');38const palletAddress = calculatePalleteAddress('appstake');
39let accounts: IKeyringPair[] = [];39let accounts: IKeyringPair[] = [];
4040
41describe('app-promotions.stake extrinsic', () => {
41before(async function () {42  before(async function () {
42  await usingPlaygrounds(async (helper, privateKeyWrapper) => {43    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
43    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();44      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
44    alice = privateKeyWrapper('//Alice');45      alice = privateKeyWrapper('//Alice');
45    palletAdmin = privateKeyWrapper('//Charlie'); // TODO use custom address46      palletAdmin = privateKeyWrapper('//Charlie'); // TODO use custom address
46    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})));47      await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
47    nominal = helper.balance.getOneTokenNominal();48      nominal = helper.balance.getOneTokenNominal();
48    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);49      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);
49    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);50      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);
50    if (!promotionStartBlock) {
51      promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();
52    }
53    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!)));
54    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests51      accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests
55  });52    });
56});53  });
5754
58after(async function () {55  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {
59  await usingPlaygrounds(async (helper) => {56    await usingPlaygrounds(async (helper) => {
60  });57      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];
61});58      const totalStakedBefore = await helper.staking.getTotalStaked();
6259
63describe('app-promotions.stake extrinsic', () => {60      // Minimum stake amount is 100:
64  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {61      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;
65    await usingPlaygrounds(async (helper) => {62      await helper.staking.stake(staker, 100n * nominal);
66      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];63
67      const totalStakedBefore = await helper.staking.getTotalStaked();64      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...
6865      // ...so he can not transfer 900
69      // Minimum stake amount is 100:66      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});
70      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;67      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;
71      await helper.staking.stake(staker, 100n * nominal);68      
7269      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);
73      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...70      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);
74      // ...so he can not transfer 90071      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
75      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});72      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 
76      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;73      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 
77      74
78      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);75      
79      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);76      await helper.staking.stake(staker, 200n * nominal);
80      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);77      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(300n * nominal);
81      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 78      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);
82      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 79      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);
8380    });
84      81  });
85      await helper.staking.stake(staker, 200n * nominal);82
86      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(300n * nominal);83  it('should allow to create maximum 10 stakes for account', async () => {
87      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);84    await usingPlaygrounds(async (helper) => {
88      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);85      const [staker] = await helper.arrange.createAccounts([2000n], alice);
89    });86      console.log(staker.address);
90  });87      for (let i = 0; i < 10; i++) {
9188        await helper.staking.stake(staker, 100n * nominal);
92  it('should allow to create maximum 10 stakes for account', async () => {89      }
93    await usingPlaygrounds(async (helper) => {90
94      const [staker] = await helper.arrange.createAccounts([2000n], alice);91      // can have 10 stakes
95      console.log(staker.address);92      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);
96      for (let i = 0; i < 10; i++) {93      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);
97        await helper.staking.stake(staker, 100n * nominal);94
98      }95      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;
9996
100      // can have 10 stakes97      // After unstake can stake again
101      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);98      await helper.staking.unstake(staker);
102      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);99      await helper.staking.stake(staker, 100n * nominal);
103100      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);
104      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;101    });
105102  });
106      // After unstake can stake again103  
107      await helper.staking.unstake(staker);104  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {
108      await helper.staking.stake(staker, 100n * nominal);105    await usingPlaygrounds(async helper => { 
109      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);106      const staker = accounts.pop()!;
110    });107
111  });108      // Can't stake full balance because Alice needs to pay some fee
112  109      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;
113  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {110      await helper.staking.stake(staker, 500n * nominal);
114    await usingPlaygrounds(async helper => { 111
115      const staker = accounts.pop()!;112      // Can't stake 500 tkn because Alice has Less than 500 transferable;
116113      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 
117      // Can't stake full balance because Alice needs to pay some fee114      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);
118      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;115    });
119      await helper.staking.stake(staker, 500n * nominal);116  });
120117  
121      // Can't stake 500 tkn because Alice has Less than 500 transferable;118  it('for different accounts in one block is possible', async () => {
122      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 119    await usingPlaygrounds(async helper => {
123      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);120      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];
124    });121      
125  });122      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));
126  123      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;
127  it('for different accounts in one block is possible', async () => {124
128    await usingPlaygrounds(async helper => {125      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));
129      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];126      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);
130      127    });
131      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));128  });
132      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;129});
133
134      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));
135      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);
136    });
137  });
138});
139130
140describe('unstake balance extrinsic', () => {  131describe('unstake balance extrinsic', () => {  
141  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {132  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {
264    await usingPlaygrounds(async (helper) => {255    await usingPlaygrounds(async (helper) => {
265      const nonAdmin = accounts.pop()!;256      const nonAdmin = accounts.pop()!;
266      // nonAdmin can not set admin not from himself nor as a sudo257      // nonAdmin can not set admin not from himself nor as a sudo
267      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;258      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;
268      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;259      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;
269260
270      // Alice can261      // Alice can
271      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;262      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
272    });263    });
273  });264  });
274  265  
279      const account = accounts.pop()!;270      const account = accounts.pop()!;
280      const ethAccount = helper.address.substrateToEth(account.address); 271      const ethAccount = helper.address.substrateToEth(account.address); 
281      // Alice sets Ethereum address as a sudo. Then Substrate address back...272      // Alice sets Ethereum address as a sudo. Then Substrate address back...
282      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;273      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;
283      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;274      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
284      275      
285      // ...It doesn't break anything;276      // ...It doesn't break anything;
286      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});277      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
287      await expect(helper.signTransaction(account, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;278      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
288    });279    });
289  });280  });
290281
293      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];284      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
294      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});285      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
295      286      
296      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;287      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;
297      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;288      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;
298      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;289      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
299      290      
300      await expect(helper.signTransaction(newAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;291      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
301    });292    });
302  });293  });
303});294});
304295
305describe('App-promotion collection sponsoring', () => {296describe('App-promotion collection sponsoring', () => {
306  before(async function () {297  before(async function () {
307    await usingPlaygrounds(async (helper) => {298    await usingPlaygrounds(async (helper) => {
308      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address}));299      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));
309      await helper.signTransaction(alice, tx);300      await helper.signTransaction(alice, tx);
310    });301    });
311  });302  });
315      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];306      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
316      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});307      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});
317      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});308      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});
318      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));309      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));
319      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);310      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);
320311
321      await token.transfer(tokenSender, {Substrate: receiver.address});312      await token.transfer(tokenSender, {Substrate: receiver.address});
334325
335      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});326      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
336      327      
337      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;328      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
338      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');329      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');
339    });330    });
340  });331  });
345      336      
346      // Can set sponsoring for collection without sponsor337      // Can set sponsoring for collection without sponsor
347      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});338      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});
348      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;339      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;
349      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});340      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
350341
351      // Can set sponsoring for collection with unconfirmed sponsor342      // Can set sponsoring for collection with unconfirmed sponsor
352      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});343      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
353      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});344      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});
354      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;345      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
355      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});346      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
356347
357      // Can set sponsoring for collection with confirmed sponsor348      // Can set sponsoring for collection with confirmed sponsor
358      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});349      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
359      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);350      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);
360      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;351      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
361      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});352      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
362    });353    });
363  });354  });
368      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});359      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
369      const collectionId = collection.collectionId;360      const collectionId = collection.collectionId;
370      361      
371      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;362      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
372      363      
373      // Collection limits still can be changed by the owner364      // Collection limits still can be changed by the owner
374      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;365      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;
386      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};377      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};
387      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});378      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});
388379
389      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;380      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;
390      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);381      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);
391    });382    });
392  });383  });
396      const collectionOwner = accounts.pop()!;387      const collectionOwner = accounts.pop()!;
397      388      
398      // collection has never existed389      // collection has never existed
399      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;390      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;
400      // collection has been burned391      // collection has been burned
401      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});392      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
402      await collection.burn(collectionOwner);393      await collection.burn(collectionOwner);
403394
404      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;395      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
405    });396    });
406  });397  });
407});398});
412      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];403      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];
413      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});404      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
414      405      
415      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;406      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
416      407      
417      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;408      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
418      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});409      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
419    });410    });
420  });411  });
425      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});416      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});
426      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});417      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});
427      418      
428      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));419      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));
429      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId));420      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));
430      421      
431      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');422      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');
432423
444      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});435      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});
445      await collection.confirmSponsorship(collectionOwner);436      await collection.confirmSponsorship(collectionOwner);
446      437      
447      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;438      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
448      439      
449      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});440      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});
450    });441    });
456      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});447      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
457      448      
458      await collection.burn(collectionOwner);449      await collection.burn(collectionOwner);
459      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;450      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
460      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;451      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;
461    });452    });
462  });453  });
463});454});
469      const flipper = await deployFlipper(web3, contractOwner);460      const flipper = await deployFlipper(web3, contractOwner);
470      const contractMethods = contractHelpers(web3, contractOwner);461      const contractMethods = contractHelpers(web3, contractOwner);
471462
472      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));463      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
473      464      
474      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  465      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
475      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  466      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
497      });488      });
498489
499      // set promotion sponsoring490      // set promotion sponsoring
500      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));491      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
501492
502      // new sponsor is pallet address493      // new sponsor is pallet address
503      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  494      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
517      const contractMethods = contractHelpers(web3, contractOwner);508      const contractMethods = contractHelpers(web3, contractOwner);
518509
519      // contract sponsored by pallet510      // contract sponsored by pallet
520      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));511      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
521512
522      // owner sets self sponsoring513      // owner sets self sponsoring
523      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;514      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
542      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;533      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
543534
544      // nonAdmin calls sponsorConract535      // nonAdmin calls sponsorConract
545      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.sponsorConract(flipper.options.address))).to.be.rejected;536      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address))).to.be.rejected;
546537
547      // contract still self-sponsored 538      // contract still self-sponsored 
548      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({539      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
569      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});560      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});
570      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);561      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);
571562
572      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));563      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
573      await flipper.methods.flip().send({from: caller});564      await flipper.methods.flip().send({from: caller});
574      expect(await flipper.methods.getValue().call()).to.be.true;565      expect(await flipper.methods.getValue().call()).to.be.true;
575566
591      await transferBalanceToEth(api, alice, flipper.options.address);582      await transferBalanceToEth(api, alice, flipper.options.address);
592      const contractHelper = contractHelpers(web3, contractOwner);583      const contractHelper = contractHelpers(web3, contractOwner);
593      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});584      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});
594      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));585      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
595      await helper.signTransaction(palletAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address));586      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));
596587
597      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  588      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  
598      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  589      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
618      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();609      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
619      const flipper = await deployFlipper(web3, contractOwner);610      const flipper = await deployFlipper(web3, contractOwner);
620611
621      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));612      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
622      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;613      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
623    });614    });
624  });615  });
625616
631      const contractHelper = contractHelpers(web3, contractOwner);622      const contractHelper = contractHelpers(web3, contractOwner);
632      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;623      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
633624
634      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;625      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
635    });626    });
636  });627  });
637});628});
640  it('can not be called by non admin', async () => {631  it('can not be called by non admin', async () => {
641    await usingPlaygrounds(async (helper) => {632    await usingPlaygrounds(async (helper) => {
642      const nonAdmin = accounts.pop()!;633      const nonAdmin = accounts.pop()!;
643      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.payoutStakers(100))).to.be.rejected;634      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;
644    });635    });
645  });636  });
646637
652      await helper.staking.stake(staker, 100n * nominal);643      await helper.staking.stake(staker, 100n * nominal);
653      await helper.staking.stake(staker, 200n * nominal);644      await helper.staking.stake(staker, 200n * nominal);
654      await waitForRelayBlock(helper.api!, 30);645      await waitForRelayBlock(helper.api!, 30);
655      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));646      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
656647
657      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);648      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
658      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);649      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);
668      await helper.staking.stake(staker, 200n * nominal);659      await helper.staking.stake(staker, 200n * nominal);
669660
670      await waitForRelayBlock(helper.api!, 55);661      await waitForRelayBlock(helper.api!, 55);
671      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));662      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
672      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});663      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
673      expect(stakedPerBlock[0][1]).to.be.equal(calculateIncome(100n * nominal, 10n, 2));664      expect(stakedPerBlock[0][1]).to.be.equal(calculateIncome(100n * nominal, 10n, 2));
674      expect(stakedPerBlock[1][1]).to.be.equal(calculateIncome(200n * nominal, 10n, 2));665      expect(stakedPerBlock[1][1]).to.be.equal(calculateIncome(200n * nominal, 10n, 2));
707      await helper.staking.stake(staker, 300n * nominal);698      await helper.staking.stake(staker, 300n * nominal);
708      699      
709      await waitForRelayBlock(helper.api!, 34);700      await waitForRelayBlock(helper.api!, 34);
710      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));701      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
711      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);702      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
712      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n), calculateIncome(300n * nominal, 10n)]);703      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n), calculateIncome(300n * nominal, 10n)]);
713      704      
714      await waitForRelayBlock(helper.api!, 20);705      await waitForRelayBlock(helper.api!, 20);
715      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));706      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
716      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);707      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
717      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2), calculateIncome(200n * nominal, 10n, 2), calculateIncome(300n * nominal, 10n, 2)]);      708      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2), calculateIncome(200n * nominal, 10n, 2), calculateIncome(300n * nominal, 10n, 2)]);      
718    });709    });

--- a/tests/src/interfaces/augment-api-consts.ts
+++ b/tests/src/interfaces/augment-api-consts.ts
@@ -15,6 +15,30 @@
 
 declare module '@polkadot/api-base/types/consts' {
   interface AugmentedConsts<ApiType extends ApiTypes> {
+    appPromotion: {
+      /**
+       * In chain blocks.
+       **/
+      day: u32 & AugmentedConst<ApiType>;
+      intervalIncome: Perbill & AugmentedConst<ApiType>;
+      nominal: u128 & AugmentedConst<ApiType>;
+      /**
+       * The app's pallet id, used for deriving its sovereign account ID.
+       **/
+      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+      /**
+       * In relay blocks.
+       **/
+      pendingInterval: u32 & AugmentedConst<ApiType>;
+      /**
+       * In relay blocks.
+       **/
+      recalculationInterval: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
     balances: {
       /**
        * The minimum amount required to keep an account open.
@@ -61,30 +85,6 @@
        * Number of blocks that pass between treasury balance updates due to inflation
        **/
       inflationBlockInterval: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    promotion: {
-      /**
-       * In chain blocks.
-       **/
-      day: u32 & AugmentedConst<ApiType>;
-      intervalIncome: Perbill & AugmentedConst<ApiType>;
-      nominal: u128 & AugmentedConst<ApiType>;
-      /**
-       * The app's pallet id, used for deriving its sovereign account ID.
-       **/
-      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
-      /**
-       * In relay blocks.
-       **/
-      pendingInterval: u32 & AugmentedConst<ApiType>;
-      /**
-       * In relay blocks.
-       **/
-      recalculationInterval: u32 & AugmentedConst<ApiType>;
       /**
        * Generic const
        **/

--- a/tests/src/interfaces/augment-api-errors.ts
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -11,6 +11,29 @@
 
 declare module '@polkadot/api-base/types/errors' {
   interface AugmentedErrors<ApiType extends ApiTypes> {
+    appPromotion: {
+      /**
+       * Error due to action requiring admin to be set
+       **/
+      AdminNotSet: AugmentedError<ApiType>;
+      /**
+       * An error related to the fact that an invalid argument was passed to perform an action
+       **/
+      InvalidArgument: AugmentedError<ApiType>;
+      /**
+       * No permission to perform an action
+       **/
+      NoPermission: AugmentedError<ApiType>;
+      /**
+       * Insufficient funds to perform an action
+       **/
+      NotSufficientFounds: AugmentedError<ApiType>;
+      PendingForBlockOverflow: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
     balances: {
       /**
        * Beneficiary account must pre-exist
@@ -430,28 +453,6 @@
        * The message's weight could not be determined.
        **/
       UnweighableMessage: AugmentedError<ApiType>;
-      /**
-       * Generic error
-       **/
-      [key: string]: AugmentedError<ApiType>;
-    };
-    promotion: {
-      /**
-       * Error due to action requiring admin to be set
-       **/
-      AdminNotSet: AugmentedError<ApiType>;
-      /**
-       * An error related to the fact that an invalid argument was passed to perform an action
-       **/
-      InvalidArgument: AugmentedError<ApiType>;
-      /**
-       * No permission to perform an action
-       **/
-      NoPermission: AugmentedError<ApiType>;
-      /**
-       * Insufficient funds to perform an action
-       **/
-      NotSufficientFounds: AugmentedError<ApiType>;
       /**
        * Generic error
        **/

--- a/tests/src/interfaces/augment-api-events.ts
+++ b/tests/src/interfaces/augment-api-events.ts
@@ -15,6 +15,13 @@
 
 declare module '@polkadot/api-base/types/events' {
   interface AugmentedEvents<ApiType extends ApiTypes> {
+    appPromotion: {
+      StakingRecalculation: AugmentedEvent<ApiType, [AccountId32, u128, u128]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
     balances: {
       /**
        * A balance was set by root.
@@ -355,13 +362,6 @@
        * \[ destination, result \]
        **/
       VersionChangeNotified: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    promotion: {
-      StakingRecalculation: AugmentedEvent<ApiType, [AccountId32, u128, u128]>;
       /**
        * Generic event
        **/

--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -17,6 +17,35 @@
 
 declare module '@polkadot/api-base/types/storage' {
   interface AugmentedQueries<ApiType extends ApiTypes> {
+    appPromotion: {
+      admin: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Stores hash a record for which the last revenue recalculation was performed.
+       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
+       **/
+      nextCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Amount of tokens pending unstake per user per block.
+       **/
+      pendingUnstake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Amount of tokens staked by account in the blocknumber.
+       **/
+      staked: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<ITuple<[u128, u32]>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;
+      /**
+       * Amount of stakes for an Account
+       **/
+      stakesPerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u8>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+      /**
+       * A block when app-promotion has started .I think this is redundant, because we only need `NextInterestBlock`.
+       **/
+      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      totalStaked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
     balances: {
       /**
        * The Balances pallet example of storing the balance of an account.
@@ -505,39 +534,6 @@
        * in the trie.
        **/
       validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    promotion: {
-      admin: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Stores hash a record for which the last revenue recalculation was performed.
-       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
-       **/
-      nextCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Next target block when interest is recalculated
-       **/
-      nextInterestBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Amount of tokens pending unstake per user per block.
-       **/
-      pendingUnstake: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;
-      /**
-       * Amount of tokens staked by account in the blocknumber.
-       **/
-      staked: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<ITuple<[u128, u32]>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;
-      /**
-       * Amount of stakes for an Account
-       **/
-      stakesPerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u8>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * A block when app-promotion has started .I think this is redundant, because we only need `NextInterestBlock`.
-       **/
-      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      totalStaked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Generic query
        **/