git.delta.rocks / unique-network / refs/commits / 35a9f8c20edd

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5304,9 +5304,11 @@
  "frame-support",
  "frame-system",
  "pallet-balances",
+ "pallet-common",
  "pallet-evm",
  "pallet-randomness-collective-flip",
  "pallet-timestamp",
+ "pallet-unique",
  "parity-scale-codec 3.1.5",
  "scale-info",
  "serde",
@@ -5314,6 +5316,7 @@
  "sp-io",
  "sp-runtime",
  "sp-std",
+ "up-data-structs",
 ]
 
 [[package]]

--- a/pallets/app-promotion/Cargo.toml
+++ b/pallets/app-promotion/Cargo.toml
@@ -104,6 +104,22 @@
 git = "https://github.com/uniquenetwork/frontier"
 branch = "unique-polkadot-v0.9.27"
 
+################################################################################
+# local dependencies
+[dependencies.up-data-structs]
+default-features = false
+path =  "../../primitives/data-structs"
+
+[dependencies.pallet-common]
+default-features = false
+path =  "../common"
+
+[dependencies.pallet-unique]
+default-features = false
+path =  "../unique"
+
+################################################################################
+
 [dependencies]
 scale-info = { version = "2.0.1", default-features = false, features = [
     "derive",

--- a/pallets/app-promotion/src/benchmarking.rs
+++ b/pallets/app-promotion/src/benchmarking.rs
@@ -59,7 +59,7 @@
 		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
 		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?;
 
-	} : {PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}
+	} : {PromototionPallet::<T>::unstake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}
 
 	recalculate_stake {
 		let caller = account::<T::AccountId>("caller", 0, SEED);

--- a/pallets/app-promotion/src/lib.rs
+++ b/pallets/app-promotion/src/lib.rs
@@ -36,11 +36,14 @@
 pub mod types;
 pub mod weights;
 
-use sp_std::{vec::Vec, iter::Sum};
+use sp_std::{vec::Vec, iter::Sum, borrow::ToOwned};
 use codec::EncodeLike;
 use pallet_balances::BalanceLock;
 pub use types::ExtendedLockableCurrency;
 
+// use up_common::constants::{DAYS, UNIQUE};
+use up_data_structs::CollectionId;
+
 use frame_support::{
 	dispatch::{DispatchResult},
 	traits::{
@@ -55,38 +58,68 @@
 use pallet_evm::account::CrossAccountId;
 use sp_runtime::{
 	Perbill,
-	traits::{BlockNumberProvider, CheckedAdd, CheckedSub},
+	traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion},
 	ArithmeticError,
 };
 
 type BalanceOf<T> =
 	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
 
-const SECONDS_TO_BLOCK: u32 = 6;
-const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK;
-const WEEK: u32 = 7 * DAY;
-const TWO_WEEK: u32 = 2 * WEEK;
-const YEAR: u32 = DAY * 365;
+// const SECONDS_TO_BLOCK: u32 = 6;
+// const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK;
+// const WEEK: u32 = 7 * DAY;
+// const TWO_WEEK: u32 = 2 * WEEK;
+// const YEAR: u32 = DAY * 365;
 
 pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";
 
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};
+	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId};
 	use frame_system::pallet_prelude::*;
+	use types::CollectionHandler;
 
 	#[pallet::config]
 	pub trait Config: frame_system::Config + pallet_evm::account::Config {
 		type Currency: ExtendedLockableCurrency<Self::AccountId>;
 
+		type CollectionHandler: CollectionHandler<
+			AccountId = Self::AccountId,
+			CollectionId = CollectionId,
+		>;
+
 		type TreasuryAccountId: Get<Self::AccountId>;
 
+		/// The app's pallet id, used for deriving its sovereign account ID.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// In relay blocks.
+		#[pallet::constant]
+		type RecalculationInterval: Get<Self::BlockNumber>;
+		/// In chain blocks.
+		#[pallet::constant]
+		type PendingInterval: Get<Self::BlockNumber>;
+
+		/// In chain blocks.
+		#[pallet::constant]
+		type Day: Get<Self::BlockNumber>; // useless
+
+		#[pallet::constant]
+		type Nominal: Get<BalanceOf<Self>>;
+
+		#[pallet::constant]
+		type IntervalIncome: Get<Perbill>;
+
 		/// Weight information for extrinsics in this pallet.
 		type WeightInfo: WeightInfo;
 
-		// The block number provider
-		type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
+		// The relay block number provider
+		type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
+
+		/// Events compatible with [`frame_system::Config::Event`].
+		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;
 
 		// /// Number of blocks that pass between treasury balance updates due to inflation
 		// #[pallet::constant]
@@ -100,6 +133,28 @@
 	#[pallet::generate_store(pub(super) trait Store)]
 	pub struct Pallet<T>(_);
 
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event<T: Config> {
+		StakingRecalculation(
+			/// Base on which interest is calculated
+			BalanceOf<T>,
+			/// Amount of accrued interest
+			BalanceOf<T>,
+		),
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		AdminNotSet,
+		/// No permission to perform action
+		NoPermission,
+		/// Insufficient funds to perform an action
+		NotSufficientFounds,
+		InvalidArgument,
+		AlreadySponsored,
+	}
+
 	#[pallet::storage]
 	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;
 
@@ -164,23 +219,33 @@
 				});
 
 			let next_interest_block = Self::get_interest_block();
-
-			if next_interest_block != 0.into() && current_block >= next_interest_block {
+			let current_relay_block = T::RelayBlockNumberProvider::current_block_number();
+			if next_interest_block != 0.into() && current_relay_block >= next_interest_block {
 				let mut acc = <BalanceOf<T>>::default();
+				let mut base_acc = <BalanceOf<T>>::default();
 
-				NextInterestBlock::<T>::set(current_block + DAY.into());
+				NextInterestBlock::<T>::set(
+					NextInterestBlock::<T>::get() + T::RecalculationInterval::get(),
+				);
 				add_weight(0, 1, 0);
 
 				Staked::<T>::iter()
-					.filter(|((_, block), _)| *block + DAY.into() <= current_block)
+					.filter(|((_, block), _)| {
+						*block + T::RecalculationInterval::get() <= current_relay_block
+					})
 					.for_each(|((staker, block), amount)| {
 						Self::recalculate_stake(&staker, block, amount, &mut acc);
 						add_weight(0, 0, T::WeightInfo::recalculate_stake());
+						base_acc += amount;
 					});
 				<TotalStaked<T>>::get()
 					.checked_add(&acc)
 					.map(|res| <TotalStaked<T>>::set(res));
+
+				Self::deposit_event(Event::StakingRecalculation(base_acc, acc));
 				add_weight(0, 1, 0);
+			} else {
+				add_weight(1, 0, 0)
 			};
 			consumed_weight
 		}
@@ -189,9 +254,9 @@
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		#[pallet::weight(T::WeightInfo::set_admin_address())]
-		pub fn set_admin_address(origin: OriginFor<T>, admin: T::AccountId) -> DispatchResult {
+		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {
 			ensure_root(origin)?;
-			<Admin<T>>::set(Some(admin));
+			<Admin<T>>::set(Some(admin.as_sub().to_owned()));
 
 			Ok(())
 		}
@@ -199,7 +264,7 @@
 		#[pallet::weight(T::WeightInfo::start_app_promotion())]
 		pub fn start_app_promotion(
 			origin: OriginFor<T>,
-			promotion_start_relay_block: T::BlockNumber,
+			promotion_start_relay_block: Option<T::BlockNumber>,
 		) -> DispatchResult
 		where
 			<T as frame_system::Config>::BlockNumber: From<u32>,
@@ -208,10 +273,13 @@
 
 			// Start app-promotion mechanics if it has not been yet initialized
 			if <StartBlock<T>>::get() == 0u32.into() {
+				let start_block = promotion_start_relay_block
+					.unwrap_or(T::RelayBlockNumberProvider::current_block_number());
+
 				// Set promotion global start block
-				<StartBlock<T>>::set(promotion_start_relay_block);
+				<StartBlock<T>>::set(start_block);
 
-				<NextInterestBlock<T>>::set(promotion_start_relay_block + DAY.into());
+				<NextInterestBlock<T>>::set(start_block + T::RecalculationInterval::get());
 			}
 
 			Ok(())
@@ -221,6 +289,8 @@
 		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
 			let staker_id = ensure_signed(staker)?;
 
+			ensure!(amount >= T::Nominal::get(), ArithmeticError::Underflow);
+
 			let balance =
 				<<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);
 
@@ -235,7 +305,7 @@
 
 			Self::add_lock_balance(&staker_id, amount)?;
 
-			let block_number = frame_system::Pallet::<T>::block_number();
+			let block_number = T::RelayBlockNumberProvider::current_block_number();
 
 			<Staked<T>>::insert(
 				(&staker_id, block_number),
@@ -271,7 +341,7 @@
 					.ok_or(ArithmeticError::Underflow)?,
 			);
 
-			let block = frame_system::Pallet::<T>::block_number() + WEEK.into();
+			let block = frame_system::Pallet::<T>::block_number() + T::PendingInterval::get();
 			<PendingUnstake<T>>::insert(
 				(&staker_id, block),
 				<PendingUnstake<T>>::get((&staker_id, block))
@@ -311,6 +381,40 @@
 
 			Ok(())
 		}
+
+		#[pallet::weight(0)]
+		pub fn sponsor_collection(
+			admin: OriginFor<T>,
+			collection_id: CollectionId,
+		) -> DispatchResult {
+			let admin_id = ensure_signed(admin)?;
+			ensure!(
+				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,
+				Error::<T>::NoPermission
+			);
+
+			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)
+		}
+		#[pallet::weight(0)]
+		pub fn stop_sponsorign_collection(
+			admin: OriginFor<T>,
+			collection_id: CollectionId,
+		) -> DispatchResult {
+			let admin_id = ensure_signed(admin)?;
+
+			ensure!(
+				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,
+				Error::<T>::NoPermission
+			);
+
+			ensure!(
+				T::CollectionHandler::get_sponsor(collection_id)?
+					.ok_or(<Error<T>>::InvalidArgument)?
+					== Self::account_id(),
+				<Error<T>>::NoPermission
+			);
+			T::CollectionHandler::remove_collection_sponsor(collection_id)
+		}
 	}
 }
 
@@ -396,13 +500,13 @@
 	// 	Ok(())
 	// }
 
-	pub fn sponsor_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {
-		Ok(())
-	}
+	// pub fn sponsor_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {
+	// 	Ok(())
+	// }
 
-	pub fn stop_sponsorign_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {
-		Ok(())
-	}
+	// pub fn stop_sponsorign_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {
+	// 	Ok(())
+	// }
 
 	pub fn sponsor_conract(admin: T::AccountId, app_id: u32) -> DispatchResult {
 		Ok(())
@@ -411,6 +515,10 @@
 	pub fn stop_sponsorign_contract(admin: T::AccountId, app_id: u32) -> DispatchResult {
 		Ok(())
 	}
+
+	pub fn account_id() -> T::AccountId {
+		T::PalletId::get().into_account_truncating()
+	}
 }
 
 impl<T: Config> Pallet<T> {
@@ -514,8 +622,7 @@
 	where
 		I: EncodeLike<BalanceOf<T>> + Balance,
 	{
-		let day_rate = Perbill::from_rational(5u32, 1_0000);
-		day_rate * base
+		T::IntervalIncome::get() * base
 	}
 }
 

--- a/pallets/app-promotion/src/tests.rs
+++ b/pallets/app-promotion/src/tests.rs
@@ -28,7 +28,7 @@
 use sp_runtime::{
 	traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup},
 	testing::Header,
-	Perbill,
+	Perbill, Perquintill,
 };
 
 // type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
@@ -126,3 +126,25 @@
 // 		test_benchmark_stake::<Test>();
 // 	} )
 // }
+
+#[test]
+fn test_perbill() {
+	const ONE_UNIQE: u128 = 1_000_000_000_000_000_000;
+	const SECONDS_TO_BLOCK: u32 = 12;
+	const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK;
+	const RECALCULATION_INTERVAL: u32 = 10;
+	let day_rate = Perbill::from_rational(5u64, 10_000);
+	let interval_rate =
+		Perbill::from_rational::<u64>(RECALCULATION_INTERVAL.into(), DAY.into()) * day_rate;
+	println!("{:?}", interval_rate * ONE_UNIQE + ONE_UNIQE);
+	println!("{:?}", day_rate * ONE_UNIQE);
+	println!("{:?}", Perbill::one() * ONE_UNIQE);
+	println!("{:?}", ONE_UNIQE);
+	let mut next_iters = ONE_UNIQE + interval_rate * ONE_UNIQE;
+	next_iters += interval_rate * next_iters;
+	println!("{:?}", next_iters);
+	let day_income = day_rate * ONE_UNIQE;
+	let interval_income = interval_rate * ONE_UNIQE;
+	let ratio = day_income / interval_income;
+	println!("{:?} || {:?}", ratio, DAY / RECALCULATION_INTERVAL);
+}

--- a/pallets/app-promotion/src/types.rs
+++ b/pallets/app-promotion/src/types.rs
@@ -1,6 +1,14 @@
 use codec::EncodeLike;
-use frame_support::{traits::LockableCurrency, WeakBoundedVec, Parameter};
+use frame_support::{
+	traits::LockableCurrency, WeakBoundedVec, Parameter, dispatch::DispatchResult, ensure,
+};
+use frame_system::Config;
 use pallet_balances::{BalanceLock, Config as BalancesConfig, Pallet as PalletBalances};
+use pallet_common::CollectionHandle;
+use pallet_unique::{Event as UniqueEvent, Error as UniqueError};
+use sp_runtime::DispatchError;
+use up_data_structs::{CollectionId, SponsorshipState};
+use sp_std::borrow::ToOwned;
 
 pub trait ExtendedLockableCurrency<AccountId: Parameter>: LockableCurrency<AccountId> {
 	fn locks<KArg>(who: KArg) -> WeakBoundedVec<BalanceLock<Self::Balance>, Self::MaxLocks>
@@ -18,3 +26,70 @@
 		Self::locks(who)
 	}
 }
+
+pub trait CollectionHandler {
+	type CollectionId;
+	type AccountId;
+
+	fn set_sponsor(
+		sponsor_id: Self::AccountId,
+		collection_id: Self::CollectionId,
+	) -> DispatchResult;
+
+	fn remove_collection_sponsor(collection_id: Self::CollectionId) -> DispatchResult;
+
+	fn get_sponsor(
+		collection_id: Self::CollectionId,
+	) -> Result<Option<Self::AccountId>, DispatchError>;
+}
+
+impl<T: pallet_unique::Config> CollectionHandler for pallet_unique::Pallet<T> {
+	type CollectionId = CollectionId;
+
+	type AccountId = T::AccountId;
+
+	fn set_sponsor(
+		sponsor_id: Self::AccountId,
+		collection_id: Self::CollectionId,
+	) -> DispatchResult {
+		let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+		target_collection.check_is_internal()?;
+		target_collection.set_sponsor(sponsor_id.clone())?;
+
+		Self::deposit_event(UniqueEvent::<T>::CollectionSponsorSet(
+			collection_id,
+			sponsor_id.clone(),
+		));
+
+		ensure!(
+			target_collection.confirm_sponsorship(&sponsor_id)?,
+			UniqueError::<T>::ConfirmUnsetSponsorFail
+		);
+
+		Self::deposit_event(UniqueEvent::<T>::SponsorshipConfirmed(
+			collection_id,
+			sponsor_id,
+		));
+
+		target_collection.save()
+	}
+
+	fn remove_collection_sponsor(collection_id: Self::CollectionId) -> DispatchResult {
+		let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+		target_collection.check_is_internal()?;
+		target_collection.sponsorship = SponsorshipState::Disabled;
+
+		Self::deposit_event(UniqueEvent::<T>::CollectionSponsorRemoved(collection_id));
+
+		target_collection.save()
+	}
+
+	fn get_sponsor(
+		collection_id: Self::CollectionId,
+	) -> Result<Option<Self::AccountId>, DispatchError> {
+		Ok(<CollectionHandle<T>>::try_get(collection_id)?
+			.sponsorship
+			.pending_sponsor()
+			.map(|acc| acc.to_owned()))
+	}
+}

