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

difftreelog

refactor Rename module in extrinsic

Trubnikov Sergey2022-09-02parent: #5b36ad8.patch.diff
in: master

13 files changed

modifiedprimitives/app_promotion_rpc/src/lib.rsdiffbeforeafterboth
--- 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::{
modifiedruntime/common/construct_runtime/mod.rsdiffbeforeafterboth
--- 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,
modifiedtests/src/app-promotion.test.tsdiffbeforeafterboth
--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -38,29 +38,20 @@
 const palletAddress = calculatePalleteAddress('appstake');
 let accounts: IKeyringPair[] = [];
 
-before(async function () {
-  await usingPlaygrounds(async (helper, privateKeyWrapper) => {
-    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
-    alice = privateKeyWrapper('//Alice');
-    palletAdmin = privateKeyWrapper('//Charlie'); // TODO use custom address
-    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})));
-    nominal = helper.balance.getOneTokenNominal();
-    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);
-    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);
-    if (!promotionStartBlock) {
-      promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();
-    }
-    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!)));
-    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests
-  });
-});
-
-after(async function () {
-  await usingPlaygrounds(async (helper) => {
+describe('app-promotions.stake extrinsic', () => {
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKeyWrapper('//Alice');
+      palletAdmin = privateKeyWrapper('//Charlie'); // TODO use custom address
+      await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
+      nominal = helper.balance.getOneTokenNominal();
+      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);
+      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);
+      accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests
+    });
   });
-});
 
-describe('app-promotions.stake extrinsic', () => {
   it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {
     await usingPlaygrounds(async (helper) => {
       const [staker, recepient] = [accounts.pop()!, accounts.pop()!];
@@ -264,11 +255,11 @@
     await usingPlaygrounds(async (helper) => {
       const nonAdmin = accounts.pop()!;
       // nonAdmin can not set admin not from himself nor as a sudo
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;
 
       // Alice can
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
     });
   });
   
@@ -279,12 +270,12 @@
       const account = accounts.pop()!;
       const ethAccount = helper.address.substrateToEth(account.address); 
       // Alice sets Ethereum address as a sudo. Then Substrate address back...
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
       
       // ...It doesn't break anything;
       const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
-      await expect(helper.signTransaction(account, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
     });
   });
 
@@ -293,11 +284,11 @@
       const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
       const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;
-      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
       
-      await expect(helper.signTransaction(newAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
     });
   });
 });
@@ -305,7 +296,7 @@
 describe('App-promotion collection sponsoring', () => {
   before(async function () {
     await usingPlaygrounds(async (helper) => {
-      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address}));
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));
       await helper.signTransaction(alice, tx);
     });
   });
@@ -315,7 +306,7 @@
       const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});
       const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));
       const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);
 
       await token.transfer(tokenSender, {Substrate: receiver.address});
@@ -334,7 +325,7 @@
 
       const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
       expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');
     });
   });
@@ -345,19 +336,19 @@
       
       // Can set sponsoring for collection without sponsor
       const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;
       expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
 
       // Can set sponsoring for collection with unconfirmed sponsor
       const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
       expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
       expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
 
       // Can set sponsoring for collection with confirmed sponsor
       const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
       await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
       expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
     });
   });
@@ -368,7 +359,7 @@
       const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       const collectionId = collection.collectionId;
       
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
       
       // Collection limits still can be changed by the owner
       expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;
@@ -386,7 +377,7 @@
       const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};
       const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});
 
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;
       expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);
     });
   });
@@ -396,12 +387,12 @@
       const collectionOwner = accounts.pop()!;
       
       // collection has never existed
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;
       // collection has been burned
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       await collection.burn(collectionOwner);
 
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
     });
   });
 });
@@ -412,9 +403,9 @@
       const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
       
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
       expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
     });
   });
@@ -425,8 +416,8 @@
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});
       const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});
       
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));
       
       expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');
 