--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -277,7 +277,7 @@
 	{
 		type Error = Error<T>;
 
-		fn deposit_event() = default;
+		pub fn deposit_event() = default;
 
 		fn on_initialize(_now: T::BlockNumber) -> Weight {
 			0

--- a/runtime/common/config/pallets/app_promotion.rs
+++ b/runtime/common/config/pallets/app_promotion.rs
@@ -16,12 +16,36 @@
 
 use crate::{
 	runtime_common::config::pallets::{TreasuryAccountId, RelayChainBlockNumberProvider},
-	Runtime, Balances,
+	Runtime, Balances, BlockNumber, Unique, Event,
+};
+
+use frame_support::{parameter_types, PalletId};
+use sp_arithmetic::Perbill;
+use up_common::{
+	constants::{DAYS, UNIQUE},
+	types::Balance,
 };
 
+parameter_types! {
+	pub const AppPromotionId: PalletId = PalletId(*b"appstake");
+	pub const RecalculationInterval: BlockNumber = 20;
+	pub const PendingInterval: BlockNumber = 10;
+	pub const Nominal: Balance = UNIQUE;
+	pub const Day: BlockNumber = DAYS;
+	pub IntervalIncome: Perbill = Perbill::from_rational(RecalculationInterval::get(), 2 * DAYS) * Perbill::from_rational(5u32, 10_000);
+}
+
 impl pallet_app_promotion::Config for Runtime {
+	type PalletId = AppPromotionId;
+	type CollectionHandler = Unique;
 	type Currency = Balances;
 	type WeightInfo = pallet_app_promotion::weights::SubstrateWeight<Self>;
 	type TreasuryAccountId = TreasuryAccountId;
-	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
+	type RelayBlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
+	type RecalculationInterval = RecalculationInterval;
+	type PendingInterval = PendingInterval;
+	type Day = Day;
+	type Nominal = Nominal;
+	type IntervalIncome = IntervalIncome;
+	type Event = Event;
 }

--- 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} = 73,
+                Promotion: pallet_app_promotion::{Pallet, Call, Storage, Event<T>} = 73,
 
                 // Frontier
                 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,

--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -40,32 +40,32 @@
 
 import chai, {use} from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import getBalance, {getBalanceSingle} from './substrate/get-balance';
-import {unique} from './interfaces/definitions';
 import {usingPlaygrounds} from './util/playgrounds';
 import {default as waitNewBlocks} from './substrate/wait-new-blocks';
 
-import BN from 'bn.js';
-import {mnemonicGenerate} from '@polkadot/util-crypto';
+import {encodeAddress, hdEthereum, mnemonicGenerate} from '@polkadot/util-crypto';
+import {stringToU8a} from '@polkadot/util';
 import {UniqueHelper} from './util/playgrounds/unique';
+import {ApiPromise} from '@polkadot/api';
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
 let alice: IKeyringPair;
 let bob: IKeyringPair;
 let palletAdmin: IKeyringPair;
-let nominal: bigint; 
+let nominal: bigint;
+let promotionStartBlock: number | null = null;
 
-describe('integration test: AppPromotion', () => {
+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');
       bob = privateKeyWrapper('//Bob');
       palletAdmin = privateKeyWrapper('//palletAdmin');
-      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
       nominal = helper.balance.getOneTokenNominal();
-      await submitTransactionAsync(alice, tx);
+      await helper.signTransaction(alice, tx);
     });
   });
   it('will change balance state to "locked", add it to "staked" map, and increase "totalStaked" amount', async () => {
@@ -85,18 +85,19 @@
       const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
       const staker = await createUser();
    
-      const firstStakedBlock = await helper.chain.getLatestBlockNumber();
       
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
+      
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(nominal / 2n))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
       expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);
       expect(9n * nominal - await helper.balance.getSubstrate(staker.address) <= nominal / 2n).to.be.true;
       expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);
       expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + nominal);
       
       await waitNewBlocks(helper.api!, 1);
-      const secondStakedBlock = await helper.chain.getLatestBlockNumber();
       
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
+      
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
       expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(3n * nominal);
       
       const stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]);
@@ -115,9 +116,9 @@
       
       const staker = await createUser();
       
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected;
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled;
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected;
       
     });
   });
@@ -128,17 +129,10 @@
 
     // assert:  query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]
     await usingPlaygrounds(async helper => {
-      // const userOne = await createUser();
-      // const userTwo = await createUser();
-      // const userThree = await createUser();
-      // const userFour = await createUser();
       const crowd = [];
       for(let i = 4; i--;) crowd.push(await createUser());
-      // const crowd = await creteAccounts([10n, 10n, 10n, 10n], alice, helper);
-      // const crowd = [userOne, userTwo, userThree, userFour];
-      
       
-      const promises = crowd.map(async user => submitTransactionAsync(user, helper.api!.tx.promotion.stake(nominal)));
+      const promises = crowd.map(async user => helper.signTransaction(user, helper.api!.tx.promotion.stake(nominal)));
       await expect(Promise.all(promises)).to.be.eventually.fulfilled;
     
       for (let i = 0; i < crowd.length; i++){
@@ -156,9 +150,9 @@
       alice = privateKeyWrapper('//Alice');
       bob = privateKeyWrapper('//Bob');
       palletAdmin = privateKeyWrapper('//palletAdmin');
-      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
       nominal = helper.balance.getOneTokenNominal();
-      await submitTransactionAsync(alice, tx);
+      await helper.signTransaction(alice, tx);
     });
   });
   
@@ -174,8 +168,8 @@
     await usingPlaygrounds(async helper => {
       const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
       const staker = await createUser();
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled;
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled;
       expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal);
       expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(2n * nominal);
       expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + 2n * nominal);
@@ -204,18 +198,18 @@
     await usingPlaygrounds(async helper => {
       const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
       const staker = await createUser();
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled;
       let stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
       expect(stakedPerBlock).to.be.deep.equal([nominal, 2n * nominal, 3n * nominal]);
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled;
       expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal / 10n);
       stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
       
       expect(stakedPerBlock).to.be.deep.equal([7n * nominal / 10n, 2n * nominal, 3n * nominal]);
       
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled;
       stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
       expect(stakedPerBlock).to.be.deep.equal([nominal, 3n * nominal]);
       const unstakedPerBlock = (await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
@@ -223,7 +217,7 @@
       expect(unstakedPerBlock).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n]);
       
       await waitNewBlocks(helper.api!, 1);
-      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled;
       expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([]);
       expect((await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n, 4n * nominal]);
     });
@@ -232,9 +226,643 @@
 });
 
 