@@ -444,7 +435,7 @@
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});
       await collection.confirmSponsorship(collectionOwner);
       
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
       
       expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});
     });
@@ -456,8 +447,8 @@
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       
       await collection.burn(collectionOwner);
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;
     });
   });
 });
@@ -469,7 +460,7 @@
       const flipper = await deployFlipper(web3, contractOwner);
       const contractMethods = contractHelpers(web3, contractOwner);
 
-      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
       
       expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
       expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
@@ -497,7 +488,7 @@
       });
 
       // set promotion sponsoring
-      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
 
       // new sponsor is pallet address
       expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
@@ -517,7 +508,7 @@
       const contractMethods = contractHelpers(web3, contractOwner);
 
       // contract sponsored by pallet
-      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
 
       // owner sets self sponsoring
       await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
@@ -542,7 +533,7 @@
       await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
 
       // nonAdmin calls sponsorConract
-      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.sponsorConract(flipper.options.address))).to.be.rejected;
+      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address))).to.be.rejected;
 
       // contract still self-sponsored 
       expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
@@ -569,7 +560,7 @@
       await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});
       await transferBalanceToEth(api, alice, flipper.options.address, 1000n);
 
-      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
       await flipper.methods.flip().send({from: caller});
       expect(await flipper.methods.getValue().call()).to.be.true;
 
@@ -591,8 +582,8 @@
       await transferBalanceToEth(api, alice, flipper.options.address);
       const contractHelper = contractHelpers(web3, contractOwner);
       await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});
-      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));
-      await helper.signTransaction(palletAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address));
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));
 
       expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  
       expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
@@ -618,8 +609,8 @@
       const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
       const flipper = await deployFlipper(web3, contractOwner);
 
-      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));
-      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
+      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorConract(flipper.options.address));
+      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
     });
   });
 
@@ -631,7 +622,7 @@
       const contractHelper = contractHelpers(web3, contractOwner);
       await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
 
-      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
+      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
     });
   });
 });
@@ -640,7 +631,7 @@
   it('can not be called by non admin', async () => {
     await usingPlaygrounds(async (helper) => {
       const nonAdmin = accounts.pop()!;
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.payoutStakers(100))).to.be.rejected;
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;
     });
   });
 
@@ -652,7 +643,7 @@
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.stake(staker, 200n * nominal);
       await waitForRelayBlock(helper.api!, 30);
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
 
       const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
       expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);
@@ -668,7 +659,7 @@
       await helper.staking.stake(staker, 200n * nominal);
 
       await waitForRelayBlock(helper.api!, 55);
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
       const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
       expect(stakedPerBlock[0][1]).to.be.equal(calculateIncome(100n * nominal, 10n, 2));
       expect(stakedPerBlock[1][1]).to.be.equal(calculateIncome(200n * nominal, 10n, 2));
@@ -707,12 +698,12 @@
       await helper.staking.stake(staker, 300n * nominal);
       
       await waitForRelayBlock(helper.api!, 34);
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
       let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
       expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n), calculateIncome(300n * nominal, 10n)]);
       
       await waitForRelayBlock(helper.api!, 20);
-      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
       totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
       expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2), calculateIncome(200n * nominal, 10n, 2), calculateIncome(300n * nominal, 10n, 2)]);      
     });
modifiedtests/src/interfaces/augment-api-consts.tsdiffbeforeafterboth
--- 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
        **/
modifiedtests/src/interfaces/augment-api-errors.tsdiffbeforeafterboth
--- 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
        **/
modifiedtests/src/interfaces/augment-api-events.tsdiffbeforeafterboth
--- 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
        **/
modifiedtests/src/interfaces/augment-api-query.tsdiffbeforeafterboth
--- 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
        **/
modifiedtests/src/interfaces/augment-api-tx.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -17,6 +17,20 @@
 
 declare module '@polkadot/api-base/types/submittable' {
   interface AugmentedSubmittables<ApiType extends ApiTypes> {
+    appPromotion: {
+      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;
+      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;
+      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+      sponsorConract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;
+      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
+      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;
+      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+    };
     balances: {
       /**
        * Exactly as `transfer`, except the origin must be root and the source account may be
@@ -370,22 +384,6 @@
        * fees.
        **/
       teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    promotion: {
-      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;
-      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;
-      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
-      sponsorConract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;
-      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
-      startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;
-      stopAppPromotion: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
-      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
-      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;
-      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
       /**
        * Generic tx
        **/
modifiedtests/src/interfaces/default/types.tsdiffbeforeafterboth
--- a/tests/src/interfaces/default/types.ts
+++ b/tests/src/interfaces/default/types.ts
@@ -812,11 +812,6 @@
   readonly asSetAdminAddress: {
     readonly admin: PalletEvmAccountBasicCrossAccountIdRepr;
   } & Struct;
-  readonly isStartAppPromotion: boolean;
-  readonly asStartAppPromotion: {
-    readonly promotionStartRelayBlock: Option<u32>;
-  } & Struct;
-  readonly isStopAppPromotion: boolean;
   readonly isStake: boolean;
   readonly asStake: {
     readonly amount: u128;
@@ -842,7 +837,7 @@
   readonly asPayoutStakers: {
     readonly stakersNumber: Option<u8>;
   } & Struct;
-  readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'StopAppPromotion' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsoringCollection' | 'SponsorConract' | 'StopSponsoringContract' | 'PayoutStakers';
+  readonly type: 'SetAdminAddress' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsoringCollection' | 'SponsorConract' | 'StopSponsoringContract' | 'PayoutStakers';
 }
 
 /** @name PalletAppPromotionError */
@@ -850,8 +845,9 @@
   readonly isAdminNotSet: boolean;
   readonly isNoPermission: boolean;
   readonly isNotSufficientFounds: boolean;
+  readonly isPendingForBlockOverflow: boolean;
   readonly isInvalidArgument: boolean;
-  readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'InvalidArgument';
+  readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'PendingForBlockOverflow' | 'InvalidArgument';
 }
 
 /** @name PalletAppPromotionEvent */
modifiedtests/src/interfaces/lookup.tsdiffbeforeafterboth
--- a/tests/src/interfaces/lookup.ts
+++ b/tests/src/interfaces/lookup.ts
@@ -2460,10 +2460,6 @@
       set_admin_address: {
         admin: 'PalletEvmAccountBasicCrossAccountIdRepr',
       },
-      start_app_promotion: {
-        promotionStartRelayBlock: 'Option<u32>',
-      },
-      stop_app_promotion: 'Null',
       stake: {
         amount: 'u128',
       },
@@ -3103,19 +3099,19 @@
     _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']
   },
   /**
-   * Lookup412: pallet_app_promotion::pallet::Error<T>
+   * Lookup415: pallet_app_promotion::pallet::Error<T>
    **/
   PalletAppPromotionError: {
-    _enum: ['AdminNotSet', 'NoPermission', 'NotSufficientFounds', 'InvalidArgument']
+    _enum: ['AdminNotSet', 'NoPermission', 'NotSufficientFounds', 'PendingForBlockOverflow', 'InvalidArgument']
   },
   /**
-   * Lookup415: pallet_evm::pallet::Error<T>
+   * Lookup418: pallet_evm::pallet::Error<T>
    **/
   PalletEvmError: {
     _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']
   },
   /**
-   * Lookup418: fp_rpc::TransactionStatus
+   * Lookup421: fp_rpc::TransactionStatus
    **/
   FpRpcTransactionStatus: {
     transactionHash: 'H256',
@@ -3127,11 +3123,11 @@
     logsBloom: 'EthbloomBloom'
   },
   /**
-   * Lookup420: ethbloom::Bloom
+   * Lookup423: ethbloom::Bloom
    **/
   EthbloomBloom: '[u8;256]',
   /**
-   * Lookup422: ethereum::receipt::ReceiptV3
+   * Lookup425: ethereum::receipt::ReceiptV3
    **/
   EthereumReceiptReceiptV3: {
     _enum: {
@@ -3141,7 +3137,7 @@
     }
   },
   /**
-   * Lookup423: ethereum::receipt::EIP658ReceiptData
+   * Lookup426: ethereum::receipt::EIP658ReceiptData
    **/
   EthereumReceiptEip658ReceiptData: {
     statusCode: 'u8',
@@ -3150,7 +3146,7 @@
     logs: 'Vec<EthereumLog>'
   },
   /**
-   * Lookup424: ethereum::block::Block<ethereum::transaction::TransactionV2>
+   * Lookup427: ethereum::block::Block<ethereum::transaction::TransactionV2>
    **/
   EthereumBlock: {
     header: 'EthereumHeader',
@@ -3158,7 +3154,7 @@
     ommers: 'Vec<EthereumHeader>'
   },
   /**
-   * Lookup425: ethereum::header::Header
+   * Lookup428: ethereum::header::Header
    **/
   EthereumHeader: {
     parentHash: 'H256',
@@ -3178,23 +3174,23 @@
     nonce: 'EthereumTypesHashH64'
   },
   /**
-   * Lookup426: ethereum_types::hash::H64
+   * Lookup429: ethereum_types::hash::H64
    **/
   EthereumTypesHashH64: '[u8;8]',
   /**
-   * Lookup431: pallet_ethereum::pallet::Error<T>
+   * Lookup434: pallet_ethereum::pallet::Error<T>
    **/
   PalletEthereumError: {
     _enum: ['InvalidSignature', 'PreLogExists']
   },
   /**
-   * Lookup432: pallet_evm_coder_substrate::pallet::Error<T>
+   * Lookup435: pallet_evm_coder_substrate::pallet::Error<T>
    **/
   PalletEvmCoderSubstrateError: {
     _enum: ['OutOfGas', 'OutOfFund']
   },
   /**
-   * Lookup433: up_data_structs::SponsorshipState<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
+   * Lookup436: up_data_structs::SponsorshipState<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
    **/
   UpDataStructsSponsorshipStateBasicCrossAccountIdRepr: {
     _enum: {
@@ -3204,25 +3200,25 @@
     }
   },
   /**
-   * Lookup434: pallet_evm_contract_helpers::SponsoringModeT
+   * Lookup437: pallet_evm_contract_helpers::SponsoringModeT
    **/
   PalletEvmContractHelpersSponsoringModeT: {
     _enum: ['Disabled', 'Allowlisted', 'Generous']
   },
   /**
-   * Lookup436: pallet_evm_contract_helpers::pallet::Error<T>
+   * Lookup439: pallet_evm_contract_helpers::pallet::Error<T>
    **/
   PalletEvmContractHelpersError: {
     _enum: ['NoPermission', 'NoPendingSponsor']
   },
   /**
-   * Lookup437: pallet_evm_migration::pallet::Error<T>
+   * Lookup440: pallet_evm_migration::pallet::Error<T>
    **/
   PalletEvmMigrationError: {
     _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']
   },
   /**
-   * Lookup439: sp_runtime::MultiSignature
+   * Lookup442: sp_runtime::MultiSignature
    **/
   SpRuntimeMultiSignature: {
     _enum: {
@@ -3232,43 +3228,43 @@
     }
   },
   /**
-   * Lookup440: sp_core::ed25519::Signature
+   * Lookup443: sp_core::ed25519::Signature
    **/
   SpCoreEd25519Signature: '[u8;64]',
   /**
-   * Lookup442: sp_core::sr25519::Signature
+   * Lookup445: sp_core::sr25519::Signature
    **/
   SpCoreSr25519Signature: '[u8;64]',
   /**
-   * Lookup443: sp_core::ecdsa::Signature
+   * Lookup446: sp_core::ecdsa::Signature
    **/
   SpCoreEcdsaSignature: '[u8;65]',
   /**
-   * Lookup446: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
+   * Lookup449: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
    **/
   FrameSystemExtensionsCheckSpecVersion: 'Null',
   /**
-   * Lookup447: frame_system::extensions::check_genesis::CheckGenesis<T>
+   * Lookup450: frame_system::extensions::check_genesis::CheckGenesis<T>
    **/
   FrameSystemExtensionsCheckGenesis: 'Null',
   /**
-   * Lookup450: frame_system::extensions::check_nonce::CheckNonce<T>
+   * Lookup453: frame_system::extensions::check_nonce::CheckNonce<T>
    **/
   FrameSystemExtensionsCheckNonce: 'Compact<u32>',
   /**
-   * Lookup451: frame_system::extensions::check_weight::CheckWeight<T>
+   * Lookup454: frame_system::extensions::check_weight::CheckWeight<T>
    **/
   FrameSystemExtensionsCheckWeight: 'Null',
   /**
-   * Lookup452: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
+   * Lookup455: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
    **/
   PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
   /**
-   * Lookup453: opal_runtime::Runtime
+   * Lookup456: opal_runtime::Runtime
    **/
   OpalRuntimeRuntime: 'Null',
   /**
-   * Lookup454: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
+   * Lookup457: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
    **/
   PalletEthereumFakeTransactionFinalizer: 'Null'
 };
modifiedtests/src/interfaces/types-lookup.tsdiffbeforeafterboth
2665 readonly asSetAdminAddress: {2665 readonly asSetAdminAddress: {
2666 readonly admin: PalletEvmAccountBasicCrossAccountIdRepr;2666 readonly admin: PalletEvmAccountBasicCrossAccountIdRepr;
2667 } & Struct;2667 } & Struct;
2668 readonly isStartAppPromotion: boolean;
2669 readonly asStartAppPromotion: {
2670 readonly promotionStartRelayBlock: Option<u32>;
2671 } & Struct;
2672 readonly isStopAppPromotion: boolean;
2673 readonly isStake: boolean;2668 readonly isStake: boolean;
2674 readonly asStake: {2669 readonly asStake: {
2675 readonly amount: u128;2670 readonly amount: u128;
2695 readonly asPayoutStakers: {2690 readonly asPayoutStakers: {
2696 readonly stakersNumber: Option<u8>;2691 readonly stakersNumber: Option<u8>;
2697 } & Struct;2692 } & Struct;
2698 readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'StopAppPromotion' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsoringCollection' | 'SponsorConract' | 'StopSponsoringContract' | 'PayoutStakers';2693 readonly type: 'SetAdminAddress' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsoringCollection' | 'SponsorConract' | 'StopSponsoringContract' | 'PayoutStakers';
2699 }2694 }
27002695
2701 /** @name PalletEvmCall (306) */2696 /** @name PalletEvmCall (306) */
3291 readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart';3286 readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart';
3292 }3287 }
32933288
3294 /** @name PalletAppPromotionError (412) */3289 /** @name PalletAppPromotionError (415) */
3295 interface PalletAppPromotionError extends Enum {3290 interface PalletAppPromotionError extends Enum {
3296 readonly isAdminNotSet: boolean;3291 readonly isAdminNotSet: boolean;
3297 readonly isNoPermission: boolean;3292 readonly isNoPermission: boolean;
3298 readonly isNotSufficientFounds: boolean;3293 readonly isNotSufficientFounds: boolean;
3294 readonly isPendingForBlockOverflow: boolean;
3299 readonly isInvalidArgument: boolean;3295 readonly isInvalidArgument: boolean;
3300 readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'InvalidArgument';3296 readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'PendingForBlockOverflow' | 'InvalidArgument';
3301 }3297 }
33023298
3303 /** @name PalletEvmError (415) */3299 /** @name PalletEvmError (418) */
3304 interface PalletEvmError extends Enum {3300 interface PalletEvmError extends Enum {
3305 readonly isBalanceLow: boolean;3301 readonly isBalanceLow: boolean;
3306 readonly isFeeOverflow: boolean;3302 readonly isFeeOverflow: boolean;
3311 readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';3307 readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';
3312 }3308 }
33133309
3314 /** @name FpRpcTransactionStatus (418) */3310 /** @name FpRpcTransactionStatus (421) */
3315 interface FpRpcTransactionStatus extends Struct {3311 interface FpRpcTransactionStatus extends Struct {
3316 readonly transactionHash: H256;3312 readonly transactionHash: H256;
3317 readonly transactionIndex: u32;3313 readonly transactionIndex: u32;
3322 readonly logsBloom: EthbloomBloom;3318 readonly logsBloom: EthbloomBloom;
3323 }3319 }
33243320
3325 /** @name EthbloomBloom (420) */3321 /** @name EthbloomBloom (423) */
3326 interface EthbloomBloom extends U8aFixed {}3322 interface EthbloomBloom extends U8aFixed {}
33273323
3328 /** @name EthereumReceiptReceiptV3 (422) */3324 /** @name EthereumReceiptReceiptV3 (425) */
3329 interface EthereumReceiptReceiptV3 extends Enum {3325 interface EthereumReceiptReceiptV3 extends Enum {
3330 readonly isLegacy: boolean;3326 readonly isLegacy: boolean;
3331 readonly asLegacy: EthereumReceiptEip658ReceiptData;3327 readonly asLegacy: EthereumReceiptEip658ReceiptData;
3336 readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';3332 readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';
3337 }3333 }
33383334
3339 /** @name EthereumReceiptEip658ReceiptData (423) */3335 /** @name EthereumReceiptEip658ReceiptData (426) */
3340 interface EthereumReceiptEip658ReceiptData extends Struct {3336 interface EthereumReceiptEip658ReceiptData extends Struct {
3341 readonly statusCode: u8;3337 readonly statusCode: u8;
3342 readonly usedGas: U256;3338 readonly usedGas: U256;
3343 readonly logsBloom: EthbloomBloom;3339 readonly logsBloom: EthbloomBloom;
3344 readonly logs: Vec<EthereumLog>;3340 readonly logs: Vec<EthereumLog>;
3345 }3341 }
33463342
3347 /** @name EthereumBlock (424) */3343 /** @name EthereumBlock (427) */
3348 interface EthereumBlock extends Struct {3344 interface EthereumBlock extends Struct {
3349 readonly header: EthereumHeader;3345 readonly header: EthereumHeader;
3350 readonly transactions: Vec<EthereumTransactionTransactionV2>;3346 readonly transactions: Vec<EthereumTransactionTransactionV2>;
3351 readonly ommers: Vec<EthereumHeader>;3347 readonly ommers: Vec<EthereumHeader>;
3352 }3348 }
33533349
3354 /** @name EthereumHeader (425) */3350 /** @name EthereumHeader (428) */
3355 interface EthereumHeader extends Struct {3351 interface EthereumHeader extends Struct {
3356 readonly parentHash: H256;3352 readonly parentHash: H256;
3357 readonly ommersHash: H256;3353 readonly ommersHash: H256;
3370 readonly nonce: EthereumTypesHashH64;3366 readonly nonce: EthereumTypesHashH64;
3371 }3367 }
33723368
3373 /** @name EthereumTypesHashH64 (426) */3369 /** @name EthereumTypesHashH64 (429) */
3374 interface EthereumTypesHashH64 extends U8aFixed {}3370 interface EthereumTypesHashH64 extends U8aFixed {}
33753371
3376 /** @name PalletEthereumError (431) */3372 /** @name PalletEthereumError (434) */
3377 interface PalletEthereumError extends Enum {3373 interface PalletEthereumError extends Enum {
3378 readonly isInvalidSignature: boolean;3374 readonly isInvalidSignature: boolean;
3379 readonly isPreLogExists: boolean;3375 readonly isPreLogExists: boolean;
3380 readonly type: 'InvalidSignature' | 'PreLogExists';3376 readonly type: 'InvalidSignature' | 'PreLogExists';
3381 }3377 }
33823378
3383 /** @name PalletEvmCoderSubstrateError (432) */3379 /** @name PalletEvmCoderSubstrateError (435) */
3384 interface PalletEvmCoderSubstrateError extends Enum {3380 interface PalletEvmCoderSubstrateError extends Enum {
3385 readonly isOutOfGas: boolean;3381 readonly isOutOfGas: boolean;
3386 readonly isOutOfFund: boolean;3382 readonly isOutOfFund: boolean;
3387 readonly type: 'OutOfGas' | 'OutOfFund';3383 readonly type: 'OutOfGas' | 'OutOfFund';
3388 }3384 }
33893385
3390 /** @name UpDataStructsSponsorshipStateBasicCrossAccountIdRepr (433) */3386 /** @name UpDataStructsSponsorshipStateBasicCrossAccountIdRepr (436) */
3391 interface UpDataStructsSponsorshipStateBasicCrossAccountIdRepr extends Enum {3387 interface UpDataStructsSponsorshipStateBasicCrossAccountIdRepr extends Enum {
3392 readonly isDisabled: boolean;3388 readonly isDisabled: boolean;
3393 readonly isUnconfirmed: boolean;3389 readonly isUnconfirmed: boolean;
3397 readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed';3393 readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed';
3398 }3394 }
33993395
3400 /** @name PalletEvmContractHelpersSponsoringModeT (434) */3396 /** @name PalletEvmContractHelpersSponsoringModeT (437) */
3401 interface PalletEvmContractHelpersSponsoringModeT extends Enum {3397 interface PalletEvmContractHelpersSponsoringModeT extends Enum {
3402 readonly isDisabled: boolean;3398 readonly isDisabled: boolean;
3403 readonly isAllowlisted: boolean;3399 readonly isAllowlisted: boolean;
3404 readonly isGenerous: boolean;3400 readonly isGenerous: boolean;
3405 readonly type: 'Disabled' | 'Allowlisted' | 'Generous';3401 readonly type: 'Disabled' | 'Allowlisted' | 'Generous';
3406 }3402 }
34073403
3408 /** @name PalletEvmContractHelpersError (436) */3404 /** @name PalletEvmContractHelpersError (439) */
3409 interface PalletEvmContractHelpersError extends Enum {3405 interface PalletEvmContractHelpersError extends Enum {
3410 readonly isNoPermission: boolean;3406 readonly isNoPermission: boolean;
3411 readonly isNoPendingSponsor: boolean;3407 readonly isNoPendingSponsor: boolean;
3412 readonly type: 'NoPermission' | 'NoPendingSponsor';3408 readonly type: 'NoPermission' | 'NoPendingSponsor';
3413 }3409 }
34143410
3415 /** @name PalletEvmMigrationError (437) */3411 /** @name PalletEvmMigrationError (440) */
3416 interface PalletEvmMigrationError extends Enum {3412 interface PalletEvmMigrationError extends Enum {
3417 readonly isAccountNotEmpty: boolean;3413 readonly isAccountNotEmpty: boolean;
3418 readonly isAccountIsNotMigrating: boolean;3414 readonly isAccountIsNotMigrating: boolean;
3419 readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';3415 readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';
3420 }3416 }
34213417
3422 /** @name SpRuntimeMultiSignature (439) */3418 /** @name SpRuntimeMultiSignature (442) */
3423 interface SpRuntimeMultiSignature extends Enum {3419 interface SpRuntimeMultiSignature extends Enum {
3424 readonly isEd25519: boolean;3420 readonly isEd25519: boolean;
3425 readonly asEd25519: SpCoreEd25519Signature;3421 readonly asEd25519: SpCoreEd25519Signature;
3430 readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';3426 readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';
3431 }3427 }
34323428
3433 /** @name SpCoreEd25519Signature (440) */3429 /** @name SpCoreEd25519Signature (443) */
3434 interface SpCoreEd25519Signature extends U8aFixed {}3430 interface SpCoreEd25519Signature extends U8aFixed {}
34353431
3436 /** @name SpCoreSr25519Signature (442) */3432 /** @name SpCoreSr25519Signature (445) */
3437 interface SpCoreSr25519Signature extends U8aFixed {}3433 interface SpCoreSr25519Signature extends U8aFixed {}
34383434
3439 /** @name SpCoreEcdsaSignature (443) */3435 /** @name SpCoreEcdsaSignature (446) */
3440 interface SpCoreEcdsaSignature extends U8aFixed {}3436 interface SpCoreEcdsaSignature extends U8aFixed {}
34413437
3442 /** @name FrameSystemExtensionsCheckSpecVersion (446) */3438 /** @name FrameSystemExtensionsCheckSpecVersion (449) */
3443 type FrameSystemExtensionsCheckSpecVersion = Null;3439 type FrameSystemExtensionsCheckSpecVersion = Null;
34443440
3445 /** @name FrameSystemExtensionsCheckGenesis (447) */3441 /** @name FrameSystemExtensionsCheckGenesis (450) */
3446 type FrameSystemExtensionsCheckGenesis = Null;3442 type FrameSystemExtensionsCheckGenesis = Null;
34473443
3448 /** @name FrameSystemExtensionsCheckNonce (450) */3444 /** @name FrameSystemExtensionsCheckNonce (453) */
3449 interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}3445 interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}
34503446
3451 /** @name FrameSystemExtensionsCheckWeight (451) */3447 /** @name FrameSystemExtensionsCheckWeight (454) */
3452 type FrameSystemExtensionsCheckWeight = Null;3448 type FrameSystemExtensionsCheckWeight = Null;
34533449
3454 /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (452) */3450 /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (455) */
3455 interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}3451 interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}
34563452
3457 /** @name OpalRuntimeRuntime (453) */3453 /** @name OpalRuntimeRuntime (456) */
3458 type OpalRuntimeRuntime = Null;3454 type OpalRuntimeRuntime = Null;
34593455
3460 /** @name PalletEthereumFakeTransactionFinalizer (454) */3456 /** @name PalletEthereumFakeTransactionFinalizer (457) */
3461 type PalletEthereumFakeTransactionFinalizer = Null;3457 type PalletEthereumFakeTransactionFinalizer = Null;
34623458
3463} // declare module3459} // declare module
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -48,7 +48,7 @@
   Fungible = 'fungible',
   NFT = 'nonfungible',
   Scheduler = 'scheduler',
-  AppPromotion = 'promotion',
+  AppPromotion = 'apppromotion',
 }
 
 export async function isUnique(): Promise<boolean> {
modifiedtests/src/util/playgrounds/unique.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -2008,7 +2008,7 @@
     if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;
     const stakeResult = await this.helper.executeExtrinsic(
       signer,
-      'api.tx.promotion.stake', [amountToStake],
+      'api.tx.appPromotion.stake', [amountToStake],
       true, `stake failed for ${label}`,
     );
     // TODO extract info from stakeResult
@@ -2026,7 +2026,7 @@
     if(typeof label === 'undefined') label = `${signer.address}`;
     const unstakeResult = await this.helper.executeExtrinsic(
       signer,
-      'api.tx.promotion.unstake', [],
+      'api.tx.appPromotion.unstake', [],
       true, `unstake failed for ${label}`,
     );
     // TODO extract info from unstakeResult