+
+describe('Admin adress', () => {
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+      palletAdmin = privateKeyWrapper('//palletAdmin');
+      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
+      
+      await helper.signTransaction(alice, tx);
+      
+      nominal = helper.balance.getOneTokenNominal();
+    });
+  });
+
+  it('can be set by sudo only', async () => {
+    // assert:  Sudo calls appPromotion.setAdminAddress(Alice) /// Sudo successfully sets Alice as admin
+    // assert:  Bob calls appPromotion.setAdminAddress(Bob) throws /// Random account can not set admin
+    // assert:  Alice calls appPromotion.setAdminAddress(Bob) throws /// Admin account can not set admin
+    await usingPlaygrounds(async (helper) => {
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(bob, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled;
+    });
+    
+  });
+  
+  it('can be any valid CrossAccountId', async () => {
+    /// We are not going to set an eth address as a sponsor,
+    /// but we do want to check, it doesn't break anything;
+
+    // arrange: Charlie creates Punks
+    // arrange: Sudo calls appPromotion.setAdminAddress(0x0...) success
+    // arrange: Sudo calls appPromotion.setAdminAddress(Alice) success
+    
+    // assert:  Alice calls appPromotion.sponsorCollection(Punks.id) success
+    
+    await usingPlaygrounds(async (helper) => {
+      
+      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
+      
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(ethAcc)))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))))).to.be.eventually.fulfilled;
+      
+      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
+    });
+    
+  });
+
+  it('can be reassigned', async () => {
+    // arrange: Charlie creates Punks
+    // arrange: Sudo calls appPromotion.setAdminAddress(Alice)
+    // act:     Sudo calls appPromotion.setAdminAddress(Bob)
+
+    // assert:  Alice calls appPromotion.sponsorCollection(Punks.id) throws /// Alice can not set collection sponsor
+    // assert:  Bob calls appPromotion.sponsorCollection(Punks.id) successful /// Bob can set collection sponsor
+
+    // act:     Sudo calls appPromotion.setAdminAddress(null) successful /// Sudo can set null as a sponsor
+    // assert:  Bob calls appPromotion.stopSponsoringCollection(Punks.id) throws /// Bob is no longer an admin
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+      
+      await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
+    });
+    
+  });
+
+});
+
+describe('App-promotion collection sponsoring', () => {
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+      palletAdmin = privateKeyWrapper('//palletAdmin');
+      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
+      await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());
+       
+      
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
+      await helper.signTransaction(alice, tx);
+      
+      // const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock));
+      // await helper.signTransaction(alice, txStart);
+      
+      nominal = helper.balance.getOneTokenNominal();
+    });
+  });
+    
+  it('can not be set by non admin', async () => {
+    
+    
+    // arrange: Charlie creates Punks
+    // arrange: Sudo calls appPromotion.setAdminAddress(Alice)
+
+    // assert:  Random calls appPromotion.sponsorCollection(Punks.id) throws /// Random account can not set sponsoring
+    // assert:  Alice calls appPromotion.sponsorCollection(Punks.id) success /// Admin account can set sponsoring
+    
+    await usingPlaygrounds(async (helper) => {
+      const colletcion  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      
+      const collectionId = colletcion.collectionId;
+      
+      await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
+    });
+    
+  });
+
+  it('will set pallet address as confirmed admin for collection without sponsor', async () => {
+    // arrange: Charlie creates Punks
+
+    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
+
+    // assert:  query collectionById: Punks sponsoring is confirmed by PalleteAddress
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection  = await helper.nft.mintCollection(alice, {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;
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
+    });
+    
+  });
+
+  it('will set pallet address as confirmed admin for collection with unconfirmed sponsor', async () => {
+    // arrange: Charlie creates Punks
+    // arrange: Charlie calls setCollectionSponsor(Punks.Id, Dave) /// Dave is unconfirmed sponsor
+
+    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
+
+    // assert:  query collectionById: Punks sponsoring is confirmed by PalleteAddress
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      await collection.setSponsor(alice, bob.address);
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});
+      
+      const collectionId = collection.collectionId;
+      
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
+    });
+    
+  });
+
+  it('will set pallet address as confirmed admin for collection with confirmed sponsor', async () => {
+    // arrange: Charlie creates Punks
+    // arrange: setCollectionSponsor(Punks.Id, Dave)
+    // arrange: confirmSponsorship(Punks.Id, Dave) /// Dave is confirmed sponsor
+
+    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
+
+    // assert:  query collectionById: Punks sponsoring is confirmed by PalleteAddress
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      await collection.setSponsor(alice, bob.address);
+  
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});
+      expect(await collection.confirmSponsorship(bob)).to.be.true;
+      
+      const collectionId = collection.collectionId;
+      
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
+    });
+  });
+
+  it('can be overwritten by collection owner', async () => {
+    // arrange: Charlie creates Punks
+    // arrange: appPromotion.sponsorCollection(Punks.Id)  /// Sponsor of Punks is pallete
+
+    // act:     Charlie calls unique.setCollectionLimits(limits) /// Charlie as owner can successfully change limits
+    // assert:  query collectionById(Punks.id) 1. sponsored by pallete, 2. limits has been changed
+
+    // act:     Charlie calls setCollectionSponsor(Dave) /// Collection owner reasignes sponsoring
+    // assert:  query collectionById: Punks sponsoring is unconfirmed by Dave
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection  = await helper.nft.mintCollection(alice, {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;
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
+      
+      expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true;
+      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);
+      
+      expect((await collection.setSponsor(alice, bob.address))).to.be.true;
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});
+    });
+    
+  });
+  
+  it('will keep collection limits set by the owner earlier', async () => {
+    // arrange: const limits = {...all possible collection limits}
+    // arrange: Charlie creates Punks
+    // arrange: Charlie calls unique.setCollectionLimits(limits) /// Owner sets all possible limits
+
+    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
+    // assert:  query collectionById(Punks.id) returns limits
+    
+    await usingPlaygrounds(async (helper) => {
+      
+      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true;
+      const limits = (await collection.getData())?.raw.limits;
+      
+      const collectionId = collection.collectionId;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
+      expect((await collection.getData())?.raw.limits).to.be.deep.equal(limits);
+    });
+    
+  });
+  
+  it('will throw if collection doesn\'t exist', async () => {
+    // assert:  Admin calls appPromotion.sponsorCollection(999999999999999) throw 
+    await usingPlaygrounds(async (helper) => {
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;
+    });
+  });
+
+  it('will throw if collection was burnt', async () => {
+    // arrange: Charlie creates Punks
+    // arrange: Charlie burns Punks
+
+    // assert:  Admin calls appPromotion.sponsorCollection(Punks.id) throw
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      const collectionId = collection.collectionId;
+      
+      expect((await collection.burn(alice))).to.be.true;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected;
+    });
+    
+  });
+});
+
+
+describe('app-promotion stopSponsoringCollection', () => {
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+      palletAdmin = privateKeyWrapper('//palletAdmin');
+      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
+      await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());
+       
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
+      await helper.signTransaction(alice, tx);
+
+      nominal = helper.balance.getOneTokenNominal();
+    });
+  });
+  
+  it('can not be called by non-admin', async () => {
+    // arrange: Alice creates Punks
+    // arrange: appPromotion.sponsorCollection(Punks.Id)
+
+    // assert:  Random calls appPromotion.stopSponsoringCollection(Punks) throws
+    // assert:  query collectionById(Punks.id): sponsoring confirmed by PalleteAddress
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection = await helper.nft.mintCollection(alice, {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(bob, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
+    });
+  });
+
+  it('will set sponsoring as disabled', async () => {
+    // arrange: Alice creates Punks
+    // arrange: appPromotion.sponsorCollection(Punks.Id)
+
+    // act:     Admin calls appPromotion.stopSponsoringCollection(Punks)
+
+    // assert:  query collectionById(Punks.id): sponsoring unconfirmed
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection = await helper.nft.mintCollection(alice, {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.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.fulfilled;
+      
+      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');
+    });
+  });
+
+  it('will not affect collection which is not sponsored by pallete', async () => {
+    // arrange: Alice creates Punks
+    // arrange: Alice calls setCollectionSponsoring(Punks)
+    // arrange: Alice calls confirmSponsorship(Punks)
+
+    // act:     Admin calls appPromotion.stopSponsoringCollection(A)
+    // assert:  query collectionById(Punks): Sponsoring: {Confirmed: Alice} /// Alice still collection owner
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      const collectionId = collection.collectionId;
+      expect(await collection.setSponsor(alice, alice.address)).to.be.true;
+      expect(await collection.confirmSponsorship(alice)).to.be.true;
+      
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;
+      
+      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: alice.address});
+    });
+    
+  });
+
+  it('will throw if collection does not exist', async () => {
+    // arrange: Alice creates Punks
+    // arrange: Alice burns Punks
+
+    // assert:  Admin calls appPromotion.stopSponsoringCollection(Punks.id) throws
+    // assert:  Admin calls appPromotion.stopSponsoringCollection(999999999999999) throw
+    
+    await usingPlaygrounds(async (helper) => {
+      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
+      const collectionId = collection.collectionId;
+      
+      expect((await collection.burn(alice))).to.be.true;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;
+    });
+  });
+});
+
+describe('app-promotion contract sponsoring', () => {
+  it('will set contract sponsoring mode and set palletes address as a sponsor', async () => {
+    // arrange: Alice deploys Flipper
+    
+    // act:     Admin calls appPromotion.sponsorContract(Flipper.address)
+
+    // assert:  contract.sponsoringMode = TODO
+    // assert:  contract.sponsor to be PalleteAddress
+  });
+
+  it('will overwrite sponsoring mode and existed sponsor', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Alice sets self sponsoring for Flipper
+
+    // act:     Admin calls appPromotion.sponsorContract(Flipper.address)
+
+    // assert:  contract.sponsoringMode = TODO
+    // assert:  contract.sponsor to be PalleteAddress
+  });
+
+  it('can be overwritten by contract owner', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
+
+    // act:     Alice sets self sponsoring for Flipper
+
+    // assert:  contract.sponsoringMode = Self
+    // assert:  contract.sponsor to be contract
+  });
+
+  it('can not be set by non admin', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Alice sets self sponsoring for Flipper
+
+    // assert:  Random calls appPromotion.sponsorContract(Flipper.address) throws
+    // assert:  contract.sponsoringMode = Self
+    // assert:  contract.sponsor to be contract
+  });
+
+  it('will return unused gas fee to app-promotion pallete', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
+
+    // assert:  Bob calls Flipper - expect balances deposit event do not appears for Bob /// Unused gas fee returns to contract
+    // assert:  Bobs balance the same
+  });
+
+  it('will failed for non contract address', async () => {
+    // arrange: web3 creates new address - 0x0
+
+    // assert: Admin calls appPromotion.sponsorContract(0x0) throws
+    // assert: Admin calls appPromotion.sponsorContract(Substrate address) throws
+  });
+
+  it('will actually sponsor transactions', async () => {
+    // TODO test it because this is a new way of contract sponsoring
+  });
+});
+
+describe('app-promotion stopSponsoringContract', () => {
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+      palletAdmin = privateKeyWrapper('//palletAdmin');
+      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
+      await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());
+       
+      const promotionStartBlock = await helper.chain.getLatestBlockNumber();
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
+      await helper.signTransaction(alice, tx);
+      
+      const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock));
+      await helper.signTransaction(alice, txStart);
+      
+      nominal = helper.balance.getOneTokenNominal();
+    });
+  });
+  
+  it('will set contract sponsoring mode as disabled', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
+    
+    // act:     Admin calls appPromotion.stopSponsoringContract(Flipper.address)
+    // assert:  contract sponsoring mode = TODO
+
+    // act:     Bob calls Flipper
+
+    // assert:  PalleteAddress balance did not change
+    // assert:  Bobs balance less than before /// Bob payed some fee
+  });
+
+  it('can not be called by non-admin', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
+
+    // assert:  Random calls appPromotion.stopSponsoringContract(Flipper.address) throws
+    // assert:  contract sponsor is PallereAddress
+  });
+
+  it('will not affect a contract which is not sponsored by pallete', async () => {
+    // arrange: Alice deploys Flipper
+    // arrange: Alice sets self sponsoring for Flipper
+    
+    // act:     Admin calls appPromotion.stopSponsoringContract(Flipper.address) throws
+
+    // assert:  contract.sponsoringMode = Self
+    // assert:  contract.sponsor to be contract
+  });
+
+  it('will failed for non contract address', async () => {
+    // arrange: web3 creates new address - 0x0
+
+    // expect stopSponsoringContract(0x0) throws
+  });
+});
+
+describe('app-promotion rewards', () => {
+  const DAY = 7200n;
+  
+  
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+      palletAdmin = privateKeyWrapper('//palletAdmin');
+      if (promotionStartBlock == null) {
+        promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();
+      }
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
+      await helper.signTransaction(alice, tx);
+      
+      const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!));
+      await helper.signTransaction(alice, txStart);
+
+      nominal = helper.balance.getOneTokenNominal();
+    });
+  });
+  
+  it('will credit 0.05% for staking period', async () => {
+    // arrange: bob.stake(10000);
+    // arrange: bob.stake(20000);
+    // arrange: waitForRewards();
+
+    // assert:  bob.staked to equal [10005, 20010]
+    
+    await usingPlaygrounds(async helper => {
+      const staker = await createUser(50n * nominal);
+      await waitForRecalculationBlock(helper.api!);
+      
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
+      await waitForRelayBlock(helper.api!, 36);
+      
+      
+      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
+        .map(([_, amount]) => amount.toBigInt()))
+        .to.be.deep.equal([calculateIncome(nominal, 10n), calculateIncome(2n * nominal, 10n)]);
+    });
+    
+  });
+  
+  it('will not be credited for unstaked (reserved) balance', async () => {
+    // arrange: bob.stake(10000);
+    // arrange: bob.unstake(5000);
+    // arrange: waitForRewards();
+
+    // assert:  bob.staked to equal [5002.5]
+    await usingPlaygrounds(async helper => {
+      const staker = await createUser(20n * nominal);
+      await waitForRecalculationBlock(helper.api!);
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(5n * nominal))).to.be.eventually.fulfilled;
+      await waitForRelayBlock(helper.api!, 38);
+
+      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
+        .map(([_, amount]) => amount.toBigInt()))
+        .to.be.deep.equal([calculateIncome(5n * nominal, 10n)]);
+      
+    });
+    
+  });
+  
+  it('will bring compound interest', async () => {
+    // arrange: bob balance = 30000
+    // arrange: bob.stake(10000);
+    // arrange: bob.stake(10000);
+    // arrange: waitForRewards();
+
+    // assert:  bob.staked() equal [10005, 10005, 10005] /// 10_000 * 1.0005
+    // act:     waitForRewards();
+
+    // assert:  bob.staked() equal [10010.0025, 10010.0025, 10010.0025] /// 10_005 * 1.0005
+    // act:     bob.unstake(10.0025)
+    // assert:  bob.staked() equal [10000, 10010.0025, 10010.0025] /// 10_005 * 1.0005
+
+    // act:     waitForRewards();
+    // assert:  bob.staked() equal [10005, 10015,00750125, 10015,00750125] ///
+    await usingPlaygrounds(async helper => {
+      const staker = await createUser(40n * nominal);
+      
+      await waitForRecalculationBlock(helper.api!);
+      // const foo = await helper.api!.registry.getChainProperties().
+
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
+      // await waitNewBlocks(helper.api!, 1);
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
+      // await waitNewBlocks(helper.api!, 1);
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
+      // console.log(await helper.balance.getSubstrate(staker.address));
+      // await waitNewBlocks(helper.api!, 17);
+      await waitForRelayBlock(helper.api!, 34);
+      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
+        .map(([_, amount]) => amount.toBigInt()))
+        .to.be.deep.equal([calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n)]);
+      
+      // console.log(await getBlockNumber(helper.api!));
+      // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]));
+      // console.log(`${calculateIncome(10n * nominal, 10n)} || ${calculateIncome(10n * nominal, 10n, 2)}`);
+      // await waitNewBlocks(helper.api!, 10);
+      await waitForRelayBlock(helper.api!, 20);
+      // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()));
+      // console.log(await helper.balance.getSubstrate(staker.address));
+      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(calculateIncome(10n * nominal, 10n, 2) - 10n * nominal))).to.be.eventually.fulfilled;
+      // console.log(calculateIncome(10n * nominal, 10n, 2));
+      // console.log(calculateIncome(10n * nominal, 10n, 3));
+      // console.log(calculateIncome(10n * nominal, 10n, 4));
+      // console.log(calculateIncome(10n * nominal, 10n, 5));
+      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
+        .map(([_, amount]) => amount.toBigInt()))
+        .to.be.deep.equal([10n * nominal, calculateIncome(10n * nominal, 10n, 2), calculateIncome(10n * nominal, 10n, 2)]);
+      
+      // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()));
+      
+      // console.log(await helper.balance.getSubstrate(staker.address));
+    });
+    
+  });
+});
+
+
+function waitForRecalculationBlock(api: ApiPromise): Promise<void> {
+  return new Promise<void>(async (resolve, reject) => {
+    const unsubscribe = await  api.query.system.events((events) => {
+     
+      events.forEach((record) => {
+      
+        const {event, phase} = record;
+        const types = event.typeDef;
+        
+        if (event.section === 'promotion' && event.method === 'StakingRecalculation') {
+          unsubscribe();
+          resolve();
+        }
+      });
+    });
+  });
+}
+
+async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise<void> {
+  const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();
+  return new Promise<void>(async (resolve, reject) => {
+    const unsubscribe = await api.query.parachainSystem.validationData(async (data) => {
+      // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`);
+      if (data.value.relayParentNumber.toNumber() - current_block >= blocks) {
+        unsubscribe();
+        resolve();
+      }
+    });
+  });
+  
+}
+
+
+function calculatePalleteAddress(palletId: any) {
+  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));
+  return encodeAddress(address);
+}
+function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {
+  const DAY = 7200n;
+  const ACCURACY = 1_000_000_000n;
+  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;
+  
+  if (iter > 1) {
+    return calculateIncome(income, calcPeriod, iter - 1);
+  } else return income;
+}
+
 async function createUser(amount?: bigint) {
-  return await usingPlaygrounds(async (helper, privateKeyWrapper) => {
-    const user: IKeyringPair = privateKeyWrapper(`//Alice+${(new Date()).getTime()}`);
+  return await usingPlaygrounds(async helper => {
+    const user: IKeyringPair = helper.util.fromSeed(mnemonicGenerate());
     await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());
     return user;
   });

--- a/tests/src/interfaces/augment-api-consts.ts
+++ b/tests/src/interfaces/augment-api-consts.ts
@@ -8,7 +8,7 @@
 import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types';
 import type { Option, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
 import type { Codec } from '@polkadot/types-codec/types';
-import type { Permill } from '@polkadot/types/interfaces/runtime';
+import type { Perbill, Permill } from '@polkadot/types/interfaces/runtime';
 import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion } from '@polkadot/types/lookup';
 
 export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
@@ -66,6 +66,30 @@
        **/
       [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 chain blocks.
+       **/
+      pendingInterval: u32 & AugmentedConst<ApiType>;
+      /**
+       * In relay blocks.
+       **/
+      recalculationInterval: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
     scheduler: {
       /**
        * The maximum weight that may be scheduled per block for any dispatchables of less

--- a/tests/src/interfaces/augment-api-errors.ts
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -425,6 +425,23 @@
        **/
       [key: string]: AugmentedError<ApiType>;
     };
+    promotion: {
+      AdminNotSet: AugmentedError<ApiType>;
+      AlreadySponsored: AugmentedError<ApiType>;
+      InvalidArgument: AugmentedError<ApiType>;
+      /**
+       * No permission to perform action
+       **/
+      NoPermission: AugmentedError<ApiType>;
+      /**
+       * Insufficient funds to perform an action
+       **/
+      NotSufficientFounds: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
     refungible: {
       /**
        * Not Refungible item data used to mint in Refungible collection.

--- a/tests/src/interfaces/augment-api-events.ts
+++ b/tests/src/interfaces/augment-api-events.ts
@@ -360,6 +360,13 @@
        **/
       [key: string]: AugmentedEvent<ApiType>;
     };
+    promotion: {
+      StakingRecalculation: AugmentedEvent<ApiType, [u128, u128]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
     rmrkCore: {
       CollectionCreated: AugmentedEvent<ApiType, [issuer: AccountId32, collectionId: u32], { issuer: AccountId32, collectionId: u32 }>;
       CollectionDestroyed: AugmentedEvent<ApiType, [issuer: AccountId32, collectionId: u32], { issuer: AccountId32, collectionId: u32 }>;

--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -363,9 +363,11 @@
       [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     promotion: {
-      setAdminAddress: AugmentedSubmittable<(admin: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
+      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;
+      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
       stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
-      startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+      startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;
+      stopSponsorignCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
       unstake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
       /**
        * Generic tx

--- a/tests/src/interfaces/augment-types.ts
+++ b/tests/src/interfaces/augment-types.ts
@@ -5,7 +5,7 @@
 // this is required to allow for ambient/previous definitions
 import '@polkadot/types/types/registry';
 
-import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletAppPromotionCall, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './default';
+import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './default';
 import type { Data, StorageKey } from '@polkadot/types';
 import type { BitVec, Bool, Bytes, F32, F64, I128, I16, I256, I32, I64, I8, Json, Null, OptionBool, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, f32, f64, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec';
 import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets';
@@ -805,6 +805,8 @@
     PageCounter: PageCounter;
     PageIndexData: PageIndexData;
     PalletAppPromotionCall: PalletAppPromotionCall;
+    PalletAppPromotionError: PalletAppPromotionError;
+    PalletAppPromotionEvent: PalletAppPromotionEvent;
     PalletBalancesAccountData: PalletBalancesAccountData;
     PalletBalancesBalanceLock: PalletBalancesBalanceLock;
     PalletBalancesCall: PalletBalancesCall;

--- a/tests/src/interfaces/default/types.ts
+++ b/tests/src/interfaces/default/types.ts
@@ -810,11 +810,11 @@
 export interface PalletAppPromotionCall extends Enum {
   readonly isSetAdminAddress: boolean;
   readonly asSetAdminAddress: {
-    readonly admin: AccountId32;
+    readonly admin: PalletEvmAccountBasicCrossAccountIdRepr;
   } & Struct;
   readonly isStartAppPromotion: boolean;
   readonly asStartAppPromotion: {
-    readonly promotionStartRelayBlock: u32;
+    readonly promotionStartRelayBlock: Option<u32>;
   } & Struct;
   readonly isStake: boolean;
   readonly asStake: {
@@ -824,7 +824,32 @@
   readonly asUnstake: {
     readonly amount: u128;
   } & Struct;
-  readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake';
+  readonly isSponsorCollection: boolean;
+  readonly asSponsorCollection: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isStopSponsorignCollection: boolean;
+  readonly asStopSponsorignCollection: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsorignCollection';
+}
+
+/** @name PalletAppPromotionError */
+export interface PalletAppPromotionError extends Enum {
+  readonly isAdminNotSet: boolean;
+  readonly isNoPermission: boolean;
+  readonly isNotSufficientFounds: boolean;
+  readonly isInvalidArgument: boolean;
+  readonly isAlreadySponsored: boolean;
+  readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'InvalidArgument' | 'AlreadySponsored';
+}
+
+/** @name PalletAppPromotionEvent */
+export interface PalletAppPromotionEvent extends Enum {
+  readonly isStakingRecalculation: boolean;
+  readonly asStakingRecalculation: ITuple<[u128, u128]>;
+  readonly type: 'StakingRecalculation';
 }
 
 /** @name PalletBalancesAccountData */

1056      }1056      }
1057    }1057    }
1058  },1058  },
1059  /**
1060   * Lookup103: pallet_app_promotion::pallet::Event<T>
1061   **/
1062  PalletAppPromotionEvent: {
1063    _enum: {
1064      StakingRecalculation: '(u128,u128)'
1065    }
1066  },
1059  /**1067  /**
1060   * Lookup103: pallet_evm::pallet::Event<T>1068   * Lookup104: pallet_evm::pallet::Event<T>
1061   **/1069   **/
1062  PalletEvmEvent: {1070  PalletEvmEvent: {
1063    _enum: {1071    _enum: {
1064      Log: 'EthereumLog',1072      Log: 'EthereumLog',
1070      BalanceWithdraw: '(AccountId32,H160,U256)'1078      BalanceWithdraw: '(AccountId32,H160,U256)'
1071    }1079    }
1072  },1080  },
1073  /**1081  /**
1074   * Lookup104: ethereum::log::Log1082   * Lookup105: ethereum::log::Log
1075   **/1083   **/
1076  EthereumLog: {1084  EthereumLog: {
1077    address: 'H160',1085    address: 'H160',
1078    topics: 'Vec<H256>',1086    topics: 'Vec<H256>',
1079    data: 'Bytes'1087    data: 'Bytes'
1080  },1088  },
1081  /**1089  /**
1082   * Lookup108: pallet_ethereum::pallet::Event1090   * Lookup109: pallet_ethereum::pallet::Event
1083   **/1091   **/
1084  PalletEthereumEvent: {1092  PalletEthereumEvent: {
1085    _enum: {1093    _enum: {
1086      Executed: '(H160,H160,H256,EvmCoreErrorExitReason)'1094      Executed: '(H160,H160,H256,EvmCoreErrorExitReason)'
1087    }1095    }
1088  },1096  },
1089  /**1097  /**
1090   * Lookup109: evm_core::error::ExitReason1098   * Lookup110: evm_core::error::ExitReason
1091   **/1099   **/
1092  EvmCoreErrorExitReason: {1100  EvmCoreErrorExitReason: {
1093    _enum: {1101    _enum: {
1094      Succeed: 'EvmCoreErrorExitSucceed',1102      Succeed: 'EvmCoreErrorExitSucceed',
1097      Fatal: 'EvmCoreErrorExitFatal'1105      Fatal: 'EvmCoreErrorExitFatal'
1098    }1106    }
1099  },1107  },
1100  /**1108  /**
1101   * Lookup110: evm_core::error::ExitSucceed1109   * Lookup111: evm_core::error::ExitSucceed
1102   **/1110   **/
1103  EvmCoreErrorExitSucceed: {1111  EvmCoreErrorExitSucceed: {
1104    _enum: ['Stopped', 'Returned', 'Suicided']1112    _enum: ['Stopped', 'Returned', 'Suicided']
1105  },1113  },
1106  /**1114  /**
1107   * Lookup111: evm_core::error::ExitError1115   * Lookup112: evm_core::error::ExitError
1108   **/1116   **/
1109  EvmCoreErrorExitError: {1117  EvmCoreErrorExitError: {
1110    _enum: {1118    _enum: {
1111      StackUnderflow: 'Null',1119      StackUnderflow: 'Null',
1125      InvalidCode: 'Null'1133      InvalidCode: 'Null'
1126    }1134    }
1127  },1135  },
1128  /**1136  /**
1129   * Lookup114: evm_core::error::ExitRevert1137   * Lookup115: evm_core::error::ExitRevert
1130   **/1138   **/
1131  EvmCoreErrorExitRevert: {1139  EvmCoreErrorExitRevert: {
1132    _enum: ['Reverted']1140    _enum: ['Reverted']
1133  },1141  },
1134  /**1142  /**
1135   * Lookup115: evm_core::error::ExitFatal1143   * Lookup116: evm_core::error::ExitFatal
1136   **/1144   **/
1137  EvmCoreErrorExitFatal: {1145  EvmCoreErrorExitFatal: {
1138    _enum: {1146    _enum: {
1139      NotSupported: 'Null',1147      NotSupported: 'Null',
1142      Other: 'Text'1150      Other: 'Text'
1143    }1151    }
1144  },1152  },
1145  /**1153  /**
1146   * Lookup116: frame_system::Phase1154   * Lookup117: frame_system::Phase
1147   **/1155   **/
1148  FrameSystemPhase: {1156  FrameSystemPhase: {
1149    _enum: {1157    _enum: {
1150      ApplyExtrinsic: 'u32',1158      ApplyExtrinsic: 'u32',
1151      Finalization: 'Null',1159      Finalization: 'Null',
1152      Initialization: 'Null'1160      Initialization: 'Null'
1153    }1161    }
1154  },1162  },
1155  /**1163  /**
1156   * Lookup118: frame_system::LastRuntimeUpgradeInfo1164   * Lookup119: frame_system::LastRuntimeUpgradeInfo
1157   **/1165   **/
1158  FrameSystemLastRuntimeUpgradeInfo: {1166  FrameSystemLastRuntimeUpgradeInfo: {
1159    specVersion: 'Compact<u32>',1167    specVersion: 'Compact<u32>',
1160    specName: 'Text'1168    specName: 'Text'
1161  },1169  },
1162  /**1170  /**
1163   * Lookup119: frame_system::pallet::Call<T>1171   * Lookup120: frame_system::pallet::Call<T>
1164   **/1172   **/
1165  FrameSystemCall: {1173  FrameSystemCall: {
1166    _enum: {1174    _enum: {
1167      fill_block: {1175      fill_block: {
1197      }1205      }
1198    }1206    }
1199  },1207  },
1200  /**1208  /**
1201   * Lookup124: frame_system::limits::BlockWeights1209   * Lookup125: frame_system::limits::BlockWeights
1202   **/1210   **/
1203  FrameSystemLimitsBlockWeights: {1211  FrameSystemLimitsBlockWeights: {
1204    baseBlock: 'u64',1212    baseBlock: 'u64',
1205    maxBlock: 'u64',1213    maxBlock: 'u64',
1206    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'1214    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'
1207  },1215  },
1208  /**1216  /**
1209   * Lookup125: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>1217   * Lookup126: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>
1210   **/1218   **/
1211  FrameSupportWeightsPerDispatchClassWeightsPerClass: {1219  FrameSupportWeightsPerDispatchClassWeightsPerClass: {
1212    normal: 'FrameSystemLimitsWeightsPerClass',1220    normal: 'FrameSystemLimitsWeightsPerClass',
1213    operational: 'FrameSystemLimitsWeightsPerClass',1221    operational: 'FrameSystemLimitsWeightsPerClass',
1214    mandatory: 'FrameSystemLimitsWeightsPerClass'1222    mandatory: 'FrameSystemLimitsWeightsPerClass'
1215  },1223  },
1216  /**1224  /**
1217   * Lookup126: frame_system::limits::WeightsPerClass1225   * Lookup127: frame_system::limits::WeightsPerClass
1218   **/1226   **/
1219  FrameSystemLimitsWeightsPerClass: {1227  FrameSystemLimitsWeightsPerClass: {
1220    baseExtrinsic: 'u64',1228    baseExtrinsic: 'u64',
1221    maxExtrinsic: 'Option<u64>',1229    maxExtrinsic: 'Option<u64>',
1222    maxTotal: 'Option<u64>',1230    maxTotal: 'Option<u64>',
1223    reserved: 'Option<u64>'1231    reserved: 'Option<u64>'
1224  },1232  },
1225  /**1233  /**
1226   * Lookup128: frame_system::limits::BlockLength1234   * Lookup129: frame_system::limits::BlockLength
1227   **/1235   **/
1228  FrameSystemLimitsBlockLength: {1236  FrameSystemLimitsBlockLength: {
1229    max: 'FrameSupportWeightsPerDispatchClassU32'1237    max: 'FrameSupportWeightsPerDispatchClassU32'
1230  },1238  },
1231  /**1239  /**
1232   * Lookup129: frame_support::weights::PerDispatchClass<T>1240   * Lookup130: frame_support::weights::PerDispatchClass<T>
1233   **/1241   **/
1234  FrameSupportWeightsPerDispatchClassU32: {1242  FrameSupportWeightsPerDispatchClassU32: {
1235    normal: 'u32',1243    normal: 'u32',
1236    operational: 'u32',1244    operational: 'u32',
1237    mandatory: 'u32'1245    mandatory: 'u32'
1238  },1246  },
1239  /**1247  /**
1240   * Lookup130: frame_support::weights::RuntimeDbWeight1248   * Lookup131: frame_support::weights::RuntimeDbWeight
1241   **/1249   **/
1242  FrameSupportWeightsRuntimeDbWeight: {1250  FrameSupportWeightsRuntimeDbWeight: {
1243    read: 'u64',1251    read: 'u64',
1244    write: 'u64'1252    write: 'u64'
1245  },1253  },
1246  /**1254  /**
1247   * Lookup131: sp_version::RuntimeVersion1255   * Lookup132: sp_version::RuntimeVersion
1248   **/1256   **/
1249  SpVersionRuntimeVersion: {1257  SpVersionRuntimeVersion: {
1250    specName: 'Text',1258    specName: 'Text',
1251    implName: 'Text',1259    implName: 'Text',
1256    transactionVersion: 'u32',1264    transactionVersion: 'u32',
1257    stateVersion: 'u8'1265    stateVersion: 'u8'
1258  },1266  },
1259  /**1267  /**
1260   * Lookup136: frame_system::pallet::Error<T>1268   * Lookup137: frame_system::pallet::Error<T>
1261   **/1269   **/
1262  FrameSystemError: {1270  FrameSystemError: {
1263    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']1271    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']
1264  },1272  },
1265  /**1273  /**
1266   * Lookup137: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>1274   * Lookup138: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>
1267   **/1275   **/
1268  PolkadotPrimitivesV2PersistedValidationData: {1276  PolkadotPrimitivesV2PersistedValidationData: {
1269    parentHead: 'Bytes',1277    parentHead: 'Bytes',
1270    relayParentNumber: 'u32',1278    relayParentNumber: 'u32',
1271    relayParentStorageRoot: 'H256',1279    relayParentStorageRoot: 'H256',
1272    maxPovSize: 'u32'1280    maxPovSize: 'u32'
1273  },1281  },
1274  /**1282  /**
1275   * Lookup140: polkadot_primitives::v2::UpgradeRestriction1283   * Lookup141: polkadot_primitives::v2::UpgradeRestriction
1276   **/1284   **/
1277  PolkadotPrimitivesV2UpgradeRestriction: {1285  PolkadotPrimitivesV2UpgradeRestriction: {
1278    _enum: ['Present']1286    _enum: ['Present']
1279  },1287  },
1280  /**1288  /**
1281   * Lookup141: sp_trie::storage_proof::StorageProof1289   * Lookup142: sp_trie::storage_proof::StorageProof
1282   **/1290   **/
1283  SpTrieStorageProof: {1291  SpTrieStorageProof: {
1284    trieNodes: 'BTreeSet<Bytes>'1292    trieNodes: 'BTreeSet<Bytes>'
1285  },1293  },
1286  /**1294  /**
1287   * Lookup143: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot1295   * Lookup144: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot
1288   **/1296   **/
1289  CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {1297  CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {
1290    dmqMqcHead: 'H256',1298    dmqMqcHead: 'H256',
1291    relayDispatchQueueSize: '(u32,u32)',1299    relayDispatchQueueSize: '(u32,u32)',
1292    ingressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>',1300    ingressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>',
1293    egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>'1301    egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>'
1294  },1302  },
1295  /**1303  /**
1296   * Lookup146: polkadot_primitives::v2::AbridgedHrmpChannel1304   * Lookup147: polkadot_primitives::v2::AbridgedHrmpChannel
1297   **/1305   **/
1298  PolkadotPrimitivesV2AbridgedHrmpChannel: {1306  PolkadotPrimitivesV2AbridgedHrmpChannel: {
1299    maxCapacity: 'u32',1307    maxCapacity: 'u32',
1300    maxTotalSize: 'u32',1308    maxTotalSize: 'u32',
1303    totalSize: 'u32',1311    totalSize: 'u32',
1304    mqcHead: 'Option<H256>'1312    mqcHead: 'Option<H256>'
1305  },1313  },
1306  /**1314  /**
1307   * Lookup147: polkadot_primitives::v2::AbridgedHostConfiguration1315   * Lookup148: polkadot_primitives::v2::AbridgedHostConfiguration
1308   **/1316   **/
1309  PolkadotPrimitivesV2AbridgedHostConfiguration: {1317  PolkadotPrimitivesV2AbridgedHostConfiguration: {
1310    maxCodeSize: 'u32',1318    maxCodeSize: 'u32',
1311    maxHeadDataSize: 'u32',1319    maxHeadDataSize: 'u32',
1317    validationUpgradeCooldown: 'u32',1325    validationUpgradeCooldown: 'u32',
1318    validationUpgradeDelay: 'u32'1326    validationUpgradeDelay: 'u32'
1319  },1327  },
1320  /**1328  /**
1321   * Lookup153: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>1329   * Lookup154: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>
1322   **/1330   **/
1323  PolkadotCorePrimitivesOutboundHrmpMessage: {1331  PolkadotCorePrimitivesOutboundHrmpMessage: {
1324    recipient: 'u32',1332    recipient: 'u32',
1325    data: 'Bytes'1333    data: 'Bytes'
1326  },1334  },
1327  /**1335  /**
1328   * Lookup154: cumulus_pallet_parachain_system::pallet::Call<T>1336   * Lookup155: cumulus_pallet_parachain_system::pallet::Call<T>
1329   **/1337   **/
1330  CumulusPalletParachainSystemCall: {1338  CumulusPalletParachainSystemCall: {
1331    _enum: {1339    _enum: {
1332      set_validation_data: {1340      set_validation_data: {
1343      }1351      }
1344    }1352    }
1345  },1353  },
1346  /**1354  /**
1347   * Lookup155: cumulus_primitives_parachain_inherent::ParachainInherentData1355   * Lookup156: cumulus_primitives_parachain_inherent::ParachainInherentData
1348   **/1356   **/
1349  CumulusPrimitivesParachainInherentParachainInherentData: {1357  CumulusPrimitivesParachainInherentParachainInherentData: {
1350    validationData: 'PolkadotPrimitivesV2PersistedValidationData',1358    validationData: 'PolkadotPrimitivesV2PersistedValidationData',
1351    relayChainState: 'SpTrieStorageProof',1359    relayChainState: 'SpTrieStorageProof',
1352    downwardMessages: 'Vec<PolkadotCorePrimitivesInboundDownwardMessage>',1360    downwardMessages: 'Vec<PolkadotCorePrimitivesInboundDownwardMessage>',
1353    horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'1361    horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'
1354  },1362  },
1355  /**1363  /**
1356   * Lookup157: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>1364   * Lookup158: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>
1357   **/1365   **/
1358  PolkadotCorePrimitivesInboundDownwardMessage: {1366  PolkadotCorePrimitivesInboundDownwardMessage: {
1359    sentAt: 'u32',1367    sentAt: 'u32',
1360    msg: 'Bytes'1368    msg: 'Bytes'
1361  },1369  },
1362  /**1370  /**
1363   * Lookup160: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>1371   * Lookup161: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>
1364   **/1372   **/
1365  PolkadotCorePrimitivesInboundHrmpMessage: {1373  PolkadotCorePrimitivesInboundHrmpMessage: {
1366    sentAt: 'u32',1374    sentAt: 'u32',
1367    data: 'Bytes'1375    data: 'Bytes'
1368  },1376  },
1369  /**1377  /**
1370   * Lookup163: cumulus_pallet_parachain_system::pallet::Error<T>1378   * Lookup164: cumulus_pallet_parachain_system::pallet::Error<T>
1371   **/1379   **/
1372  CumulusPalletParachainSystemError: {1380  CumulusPalletParachainSystemError: {
1373    _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']1381    _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']
1374  },1382  },
1375  /**1383  /**
1376   * Lookup165: pallet_balances::BalanceLock<Balance>1384   * Lookup166: pallet_balances::BalanceLock<Balance>
1377   **/1385   **/
1378  PalletBalancesBalanceLock: {1386  PalletBalancesBalanceLock: {
1379    id: '[u8;8]',1387    id: '[u8;8]',
1380    amount: 'u128',1388    amount: 'u128',
1381    reasons: 'PalletBalancesReasons'1389    reasons: 'PalletBalancesReasons'
1382  },1390  },
1383  /**1391  /**
1384   * Lookup166: pallet_balances::Reasons1392   * Lookup167: pallet_balances::Reasons
1385   **/1393   **/
1386  PalletBalancesReasons: {1394  PalletBalancesReasons: {
1387    _enum: ['Fee', 'Misc', 'All']1395    _enum: ['Fee', 'Misc', 'All']
1388  },1396  },
1389  /**1397  /**
1390   * Lookup169: pallet_balances::ReserveData<ReserveIdentifier, Balance>1398   * Lookup170: pallet_balances::ReserveData<ReserveIdentifier, Balance>
1391   **/1399   **/
1392  PalletBalancesReserveData: {1400  PalletBalancesReserveData: {
1393    id: '[u8;16]',1401    id: '[u8;16]',
1394    amount: 'u128'1402    amount: 'u128'
1395  },1403  },
1396  /**1404  /**
1397   * Lookup171: pallet_balances::Releases1405   * Lookup172: pallet_balances::Releases
1398   **/1406   **/
1399  PalletBalancesReleases: {1407  PalletBalancesReleases: {
1400    _enum: ['V1_0_0', 'V2_0_0']1408    _enum: ['V1_0_0', 'V2_0_0']
1401  },1409  },
1402  /**1410  /**
1403   * Lookup172: pallet_balances::pallet::Call<T, I>1411   * Lookup173: pallet_balances::pallet::Call<T, I>
1404   **/1412   **/
1405  PalletBalancesCall: {1413  PalletBalancesCall: {
1406    _enum: {1414    _enum: {
1407      transfer: {1415      transfer: {
1432      }1440      }
1433    }1441    }
1434  },1442  },
1435  /**1443  /**
1436   * Lookup175: pallet_balances::pallet::Error<T, I>1444   * Lookup176: pallet_balances::pallet::Error<T, I>
1437   **/1445   **/
1438  PalletBalancesError: {1446  PalletBalancesError: {
1439    _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'KeepAlive', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves']1447    _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'KeepAlive', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves']
1440  },1448  },
1441  /**1449  /**
1442   * Lookup177: pallet_timestamp::pallet::Call<T>1450   * Lookup178: pallet_timestamp::pallet::Call<T>
1443   **/1451   **/
1444  PalletTimestampCall: {1452  PalletTimestampCall: {
1445    _enum: {1453    _enum: {
1446      set: {1454      set: {
1447        now: 'Compact<u64>'1455        now: 'Compact<u64>'
1448      }1456      }
1449    }1457    }
1450  },1458  },
1451  /**1459  /**
1452   * Lookup179: pallet_transaction_payment::Releases1460   * Lookup180: pallet_transaction_payment::Releases
1453   **/1461   **/
1454  PalletTransactionPaymentReleases: {1462  PalletTransactionPaymentReleases: {
1455    _enum: ['V1Ancient', 'V2']1463    _enum: ['V1Ancient', 'V2']
1456  },1464  },
1457  /**1465  /**
1458   * Lookup180: pallet_treasury::Proposal<sp_core::crypto::AccountId32, Balance>1466   * Lookup181: pallet_treasury::Proposal<sp_core::crypto::AccountId32, Balance>
1459   **/1467   **/
1460  PalletTreasuryProposal: {1468  PalletTreasuryProposal: {
1461    proposer: 'AccountId32',1469    proposer: 'AccountId32',
1462    value: 'u128',1470    value: 'u128',
1463    beneficiary: 'AccountId32',1471    beneficiary: 'AccountId32',
1464    bond: 'u128'1472    bond: 'u128'
1465  },1473  },
1466  /**1474  /**
1467   * Lookup183: pallet_treasury::pallet::Call<T, I>1475   * Lookup184: pallet_treasury::pallet::Call<T, I>
1468   **/1476   **/
1469  PalletTreasuryCall: {1477  PalletTreasuryCall: {
1470    _enum: {1478    _enum: {
1471      propose_spend: {1479      propose_spend: {
1487      }1495      }
1488    }1496    }
1489  },1497  },
1490  /**1498  /**
1491   * Lookup186: frame_support::PalletId1499   * Lookup187: frame_support::PalletId
1492   **/1500   **/
1493  FrameSupportPalletId: '[u8;8]',1501  FrameSupportPalletId: '[u8;8]',
1494  /**1502  /**
1495   * Lookup187: pallet_treasury::pallet::Error<T, I>1503   * Lookup188: pallet_treasury::pallet::Error<T, I>
1496   **/1504   **/
1497  PalletTreasuryError: {1505  PalletTreasuryError: {
1498    _enum: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved']1506    _enum: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved']
1499  },1507  },
1500  /**1508  /**
1501   * Lookup188: pallet_sudo::pallet::Call<T>1509   * Lookup189: pallet_sudo::pallet::Call<T>
1502   **/1510   **/
1503  PalletSudoCall: {1511  PalletSudoCall: {
1504    _enum: {1512    _enum: {
1505      sudo: {1513      sudo: {
1521      }1529      }
1522    }1530    }
1523  },1531  },
1524  /**1532  /**
1525   * Lookup190: orml_vesting::module::Call<T>1533   * Lookup191: orml_vesting::module::Call<T>
1526   **/1534   **/
1527  OrmlVestingModuleCall: {1535  OrmlVestingModuleCall: {
1528    _enum: {1536    _enum: {
1529      claim: 'Null',1537      claim: 'Null',
1540      }1548      }
1541    }1549    }
1542  },1550  },
1543  /**1551  /**
1544   * Lookup192: cumulus_pallet_xcmp_queue::pallet::Call<T>1552   * Lookup193: cumulus_pallet_xcmp_queue::pallet::Call<T>
1545   **/1553   **/
1546  CumulusPalletXcmpQueueCall: {1554  CumulusPalletXcmpQueueCall: {
1547    _enum: {1555    _enum: {
1548      service_overweight: {1556      service_overweight: {
1589      }1597      }
1590    }1598    }
1591  },1599  },
1592  /**1600  /**
1593   * Lookup193: pallet_xcm::pallet::Call<T>1601   * Lookup194: pallet_xcm::pallet::Call<T>
1594   **/1602   **/
1595  PalletXcmCall: {1603  PalletXcmCall: {
1596    _enum: {1604    _enum: {
1597      send: {1605      send: {
1643      }1651      }
1644    }1652    }
1645  },1653  },
1646  /**1654  /**
1647   * Lookup194: xcm::VersionedXcm<Call>1655   * Lookup195: xcm::VersionedXcm<Call>
1648   **/1656   **/
1649  XcmVersionedXcm: {1657  XcmVersionedXcm: {
1650    _enum: {1658    _enum: {
1651      V0: 'XcmV0Xcm',1659      V0: 'XcmV0Xcm',
1652      V1: 'XcmV1Xcm',1660      V1: 'XcmV1Xcm',
1653      V2: 'XcmV2Xcm'1661      V2: 'XcmV2Xcm'
1654    }1662    }
1655  },1663  },
1656  /**1664  /**
1657   * Lookup195: xcm::v0::Xcm<Call>1665   * Lookup196: xcm::v0::Xcm<Call>
1658   **/1666   **/
1659  XcmV0Xcm: {1667  XcmV0Xcm: {
1660    _enum: {1668    _enum: {
1661      WithdrawAsset: {1669      WithdrawAsset: {
1707      }1715      }
1708    }1716    }
1709  },1717  },
1710  /**1718  /**
1711   * Lookup197: xcm::v0::order::Order<Call>1719   * Lookup198: xcm::v0::order::Order<Call>
1712   **/1720   **/
1713  XcmV0Order: {1721  XcmV0Order: {
1714    _enum: {1722    _enum: {
1715      Null: 'Null',1723      Null: 'Null',
1750      }1758      }
1751    }1759    }
1752  },1760  },
1753  /**1761  /**
1754   * Lookup199: xcm::v0::Response1762   * Lookup200: xcm::v0::Response
1755   **/1763   **/
1756  XcmV0Response: {1764  XcmV0Response: {
1757    _enum: {1765    _enum: {
1758      Assets: 'Vec<XcmV0MultiAsset>'1766      Assets: 'Vec<XcmV0MultiAsset>'
1759    }1767    }
1760  },1768  },
1761  /**1769  /**
1762   * Lookup200: xcm::v1::Xcm<Call>1770   * Lookup201: xcm::v1::Xcm<Call>
1763   **/1771   **/
1764  XcmV1Xcm: {1772  XcmV1Xcm: {
1765    _enum: {1773    _enum: {
1766      WithdrawAsset: {1774      WithdrawAsset: {
1817      UnsubscribeVersion: 'Null'1825      UnsubscribeVersion: 'Null'
1818    }1826    }
1819  },1827  },
1820  /**1828  /**
1821   * Lookup202: xcm::v1::order::Order<Call>1829   * Lookup203: xcm::v1::order::Order<Call>
1822   **/1830   **/
1823  XcmV1Order: {1831  XcmV1Order: {
1824    _enum: {1832    _enum: {
1825      Noop: 'Null',1833      Noop: 'Null',
1862      }1870      }
1863    }1871    }
1864  },1872  },
1865  /**1873  /**
1866   * Lookup204: xcm::v1::Response1874   * Lookup205: xcm::v1::Response
1867   **/1875   **/
1868  XcmV1Response: {1876  XcmV1Response: {
1869    _enum: {1877    _enum: {
1870      Assets: 'XcmV1MultiassetMultiAssets',1878      Assets: 'XcmV1MultiassetMultiAssets',
1871      Version: 'u32'1879      Version: 'u32'
1872    }1880    }
1873  },1881  },
1874  /**1882  /**
1875   * Lookup218: cumulus_pallet_xcm::pallet::Call<T>1883   * Lookup219: cumulus_pallet_xcm::pallet::Call<T>
1876   **/1884   **/
1877  CumulusPalletXcmCall: 'Null',1885  CumulusPalletXcmCall: 'Null',
1878  /**1886  /**
1879   * Lookup219: cumulus_pallet_dmp_queue::pallet::Call<T>1887   * Lookup220: cumulus_pallet_dmp_queue::pallet::Call<T>
1880   **/1888   **/
1881  CumulusPalletDmpQueueCall: {1889  CumulusPalletDmpQueueCall: {
1882    _enum: {1890    _enum: {
1883      service_overweight: {1891      service_overweight: {
1886      }1894      }
1887    }1895    }
1888  },1896  },
1889  /**1897  /**
1890   * Lookup220: pallet_inflation::pallet::Call<T>1898   * Lookup221: pallet_inflation::pallet::Call<T>
1891   **/1899   **/
1892  PalletInflationCall: {1900  PalletInflationCall: {
1893    _enum: {1901    _enum: {
1894      start_inflation: {1902      start_inflation: {
1895        inflationStartRelayBlock: 'u32'1903        inflationStartRelayBlock: 'u32'
1896      }1904      }
1897    }1905    }
1898  },1906  },
1899  /**1907  /**
1900   * Lookup221: pallet_unique::Call<T>1908   * Lookup222: pallet_unique::Call<T>
1901   **/1909   **/
1902  PalletUniqueCall: {1910  PalletUniqueCall: {
1903    _enum: {1911    _enum: {
1904      create_collection: {1912      create_collection: {
2028      }2036      }
2029    }2037    }
2030  },2038  },
2031  /**2039  /**
2032   * Lookup226: up_data_structs::CollectionMode2040   * Lookup227: up_data_structs::CollectionMode
2033   **/2041   **/
2034  UpDataStructsCollectionMode: {2042  UpDataStructsCollectionMode: {
2035    _enum: {2043    _enum: {
2036      NFT: 'Null',2044      NFT: 'Null',
2037      Fungible: 'u8',2045      Fungible: 'u8',
2038      ReFungible: 'Null'2046      ReFungible: 'Null'
2039    }2047    }
2040  },2048  },
2041  /**2049  /**
2042   * Lookup227: up_data_structs::CreateCollectionData<sp_core::crypto::AccountId32>2050   * Lookup228: up_data_structs::CreateCollectionData<sp_core::crypto::AccountId32>
2043   **/2051   **/
2044  UpDataStructsCreateCollectionData: {2052  UpDataStructsCreateCollectionData: {
2045    mode: 'UpDataStructsCollectionMode',2053    mode: 'UpDataStructsCollectionMode',
2046    access: 'Option<UpDataStructsAccessMode>',2054    access: 'Option<UpDataStructsAccessMode>',
2053    tokenPropertyPermissions: 'Vec<UpDataStructsPropertyKeyPermission>',2061    tokenPropertyPermissions: 'Vec<UpDataStructsPropertyKeyPermission>',
2054    properties: 'Vec<UpDataStructsProperty>'2062    properties: 'Vec<UpDataStructsProperty>'
2055  },2063  },
2056  /**2064  /**
2057   * Lookup229: up_data_structs::AccessMode2065   * Lookup230: up_data_structs::AccessMode
2058   **/2066   **/
2059  UpDataStructsAccessMode: {2067  UpDataStructsAccessMode: {
2060    _enum: ['Normal', 'AllowList']2068    _enum: ['Normal', 'AllowList']
2061  },2069  },
2062  /**2070  /**
2063   * Lookup231: up_data_structs::CollectionLimits2071   * Lookup232: up_data_structs::CollectionLimits
2064   **/2072   **/
2065  UpDataStructsCollectionLimits: {2073  UpDataStructsCollectionLimits: {
2066    accountTokenOwnershipLimit: 'Option<u32>',2074    accountTokenOwnershipLimit: 'Option<u32>',
2067    sponsoredDataSize: 'Option<u32>',2075    sponsoredDataSize: 'Option<u32>',
2073    ownerCanDestroy: 'Option<bool>',2081    ownerCanDestroy: 'Option<bool>',
2074    transfersEnabled: 'Option<bool>'2082    transfersEnabled: 'Option<bool>'
2075  },2083  },
2076  /**2084  /**
2077   * Lookup233: up_data_structs::SponsoringRateLimit2085   * Lookup234: up_data_structs::SponsoringRateLimit
2078   **/2086   **/
2079  UpDataStructsSponsoringRateLimit: {2087  UpDataStructsSponsoringRateLimit: {
2080    _enum: {2088    _enum: {
2081      SponsoringDisabled: 'Null',2089      SponsoringDisabled: 'Null',
2082      Blocks: 'u32'2090      Blocks: 'u32'
2083    }2091    }
2084  },2092  },
2085  /**2093  /**
2086   * Lookup236: up_data_structs::CollectionPermissions2094   * Lookup237: up_data_structs::CollectionPermissions
2087   **/2095   **/
2088  UpDataStructsCollectionPermissions: {2096  UpDataStructsCollectionPermissions: {
2089    access: 'Option<UpDataStructsAccessMode>',2097    access: 'Option<UpDataStructsAccessMode>',
2090    mintMode: 'Option<bool>',2098    mintMode: 'Option<bool>',
2091    nesting: 'Option<UpDataStructsNestingPermissions>'2099    nesting: 'Option<UpDataStructsNestingPermissions>'
2092  },2100  },
2093  /**2101  /**
2094   * Lookup238: up_data_structs::NestingPermissions2102   * Lookup239: up_data_structs::NestingPermissions
2095   **/2103   **/
2096  UpDataStructsNestingPermissions: {2104  UpDataStructsNestingPermissions: {
2097    tokenOwner: 'bool',2105    tokenOwner: 'bool',
2098    collectionAdmin: 'bool',2106    collectionAdmin: 'bool',
2099    restricted: 'Option<UpDataStructsOwnerRestrictedSet>'2107    restricted: 'Option<UpDataStructsOwnerRestrictedSet>'
2100  },2108  },
2101  /**2109  /**
2102   * Lookup240: up_data_structs::OwnerRestrictedSet2110   * Lookup241: up_data_structs::OwnerRestrictedSet
2103   **/2111   **/
2104  UpDataStructsOwnerRestrictedSet: 'BTreeSet<u32>',2112  UpDataStructsOwnerRestrictedSet: 'BTreeSet<u32>',
2105  /**2113  /**
2106   * Lookup245: up_data_structs::PropertyKeyPermission2114   * Lookup246: up_data_structs::PropertyKeyPermission
2107   **/2115   **/
2108  UpDataStructsPropertyKeyPermission: {2116  UpDataStructsPropertyKeyPermission: {
2109    key: 'Bytes',2117    key: 'Bytes',
2110    permission: 'UpDataStructsPropertyPermission'2118    permission: 'UpDataStructsPropertyPermission'
2111  },2119  },
2112  /**2120  /**
2113   * Lookup246: up_data_structs::PropertyPermission2121   * Lookup247: up_data_structs::PropertyPermission
2114   **/2122   **/
2115  UpDataStructsPropertyPermission: {2123  UpDataStructsPropertyPermission: {
2116    mutable: 'bool',2124    mutable: 'bool',
2117    collectionAdmin: 'bool',2125    collectionAdmin: 'bool',
2118    tokenOwner: 'bool'2126    tokenOwner: 'bool'
2119  },2127  },
2120  /**2128  /**
2121   * Lookup249: up_data_structs::Property2129   * Lookup250: up_data_structs::Property
2122   **/2130   **/
2123  UpDataStructsProperty: {2131  UpDataStructsProperty: {
2124    key: 'Bytes',2132    key: 'Bytes',
2125    value: 'Bytes'2133    value: 'Bytes'
2126  },2134  },
2127  /**2135  /**
2128   * Lookup252: up_data_structs::CreateItemData2136   * Lookup253: up_data_structs::CreateItemData
2129   **/2137   **/
2130  UpDataStructsCreateItemData: {2138  UpDataStructsCreateItemData: {
2131    _enum: {2139    _enum: {
2132      NFT: 'UpDataStructsCreateNftData',2140      NFT: 'UpDataStructsCreateNftData',
2133      Fungible: 'UpDataStructsCreateFungibleData',2141      Fungible: 'UpDataStructsCreateFungibleData',
2134      ReFungible: 'UpDataStructsCreateReFungibleData'2142      ReFungible: 'UpDataStructsCreateReFungibleData'
2135    }2143    }
2136  },2144  },
2137  /**2145  /**
2138   * Lookup253: up_data_structs::CreateNftData2146   * Lookup254: up_data_structs::CreateNftData
2139   **/2147   **/
2140  UpDataStructsCreateNftData: {2148  UpDataStructsCreateNftData: {
2141    properties: 'Vec<UpDataStructsProperty>'2149    properties: 'Vec<UpDataStructsProperty>'
2142  },2150  },
2143  /**2151  /**
2144   * Lookup254: up_data_structs::CreateFungibleData2152   * Lookup255: up_data_structs::CreateFungibleData
2145   **/2153   **/
2146  UpDataStructsCreateFungibleData: {2154  UpDataStructsCreateFungibleData: {
2147    value: 'u128'2155    value: 'u128'
2148  },2156  },
2149  /**2157  /**
2150   * Lookup255: up_data_structs::CreateReFungibleData2158   * Lookup256: up_data_structs::CreateReFungibleData
2151   **/2159   **/
2152  UpDataStructsCreateReFungibleData: {2160  UpDataStructsCreateReFungibleData: {
2153    pieces: 'u128',2161    pieces: 'u128',
2154    properties: 'Vec<UpDataStructsProperty>'2162    properties: 'Vec<UpDataStructsProperty>'
2155  },2163  },
2156  /**2164  /**
2157   * Lookup258: up_data_structs::CreateItemExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>2165   * Lookup259: up_data_structs::CreateItemExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
2158   **/2166   **/
2159  UpDataStructsCreateItemExData: {2167  UpDataStructsCreateItemExData: {
2160    _enum: {2168    _enum: {
2161      NFT: 'Vec<UpDataStructsCreateNftExData>',2169      NFT: 'Vec<UpDataStructsCreateNftExData>',
2164      RefungibleMultipleOwners: 'UpDataStructsCreateRefungibleExMultipleOwners'2172      RefungibleMultipleOwners: 'UpDataStructsCreateRefungibleExMultipleOwners'
2165    }2173    }
2166  },2174  },
2167  /**2175  /**
2168   * Lookup260: up_data_structs::CreateNftExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>2176   * Lookup261: up_data_structs::CreateNftExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
2169   **/2177   **/
2170  UpDataStructsCreateNftExData: {2178  UpDataStructsCreateNftExData: {
2171    properties: 'Vec<UpDataStructsProperty>',2179    properties: 'Vec<UpDataStructsProperty>',
2172    owner: 'PalletEvmAccountBasicCrossAccountIdRepr'2180    owner: 'PalletEvmAccountBasicCrossAccountIdRepr'
2173  },2181  },
2174  /**2182  /**
2175   * Lookup267: up_data_structs::CreateRefungibleExSingleOwner<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>2183   * Lookup268: up_data_structs::CreateRefungibleExSingleOwner<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
2176   **/2184   **/
2177  UpDataStructsCreateRefungibleExSingleOwner: {2185  UpDataStructsCreateRefungibleExSingleOwner: {
2178    user: 'PalletEvmAccountBasicCrossAccountIdRepr',2186    user: 'PalletEvmAccountBasicCrossAccountIdRepr',
2179    pieces: 'u128',2187    pieces: 'u128',
2180    properties: 'Vec<UpDataStructsProperty>'2188    properties: 'Vec<UpDataStructsProperty>'
2181  },2189  },
2182  /**2190  /**
2183   * Lookup269: up_data_structs::CreateRefungibleExMultipleOwners<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>2191   * Lookup270: up_data_structs::CreateRefungibleExMultipleOwners<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
2184   **/2192   **/
2185  UpDataStructsCreateRefungibleExMultipleOwners: {2193  UpDataStructsCreateRefungibleExMultipleOwners: {
2186    users: 'BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>',2194    users: 'BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>',
2187    properties: 'Vec<UpDataStructsProperty>'2195    properties: 'Vec<UpDataStructsProperty>'
2188  },2196  },
2189  /**2197  /**
2190   * Lookup270: pallet_unique_scheduler::pallet::Call<T>2198   * Lookup271: pallet_unique_scheduler::pallet::Call<T>
2191   **/2199   **/
2192  PalletUniqueSchedulerCall: {2200  PalletUniqueSchedulerCall: {
2193    _enum: {2201    _enum: {
2194      schedule_named: {2202      schedule_named: {
2210      }2218      }
2211    }2219    }
2212  },2220  },
2213  /**2221  /**
2214   * Lookup272: frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>2222   * Lookup273: frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>
2215   **/2223   **/
2216  FrameSupportScheduleMaybeHashed: {2224  FrameSupportScheduleMaybeHashed: {
2217    _enum: {2225    _enum: {
2218      Value: 'Call',2226      Value: 'Call',
2219      Hash: 'H256'2227      Hash: 'H256'
2220    }2228    }
2221  },2229  },
2222  /**2230  /**
2223   * Lookup273: pallet_configuration::pallet::Call<T>2231   * Lookup274: pallet_configuration::pallet::Call<T>
2224   **/2232   **/
2225  PalletConfigurationCall: {2233  PalletConfigurationCall: {
2226    _enum: {2234    _enum: {
2227      set_weight_to_fee_coefficient_override: {2235      set_weight_to_fee_coefficient_override: {
2232      }2240      }
2233    }2241    }
2234  },2242  },
2235  /**2243  /**
2236   * Lookup274: pallet_template_transaction_payment::Call<T>2244   * Lookup275: pallet_template_transaction_payment::Call<T>
2237   **/2245   **/
2238  PalletTemplateTransactionPaymentCall: 'Null',2246  PalletTemplateTransactionPaymentCall: 'Null',
2239  /**2247  /**
2240   * Lookup275: pallet_structure::pallet::Call<T>2248   * Lookup276: pallet_structure::pallet::Call<T>
2241   **/2249   **/
2242  PalletStructureCall: 'Null',2250  PalletStructureCall: 'Null',
2243  /**2251  /**
2244   * Lookup276: pallet_rmrk_core::pallet::Call<T>2252   * Lookup277: pallet_rmrk_core::pallet::Call<T>
2245   **/2253   **/
2246  PalletRmrkCoreCall: {2254  PalletRmrkCoreCall: {
2247    _enum: {2255    _enum: {
2248      create_collection: {2256      create_collection: {
2331      }2339      }
2332    }2340    }
2333  },2341  },
2334  /**2342  /**
2335   * Lookup282: rmrk_traits::resource::ResourceTypes<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2343   * Lookup283: rmrk_traits::resource::ResourceTypes<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2336   **/2344   **/
2337  RmrkTraitsResourceResourceTypes: {2345  RmrkTraitsResourceResourceTypes: {
2338    _enum: {2346    _enum: {
2339      Basic: 'RmrkTraitsResourceBasicResource',2347      Basic: 'RmrkTraitsResourceBasicResource',
2340      Composable: 'RmrkTraitsResourceComposableResource',2348      Composable: 'RmrkTraitsResourceComposableResource',
2341      Slot: 'RmrkTraitsResourceSlotResource'2349      Slot: 'RmrkTraitsResourceSlotResource'
2342    }2350    }
2343  },2351  },
2344  /**2352  /**
2345   * Lookup284: rmrk_traits::resource::BasicResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2353   * Lookup285: rmrk_traits::resource::BasicResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2346   **/2354   **/
2347  RmrkTraitsResourceBasicResource: {2355  RmrkTraitsResourceBasicResource: {
2348    src: 'Option<Bytes>',2356    src: 'Option<Bytes>',
2349    metadata: 'Option<Bytes>',2357    metadata: 'Option<Bytes>',
2350    license: 'Option<Bytes>',2358    license: 'Option<Bytes>',
2351    thumb: 'Option<Bytes>'2359    thumb: 'Option<Bytes>'
2352  },2360  },
2353  /**2361  /**
2354   * Lookup286: rmrk_traits::resource::ComposableResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2362   * Lookup287: rmrk_traits::resource::ComposableResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2355   **/2363   **/
2356  RmrkTraitsResourceComposableResource: {2364  RmrkTraitsResourceComposableResource: {
2357    parts: 'Vec<u32>',2365    parts: 'Vec<u32>',
2358    base: 'u32',2366    base: 'u32',
2361    license: 'Option<Bytes>',2369    license: 'Option<Bytes>',
2362    thumb: 'Option<Bytes>'2370    thumb: 'Option<Bytes>'
2363  },2371  },
2364  /**2372  /**
2365   * Lookup287: rmrk_traits::resource::SlotResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2373   * Lookup288: rmrk_traits::resource::SlotResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2366   **/2374   **/
2367  RmrkTraitsResourceSlotResource: {2375  RmrkTraitsResourceSlotResource: {
2368    base: 'u32',2376    base: 'u32',
2369    src: 'Option<Bytes>',2377    src: 'Option<Bytes>',
2372    license: 'Option<Bytes>',2380    license: 'Option<Bytes>',
2373    thumb: 'Option<Bytes>'2381    thumb: 'Option<Bytes>'
2374  },2382  },
2375  /**2383  /**
2376   * Lookup290: pallet_rmrk_equip::pallet::Call<T>2384   * Lookup291: pallet_rmrk_equip::pallet::Call<T>
2377   **/2385   **/
2378  PalletRmrkEquipCall: {2386  PalletRmrkEquipCall: {
2379    _enum: {2387    _enum: {
2380      create_base: {2388      create_base: {
2393      }2401      }
2394    }2402    }
2395  },2403  },
2396  /**2404  /**
2397   * Lookup293: rmrk_traits::part::PartType<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2405   * Lookup294: rmrk_traits::part::PartType<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2398   **/2406   **/
2399  RmrkTraitsPartPartType: {2407  RmrkTraitsPartPartType: {
2400    _enum: {2408    _enum: {
2401      FixedPart: 'RmrkTraitsPartFixedPart',2409      FixedPart: 'RmrkTraitsPartFixedPart',
2402      SlotPart: 'RmrkTraitsPartSlotPart'2410      SlotPart: 'RmrkTraitsPartSlotPart'
2403    }2411    }
2404  },2412  },
2405  /**2413  /**
2406   * Lookup295: rmrk_traits::part::FixedPart<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2414   * Lookup296: rmrk_traits::part::FixedPart<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2407   **/2415   **/
2408  RmrkTraitsPartFixedPart: {2416  RmrkTraitsPartFixedPart: {
2409    id: 'u32',2417    id: 'u32',
2410    z: 'u32',2418    z: 'u32',
2411    src: 'Bytes'2419    src: 'Bytes'
2412  },2420  },
2413  /**2421  /**
2414   * Lookup296: rmrk_traits::part::SlotPart<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2422   * Lookup297: rmrk_traits::part::SlotPart<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2415   **/2423   **/
2416  RmrkTraitsPartSlotPart: {2424  RmrkTraitsPartSlotPart: {
2417    id: 'u32',2425    id: 'u32',
2418    equippable: 'RmrkTraitsPartEquippableList',2426    equippable: 'RmrkTraitsPartEquippableList',
2419    src: 'Bytes',2427    src: 'Bytes',
2420    z: 'u32'2428    z: 'u32'
2421  },2429  },
2422  /**2430  /**
2423   * Lookup297: rmrk_traits::part::EquippableList<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2431   * Lookup298: rmrk_traits::part::EquippableList<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2424   **/2432   **/
2425  RmrkTraitsPartEquippableList: {2433  RmrkTraitsPartEquippableList: {
2426    _enum: {2434    _enum: {
2427      All: 'Null',2435      All: 'Null',
2428      Empty: 'Null',2436      Empty: 'Null',
2429      Custom: 'Vec<u32>'2437      Custom: 'Vec<u32>'
2430    }2438    }
2431  },2439  },
2432  /**2440  /**
2433   * Lookup299: rmrk_traits::theme::Theme<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<rmrk_traits::theme::ThemeProperty<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>, S>>2441   * Lookup300: rmrk_traits::theme::Theme<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<rmrk_traits::theme::ThemeProperty<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>, S>>
2434   **/2442   **/
2435  RmrkTraitsTheme: {2443  RmrkTraitsTheme: {
2436    name: 'Bytes',2444    name: 'Bytes',
2437    properties: 'Vec<RmrkTraitsThemeThemeProperty>',2445    properties: 'Vec<RmrkTraitsThemeThemeProperty>',
2438    inherit: 'bool'2446    inherit: 'bool'
2439  },2447  },
2440  /**2448  /**
2441   * Lookup301: rmrk_traits::theme::ThemeProperty<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2449   * Lookup302: rmrk_traits::theme::ThemeProperty<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2442   **/2450   **/
2443  RmrkTraitsThemeThemeProperty: {2451  RmrkTraitsThemeThemeProperty: {
2444    key: 'Bytes',2452    key: 'Bytes',
2445    value: 'Bytes'2453    value: 'Bytes'
2446  },2454  },
2447  /**2455  /**
2448   * Lookup303: pallet_app_promotion::pallet::Call<T>2456   * Lookup304: pallet_app_promotion::pallet::Call<T>
2449   **/2457   **/
2450  PalletAppPromotionCall: {2458  PalletAppPromotionCall: {
2451    _enum: {2459    _enum: {
2452      set_admin_address: {2460      set_admin_address: {
2453        admin: 'AccountId32',2461        admin: 'PalletEvmAccountBasicCrossAccountIdRepr',
2454      },2462      },
2455      start_app_promotion: {2463      start_app_promotion: {
2456        promotionStartRelayBlock: 'u32',2464        promotionStartRelayBlock: 'Option<u32>',
2457      },2465      },
2458      stake: {2466      stake: {
2459        amount: 'u128',2467        amount: 'u128',
2460      },2468      },
2461      unstake: {2469      unstake: {
2462        amount: 'u128'2470        amount: 'u128',
2463      }2471      },
2472      sponsor_collection: {
2473        collectionId: 'u32',
2474      },
2475      stop_sponsorign_collection: {
2476        collectionId: 'u32'
2477      }
2464    }2478    }
2465  },2479  },
2466  /**2480  /**
2467   * Lookup304: pallet_evm::pallet::Call<T>2481   * Lookup305: pallet_evm::pallet::Call<T>
2468   **/2482   **/
2469  PalletEvmCall: {2483  PalletEvmCall: {
2470    _enum: {2484    _enum: {
2471      withdraw: {2485      withdraw: {
2506      }2520      }
2507    }2521    }
2508  },2522  },
2509  /**2523  /**
2510   * Lookup308: pallet_ethereum::pallet::Call<T>2524   * Lookup309: pallet_ethereum::pallet::Call<T>
2511   **/2525   **/
2512  PalletEthereumCall: {2526  PalletEthereumCall: {
2513    _enum: {2527    _enum: {
2514      transact: {2528      transact: {
2515        transaction: 'EthereumTransactionTransactionV2'2529        transaction: 'EthereumTransactionTransactionV2'
2516      }2530      }
2517    }2531    }
2518  },2532  },
2519  /**2533  /**
2520   * Lookup309: ethereum::transaction::TransactionV22534   * Lookup310: ethereum::transaction::TransactionV2
2521   **/2535   **/
2522  EthereumTransactionTransactionV2: {2536  EthereumTransactionTransactionV2: {
2523    _enum: {2537    _enum: {
2524      Legacy: 'EthereumTransactionLegacyTransaction',2538      Legacy: 'EthereumTransactionLegacyTransaction',
2525      EIP2930: 'EthereumTransactionEip2930Transaction',2539      EIP2930: 'EthereumTransactionEip2930Transaction',
2526      EIP1559: 'EthereumTransactionEip1559Transaction'2540      EIP1559: 'EthereumTransactionEip1559Transaction'
2527    }2541    }
2528  },2542  },
2529  /**2543  /**
2530   * Lookup310: ethereum::transaction::LegacyTransaction2544   * Lookup311: ethereum::transaction::LegacyTransaction
2531   **/2545   **/
2532  EthereumTransactionLegacyTransaction: {2546  EthereumTransactionLegacyTransaction: {
2533    nonce: 'U256',2547    nonce: 'U256',
2534    gasPrice: 'U256',2548    gasPrice: 'U256',
2538    input: 'Bytes',2552    input: 'Bytes',
2539    signature: 'EthereumTransactionTransactionSignature'2553    signature: 'EthereumTransactionTransactionSignature'
2540  },2554  },
2541  /**2555  /**
2542   * Lookup311: ethereum::transaction::TransactionAction2556   * Lookup312: ethereum::transaction::TransactionAction
2543   **/2557   **/
2544  EthereumTransactionTransactionAction: {2558  EthereumTransactionTransactionAction: {
2545    _enum: {2559    _enum: {
2546      Call: 'H160',2560      Call: 'H160',
2547      Create: 'Null'2561      Create: 'Null'
2548    }2562    }
2549  },2563  },
2550  /**2564  /**
2551   * Lookup312: ethereum::transaction::TransactionSignature2565   * Lookup313: ethereum::transaction::TransactionSignature
2552   **/2566   **/
2553  EthereumTransactionTransactionSignature: {2567  EthereumTransactionTransactionSignature: {
2554    v: 'u64',2568    v: 'u64',
2555    r: 'H256',2569    r: 'H256',
2556    s: 'H256'2570    s: 'H256'
2557  },2571  },
2558  /**2572  /**
2559   * Lookup314: ethereum::transaction::EIP2930Transaction2573   * Lookup315: ethereum::transaction::EIP2930Transaction
2560   **/2574   **/
2561  EthereumTransactionEip2930Transaction: {2575  EthereumTransactionEip2930Transaction: {
2562    chainId: 'u64',2576    chainId: 'u64',
2563    nonce: 'U256',2577    nonce: 'U256',
2571    r: 'H256',2585    r: 'H256',
2572    s: 'H256'2586    s: 'H256'
2573  },2587  },
2574  /**2588  /**
2575   * Lookup316: ethereum::transaction::AccessListItem2589   * Lookup317: ethereum::transaction::AccessListItem
2576   **/2590   **/
2577  EthereumTransactionAccessListItem: {2591  EthereumTransactionAccessListItem: {
2578    address: 'H160',2592    address: 'H160',
2579    storageKeys: 'Vec<H256>'2593    storageKeys: 'Vec<H256>'
2580  },2594  },
2581  /**2595  /**
2582   * Lookup317: ethereum::transaction::EIP1559Transaction2596   * Lookup318: ethereum::transaction::EIP1559Transaction
2583   **/2597   **/
2584  EthereumTransactionEip1559Transaction: {2598  EthereumTransactionEip1559Transaction: {
2585    chainId: 'u64',2599    chainId: 'u64',
2586    nonce: 'U256',2600    nonce: 'U256',
2595    r: 'H256',2609    r: 'H256',
2596    s: 'H256'2610    s: 'H256'
2597  },2611  },
2598  /**2612  /**
2599   * Lookup318: pallet_evm_migration::pallet::Call<T>2613   * Lookup319: pallet_evm_migration::pallet::Call<T>
2600   **/2614   **/
2601  PalletEvmMigrationCall: {2615  PalletEvmMigrationCall: {
2602    _enum: {2616    _enum: {
2603      begin: {2617      begin: {
2613      }2627      }
2614    }2628    }
2615  },2629  },
2616  /**2630  /**
2617   * Lookup321: pallet_sudo::pallet::Error<T>2631   * Lookup322: pallet_sudo::pallet::Error<T>
2618   **/2632   **/
2619  PalletSudoError: {2633  PalletSudoError: {
2620    _enum: ['RequireSudo']2634    _enum: ['RequireSudo']
2621  },2635  },
2622  /**2636  /**
2623   * Lookup323: orml_vesting::module::Error<T>2637   * Lookup324: orml_vesting::module::Error<T>
2624   **/2638   **/
2625  OrmlVestingModuleError: {2639  OrmlVestingModuleError: {
2626    _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']2640    _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']
2627  },2641  },
2628  /**2642  /**
2629   * Lookup325: cumulus_pallet_xcmp_queue::InboundChannelDetails2643   * Lookup326: cumulus_pallet_xcmp_queue::InboundChannelDetails
2630   **/2644   **/
2631  CumulusPalletXcmpQueueInboundChannelDetails: {2645  CumulusPalletXcmpQueueInboundChannelDetails: {
2632    sender: 'u32',2646    sender: 'u32',
2633    state: 'CumulusPalletXcmpQueueInboundState',2647    state: 'CumulusPalletXcmpQueueInboundState',
2634    messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>'2648    messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>'
2635  },2649  },
2636  /**2650  /**
2637   * Lookup326: cumulus_pallet_xcmp_queue::InboundState2651   * Lookup327: cumulus_pallet_xcmp_queue::InboundState
2638   **/2652   **/
2639  CumulusPalletXcmpQueueInboundState: {2653  CumulusPalletXcmpQueueInboundState: {
2640    _enum: ['Ok', 'Suspended']2654    _enum: ['Ok', 'Suspended']
2641  },2655  },
2642  /**2656  /**
2643   * Lookup329: polkadot_parachain::primitives::XcmpMessageFormat2657   * Lookup330: polkadot_parachain::primitives::XcmpMessageFormat
2644   **/2658   **/
2645  PolkadotParachainPrimitivesXcmpMessageFormat: {2659  PolkadotParachainPrimitivesXcmpMessageFormat: {
2646    _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']2660    _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']
2647  },2661  },
2648  /**2662  /**
2649   * Lookup332: cumulus_pallet_xcmp_queue::OutboundChannelDetails2663   * Lookup333: cumulus_pallet_xcmp_queue::OutboundChannelDetails
2650   **/2664   **/
2651  CumulusPalletXcmpQueueOutboundChannelDetails: {2665  CumulusPalletXcmpQueueOutboundChannelDetails: {
2652    recipient: 'u32',2666    recipient: 'u32',
2653    state: 'CumulusPalletXcmpQueueOutboundState',2667    state: 'CumulusPalletXcmpQueueOutboundState',
2654    signalsExist: 'bool',2668    signalsExist: 'bool',
2655    firstIndex: 'u16',2669    firstIndex: 'u16',
2656    lastIndex: 'u16'2670    lastIndex: 'u16'
2657  },2671  },
2658  /**2672  /**
2659   * Lookup333: cumulus_pallet_xcmp_queue::OutboundState2673   * Lookup334: cumulus_pallet_xcmp_queue::OutboundState
2660   **/2674   **/
2661  CumulusPalletXcmpQueueOutboundState: {2675  CumulusPalletXcmpQueueOutboundState: {
2662    _enum: ['Ok', 'Suspended']2676    _enum: ['Ok', 'Suspended']
2663  },2677  },
2664  /**2678  /**
2665   * Lookup335: cumulus_pallet_xcmp_queue::QueueConfigData2679   * Lookup336: cumulus_pallet_xcmp_queue::QueueConfigData
2666   **/2680   **/
2667  CumulusPalletXcmpQueueQueueConfigData: {2681  CumulusPalletXcmpQueueQueueConfigData: {
2668    suspendThreshold: 'u32',2682    suspendThreshold: 'u32',
2669    dropThreshold: 'u32',2683    dropThreshold: 'u32',
2672    weightRestrictDecay: 'u64',2686    weightRestrictDecay: 'u64',
2673    xcmpMaxIndividualWeight: 'u64'2687    xcmpMaxIndividualWeight: 'u64'
2674  },2688  },
2675  /**2689  /**
2676   * Lookup337: cumulus_pallet_xcmp_queue::pallet::Error<T>2690   * Lookup338: cumulus_pallet_xcmp_queue::pallet::Error<T>
2677   **/2691   **/
2678  CumulusPalletXcmpQueueError: {2692  CumulusPalletXcmpQueueError: {
2679    _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit']2693    _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit']
2680  },2694  },
2681  /**2695  /**
2682   * Lookup338: pallet_xcm::pallet::Error<T>2696   * Lookup339: pallet_xcm::pallet::Error<T>
2683   **/2697   **/
2684  PalletXcmError: {2698  PalletXcmError: {
2685    _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed']2699    _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed']
2686  },2700  },
2687  /**2701  /**
2688   * Lookup339: cumulus_pallet_xcm::pallet::Error<T>2702   * Lookup340: cumulus_pallet_xcm::pallet::Error<T>
2689   **/2703   **/
2690  CumulusPalletXcmError: 'Null',2704  CumulusPalletXcmError: 'Null',
2691  /**2705  /**
2692   * Lookup340: cumulus_pallet_dmp_queue::ConfigData2706   * Lookup341: cumulus_pallet_dmp_queue::ConfigData
2693   **/2707   **/
2694  CumulusPalletDmpQueueConfigData: {2708  CumulusPalletDmpQueueConfigData: {
2695    maxIndividual: 'u64'2709    maxIndividual: 'u64'
2696  },2710  },
2697  /**2711  /**
2698   * Lookup341: cumulus_pallet_dmp_queue::PageIndexData2712   * Lookup342: cumulus_pallet_dmp_queue::PageIndexData
2699   **/2713   **/
2700  CumulusPalletDmpQueuePageIndexData: {2714  CumulusPalletDmpQueuePageIndexData: {
2701    beginUsed: 'u32',2715    beginUsed: 'u32',
2702    endUsed: 'u32',2716    endUsed: 'u32',
2703    overweightCount: 'u64'2717    overweightCount: 'u64'
2704  },2718  },
2705  /**2719  /**
2706   * Lookup344: cumulus_pallet_dmp_queue::pallet::Error<T>2720   * Lookup345: cumulus_pallet_dmp_queue::pallet::Error<T>
2707   **/2721   **/
2708  CumulusPalletDmpQueueError: {2722  CumulusPalletDmpQueueError: {
2709    _enum: ['Unknown', 'OverLimit']2723    _enum: ['Unknown', 'OverLimit']
2710  },2724  },
2711  /**2725  /**
2712   * Lookup348: pallet_unique::Error<T>2726   * Lookup349: pallet_unique::Error<T>
2713   **/2727   **/
2714  PalletUniqueError: {2728  PalletUniqueError: {
2715    _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection']2729    _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection']
2716  },2730  },
2717  /**2731  /**
2718   * Lookup351: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>2732   * Lookup352: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>
2719   **/2733   **/
2720  PalletUniqueSchedulerScheduledV3: {2734  PalletUniqueSchedulerScheduledV3: {
2721    maybeId: 'Option<[u8;16]>',2735    maybeId: 'Option<[u8;16]>',
2722    priority: 'u8',2736    priority: 'u8',
2723    call: 'FrameSupportScheduleMaybeHashed',2737    call: 'FrameSupportScheduleMaybeHashed',
2724    maybePeriodic: 'Option<(u32,u32)>',2738    maybePeriodic: 'Option<(u32,u32)>',
2725    origin: 'OpalRuntimeOriginCaller'2739    origin: 'OpalRuntimeOriginCaller'
2726  },2740  },
2727  /**2741  /**
2728   * Lookup352: opal_runtime::OriginCaller2742   * Lookup353: opal_runtime::OriginCaller
2729   **/2743   **/
2730  OpalRuntimeOriginCaller: {2744  OpalRuntimeOriginCaller: {
2731    _enum: {2745    _enum: {
2732      system: 'FrameSupportDispatchRawOrigin',2746      system: 'FrameSupportDispatchRawOrigin',
2833      Ethereum: 'PalletEthereumRawOrigin'2847      Ethereum: 'PalletEthereumRawOrigin'
2834    }2848    }
2835  },2849  },
2836  /**2850  /**
2837   * Lookup353: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>2851   * Lookup354: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
2838   **/2852   **/
2839  FrameSupportDispatchRawOrigin: {2853  FrameSupportDispatchRawOrigin: {
2840    _enum: {2854    _enum: {
2841      Root: 'Null',2855      Root: 'Null',
2842      Signed: 'AccountId32',2856      Signed: 'AccountId32',
2843      None: 'Null'2857      None: 'Null'
2844    }2858    }
2845  },2859  },
2846  /**2860  /**
2847   * Lookup354: pallet_xcm::pallet::Origin2861   * Lookup355: pallet_xcm::pallet::Origin
2848   **/2862   **/
2849  PalletXcmOrigin: {2863  PalletXcmOrigin: {
2850    _enum: {2864    _enum: {
2851      Xcm: 'XcmV1MultiLocation',2865      Xcm: 'XcmV1MultiLocation',
2852      Response: 'XcmV1MultiLocation'2866      Response: 'XcmV1MultiLocation'
2853    }2867    }
2854  },2868  },
2855  /**2869  /**
2856   * Lookup355: cumulus_pallet_xcm::pallet::Origin2870   * Lookup356: cumulus_pallet_xcm::pallet::Origin
2857   **/2871   **/
2858  CumulusPalletXcmOrigin: {2872  CumulusPalletXcmOrigin: {
2859    _enum: {2873    _enum: {
2860      Relay: 'Null',2874      Relay: 'Null',
2861      SiblingParachain: 'u32'2875      SiblingParachain: 'u32'
2862    }2876    }
2863  },2877  },
2864  /**2878  /**
2865   * Lookup356: pallet_ethereum::RawOrigin2879   * Lookup357: pallet_ethereum::RawOrigin
2866   **/2880   **/
2867  PalletEthereumRawOrigin: {2881  PalletEthereumRawOrigin: {
2868    _enum: {2882    _enum: {
2869      EthereumTransaction: 'H160'2883      EthereumTransaction: 'H160'
2870    }2884    }
2871  },2885  },
2872  /**2886  /**
2873   * Lookup357: sp_core::Void2887   * Lookup358: sp_core::Void
2874   **/2888   **/
2875  SpCoreVoid: 'Null',2889  SpCoreVoid: 'Null',
2876  /**2890  /**
2877   * Lookup358: pallet_unique_scheduler::pallet::Error<T>2891   * Lookup359: pallet_unique_scheduler::pallet::Error<T>
2878   **/2892   **/
2879  PalletUniqueSchedulerError: {2893  PalletUniqueSchedulerError: {
2880    _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']2894    _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']
2881  },2895  },
2882  /**2896  /**
2883   * Lookup359: up_data_structs::Collection<sp_core::crypto::AccountId32>2897   * Lookup360: up_data_structs::Collection<sp_core::crypto::AccountId32>
2884   **/2898   **/
2885  UpDataStructsCollection: {2899  UpDataStructsCollection: {
2886    owner: 'AccountId32',2900    owner: 'AccountId32',
2887    mode: 'UpDataStructsCollectionMode',2901    mode: 'UpDataStructsCollectionMode',
2893    permissions: 'UpDataStructsCollectionPermissions',2907    permissions: 'UpDataStructsCollectionPermissions',
2894    externalCollection: 'bool'2908    externalCollection: 'bool'
2895  },2909  },
2896  /**2910  /**
2897   * Lookup360: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>2911   * Lookup361: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>
2898   **/2912   **/
2899  UpDataStructsSponsorshipState: {2913  UpDataStructsSponsorshipState: {
2900    _enum: {2914    _enum: {
2901      Disabled: 'Null',2915      Disabled: 'Null',
2902      Unconfirmed: 'AccountId32',2916      Unconfirmed: 'AccountId32',
2903      Confirmed: 'AccountId32'2917      Confirmed: 'AccountId32'
2904    }2918    }
2905  },2919  },
2906  /**2920  /**
2907   * Lookup361: up_data_structs::Properties2921   * Lookup362: up_data_structs::Properties
2908   **/2922   **/
2909  UpDataStructsProperties: {2923  UpDataStructsProperties: {
2910    map: 'UpDataStructsPropertiesMapBoundedVec',2924    map: 'UpDataStructsPropertiesMapBoundedVec',
2911    consumedSpace: 'u32',2925    consumedSpace: 'u32',
2912    spaceLimit: 'u32'2926    spaceLimit: 'u32'
2913  },2927  },
2914  /**2928  /**
2915   * Lookup362: up_data_structs::PropertiesMap<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2929   * Lookup363: up_data_structs::PropertiesMap<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2916   **/2930   **/
2917  UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',2931  UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',
2918  /**2932  /**
2919   * Lookup367: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>2933   * Lookup368: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>
2920   **/2934   **/
2921  UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',2935  UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',
2922  /**2936  /**
2923   * Lookup374: up_data_structs::CollectionStats2937   * Lookup375: up_data_structs::CollectionStats
2924   **/2938   **/
2925  UpDataStructsCollectionStats: {2939  UpDataStructsCollectionStats: {
2926    created: 'u32',2940    created: 'u32',
2927    destroyed: 'u32',2941    destroyed: 'u32',
2928    alive: 'u32'2942    alive: 'u32'
2929  },2943  },
2930  /**2944  /**
2931   * Lookup375: up_data_structs::TokenChild2945   * Lookup376: up_data_structs::TokenChild
2932   **/2946   **/
2933  UpDataStructsTokenChild: {2947  UpDataStructsTokenChild: {
2934    token: 'u32',2948    token: 'u32',
2935    collection: 'u32'2949    collection: 'u32'
2936  },2950  },
2937  /**2951  /**
2938   * Lookup376: PhantomType::up_data_structs<T>2952   * Lookup377: PhantomType::up_data_structs<T>
2939   **/2953   **/
2940  PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]',2954  PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]',
2941  /**2955  /**
2942   * Lookup378: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>2956   * Lookup379: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
2943   **/2957   **/
2944  UpDataStructsTokenData: {2958  UpDataStructsTokenData: {
2945    properties: 'Vec<UpDataStructsProperty>',2959    properties: 'Vec<UpDataStructsProperty>',
2946    owner: 'Option<PalletEvmAccountBasicCrossAccountIdRepr>',2960    owner: 'Option<PalletEvmAccountBasicCrossAccountIdRepr>',
2947    pieces: 'u128'2961    pieces: 'u128'
2948  },2962  },
2949  /**2963  /**
2950   * Lookup380: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>2964   * Lookup381: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>
2951   **/2965   **/
2952  UpDataStructsRpcCollection: {2966  UpDataStructsRpcCollection: {
2953    owner: 'AccountId32',2967    owner: 'AccountId32',
2954    mode: 'UpDataStructsCollectionMode',2968    mode: 'UpDataStructsCollectionMode',
2962    properties: 'Vec<UpDataStructsProperty>',2976    properties: 'Vec<UpDataStructsProperty>',
2963    readOnly: 'bool'2977    readOnly: 'bool'
2964  },2978  },
2965  /**2979  /**
2966   * Lookup381: rmrk_traits::collection::CollectionInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>2980   * Lookup382: rmrk_traits::collection::CollectionInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>
2967   **/2981   **/
2968  RmrkTraitsCollectionCollectionInfo: {2982  RmrkTraitsCollectionCollectionInfo: {
2969    issuer: 'AccountId32',2983    issuer: 'AccountId32',
2970    metadata: 'Bytes',2984    metadata: 'Bytes',
2971    max: 'Option<u32>',2985    max: 'Option<u32>',
2972    symbol: 'Bytes',2986    symbol: 'Bytes',
2973    nftsCount: 'u32'2987    nftsCount: 'u32'
2974  },2988  },
2975  /**2989  /**
2976   * Lookup382: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>2990   * Lookup383: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2977   **/2991   **/
2978  RmrkTraitsNftNftInfo: {2992  RmrkTraitsNftNftInfo: {
2979    owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',2993    owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
2980    royalty: 'Option<RmrkTraitsNftRoyaltyInfo>',2994    royalty: 'Option<RmrkTraitsNftRoyaltyInfo>',
2981    metadata: 'Bytes',2995    metadata: 'Bytes',
2982    equipped: 'bool',2996    equipped: 'bool',
2983    pending: 'bool'2997    pending: 'bool'
2984  },2998  },
2985  /**2999  /**
2986   * Lookup384: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>3000   * Lookup385: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>
2987   **/3001   **/
2988  RmrkTraitsNftRoyaltyInfo: {3002  RmrkTraitsNftRoyaltyInfo: {
2989    recipient: 'AccountId32',3003    recipient: 'AccountId32',
2990    amount: 'Permill'3004    amount: 'Permill'
2991  },3005  },
2992  /**3006  /**
2993   * Lookup385: rmrk_traits::resource::ResourceInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>3007   * Lookup386: rmrk_traits::resource::ResourceInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
2994   **/3008   **/
2995  RmrkTraitsResourceResourceInfo: {3009  RmrkTraitsResourceResourceInfo: {
2996    id: 'u32',3010    id: 'u32',
2997    resource: 'RmrkTraitsResourceResourceTypes',3011    resource: 'RmrkTraitsResourceResourceTypes',
2998    pending: 'bool',3012    pending: 'bool',
2999    pendingRemoval: 'bool'3013    pendingRemoval: 'bool'
3000  },3014  },
3001  /**3015  /**
3002   * Lookup386: rmrk_traits::property::PropertyInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>3016   * Lookup387: rmrk_traits::property::PropertyInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
3003   **/3017   **/
3004  RmrkTraitsPropertyPropertyInfo: {3018  RmrkTraitsPropertyPropertyInfo: {
3005    key: 'Bytes',3019    key: 'Bytes',
3006    value: 'Bytes'3020    value: 'Bytes'
3007  },3021  },
3008  /**3022  /**
3009   * Lookup387: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>3023   * Lookup388: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
3010   **/3024   **/
3011  RmrkTraitsBaseBaseInfo: {3025  RmrkTraitsBaseBaseInfo: {
3012    issuer: 'AccountId32',3026    issuer: 'AccountId32',
3013    baseType: 'Bytes',3027    baseType: 'Bytes',
3014    symbol: 'Bytes'3028    symbol: 'Bytes'
3015  },3029  },
3016  /**3030  /**
3017   * Lookup388: rmrk_traits::nft::NftChild3031   * Lookup389: rmrk_traits::nft::NftChild
3018   **/3032   **/
3019  RmrkTraitsNftNftChild: {3033  RmrkTraitsNftNftChild: {
3020    collectionId: 'u32',3034    collectionId: 'u32',
3021    nftId: 'u32'3035    nftId: 'u32'
3022  },3036  },
3023  /**3037  /**
3024   * Lookup390: pallet_common::pallet::Error<T>3038   * Lookup391: pallet_common::pallet::Error<T>
3025   **/3039   **/
3026  PalletCommonError: {3040  PalletCommonError: {
3027    _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'CantDestroyNotEmptyCollection', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'UserIsNotAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached', 'PropertyKeyIsTooLong', 'InvalidCharacterInPropertyKey', 'EmptyPropertyKey', 'CollectionIsExternal', 'CollectionIsInternal']3041    _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'CantDestroyNotEmptyCollection', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'UserIsNotAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached', 'PropertyKeyIsTooLong', 'InvalidCharacterInPropertyKey', 'EmptyPropertyKey', 'CollectionIsExternal', 'CollectionIsInternal']
3028  },3042  },
3029  /**3043  /**
3030   * Lookup392: pallet_fungible::pallet::Error<T>3044   * Lookup393: pallet_fungible::pallet::Error<T>
3031   **/3045   **/
3032  PalletFungibleError: {3046  PalletFungibleError: {
3033    _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']3047    _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
3034  },3048  },
3035  /**3049  /**
3036   * Lookup393: pallet_refungible::ItemData3050   * Lookup394: pallet_refungible::ItemData
3037   **/3051   **/
3038  PalletRefungibleItemData: {3052  PalletRefungibleItemData: {
3039    constData: 'Bytes'3053    constData: 'Bytes'
3040  },3054  },
3041  /**3055  /**
3042   * Lookup398: pallet_refungible::pallet::Error<T>3056   * Lookup399: pallet_refungible::pallet::Error<T>
3043   **/3057   **/
3044  PalletRefungibleError: {3058  PalletRefungibleError: {
3045    _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']3059    _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
3046  },3060  },
3047  /**3061  /**
3048   * Lookup399: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>3062   * Lookup400: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
3049   **/3063   **/
3050  PalletNonfungibleItemData: {3064  PalletNonfungibleItemData: {
3051    owner: 'PalletEvmAccountBasicCrossAccountIdRepr'3065    owner: 'PalletEvmAccountBasicCrossAccountIdRepr'
3052  },3066  },
3053  /**3067  /**
3054   * Lookup401: up_data_structs::PropertyScope3068   * Lookup402: up_data_structs::PropertyScope
3055   **/3069   **/
3056  UpDataStructsPropertyScope: {3070  UpDataStructsPropertyScope: {
3057    _enum: ['None', 'Rmrk', 'Eth']3071    _enum: ['None', 'Rmrk', 'Eth']
3058  },3072  },
3059  /**3073  /**
3060   * Lookup403: pallet_nonfungible::pallet::Error<T>3074   * Lookup404: pallet_nonfungible::pallet::Error<T>
3061   **/3075   **/
3062  PalletNonfungibleError: {3076  PalletNonfungibleError: {
3063    _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren']3077    _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren']
3064  },3078  },
3065  /**3079  /**
3066   * Lookup404: pallet_structure::pallet::Error<T>3080   * Lookup405: pallet_structure::pallet::Error<T>
3067   **/3081   **/
3068  PalletStructureError: {3082  PalletStructureError: {
3069    _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound']3083    _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound']
3070  },3084  },
3071  /**3085  /**
3072   * Lookup405: pallet_rmrk_core::pallet::Error<T>3086   * Lookup406: pallet_rmrk_core::pallet::Error<T>
3073   **/3087   **/
3074  PalletRmrkCoreError: {3088  PalletRmrkCoreError: {
3075    _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']3089    _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']
3076  },3090  },
3077  /**3091  /**
3078   * Lookup407: pallet_rmrk_equip::pallet::Error<T>3092   * Lookup408: pallet_rmrk_equip::pallet::Error<T>
3079   **/3093   **/
3080  PalletRmrkEquipError: {3094  PalletRmrkEquipError: {
3081    _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']3095    _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']
3082  },3096  },
3097  /**
3098   * Lookup410: pallet_app_promotion::pallet::Error<T>
3099   **/
3100  PalletAppPromotionError: {
3101    _enum: ['AdminNotSet', 'NoPermission', 'NotSufficientFounds', 'InvalidArgument', 'AlreadySponsored']
3102  },
3083  /**3103  /**
3084   * Lookup411: pallet_evm::pallet::Error<T>3104   * Lookup413: pallet_evm::pallet::Error<T>
3085   **/3105   **/
3086  PalletEvmError: {3106  PalletEvmError: {
3087    _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']3107    _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']
3088  },3108  },
3089  /**3109  /**
3090   * Lookup414: fp_rpc::TransactionStatus3110   * Lookup416: fp_rpc::TransactionStatus
3091   **/3111   **/
3092  FpRpcTransactionStatus: {3112  FpRpcTransactionStatus: {
3093    transactionHash: 'H256',3113    transactionHash: 'H256',
3094    transactionIndex: 'u32',3114    transactionIndex: 'u32',
3098    logs: 'Vec<EthereumLog>',3118    logs: 'Vec<EthereumLog>',
3099    logsBloom: 'EthbloomBloom'3119    logsBloom: 'EthbloomBloom'
3100  },3120  },
3101  /**3121  /**
3102   * Lookup416: ethbloom::Bloom3122   * Lookup418: ethbloom::Bloom
3103   **/3123   **/
3104  EthbloomBloom: '[u8;256]',3124  EthbloomBloom: '[u8;256]',
3105  /**3125  /**
3106   * Lookup418: ethereum::receipt::ReceiptV33126   * Lookup420: ethereum::receipt::ReceiptV3
3107   **/3127   **/
3108  EthereumReceiptReceiptV3: {3128  EthereumReceiptReceiptV3: {
3109    _enum: {3129    _enum: {
3110      Legacy: 'EthereumReceiptEip658ReceiptData',3130      Legacy: 'EthereumReceiptEip658ReceiptData',
3111      EIP2930: 'EthereumReceiptEip658ReceiptData',3131      EIP2930: 'EthereumReceiptEip658ReceiptData',
3112      EIP1559: 'EthereumReceiptEip658ReceiptData'3132      EIP1559: 'EthereumReceiptEip658ReceiptData'
3113    }3133    }
3114  },3134  },
3115  /**3135  /**
3116   * Lookup419: ethereum::receipt::EIP658ReceiptData3136   * Lookup421: ethereum::receipt::EIP658ReceiptData
3117   **/3137   **/
3118  EthereumReceiptEip658ReceiptData: {3138  EthereumReceiptEip658ReceiptData: {
3119    statusCode: 'u8',3139    statusCode: 'u8',
3120    usedGas: 'U256',3140    usedGas: 'U256',
3121    logsBloom: 'EthbloomBloom',3141    logsBloom: 'EthbloomBloom',
3122    logs: 'Vec<EthereumLog>'3142    logs: 'Vec<EthereumLog>'
3123  },3143  },
3124  /**3144  /**
3125   * Lookup420: ethereum::block::Block<ethereum::transaction::TransactionV2>3145   * Lookup422: ethereum::block::Block<ethereum::transaction::TransactionV2>
3126   **/3146   **/
3127  EthereumBlock: {3147  EthereumBlock: {
3128    header: 'EthereumHeader',3148    header: 'EthereumHeader',
3129    transactions: 'Vec<EthereumTransactionTransactionV2>',3149    transactions: 'Vec<EthereumTransactionTransactionV2>',
3130    ommers: 'Vec<EthereumHeader>'3150    ommers: 'Vec<EthereumHeader>'
3131  },3151  },
3132  /**3152  /**
3133   * Lookup421: ethereum::header::Header3153   * Lookup423: ethereum::header::Header
3134   **/3154   **/
3135  EthereumHeader: {3155  EthereumHeader: {
3136    parentHash: 'H256',3156    parentHash: 'H256',
3137    ommersHash: 'H256',3157    ommersHash: 'H256',
3149    mixHash: 'H256',3169    mixHash: 'H256',
3150    nonce: 'EthereumTypesHashH64'3170    nonce: 'EthereumTypesHashH64'
3151  },3171  },
3152  /**3172  /**
3153   * Lookup422: ethereum_types::hash::H643173   * Lookup424: ethereum_types::hash::H64
3154   **/3174   **/
3155  EthereumTypesHashH64: '[u8;8]',3175  EthereumTypesHashH64: '[u8;8]',
3156  /**3176  /**
3157   * Lookup427: pallet_ethereum::pallet::Error<T>3177   * Lookup429: pallet_ethereum::pallet::Error<T>
3158   **/3178   **/
3159  PalletEthereumError: {3179  PalletEthereumError: {
3160    _enum: ['InvalidSignature', 'PreLogExists']3180    _enum: ['InvalidSignature', 'PreLogExists']
3161  },3181  },
3162  /**3182  /**
3163   * Lookup428: pallet_evm_coder_substrate::pallet::Error<T>3183   * Lookup430: pallet_evm_coder_substrate::pallet::Error<T>
3164   **/3184   **/
3165  PalletEvmCoderSubstrateError: {3185  PalletEvmCoderSubstrateError: {
3166    _enum: ['OutOfGas', 'OutOfFund']3186    _enum: ['OutOfGas', 'OutOfFund']
3167  },3187  },
3168  /**3188  /**
3169   * Lookup429: pallet_evm_contract_helpers::SponsoringModeT3189   * Lookup431: pallet_evm_contract_helpers::SponsoringModeT
3170   **/3190   **/
3171  PalletEvmContractHelpersSponsoringModeT: {3191  PalletEvmContractHelpersSponsoringModeT: {
3172    _enum: ['Disabled', 'Allowlisted', 'Generous']3192    _enum: ['Disabled', 'Allowlisted', 'Generous']
3173  },3193  },
3174  /**3194  /**
3175   * Lookup431: pallet_evm_contract_helpers::pallet::Error<T>3195   * Lookup433: pallet_evm_contract_helpers::pallet::Error<T>
3176   **/3196   **/
3177  PalletEvmContractHelpersError: {3197  PalletEvmContractHelpersError: {
3178    _enum: ['NoPermission']3198    _enum: ['NoPermission']
3179  },3199  },
3180  /**3200  /**
3181   * Lookup432: pallet_evm_migration::pallet::Error<T>3201   * Lookup434: pallet_evm_migration::pallet::Error<T>
3182   **/3202   **/
3183  PalletEvmMigrationError: {3203  PalletEvmMigrationError: {
3184    _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']3204    _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']
3185  },3205  },
3186  /**3206  /**
3187   * Lookup434: sp_runtime::MultiSignature3207   * Lookup436: sp_runtime::MultiSignature
3188   **/3208   **/
3189  SpRuntimeMultiSignature: {3209  SpRuntimeMultiSignature: {
3190    _enum: {3210    _enum: {
3191      Ed25519: 'SpCoreEd25519Signature',3211      Ed25519: 'SpCoreEd25519Signature',
3192      Sr25519: 'SpCoreSr25519Signature',3212      Sr25519: 'SpCoreSr25519Signature',
3193      Ecdsa: 'SpCoreEcdsaSignature'3213      Ecdsa: 'SpCoreEcdsaSignature'
3194    }3214    }
3195  },3215  },
3196  /**3216  /**
3197   * Lookup435: sp_core::ed25519::Signature3217   * Lookup437: sp_core::ed25519::Signature
3198   **/3218   **/
3199  SpCoreEd25519Signature: '[u8;64]',3219  SpCoreEd25519Signature: '[u8;64]',
3200  /**3220  /**
3201   * Lookup437: sp_core::sr25519::Signature3221   * Lookup439: sp_core::sr25519::Signature
3202   **/3222   **/
3203  SpCoreSr25519Signature: '[u8;64]',3223  SpCoreSr25519Signature: '[u8;64]',
3204  /**3224  /**
3205   * Lookup438: sp_core::ecdsa::Signature3225   * Lookup440: sp_core::ecdsa::Signature
3206   **/3226   **/
3207  SpCoreEcdsaSignature: '[u8;65]',3227  SpCoreEcdsaSignature: '[u8;65]',
3208  /**3228  /**
3209   * Lookup441: frame_system::extensions::check_spec_version::CheckSpecVersion<T>3229   * Lookup443: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
3210   **/3230   **/
3211  FrameSystemExtensionsCheckSpecVersion: 'Null',3231  FrameSystemExtensionsCheckSpecVersion: 'Null',
3212  /**3232  /**
3213   * Lookup442: frame_system::extensions::check_genesis::CheckGenesis<T>3233   * Lookup444: frame_system::extensions::check_genesis::CheckGenesis<T>
3214   **/3234   **/
3215  FrameSystemExtensionsCheckGenesis: 'Null',3235  FrameSystemExtensionsCheckGenesis: 'Null',
3216  /**3236  /**
3217   * Lookup445: frame_system::extensions::check_nonce::CheckNonce<T>3237   * Lookup447: frame_system::extensions::check_nonce::CheckNonce<T>
3218   **/3238   **/
3219  FrameSystemExtensionsCheckNonce: 'Compact<u32>',3239  FrameSystemExtensionsCheckNonce: 'Compact<u32>',
3220  /**3240  /**
3221   * Lookup446: frame_system::extensions::check_weight::CheckWeight<T>3241   * Lookup448: frame_system::extensions::check_weight::CheckWeight<T>
3222   **/3242   **/
3223  FrameSystemExtensionsCheckWeight: 'Null',3243  FrameSystemExtensionsCheckWeight: 'Null',
3224  /**3244  /**
3225   * Lookup447: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>3245   * Lookup449: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
3226   **/3246   **/
3227  PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',3247  PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
3228  /**3248  /**
3229   * Lookup448: opal_runtime::Runtime3249   * Lookup450: opal_runtime::Runtime
3230   **/3250   **/
3231  OpalRuntimeRuntime: 'Null',3251  OpalRuntimeRuntime: 'Null',
3232  /**3252  /**
3233   * Lookup449: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>3253   * Lookup451: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
3234   **/3254   **/
3235  PalletEthereumFakeTransactionFinalizer: 'Null'3255  PalletEthereumFakeTransactionFinalizer: 'Null'
3236};3256};
32373257