git.delta.rocks / unique-network / refs/commits / 4d07c60d3d95

--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -262,6 +262,14 @@
 	#[method(name = "unique_totalStakingLocked")]
 	fn total_staking_locked(&self, staker: CrossAccountId, at: Option<BlockHash>)
 		-> Result<String>;
+
+	/// Return the total amount locked by staking tokens.
+	#[method(name = "unique_pendingUnstake")]
+	fn pending_unstake(
+		&self,
+		staker: Option<CrossAccountId>,
+		at: Option<BlockHash>,
+	) -> Result<String>;
 }
 
 mod rmrk_unique_rpc {
@@ -548,6 +556,7 @@
 		.map(|(b, a)| (b, a.to_string()))
 		.collect::<Vec<_>>(), unique_api);
 	pass_method!(total_staking_locked(staker: CrossAccountId) -> String => |v| v.to_string(), unique_api);
+	pass_method!(pending_unstake(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), unique_api);
 }
 
 #[allow(deprecated)]

--- a/node/cli/src/service.rs
+++ b/node/cli/src/service.rs
@@ -63,7 +63,7 @@
 use fc_rpc_core::types::FilterPool;
 use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};
 
-use unique_runtime_common::types::{
+use up_common::types::opaque::{
 	AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block, BlockNumber,
 };
 

--- a/pallets/app-promotion/src/lib.rs
+++ b/pallets/app-promotion/src/lib.rs
@@ -31,12 +31,12 @@
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
-pub mod types;
-
 #[cfg(test)]
 mod tests;
+pub mod types;
+pub mod weights;
 
-use sp_std::vec::Vec;
+use sp_std::{vec::Vec, iter::Sum};
 use codec::EncodeLike;
 use pallet_balances::BalanceLock;
 pub use types::ExtendedLockableCurrency;
@@ -48,6 +48,9 @@
 	},
 	ensure,
 };
+
+use weights::WeightInfo;
+
 pub use pallet::*;
 use pallet_evm::account::CrossAccountId;
 use sp_runtime::{
@@ -79,6 +82,9 @@
 
 		type TreasuryAccountId: Get<Self::AccountId>;
 
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
 		// The block number provider
 		type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
 
@@ -136,6 +142,7 @@
 		fn on_initialize(current_block: T::BlockNumber) -> Weight
 		where
 			<T as frame_system::Config>::BlockNumber: From<u32>,
+			// <<T as pallet::Config>::Currency as Currency<T::AccountId>>::Balance: Sum,
 		{
 			PendingUnstake::<T>::iter()
 				.filter_map(|((staker, block), amount)| {
@@ -172,7 +179,7 @@
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::set_admin_address())]
 		pub fn set_admin_address(origin: OriginFor<T>, admin: T::AccountId) -> DispatchResult {
 			ensure_root(origin)?;
 			<Admin<T>>::set(Some(admin));
@@ -180,7 +187,7 @@
 			Ok(())
 		}
 
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::start_app_promotion())]
 		pub fn start_app_promotion(
 			origin: OriginFor<T>,
 			promotion_start_relay_block: T::BlockNumber,
@@ -201,7 +208,7 @@
 			Ok(())
 		}
 
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::stake())]
 		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
 			let staker_id = ensure_signed(staker)?;
 
@@ -210,10 +217,16 @@
 
 			ensure!(balance >= amount, ArithmeticError::Underflow);
 
-			Self::set_lock_unchecked(&staker_id, amount);
+			<<T as Config>::Currency as Currency<T::AccountId>>::ensure_can_withdraw(
+				&staker_id,
+				amount,
+				WithdrawReasons::all(),
+				balance - amount,
+			)?;
+
+			Self::add_lock_balance(&staker_id, amount)?;
 
-			let block_number =
-				<T::BlockNumberProvider as BlockNumberProvider>::current_block_number();
+			let block_number = frame_system::Pallet::<T>::block_number();
 
 			<Staked<T>>::insert(
 				(&staker_id, block_number),
@@ -231,7 +244,7 @@
 			Ok(())
 		}
 
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::unstake())]
 		pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
 			let staker_id = ensure_signed(staker)?;
 
@@ -249,7 +262,7 @@
 					.ok_or(ArithmeticError::Underflow)?,
 			);
 
-			let block = <T::BlockNumberProvider>::current_block_number() + WEEK.into();
+			let block = frame_system::Pallet::<T>::block_number() + WEEK.into();
 			<PendingUnstake<T>>::insert(
 				(&staker_id, block),
 				<PendingUnstake<T>>::get((&staker_id, block))
@@ -400,8 +413,8 @@
 
 	fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
 		Self::get_locked_balance(staker)
-			.map(|l| l.amount)
-			.and_then(|b| b.checked_add(&amount))
+			.map_or(<BalanceOf<T>>::default(), |l| l.amount)
+			.checked_add(&amount)
 			.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))
 			.ok_or(ArithmeticError::Overflow.into())
 	}
@@ -437,10 +450,11 @@
 	pub fn total_staked_by_id_per_block(
 		staker: impl EncodeLike<T::AccountId>,
 	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {
-		let staked = Staked::<T>::iter_prefix((staker,))
+		let mut staked = Staked::<T>::iter_prefix((staker,))
 			.into_iter()
 			.map(|(block, amount)| (block, amount))
 			.collect::<Vec<_>>();
+		staked.sort_by_key(|(block, _)| *block);
 		if !staked.is_empty() {
 			Some(staked)
 		} else {
@@ -495,3 +509,14 @@
 		day_rate * base
 	}
 }
+
+impl<T: Config> Pallet<T>
+where
+	<<T as pallet::Config>::Currency as Currency<T::AccountId>>::Balance: Sum,
+{
+	pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {
+		staker.map_or(PendingUnstake::<T>::iter_values().sum(), |s| {
+			PendingUnstake::<T>::iter_prefix_values((s.as_sub(),)).sum()
+		})
+	}
+}

--- a/primitives/rpc/src/lib.rs
+++ b/primitives/rpc/src/lib.rs
@@ -129,5 +129,6 @@
 		fn total_staked(staker: Option<CrossAccountId>) -> Result<u128>;
 		fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>>;
 		fn total_staking_locked(staker: CrossAccountId) -> Result<u128>;
+		fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128>;
 	}
 }

--- a/runtime/common/config/pallets/mod.rs
+++ b/runtime/common/config/pallets/mod.rs
@@ -40,6 +40,9 @@
 #[cfg(feature = "scheduler")]
 pub mod scheduler;
 
+#[cfg(feature = "app-promotion")]
+pub mod app_promotion;
+
 parameter_types! {
 	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();
 	pub const CollectionCreationPrice: Balance = 2 * UNIQUE;

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

--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -190,7 +190,6 @@
 
                 fn total_staked(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {
                     Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked(staker).unwrap_or_default())
-                    // Ok(0)
                 }
 
                 fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>, DispatchError> {
@@ -198,9 +197,12 @@
                 }
 
                 fn total_staking_locked(staker: CrossAccountId) -> Result<u128, DispatchError> {
-                    // Ok(0)
                     Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_locked_balance(staker))
                 }
+
+                fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {
+                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_pending_unstake(staker))
+                }
             }
 
             impl rmrk_rpc::RmrkApi<

--- a/runtime/opal/Cargo.toml
+++ b/runtime/opal/Cargo.toml
@@ -124,11 +124,12 @@
     "orml-vesting/std",
 ]
 limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']
-opal-runtime = ['refungible', 'scheduler', 'rmrk']
+opal-runtime = ['refungible', 'scheduler', 'rmrk', 'app-promotion']
 
 refungible = []
 scheduler = []
 rmrk = []
+app-promotion = []
 
 ################################################################################
 # Substrate Dependencies

--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -15,7 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {default as usingApi, submitTransactionAsync} from './substrate/substrate-api';
-import {IKeyringPair} from '@polkadot/types/types';
+import {IKeyringPair, ITuple} from '@polkadot/types/types';
 import {
   
   createMultipleItemsExpectSuccess,
@@ -33,26 +33,38 @@
   U128_MAX,
   burnFromExpectSuccess,
   UNIQUE,
+  getModuleNames,
+  Pallets,
+  getBlockNumber,
 } from './util/helpers';
 
-import chai from 'chai';
+import chai, {use} from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import getBalance from './substrate/get-balance';
-import { unique } from './interfaces/definitions';
+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 {UniqueHelper} from './util/playgrounds/unique';
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
 let alice: IKeyringPair;
 let bob: IKeyringPair;
 let palletAdmin: IKeyringPair;
+let nominal: bigint; 
 
 describe('integration test: AppPromotion', () => {
-  before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
+  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 = api.tx.sudo.sudo(api.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
+      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
+      nominal = helper.balance.getOneTokenNominal();
       await submitTransactionAsync(alice, tx);
     });
   });
@@ -69,22 +81,110 @@
     // assert:  query appPromotion.staked(Alice) equal [100, 200]
     // assert:  query appPromotion.totalStaked() increased by 200
     
-    await usingApi(async (api, privateKeyWrapper) => {
-      await submitTransactionAsync(alice, api.tx.balances.transfer(bob.addressRaw, 10n * UNIQUE));
-      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alice.address, bob.address]);
+    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+      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;
+      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);
       
-      console.log(`alice: ${alicesBalanceBefore} \n bob: ${bobsBalanceBefore}`);
+      await waitNewBlocks(helper.api!, 1);
+      const secondStakedBlock = await helper.chain.getLatestBlockNumber();
       
-      await submitTransactionAsync(alice, api.tx.promotion.stake(1n * UNIQUE));
-      await submitTransactionAsync(bob, api.tx.promotion.stake(1n * UNIQUE));
-      const alice_total_staked = (await (api.rpc.unique.totalStaked(normalizeAccountId(alice)))).toBigInt();
-      const bob_total_staked = (await api.rpc.unique.totalStaked(normalizeAccountId(bob))).toBigInt();
-       
-      console.log(`alice staked: ${alice_total_staked} \n bob staked: ${bob_total_staked}, total staked: ${(await api.rpc.unique.totalStaked()).toBigInt()}`);
+      await expect(submitTransactionAsync(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()]);
+      expect(stakedPerBlock.map((x) => x[1])).to.be.deep.equal([nominal, 2n * nominal]);
+    });
+  });
+  
+  it('will throws if stake amount is more than total free balance', async () => {
+    // arrange: Alice balance = 1000
+    // assert:  Alice calls appPromotion.stake(1000) throws /// because Alice needs some fee
+
+    // act:     Alice calls appPromotion.stake(700)
+    // assert:  Alice calls appPromotion.stake(400) throws /// because Alice has ~300 free QTZ and 700 locked
+
+    await usingPlaygrounds(async helper => { 
       
+      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;
       
     });
   });
+  
+  it.skip('for different accounts in one block is possible', async () => {
+    // arrange: Alice, Bob, Charlie, Dave balance = 1000
+    // arrange: Alice, Bob, Charlie, Dave calls appPromotion.stake(100) in the same time
+
+    // assert:  query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]
+    await usingPlaygrounds(async helper => {
+      const crowd = await creteAccounts([10n, 10n, 10n, 10n], alice, helper);
+      // const promises = crowd.map(async user => submitTransactionAsync(user, helper.api!.tx.promotion.stake(nominal)));
+      // await expect(Promise.all(promises)).to.be.eventually.fulfilled;
+    });
+  });
+
+});
+
+describe.skip('unstake balance 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));
+      nominal = helper.balance.getOneTokenNominal();
+      await submitTransactionAsync(alice, tx);
+    });
+  });
+  it('will change balance state to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {
+    // arrange: Alice balance = 1000
+    // arrange: Alice calls appPromotion.stake(Alice, 500)
+
+    // act:     Alice calls appPromotion.unstake(300)
+    // assert:  Alice reserved balance to equal 300
+    // assert:  query appPromotion.staked(Alice) equal [200] /// 500 - 300
+    // assert:  query appPromotion.pendingUnstake(Alice) to equal [300]
+    // assert:  query appPromotion.totalStaked() decreased by 300
+  });
+});
+
+
+
+async function createUser(amount?: bigint) {
+  return await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+    const user: IKeyringPair = privateKeyWrapper(`//Alice+${(new Date()).getTime()}`);
+    await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());
+    return user;
+  });
+}
+
+const creteAccounts = async (balances: bigint[], donor: IKeyringPair, helper: UniqueHelper) => {
+  let nonce = await helper.chain.getNonce(donor.address);
+  const tokenNominal = helper.balance.getOneTokenNominal();
+  const transactions = [];
+  const accounts = [];
+  for (const balance of balances) {
+    const recepient = helper.util.fromSeed(mnemonicGenerate());
+    accounts.push(recepient);
+    if (balance !== 0n){
+      const tx = helper.constructApiCall('api.tx.balances.transfer', [{Id: recepient.address}, balance * tokenNominal]);
+      transactions.push(helper.signTransaction(donor, tx, 'account generation', {nonce}));
+      nonce++;
+    }
+  }
 
-});
\ No newline at end of file
+  await Promise.all(transactions);
+  return accounts;
+};
\ No newline at end of file

--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -703,6 +703,10 @@
        **/
       nextSponsored: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;
       /**
+       * Returns the total amount of unstaked tokens
+       **/
+      pendingUnstake: AugmentedRpc<(staker?: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;
+      /**
        * Get property permissions, optionally limited to the provided keys
        **/
       propertyPermissions: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, propertyKeys?: Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsPropertyKeyPermission>>>;

--- a/tests/src/interfaces/lookup.ts
+++ b/tests/src/interfaces/lookup.ts
@@ -5,1266 +5,8 @@
 
 export default {
   /**
-   * Lookup3: frame_system::AccountInfo<Index, pallet_balances::AccountData<Balance>>
-   **/
-  FrameSystemAccountInfo: {
-    nonce: 'u32',
-    consumers: 'u32',
-    providers: 'u32',
-    sufficients: 'u32',
-    data: 'PalletBalancesAccountData'
-  },
-  /**
-   * Lookup5: pallet_balances::AccountData<Balance>
-   **/
-  PalletBalancesAccountData: {
-    free: 'u128',
-    reserved: 'u128',
-    miscFrozen: 'u128',
-    feeFrozen: 'u128'
-  },
-  /**
-   * Lookup7: frame_support::weights::PerDispatchClass<T>
-   **/
-  FrameSupportWeightsPerDispatchClassU64: {
-    normal: 'u64',
-    operational: 'u64',
-    mandatory: 'u64'
-  },
-  /**
-   * Lookup11: sp_runtime::generic::digest::Digest
-   **/
-  SpRuntimeDigest: {
-    logs: 'Vec<SpRuntimeDigestDigestItem>'
-  },
-  /**
-   * Lookup13: sp_runtime::generic::digest::DigestItem
-   **/
-  SpRuntimeDigestDigestItem: {
-    _enum: {
-      Other: 'Bytes',
-      __Unused1: 'Null',
-      __Unused2: 'Null',
-      __Unused3: 'Null',
-      Consensus: '([u8;4],Bytes)',
-      Seal: '([u8;4],Bytes)',
-      PreRuntime: '([u8;4],Bytes)',
-      __Unused7: 'Null',
-      RuntimeEnvironmentUpdated: 'Null'
-    }
-  },
-  /**
-   * Lookup16: frame_system::EventRecord<opal_runtime::Event, primitive_types::H256>
-   **/
-  FrameSystemEventRecord: {
-    phase: 'FrameSystemPhase',
-    event: 'Event',
-    topics: 'Vec<H256>'
-  },
-  /**
-   * Lookup18: frame_system::pallet::Event<T>
-   **/
-  FrameSystemEvent: {
-    _enum: {
-      ExtrinsicSuccess: {
-        dispatchInfo: 'FrameSupportWeightsDispatchInfo',
-      },
-      ExtrinsicFailed: {
-        dispatchError: 'SpRuntimeDispatchError',
-        dispatchInfo: 'FrameSupportWeightsDispatchInfo',
-      },
-      CodeUpdated: 'Null',
-      NewAccount: {
-        account: 'AccountId32',
-      },
-      KilledAccount: {
-        account: 'AccountId32',
-      },
-      Remarked: {
-        _alias: {
-          hash_: 'hash',
-        },
-        sender: 'AccountId32',
-        hash_: 'H256'
-      }
-    }
-  },
-  /**
-   * Lookup19: frame_support::weights::DispatchInfo
-   **/
-  FrameSupportWeightsDispatchInfo: {
-    weight: 'u64',
-    class: 'FrameSupportWeightsDispatchClass',
-    paysFee: 'FrameSupportWeightsPays'
-  },
-  /**
-   * Lookup20: frame_support::weights::DispatchClass
-   **/
-  FrameSupportWeightsDispatchClass: {
-    _enum: ['Normal', 'Operational', 'Mandatory']
-  },
-  /**
-   * Lookup21: frame_support::weights::Pays
-   **/
-  FrameSupportWeightsPays: {
-    _enum: ['Yes', 'No']
-  },
-  /**
-   * Lookup22: sp_runtime::DispatchError
-   **/
-  SpRuntimeDispatchError: {
-    _enum: {
-      Other: 'Null',
-      CannotLookup: 'Null',
-      BadOrigin: 'Null',
-      Module: 'SpRuntimeModuleError',
-      ConsumerRemaining: 'Null',
-      NoProviders: 'Null',
-      TooManyConsumers: 'Null',
-      Token: 'SpRuntimeTokenError',
-      Arithmetic: 'SpRuntimeArithmeticError',
-      Transactional: 'SpRuntimeTransactionalError'
-    }
-  },
-  /**
-   * Lookup23: sp_runtime::ModuleError
-   **/
-  SpRuntimeModuleError: {
-    index: 'u8',
-    error: '[u8;4]'
-  },
-  /**
-   * Lookup24: sp_runtime::TokenError
-   **/
-  SpRuntimeTokenError: {
-    _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported']
-  },
-  /**
-   * Lookup25: sp_runtime::ArithmeticError
-   **/
-  SpRuntimeArithmeticError: {
-    _enum: ['Underflow', 'Overflow', 'DivisionByZero']
-  },
-  /**
-   * Lookup26: sp_runtime::TransactionalError
-   **/
-  SpRuntimeTransactionalError: {
-    _enum: ['LimitReached', 'NoLayer']
-  },
-  /**
-   * Lookup27: cumulus_pallet_parachain_system::pallet::Event<T>
-   **/
-  CumulusPalletParachainSystemEvent: {
-    _enum: {
-      ValidationFunctionStored: 'Null',
-      ValidationFunctionApplied: {
-        relayChainBlockNum: 'u32',
-      },
-      ValidationFunctionDiscarded: 'Null',
-      UpgradeAuthorized: {
-        codeHash: 'H256',
-      },
-      DownwardMessagesReceived: {
-        count: 'u32',
-      },
-      DownwardMessagesProcessed: {
-        weightUsed: 'u64',
-        dmqHead: 'H256'
-      }
-    }
-  },
-  /**
-   * Lookup28: pallet_balances::pallet::Event<T, I>
-   **/
-  PalletBalancesEvent: {
-    _enum: {
-      Endowed: {
-        account: 'AccountId32',
-        freeBalance: 'u128',
-      },
-      DustLost: {
-        account: 'AccountId32',
-        amount: 'u128',
-      },
-      Transfer: {
-        from: 'AccountId32',
-        to: 'AccountId32',
-        amount: 'u128',
-      },
-      BalanceSet: {
-        who: 'AccountId32',
-        free: 'u128',
-        reserved: 'u128',
-      },
-      Reserved: {
-        who: 'AccountId32',
-        amount: 'u128',
-      },
-      Unreserved: {
-        who: 'AccountId32',
-        amount: 'u128',
-      },
-      ReserveRepatriated: {
-        from: 'AccountId32',
-        to: 'AccountId32',
-        amount: 'u128',
-        destinationStatus: 'FrameSupportTokensMiscBalanceStatus',
-      },
-      Deposit: {
-        who: 'AccountId32',
-        amount: 'u128',
-      },
-      Withdraw: {
-        who: 'AccountId32',
-        amount: 'u128',
-      },
-      Slashed: {
-        who: 'AccountId32',
-        amount: 'u128'
-      }
-    }
-  },
-  /**
-   * Lookup29: frame_support::traits::tokens::misc::BalanceStatus
-   **/
-  FrameSupportTokensMiscBalanceStatus: {
-    _enum: ['Free', 'Reserved']
-  },
-  /**
-   * Lookup30: pallet_transaction_payment::pallet::Event<T>
-   **/
-  PalletTransactionPaymentEvent: {
-    _enum: {
-      TransactionFeePaid: {
-        who: 'AccountId32',
-        actualFee: 'u128',
-        tip: 'u128'
-      }
-    }
-  },
-  /**
-   * Lookup31: pallet_treasury::pallet::Event<T, I>
-   **/
-  PalletTreasuryEvent: {
-    _enum: {
-      Proposed: {
-        proposalIndex: 'u32',
-      },
-      Spending: {
-        budgetRemaining: 'u128',
-      },
-      Awarded: {
-        proposalIndex: 'u32',
-        award: 'u128',
-        account: 'AccountId32',
-      },
-      Rejected: {
-        proposalIndex: 'u32',
-        slashed: 'u128',
-      },
-      Burnt: {
-        burntFunds: 'u128',
-      },
-      Rollover: {
-        rolloverBalance: 'u128',
-      },
-      Deposit: {
-        value: 'u128',
-      },
-      SpendApproved: {
-        proposalIndex: 'u32',
-        amount: 'u128',
-        beneficiary: 'AccountId32'
-      }
-    }
-  },
-  /**
-   * Lookup32: pallet_sudo::pallet::Event<T>
-   **/
-  PalletSudoEvent: {
-    _enum: {
-      Sudid: {
-        sudoResult: 'Result<Null, SpRuntimeDispatchError>',
-      },
-      KeyChanged: {
-        oldSudoer: 'Option<AccountId32>',
-      },
-      SudoAsDone: {
-        sudoResult: 'Result<Null, SpRuntimeDispatchError>'
-      }
-    }
-  },
-  /**
-   * Lookup36: orml_vesting::module::Event<T>
-   **/
-  OrmlVestingModuleEvent: {
-    _enum: {
-      VestingScheduleAdded: {
-        from: 'AccountId32',
-        to: 'AccountId32',
-        vestingSchedule: 'OrmlVestingVestingSchedule',
-      },
-      Claimed: {
-        who: 'AccountId32',
-        amount: 'u128',
-      },
-      VestingSchedulesUpdated: {
-        who: 'AccountId32'
-      }
-    }
-  },
-  /**
-   * Lookup37: orml_vesting::VestingSchedule<BlockNumber, Balance>
-   **/
-  OrmlVestingVestingSchedule: {
-    start: 'u32',
-    period: 'u32',
-    periodCount: 'u32',
-    perPeriod: 'Compact<u128>'
-  },
-  /**
-   * Lookup39: cumulus_pallet_xcmp_queue::pallet::Event<T>
-   **/
-  CumulusPalletXcmpQueueEvent: {
-    _enum: {
-      Success: {
-        messageHash: 'Option<H256>',
-        weight: 'u64',
-      },
-      Fail: {
-        messageHash: 'Option<H256>',
-        error: 'XcmV2TraitsError',
-        weight: 'u64',
-      },
-      BadVersion: {
-        messageHash: 'Option<H256>',
-      },
-      BadFormat: {
-        messageHash: 'Option<H256>',
-      },
-      UpwardMessageSent: {
-        messageHash: 'Option<H256>',
-      },
-      XcmpMessageSent: {
-        messageHash: 'Option<H256>',
-      },
-      OverweightEnqueued: {
-        sender: 'u32',
-        sentAt: 'u32',
-        index: 'u64',
-        required: 'u64',
-      },
-      OverweightServiced: {
-        index: 'u64',
-        used: 'u64'
-      }
-    }
-  },
-  /**
-   * Lookup41: xcm::v2::traits::Error
-   **/
-  XcmV2TraitsError: {
-    _enum: {
-      Overflow: 'Null',
-      Unimplemented: 'Null',
-      UntrustedReserveLocation: 'Null',
-      UntrustedTeleportLocation: 'Null',
-      MultiLocationFull: 'Null',
-      MultiLocationNotInvertible: 'Null',
-      BadOrigin: 'Null',
-      InvalidLocation: 'Null',
-      AssetNotFound: 'Null',
-      FailedToTransactAsset: 'Null',
-      NotWithdrawable: 'Null',
-      LocationCannotHold: 'Null',
-      ExceedsMaxMessageSize: 'Null',
-      DestinationUnsupported: 'Null',
-      Transport: 'Null',
-      Unroutable: 'Null',
-      UnknownClaim: 'Null',
-      FailedToDecode: 'Null',
-      MaxWeightInvalid: 'Null',
-      NotHoldingFees: 'Null',
-      TooExpensive: 'Null',
-      Trap: 'u64',
-      UnhandledXcmVersion: 'Null',
-      WeightLimitReached: 'u64',
-      Barrier: 'Null',
-      WeightNotComputable: 'Null'
-    }
-  },
-  /**
-   * Lookup43: pallet_xcm::pallet::Event<T>
-   **/
-  PalletXcmEvent: {
-    _enum: {
-      Attempted: 'XcmV2TraitsOutcome',
-      Sent: '(XcmV1MultiLocation,XcmV1MultiLocation,XcmV2Xcm)',
-      UnexpectedResponse: '(XcmV1MultiLocation,u64)',
-      ResponseReady: '(u64,XcmV2Response)',
-      Notified: '(u64,u8,u8)',
-      NotifyOverweight: '(u64,u8,u8,u64,u64)',
-      NotifyDispatchError: '(u64,u8,u8)',
-      NotifyDecodeFailed: '(u64,u8,u8)',
-      InvalidResponder: '(XcmV1MultiLocation,u64,Option<XcmV1MultiLocation>)',
-      InvalidResponderVersion: '(XcmV1MultiLocation,u64)',
-      ResponseTaken: 'u64',
-      AssetsTrapped: '(H256,XcmV1MultiLocation,XcmVersionedMultiAssets)',
-      VersionChangeNotified: '(XcmV1MultiLocation,u32)',
-      SupportedVersionChanged: '(XcmV1MultiLocation,u32)',
-      NotifyTargetSendFail: '(XcmV1MultiLocation,u64,XcmV2TraitsError)',
-      NotifyTargetMigrationFail: '(XcmVersionedMultiLocation,u64)'
-    }
-  },
-  /**
-   * Lookup44: xcm::v2::traits::Outcome
-   **/
-  XcmV2TraitsOutcome: {
-    _enum: {
-      Complete: 'u64',
-      Incomplete: '(u64,XcmV2TraitsError)',
-      Error: 'XcmV2TraitsError'
-    }
-  },
-  /**
-   * Lookup45: xcm::v1::multilocation::MultiLocation
-   **/
-  XcmV1MultiLocation: {
-    parents: 'u8',
-    interior: 'XcmV1MultilocationJunctions'
-  },
-  /**
-   * Lookup46: xcm::v1::multilocation::Junctions
-   **/
-  XcmV1MultilocationJunctions: {
-    _enum: {
-      Here: 'Null',
-      X1: 'XcmV1Junction',
-      X2: '(XcmV1Junction,XcmV1Junction)',
-      X3: '(XcmV1Junction,XcmV1Junction,XcmV1Junction)',
-      X4: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
-      X5: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
-      X6: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
-      X7: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
-      X8: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)'
-    }
-  },
-  /**
-   * Lookup47: xcm::v1::junction::Junction
-   **/
-  XcmV1Junction: {
-    _enum: {
-      Parachain: 'Compact<u32>',
-      AccountId32: {
-        network: 'XcmV0JunctionNetworkId',
-        id: '[u8;32]',
-      },
-      AccountIndex64: {
-        network: 'XcmV0JunctionNetworkId',
-        index: 'Compact<u64>',
-      },
-      AccountKey20: {
-        network: 'XcmV0JunctionNetworkId',
-        key: '[u8;20]',
-      },
-      PalletInstance: 'u8',
-      GeneralIndex: 'Compact<u128>',
-      GeneralKey: 'Bytes',
-      OnlyChild: 'Null',
-      Plurality: {
-        id: 'XcmV0JunctionBodyId',
-        part: 'XcmV0JunctionBodyPart'
-      }
-    }
-  },
-  /**
-   * Lookup49: xcm::v0::junction::NetworkId
-   **/
-  XcmV0JunctionNetworkId: {
-    _enum: {
-      Any: 'Null',
-      Named: 'Bytes',
-      Polkadot: 'Null',
-      Kusama: 'Null'
-    }
-  },
-  /**
-   * Lookup53: xcm::v0::junction::BodyId
-   **/
-  XcmV0JunctionBodyId: {
-    _enum: {
-      Unit: 'Null',
-      Named: 'Bytes',
-      Index: 'Compact<u32>',
-      Executive: 'Null',
-      Technical: 'Null',
-      Legislative: 'Null',
-      Judicial: 'Null'
-    }
-  },
-  /**
-   * Lookup54: xcm::v0::junction::BodyPart
-   **/
-  XcmV0JunctionBodyPart: {
-    _enum: {
-      Voice: 'Null',
-      Members: {
-        count: 'Compact<u32>',
-      },
-      Fraction: {
-        nom: 'Compact<u32>',
-        denom: 'Compact<u32>',
-      },
-      AtLeastProportion: {
-        nom: 'Compact<u32>',
-        denom: 'Compact<u32>',
-      },
-      MoreThanProportion: {
-        nom: 'Compact<u32>',
-        denom: 'Compact<u32>'
-      }
-    }
-  },
-  /**
-   * Lookup55: xcm::v2::Xcm<Call>
-   **/
-  XcmV2Xcm: 'Vec<XcmV2Instruction>',
-  /**
-   * Lookup57: xcm::v2::Instruction<Call>
-   **/
-  XcmV2Instruction: {
-    _enum: {
-      WithdrawAsset: 'XcmV1MultiassetMultiAssets',
-      ReserveAssetDeposited: 'XcmV1MultiassetMultiAssets',
-      ReceiveTeleportedAsset: 'XcmV1MultiassetMultiAssets',
-      QueryResponse: {
-        queryId: 'Compact<u64>',
-        response: 'XcmV2Response',
-        maxWeight: 'Compact<u64>',
-      },
-      TransferAsset: {
-        assets: 'XcmV1MultiassetMultiAssets',
-        beneficiary: 'XcmV1MultiLocation',
-      },
-      TransferReserveAsset: {
-        assets: 'XcmV1MultiassetMultiAssets',
-        dest: 'XcmV1MultiLocation',
-        xcm: 'XcmV2Xcm',
-      },
-      Transact: {
-        originType: 'XcmV0OriginKind',
-        requireWeightAtMost: 'Compact<u64>',
-        call: 'XcmDoubleEncoded',
-      },
-      HrmpNewChannelOpenRequest: {
-        sender: 'Compact<u32>',
-        maxMessageSize: 'Compact<u32>',
-        maxCapacity: 'Compact<u32>',
-      },
-      HrmpChannelAccepted: {
-        recipient: 'Compact<u32>',
-      },
-      HrmpChannelClosing: {
-        initiator: 'Compact<u32>',
-        sender: 'Compact<u32>',
-        recipient: 'Compact<u32>',
-      },
-      ClearOrigin: 'Null',
-      DescendOrigin: 'XcmV1MultilocationJunctions',
-      ReportError: {
-        queryId: 'Compact<u64>',
-        dest: 'XcmV1MultiLocation',
-        maxResponseWeight: 'Compact<u64>',
-      },
-      DepositAsset: {
-        assets: 'XcmV1MultiassetMultiAssetFilter',
-        maxAssets: 'Compact<u32>',
-        beneficiary: 'XcmV1MultiLocation',
-      },
-      DepositReserveAsset: {
-        assets: 'XcmV1MultiassetMultiAssetFilter',
-        maxAssets: 'Compact<u32>',
-        dest: 'XcmV1MultiLocation',
-        xcm: 'XcmV2Xcm',
-      },
-      ExchangeAsset: {
-        give: 'XcmV1MultiassetMultiAssetFilter',
-        receive: 'XcmV1MultiassetMultiAssets',
-      },
-      InitiateReserveWithdraw: {
-        assets: 'XcmV1MultiassetMultiAssetFilter',
-        reserve: 'XcmV1MultiLocation',
-        xcm: 'XcmV2Xcm',
-      },
-      InitiateTeleport: {
-        assets: 'XcmV1MultiassetMultiAssetFilter',
-        dest: 'XcmV1MultiLocation',
-        xcm: 'XcmV2Xcm',
-      },
-      QueryHolding: {
-        queryId: 'Compact<u64>',
-        dest: 'XcmV1MultiLocation',
-        assets: 'XcmV1MultiassetMultiAssetFilter',
-        maxResponseWeight: 'Compact<u64>',
-      },
-      BuyExecution: {
-        fees: 'XcmV1MultiAsset',
-        weightLimit: 'XcmV2WeightLimit',
-      },
-      RefundSurplus: 'Null',
-      SetErrorHandler: 'XcmV2Xcm',
-      SetAppendix: 'XcmV2Xcm',
-      ClearError: 'Null',
-      ClaimAsset: {
-        assets: 'XcmV1MultiassetMultiAssets',
-        ticket: 'XcmV1MultiLocation',
-      },
-      Trap: 'Compact<u64>',
-      SubscribeVersion: {
-        queryId: 'Compact<u64>',
-        maxResponseWeight: 'Compact<u64>',
-      },
-      UnsubscribeVersion: 'Null'
-    }
-  },
-  /**
-   * Lookup58: xcm::v1::multiasset::MultiAssets
-   **/
-  XcmV1MultiassetMultiAssets: 'Vec<XcmV1MultiAsset>',
-  /**
-   * Lookup60: xcm::v1::multiasset::MultiAsset
-   **/
-  XcmV1MultiAsset: {
-    id: 'XcmV1MultiassetAssetId',
-    fun: 'XcmV1MultiassetFungibility'
-  },
-  /**
-   * Lookup61: xcm::v1::multiasset::AssetId
-   **/
-  XcmV1MultiassetAssetId: {
-    _enum: {
-      Concrete: 'XcmV1MultiLocation',
-      Abstract: 'Bytes'
-    }
-  },
-  /**
-   * Lookup62: xcm::v1::multiasset::Fungibility
-   **/
-  XcmV1MultiassetFungibility: {
-    _enum: {
-      Fungible: 'Compact<u128>',
-      NonFungible: 'XcmV1MultiassetAssetInstance'
-    }
-  },
-  /**
-   * Lookup63: xcm::v1::multiasset::AssetInstance
-   **/
-  XcmV1MultiassetAssetInstance: {
-    _enum: {
-      Undefined: 'Null',
-      Index: 'Compact<u128>',
-      Array4: '[u8;4]',
-      Array8: '[u8;8]',
-      Array16: '[u8;16]',
-      Array32: '[u8;32]',
-      Blob: 'Bytes'
-    }
-  },
-  /**
-   * Lookup66: xcm::v2::Response
-   **/
-  XcmV2Response: {
-    _enum: {
-      Null: 'Null',
-      Assets: 'XcmV1MultiassetMultiAssets',
-      ExecutionResult: 'Option<(u32,XcmV2TraitsError)>',
-      Version: 'u32'
-    }
-  },
-  /**
-   * Lookup69: xcm::v0::OriginKind
-   **/
-  XcmV0OriginKind: {
-    _enum: ['Native', 'SovereignAccount', 'Superuser', 'Xcm']
-  },
-  /**
-   * Lookup70: xcm::double_encoded::DoubleEncoded<T>
-   **/
-  XcmDoubleEncoded: {
-    encoded: 'Bytes'
-  },
-  /**
-   * Lookup71: xcm::v1::multiasset::MultiAssetFilter
-   **/
-  XcmV1MultiassetMultiAssetFilter: {
-    _enum: {
-      Definite: 'XcmV1MultiassetMultiAssets',
-      Wild: 'XcmV1MultiassetWildMultiAsset'
-    }
-  },
-  /**
-   * Lookup72: xcm::v1::multiasset::WildMultiAsset
-   **/
-  XcmV1MultiassetWildMultiAsset: {
-    _enum: {
-      All: 'Null',
-      AllOf: {
-        id: 'XcmV1MultiassetAssetId',
-        fun: 'XcmV1MultiassetWildFungibility'
-      }
-    }
-  },
-  /**
-   * Lookup73: xcm::v1::multiasset::WildFungibility
-   **/
-  XcmV1MultiassetWildFungibility: {
-    _enum: ['Fungible', 'NonFungible']
-  },
-  /**
-   * Lookup74: xcm::v2::WeightLimit
-   **/
-  XcmV2WeightLimit: {
-    _enum: {
-      Unlimited: 'Null',
-      Limited: 'Compact<u64>'
-    }
-  },
-  /**
-   * Lookup76: xcm::VersionedMultiAssets
-   **/
-  XcmVersionedMultiAssets: {
-    _enum: {
-      V0: 'Vec<XcmV0MultiAsset>',
-      V1: 'XcmV1MultiassetMultiAssets'
-    }
-  },
-  /**
-   * Lookup78: xcm::v0::multi_asset::MultiAsset
-   **/
-  XcmV0MultiAsset: {
-    _enum: {
-      None: 'Null',
-      All: 'Null',
-      AllFungible: 'Null',
-      AllNonFungible: 'Null',
-      AllAbstractFungible: {
-        id: 'Bytes',
-      },
-      AllAbstractNonFungible: {
-        class: 'Bytes',
-      },
-      AllConcreteFungible: {
-        id: 'XcmV0MultiLocation',
-      },
-      AllConcreteNonFungible: {
-        class: 'XcmV0MultiLocation',
-      },
-      AbstractFungible: {
-        id: 'Bytes',
-        amount: 'Compact<u128>',
-      },
-      AbstractNonFungible: {
-        class: 'Bytes',
-        instance: 'XcmV1MultiassetAssetInstance',
-      },
-      ConcreteFungible: {
-        id: 'XcmV0MultiLocation',
-        amount: 'Compact<u128>',
-      },
-      ConcreteNonFungible: {
-        class: 'XcmV0MultiLocation',
-        instance: 'XcmV1MultiassetAssetInstance'
-      }
-    }
-  },
-  /**
-   * Lookup79: xcm::v0::multi_location::MultiLocation
-   **/
-  XcmV0MultiLocation: {
-    _enum: {
-      Null: 'Null',
-      X1: 'XcmV0Junction',
-      X2: '(XcmV0Junction,XcmV0Junction)',
-      X3: '(XcmV0Junction,XcmV0Junction,XcmV0Junction)',
-      X4: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
-      X5: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
-      X6: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
-      X7: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
-      X8: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)'
-    }
-  },
-  /**
-   * Lookup80: xcm::v0::junction::Junction
-   **/
-  XcmV0Junction: {
-    _enum: {
-      Parent: 'Null',
-      Parachain: 'Compact<u32>',
-      AccountId32: {
-        network: 'XcmV0JunctionNetworkId',
-        id: '[u8;32]',
-      },
-      AccountIndex64: {
-        network: 'XcmV0JunctionNetworkId',
-        index: 'Compact<u64>',
-      },
-      AccountKey20: {
-        network: 'XcmV0JunctionNetworkId',
-        key: '[u8;20]',
-      },
-      PalletInstance: 'u8',
-      GeneralIndex: 'Compact<u128>',
-      GeneralKey: 'Bytes',
-      OnlyChild: 'Null',
-      Plurality: {
-        id: 'XcmV0JunctionBodyId',
-        part: 'XcmV0JunctionBodyPart'
-      }
-    }
-  },
-  /**
-   * Lookup81: xcm::VersionedMultiLocation
-   **/
-  XcmVersionedMultiLocation: {
-    _enum: {
-      V0: 'XcmV0MultiLocation',
-      V1: 'XcmV1MultiLocation'
-    }
-  },
-  /**
-   * Lookup82: cumulus_pallet_xcm::pallet::Event<T>
-   **/
-  CumulusPalletXcmEvent: {
-    _enum: {
-      InvalidFormat: '[u8;8]',
-      UnsupportedVersion: '[u8;8]',
-      ExecutedDownward: '([u8;8],XcmV2TraitsOutcome)'
-    }
-  },
-  /**
-   * Lookup83: cumulus_pallet_dmp_queue::pallet::Event<T>
-   **/
-  CumulusPalletDmpQueueEvent: {
-    _enum: {
-      InvalidFormat: {
-        messageId: '[u8;32]',
-      },
-      UnsupportedVersion: {
-        messageId: '[u8;32]',
-      },
-      ExecutedDownward: {
-        messageId: '[u8;32]',
-        outcome: 'XcmV2TraitsOutcome',
-      },
-      WeightExhausted: {
-        messageId: '[u8;32]',
-        remainingWeight: 'u64',
-        requiredWeight: 'u64',
-      },
-      OverweightEnqueued: {
-        messageId: '[u8;32]',
-        overweightIndex: 'u64',
-        requiredWeight: 'u64',
-      },
-      OverweightServiced: {
-        overweightIndex: 'u64',
-        weightUsed: 'u64'
-      }
-    }
-  },
-  /**
-   * Lookup84: pallet_unique::RawEvent<sp_core::crypto::AccountId32, pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
-   **/
-  PalletUniqueRawEvent: {
-    _enum: {
-      CollectionSponsorRemoved: 'u32',
-      CollectionAdminAdded: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
-      CollectionOwnedChanged: '(u32,AccountId32)',
-      CollectionSponsorSet: '(u32,AccountId32)',
-      SponsorshipConfirmed: '(u32,AccountId32)',
-      CollectionAdminRemoved: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
-      AllowListAddressRemoved: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
-      AllowListAddressAdded: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
-      CollectionLimitSet: 'u32',
-      CollectionPermissionSet: 'u32'
-    }
-  },
-  /**
-   * Lookup85: pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>
-   **/
-  PalletEvmAccountBasicCrossAccountIdRepr: {
-    _enum: {
-      Substrate: 'AccountId32',
-      Ethereum: 'H160'
-    }
-  },
-  /**
-   * Lookup88: pallet_unique_scheduler::pallet::Event<T>
-   **/
-  PalletUniqueSchedulerEvent: {
-    _enum: {
-      Scheduled: {
-        when: 'u32',
-        index: 'u32',
-      },
-      Canceled: {
-        when: 'u32',
-        index: 'u32',
-      },
-      Dispatched: {
-        task: '(u32,u32)',
-        id: 'Option<[u8;16]>',
-        result: 'Result<Null, SpRuntimeDispatchError>',
-      },
-      CallLookupFailed: {
-        task: '(u32,u32)',
-        id: 'Option<[u8;16]>',
-        error: 'FrameSupportScheduleLookupError'
-      }
-    }
-  },
-  /**
-   * Lookup91: frame_support::traits::schedule::LookupError
-   **/
-  FrameSupportScheduleLookupError: {
-    _enum: ['Unknown', 'BadFormat']
-  },
-  /**
-   * Lookup92: pallet_common::pallet::Event<T>
-   **/
-  PalletCommonEvent: {
-    _enum: {
-      CollectionCreated: '(u32,u8,AccountId32)',
-      CollectionDestroyed: 'u32',
-      ItemCreated: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
-      ItemDestroyed: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
-      Transfer: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
-      Approved: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
-      CollectionPropertySet: '(u32,Bytes)',
-      CollectionPropertyDeleted: '(u32,Bytes)',
-      TokenPropertySet: '(u32,u32,Bytes)',
-      TokenPropertyDeleted: '(u32,u32,Bytes)',
-      PropertyPermissionSet: '(u32,Bytes)'
-    }
-  },
-  /**
-   * Lookup95: pallet_structure::pallet::Event<T>
-   **/
-  PalletStructureEvent: {
-    _enum: {
-      Executed: 'Result<Null, SpRuntimeDispatchError>'
-    }
-  },
-  /**
-   * Lookup96: pallet_rmrk_core::pallet::Event<T>
-   **/
-  PalletRmrkCoreEvent: {
-    _enum: {
-      CollectionCreated: {
-        issuer: 'AccountId32',
-        collectionId: 'u32',
-      },
-      CollectionDestroyed: {
-        issuer: 'AccountId32',
-        collectionId: 'u32',
-      },
-      IssuerChanged: {
-        oldIssuer: 'AccountId32',
-        newIssuer: 'AccountId32',
-        collectionId: 'u32',
-      },
-      CollectionLocked: {
-        issuer: 'AccountId32',
-        collectionId: 'u32',
-      },
-      NftMinted: {
-        owner: 'AccountId32',
-        collectionId: 'u32',
-        nftId: 'u32',
-      },
-      NFTBurned: {
-        owner: 'AccountId32',
-        nftId: 'u32',
-      },
-      NFTSent: {
-        sender: 'AccountId32',
-        recipient: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
-        collectionId: 'u32',
-        nftId: 'u32',
-        approvalRequired: 'bool',
-      },
-      NFTAccepted: {
-        sender: 'AccountId32',
-        recipient: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
-        collectionId: 'u32',
-        nftId: 'u32',
-      },
-      NFTRejected: {
-        sender: 'AccountId32',
-        collectionId: 'u32',
-        nftId: 'u32',
-      },
-      PropertySet: {
-        collectionId: 'u32',
-        maybeNftId: 'Option<u32>',
-        key: 'Bytes',
-        value: 'Bytes',
-      },
-      ResourceAdded: {
-        nftId: 'u32',
-        resourceId: 'u32',
-      },
-      ResourceRemoval: {
-        nftId: 'u32',
-        resourceId: 'u32',
-      },
-      ResourceAccepted: {
-        nftId: 'u32',
-        resourceId: 'u32',
-      },
-      ResourceRemovalAccepted: {
-        nftId: 'u32',
-        resourceId: 'u32',
-      },
-      PrioritySet: {
-        collectionId: 'u32',
-        nftId: 'u32'
-      }
-    }
-  },
-  /**
-   * Lookup97: rmrk_traits::nft::AccountIdOrCollectionNftTuple<sp_core::crypto::AccountId32>
-   **/
-  RmrkTraitsNftAccountIdOrCollectionNftTuple: {
-    _enum: {
-      AccountId: 'AccountId32',
-      CollectionAndNftTuple: '(u32,u32)'
-    }
-  },
-  /**
-   * Lookup102: pallet_rmrk_equip::pallet::Event<T>
-   **/
-  PalletRmrkEquipEvent: {
-    _enum: {
-      BaseCreated: {
-        issuer: 'AccountId32',
-        baseId: 'u32',
-      },
-      EquippablesUpdated: {
-        baseId: 'u32',
-        slotId: 'u32'
-      }
-    }
-  },
-  /**
-   * Lookup103: pallet_evm::pallet::Event<T>
-   **/
-  PalletEvmEvent: {
-    _enum: {
-      Log: 'EthereumLog',
-      Created: 'H160',
-      CreatedFailed: 'H160',
-      Executed: 'H160',
-      ExecutedFailed: 'H160',
-      BalanceDeposit: '(AccountId32,H160,U256)',
-      BalanceWithdraw: '(AccountId32,H160,U256)'
-    }
-  },
-  /**
-   * Lookup104: ethereum::log::Log
-   **/
-  EthereumLog: {
-    address: 'H160',
-    topics: 'Vec<H256>',
-    data: 'Bytes'
-  },
-  /**
-   * Lookup108: pallet_ethereum::pallet::Event
-   **/
-  PalletEthereumEvent: {
-    _enum: {
-      Executed: '(H160,H160,H256,EvmCoreErrorExitReason)'
-    }
-  },
-  /**
-   * Lookup109: evm_core::error::ExitReason
-   **/
-  EvmCoreErrorExitReason: {
-    _enum: {
-      Succeed: 'EvmCoreErrorExitSucceed',
-      Error: 'EvmCoreErrorExitError',
-      Revert: 'EvmCoreErrorExitRevert',
-      Fatal: 'EvmCoreErrorExitFatal'
-    }
-  },
-  /**
-   * Lookup110: evm_core::error::ExitSucceed
-   **/
-  EvmCoreErrorExitSucceed: {
-    _enum: ['Stopped', 'Returned', 'Suicided']
-  },
-  /**
-   * Lookup111: evm_core::error::ExitError
-   **/
-  EvmCoreErrorExitError: {
-    _enum: {
-      StackUnderflow: 'Null',
-      StackOverflow: 'Null',
-      InvalidJump: 'Null',
-      InvalidRange: 'Null',
-      DesignatedInvalid: 'Null',
-      CallTooDeep: 'Null',
-      CreateCollision: 'Null',
-      CreateContractLimit: 'Null',
-      OutOfOffset: 'Null',
-      OutOfGas: 'Null',
-      OutOfFund: 'Null',
-      PCUnderflow: 'Null',
-      CreateEmpty: 'Null',
-      Other: 'Text',
-      InvalidCode: 'Null'
-    }
-  },
-  /**
-   * Lookup114: evm_core::error::ExitRevert
-   **/
-  EvmCoreErrorExitRevert: {
-    _enum: ['Reverted']
-  },
-  /**
-   * Lookup115: evm_core::error::ExitFatal
-   **/
-  EvmCoreErrorExitFatal: {
-    _enum: {
-      NotSupported: 'Null',
-      UnhandledInterrupt: 'Null',
-      CallErrorAsFatal: 'EvmCoreErrorExitError',
-      Other: 'Text'
-    }
-  },
-  /**
-   * Lookup116: frame_system::Phase
-   **/
-  FrameSystemPhase: {
-    _enum: {
-      ApplyExtrinsic: 'u32',
-      Finalization: 'Null',
-      Initialization: 'Null'
-    }
-  },
-  /**
-   * Lookup118: frame_system::LastRuntimeUpgradeInfo
-   **/
-  FrameSystemLastRuntimeUpgradeInfo: {
-    specVersion: 'Compact<u32>',
-    specName: 'Text'
-  },
-  /**
-   * Lookup119: frame_system::pallet::Call<T>
-   **/
-  FrameSystemCall: {
-    _enum: {
-      fill_block: {
-        ratio: 'Perbill',
-      },
-      remark: {
-        remark: 'Bytes',
-      },
-      set_heap_pages: {
-        pages: 'u64',
-      },
-      set_code: {
-        code: 'Bytes',
-      },
-      set_code_without_checks: {
-        code: 'Bytes',
-      },
-      set_storage: {
-        items: 'Vec<(Bytes,Bytes)>',
-      },
-      kill_storage: {
-        _alias: {
-          keys_: 'keys',
-        },
-        keys_: 'Vec<Bytes>',
-      },
-      kill_prefix: {
-        prefix: 'Bytes',
-        subkeys: 'u32',
-      },
-      remark_with_event: {
-        remark: 'Bytes'
-      }
-    }
-  },
-  /**
-   * Lookup124: frame_system::limits::BlockWeights
-   **/
-  FrameSystemLimitsBlockWeights: {
-    baseBlock: 'u64',
-    maxBlock: 'u64',
-    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'
-  },
-  /**
-   * Lookup125: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>
-   **/
-  FrameSupportWeightsPerDispatchClassWeightsPerClass: {
-    normal: 'FrameSystemLimitsWeightsPerClass',
-    operational: 'FrameSystemLimitsWeightsPerClass',
-    mandatory: 'FrameSystemLimitsWeightsPerClass'
-  },
-  /**
-   * Lookup126: frame_system::limits::WeightsPerClass
-   **/
-  FrameSystemLimitsWeightsPerClass: {
-    baseExtrinsic: 'u64',
-    maxExtrinsic: 'Option<u64>',
-    maxTotal: 'Option<u64>',
-    reserved: 'Option<u64>'
-  },
-  /**
-   * Lookup128: frame_system::limits::BlockLength
+   * Lookup2: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>
    **/
-  FrameSystemLimitsBlockLength: {
-    max: 'FrameSupportWeightsPerDispatchClassU32'
-  },
-  /**
-   * Lookup129: frame_support::weights::PerDispatchClass<T>
-   **/
-  FrameSupportWeightsPerDispatchClassU32: {
-    normal: 'u32',
-    operational: 'u32',
-    mandatory: 'u32'
-  },
-  /**
-   * Lookup130: frame_support::weights::RuntimeDbWeight
-   **/
-  FrameSupportWeightsRuntimeDbWeight: {
-    read: 'u64',
-    write: 'u64'
-  },
-  /**
-   * Lookup131: sp_version::RuntimeVersion
-   **/
-  SpVersionRuntimeVersion: {
-    specName: 'Text',
-    implName: 'Text',
-    authoringVersion: 'u32',
-    specVersion: 'u32',
-    implVersion: 'u32',
-    apis: 'Vec<([u8;8],u32)>',
-    transactionVersion: 'u32',
-    stateVersion: 'u8'
-  },
-  /**
-   * Lookup136: frame_system::pallet::Error<T>
-   **/
-  FrameSystemError: {
-    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']
-  },
-  /**
-   * Lookup137: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>
-   **/
   PolkadotPrimitivesV2PersistedValidationData: {
     parentHead: 'Bytes',
     relayParentNumber: 'u32',
@@ -1272,19 +14,19 @@
     maxPovSize: 'u32'
   },
   /**
-   * Lookup140: polkadot_primitives::v2::UpgradeRestriction
+   * Lookup9: polkadot_primitives::v2::UpgradeRestriction
    **/
   PolkadotPrimitivesV2UpgradeRestriction: {
     _enum: ['Present']
   },
   /**
-   * Lookup141: sp_trie::storage_proof::StorageProof
+   * Lookup10: sp_trie::storage_proof::StorageProof
    **/
   SpTrieStorageProof: {
     trieNodes: 'BTreeSet<Bytes>'
   },
   /**
-   * Lookup143: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot
+   * Lookup13: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot
    **/
   CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {
     dmqMqcHead: 'H256',
@@ -1293,7 +35,7 @@
     egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>'
   },
   /**
-   * Lookup146: polkadot_primitives::v2::AbridgedHrmpChannel
+   * Lookup18: polkadot_primitives::v2::AbridgedHrmpChannel
    **/
   PolkadotPrimitivesV2AbridgedHrmpChannel: {
     maxCapacity: 'u32',
@@ -1304,7 +46,7 @@
     mqcHead: 'Option<H256>'
   },
   /**
-   * Lookup147: polkadot_primitives::v2::AbridgedHostConfiguration
+   * Lookup20: polkadot_primitives::v2::AbridgedHostConfiguration
    **/
   PolkadotPrimitivesV2AbridgedHostConfiguration: {
     maxCodeSize: 'u32',
@@ -1318,14 +60,14 @@
     validationUpgradeDelay: 'u32'
   },
   /**
-   * Lookup153: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>
+   * Lookup26: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>
    **/
   PolkadotCorePrimitivesOutboundHrmpMessage: {
     recipient: 'u32',
     data: 'Bytes'
   },
   /**
-   * Lookup154: cumulus_pallet_parachain_system::pallet::Call<T>
+   * Lookup28: cumulus_pallet_parachain_system::pallet::Call<T>
    **/
   CumulusPalletParachainSystemCall: {
     _enum: {
@@ -1344,7 +86,7 @@
     }
   },
   /**
-   * Lookup155: cumulus_primitives_parachain_inherent::ParachainInherentData
+   * Lookup29: cumulus_primitives_parachain_inherent::ParachainInherentData
    **/
   CumulusPrimitivesParachainInherentParachainInherentData: {
     validationData: 'PolkadotPrimitivesV2PersistedValidationData',
@@ -1353,27 +95,58 @@
     horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'
   },
   /**
-   * Lookup157: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>
+   * Lookup31: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>
    **/
   PolkadotCorePrimitivesInboundDownwardMessage: {
     sentAt: 'u32',
     msg: 'Bytes'
   },
   /**
-   * Lookup160: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>
+   * Lookup34: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>
    **/
   PolkadotCorePrimitivesInboundHrmpMessage: {
     sentAt: 'u32',
     data: 'Bytes'
   },
   /**
-   * Lookup163: cumulus_pallet_parachain_system::pallet::Error<T>
+   * Lookup37: cumulus_pallet_parachain_system::pallet::Event<T>
+   **/
+  CumulusPalletParachainSystemEvent: {
+    _enum: {
+      ValidationFunctionStored: 'Null',
+      ValidationFunctionApplied: {
+        relayChainBlockNum: 'u32',
+      },
+      ValidationFunctionDiscarded: 'Null',
+      UpgradeAuthorized: {
+        codeHash: 'H256',
+      },
+      DownwardMessagesReceived: {
+        count: 'u32',
+      },
+      DownwardMessagesProcessed: {
+        weightUsed: 'u64',
+        dmqHead: 'H256'
+      }
+    }
+  },
+  /**
+   * Lookup38: cumulus_pallet_parachain_system::pallet::Error<T>
    **/
   CumulusPalletParachainSystemError: {
     _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']
   },
   /**
-   * Lookup165: pallet_balances::BalanceLock<Balance>
+   * Lookup41: pallet_balances::AccountData<Balance>
+   **/
+  PalletBalancesAccountData: {
+    free: 'u128',
+    reserved: 'u128',
+    miscFrozen: 'u128',
+    feeFrozen: 'u128'
+  },
+  /**
+   * Lookup43: pallet_balances::BalanceLock<Balance>
    **/
   PalletBalancesBalanceLock: {
     id: '[u8;8]',
@@ -1381,13 +154,13 @@
     reasons: 'PalletBalancesReasons'
   },
   /**
-   * Lookup166: pallet_balances::Reasons
+   * Lookup45: pallet_balances::Reasons
    **/
   PalletBalancesReasons: {
     _enum: ['Fee', 'Misc', 'All']
   },
   /**
-   * Lookup169: pallet_balances::ReserveData<ReserveIdentifier, Balance>
+   * Lookup48: pallet_balances::ReserveData<ReserveIdentifier, Balance>
    **/
   PalletBalancesReserveData: {
     id: '[u8;16]',
@@ -2706,13 +1479,13 @@
     _enum: ['Unknown', 'OverLimit']
   },
   /**
-   * Lookup347: pallet_unique::Error<T>
+   * Lookup346: pallet_unique::Error<T>
    **/
   PalletUniqueError: {
     _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection']
   },
   /**
-   * Lookup350: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>
+   * Lookup349: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>
    **/
   PalletUniqueSchedulerScheduledV3: {
     maybeId: 'Option<[u8;16]>',
@@ -2722,7 +1495,7 @@
     origin: 'OpalRuntimeOriginCaller'
   },
   /**
-   * Lookup351: opal_runtime::OriginCaller
+   * Lookup350: opal_runtime::OriginCaller
    **/
   OpalRuntimeOriginCaller: {
     _enum: {
@@ -2831,7 +1604,7 @@
     }
   },
   /**
-   * Lookup352: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
+   * Lookup351: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
    **/
   FrameSupportDispatchRawOrigin: {
     _enum: {
@@ -2841,7 +1614,7 @@
     }
   },
   /**
-   * Lookup353: pallet_xcm::pallet::Origin
+   * Lookup352: pallet_xcm::pallet::Origin
    **/
   PalletXcmOrigin: {
     _enum: {
@@ -2850,7 +1623,7 @@
     }
   },
   /**
-   * Lookup354: cumulus_pallet_xcm::pallet::Origin
+   * Lookup353: cumulus_pallet_xcm::pallet::Origin
    **/
   CumulusPalletXcmOrigin: {
     _enum: {
@@ -2859,7 +1632,7 @@
     }
   },
   /**
-   * Lookup355: pallet_ethereum::RawOrigin
+   * Lookup354: pallet_ethereum::RawOrigin
    **/
   PalletEthereumRawOrigin: {
     _enum: {
@@ -2867,17 +1640,17 @@
     }
   },
   /**
-   * Lookup356: sp_core::Void
+   * Lookup355: sp_core::Void
    **/
   SpCoreVoid: 'Null',
   /**
-   * Lookup357: pallet_unique_scheduler::pallet::Error<T>
+   * Lookup356: pallet_unique_scheduler::pallet::Error<T>
    **/
   PalletUniqueSchedulerError: {
     _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']
   },
   /**
-   * Lookup358: up_data_structs::Collection<sp_core::crypto::AccountId32>
+   * Lookup357: up_data_structs::Collection<sp_core::crypto::AccountId32>
    **/
   UpDataStructsCollection: {
     owner: 'AccountId32',
@@ -2891,7 +1664,7 @@
     externalCollection: 'bool'
   },
   /**
-   * Lookup359: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>
+   * Lookup358: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>
    **/
   UpDataStructsSponsorshipState: {
     _enum: {
@@ -2901,7 +1674,7 @@
     }
   },
   /**
-   * Lookup360: up_data_structs::Properties
+   * Lookup359: up_data_structs::Properties
    **/
   UpDataStructsProperties: {
     map: 'UpDataStructsPropertiesMapBoundedVec',
@@ -2909,7 +1682,7 @@
     spaceLimit: 'u32'
   },
   /**
-   * Lookup361: up_data_structs::PropertiesMap<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
+   * Lookup360: up_data_structs::PropertiesMap<frame_support::storage::bounded_vec::BoundedVec<T, S>>
    **/
   UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',
   /**
@@ -2917,7 +1690,7 @@
    **/
   UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',
   /**
-   * Lookup373: up_data_structs::CollectionStats
+   * Lookup372: up_data_structs::CollectionStats
    **/
   UpDataStructsCollectionStats: {
     created: 'u32',
@@ -2925,18 +1698,18 @@
     alive: 'u32'
   },
   /**
-   * Lookup374: up_data_structs::TokenChild
+   * Lookup373: up_data_structs::TokenChild
    **/
   UpDataStructsTokenChild: {
     token: 'u32',
     collection: 'u32'
   },
   /**
-   * Lookup375: PhantomType::up_data_structs<T>
+   * Lookup374: PhantomType::up_data_structs<T>
    **/
   PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]',
   /**
-   * Lookup377: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
+   * Lookup376: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
    **/
   UpDataStructsTokenData: {
     properties: 'Vec<UpDataStructsProperty>',
@@ -2944,7 +1717,7 @@
     pieces: 'u128'
   },
   /**
-   * Lookup379: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>
+   * Lookup378: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>
    **/
   UpDataStructsRpcCollection: {
     owner: 'AccountId32',
@@ -2960,7 +1733,7 @@
     readOnly: 'bool'
   },
   /**
-   * Lookup380: rmrk_traits::collection::CollectionInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>
+   * Lookup379: rmrk_traits::collection::CollectionInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>
    **/
   RmrkTraitsCollectionCollectionInfo: {
     issuer: 'AccountId32',
@@ -2970,7 +1743,7 @@
     nftsCount: 'u32'
   },
   /**
-   * Lookup381: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
+   * Lookup380: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, frame_support::storage::bounded_vec::BoundedVec<T, S>>
    **/
   RmrkTraitsNftNftInfo: {
     owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
@@ -2980,14 +1753,14 @@
     pending: 'bool'
   },
   /**
-   * Lookup383: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>
+   * Lookup382: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>
    **/
   RmrkTraitsNftRoyaltyInfo: {
     recipient: 'AccountId32',
     amount: 'Permill'
   },
   /**
-   * Lookup384: rmrk_traits::resource::ResourceInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
+   * Lookup383: rmrk_traits::resource::ResourceInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
    **/
   RmrkTraitsResourceResourceInfo: {
     id: 'u32',
@@ -2996,14 +1769,14 @@
     pendingRemoval: 'bool'
   },
   /**
-   * Lookup385: rmrk_traits::property::PropertyInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
+   * Lookup384: rmrk_traits::property::PropertyInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
    **/
   RmrkTraitsPropertyPropertyInfo: {
     key: 'Bytes',
     value: 'Bytes'
   },
   /**
-   * Lookup386: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>
+   * Lookup385: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, frame_support::storage::bounded_vec::BoundedVec<T, S>>
    **/
   RmrkTraitsBaseBaseInfo: {
     issuer: 'AccountId32',
@@ -3011,80 +1784,80 @@
     symbol: 'Bytes'
   },
   /**
-   * Lookup387: rmrk_traits::nft::NftChild
+   * Lookup386: rmrk_traits::nft::NftChild
    **/
   RmrkTraitsNftNftChild: {
     collectionId: 'u32',
     nftId: 'u32'
   },
   /**
-   * Lookup389: pallet_common::pallet::Error<T>
+   * Lookup388: pallet_common::pallet::Error<T>
    **/
   PalletCommonError: {
     _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']
   },
   /**
-   * Lookup391: pallet_fungible::pallet::Error<T>
+   * Lookup390: pallet_fungible::pallet::Error<T>
    **/
   PalletFungibleError: {
     _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
   },
   /**
-   * Lookup392: pallet_refungible::ItemData
+   * Lookup391: pallet_refungible::ItemData
    **/
   PalletRefungibleItemData: {
     constData: 'Bytes'
   },
   /**
-   * Lookup397: pallet_refungible::pallet::Error<T>
+   * Lookup394: pallet_refungible::pallet::Error<T>
    **/
   PalletRefungibleError: {
     _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
   },
   /**
-   * Lookup398: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
+   * Lookup395: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
    **/
   PalletNonfungibleItemData: {
     owner: 'PalletEvmAccountBasicCrossAccountIdRepr'
   },
   /**
-   * Lookup400: up_data_structs::PropertyScope
+   * Lookup397: up_data_structs::PropertyScope
    **/
   UpDataStructsPropertyScope: {
     _enum: ['None', 'Rmrk', 'Eth']
   },
   /**
-   * Lookup402: pallet_nonfungible::pallet::Error<T>
+   * Lookup399: pallet_nonfungible::pallet::Error<T>
    **/
   PalletNonfungibleError: {
     _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren']
   },
   /**
-   * Lookup403: pallet_structure::pallet::Error<T>
+   * Lookup400: pallet_structure::pallet::Error<T>
    **/
   PalletStructureError: {
     _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound']
   },
   /**
-   * Lookup404: pallet_rmrk_core::pallet::Error<T>
+   * Lookup401: pallet_rmrk_core::pallet::Error<T>
    **/
   PalletRmrkCoreError: {
     _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']
   },
   /**
-   * Lookup406: pallet_rmrk_equip::pallet::Error<T>
+   * Lookup403: pallet_rmrk_equip::pallet::Error<T>
    **/
   PalletRmrkEquipError: {
     _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']
   },
   /**
-   * Lookup409: pallet_evm::pallet::Error<T>
+   * Lookup406: pallet_evm::pallet::Error<T>
    **/
   PalletEvmError: {
     _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']
   },
   /**
-   * Lookup412: fp_rpc::TransactionStatus
+   * Lookup409: fp_rpc::TransactionStatus
    **/
   FpRpcTransactionStatus: {
     transactionHash: 'H256',
@@ -3096,11 +1869,11 @@
     logsBloom: 'EthbloomBloom'
   },
   /**
-   * Lookup414: ethbloom::Bloom
+   * Lookup411: ethbloom::Bloom
    **/
   EthbloomBloom: '[u8;256]',
   /**
-   * Lookup416: ethereum::receipt::ReceiptV3
+   * Lookup413: ethereum::receipt::ReceiptV3
    **/
   EthereumReceiptReceiptV3: {
     _enum: {
@@ -3110,7 +1883,7 @@
     }
   },
   /**
-   * Lookup417: ethereum::receipt::EIP658ReceiptData
+   * Lookup414: ethereum::receipt::EIP658ReceiptData
    **/
   EthereumReceiptEip658ReceiptData: {
     statusCode: 'u8',
@@ -3119,7 +1892,7 @@
     logs: 'Vec<EthereumLog>'
   },
   /**
-   * Lookup418: ethereum::block::Block<ethereum::transaction::TransactionV2>
+   * Lookup415: ethereum::block::Block<ethereum::transaction::TransactionV2>
    **/
   EthereumBlock: {
     header: 'EthereumHeader',
@@ -3127,7 +1900,7 @@
     ommers: 'Vec<EthereumHeader>'
   },
   /**
-   * Lookup419: ethereum::header::Header
+   * Lookup416: ethereum::header::Header
    **/
   EthereumHeader: {
     parentHash: 'H256',
@@ -3147,41 +1920,41 @@
     nonce: 'EthereumTypesHashH64'
   },
   /**
-   * Lookup420: ethereum_types::hash::H64
+   * Lookup417: ethereum_types::hash::H64
    **/
   EthereumTypesHashH64: '[u8;8]',
   /**
-   * Lookup425: pallet_ethereum::pallet::Error<T>
+   * Lookup422: pallet_ethereum::pallet::Error<T>
    **/
   PalletEthereumError: {
     _enum: ['InvalidSignature', 'PreLogExists']
   },
   /**
-   * Lookup426: pallet_evm_coder_substrate::pallet::Error<T>
+   * Lookup423: pallet_evm_coder_substrate::pallet::Error<T>
    **/
   PalletEvmCoderSubstrateError: {
     _enum: ['OutOfGas', 'OutOfFund']
   },
   /**
-   * Lookup427: pallet_evm_contract_helpers::SponsoringModeT
+   * Lookup424: pallet_evm_contract_helpers::SponsoringModeT
    **/
   PalletEvmContractHelpersSponsoringModeT: {
     _enum: ['Disabled', 'Allowlisted', 'Generous']
   },
   /**
-   * Lookup429: pallet_evm_contract_helpers::pallet::Error<T>
+   * Lookup426: pallet_evm_contract_helpers::pallet::Error<T>
    **/
   PalletEvmContractHelpersError: {
     _enum: ['NoPermission']
   },
   /**
-   * Lookup430: pallet_evm_migration::pallet::Error<T>
+   * Lookup427: pallet_evm_migration::pallet::Error<T>
    **/
   PalletEvmMigrationError: {
     _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']
   },
   /**
-   * Lookup432: sp_runtime::MultiSignature
+   * Lookup429: sp_runtime::MultiSignature
    **/
   SpRuntimeMultiSignature: {
     _enum: {
@@ -3191,43 +1964,43 @@
     }
   },
   /**
-   * Lookup433: sp_core::ed25519::Signature
+   * Lookup430: sp_core::ed25519::Signature
    **/
   SpCoreEd25519Signature: '[u8;64]',
   /**
-   * Lookup435: sp_core::sr25519::Signature
+   * Lookup434: sp_core::sr25519::Signature
    **/
   SpCoreSr25519Signature: '[u8;64]',
   /**
-   * Lookup436: sp_core::ecdsa::Signature
+   * Lookup435: sp_core::ecdsa::Signature
    **/
   SpCoreEcdsaSignature: '[u8;65]',
   /**
-   * Lookup439: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
+   * Lookup438: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
    **/
   FrameSystemExtensionsCheckSpecVersion: 'Null',
   /**
-   * Lookup440: frame_system::extensions::check_genesis::CheckGenesis<T>
+   * Lookup439: frame_system::extensions::check_genesis::CheckGenesis<T>
    **/
   FrameSystemExtensionsCheckGenesis: 'Null',
   /**
-   * Lookup443: frame_system::extensions::check_nonce::CheckNonce<T>
+   * Lookup442: frame_system::extensions::check_nonce::CheckNonce<T>
    **/
   FrameSystemExtensionsCheckNonce: 'Compact<u32>',
   /**
-   * Lookup444: frame_system::extensions::check_weight::CheckWeight<T>
+   * Lookup443: frame_system::extensions::check_weight::CheckWeight<T>
    **/
   FrameSystemExtensionsCheckWeight: 'Null',
   /**
-   * Lookup445: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
+   * Lookup444: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
    **/
   PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
   /**
-   * Lookup446: opal_runtime::Runtime
+   * Lookup445: opal_runtime::Runtime
    **/
   OpalRuntimeRuntime: 'Null',
   /**
-   * Lookup447: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
+   * Lookup444: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
    **/
   PalletEthereumFakeTransactionFinalizer: 'Null'
 };

1393    readonly type: 'StartInflation';1393    readonly type: 'StartInflation';
1394  }1394  }
13951395
1396  /** @name PalletAppPromotionCall (148) */1396  /** @name PalletUniqueCall (148) */
1397  export interface PalletAppPromotionCall extends Enum {
1398    readonly isSetAdminAddress: boolean;
1399    readonly asSetAdminAddress: {
1400      readonly admin: AccountId32;
1401    } & Struct;
1402    readonly isStartAppPromotion: boolean;
1403    readonly asStartAppPromotion: {
1404      readonly promotionStartRelayBlock: u32;
1405    } & Struct;
1406    readonly isStake: boolean;
1407    readonly asStake: {
1408      readonly amount: u128;
1409    } & Struct;
1410    readonly isUnstake: boolean;
1411    readonly asUnstake: {
1412      readonly amount: u128;
1413    } & Struct;
1414    readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake';
1415  }
1416
1417  /** @name PalletUniqueCall (149) */
1418  export interface PalletUniqueCall extends Enum {1397  export interface PalletUniqueCall extends Enum {
1419    readonly isCreateCollection: boolean;1398    readonly isCreateCollection: boolean;
1420    readonly asCreateCollection: {1399    readonly asCreateCollection: {
1629      readonly nftId: u32;1608      readonly nftId: u32;
1630      readonly resourceId: u32;1609      readonly resourceId: u32;
1631    } & Struct;1610    } & Struct;
1632    readonly isResourceRemovalAccepted: boolean;1611    readonly isCreateMultipleItemsEx: boolean;
1633    readonly asResourceRemovalAccepted: {1612    readonly asCreateMultipleItemsEx: {
1634      readonly nftId: u32;1613      readonly collectionId: u32;
1635      readonly resourceId: u32;1614      readonly data: UpDataStructsCreateItemExData;
1636    } & Struct;1615    } & Struct;
1637    readonly isPrioritySet: boolean;1616    readonly isSetTransfersEnabledFlag: boolean;
1638    readonly asPrioritySet: {1617    readonly asSetTransfersEnabledFlag: {
1639      readonly collectionId: u32;1618      readonly collectionId: u32;
1640      readonly nftId: u32;1619      readonly value: bool;
1641    } & Struct;1620    } & Struct;
1642    readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'NftSent' | 'NftAccepted' | 'NftRejected' | 'PropertySet' | 'ResourceAdded' | 'ResourceRemoval' | 'ResourceAccepted' | 'ResourceRemovalAccepted' | 'PrioritySet';1621    readonly isBurnItem: boolean;
1643  }
1644
1645<<<<<<< HEAD
1646  /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (97) */
1647  interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum {
1648    readonly isAccountId: boolean;
1649    readonly asAccountId: AccountId32;1622    readonly asBurnItem: {
1650    readonly isCollectionAndNftTuple: boolean;1623      readonly collectionId: u32;
1651    readonly asCollectionAndNftTuple: ITuple<[u32, u32]>;
1652    readonly type: 'AccountId' | 'CollectionAndNftTuple';1624      readonly itemId: u32;
1653  }
1654
1655  /** @name PalletRmrkEquipEvent (102) */
1656  interface PalletRmrkEquipEvent extends Enum {
1657    readonly isBaseCreated: boolean;
1658    readonly asBaseCreated: {1625      readonly value: u128;
1659      readonly issuer: AccountId32;
1660      readonly baseId: u32;
1661    } & Struct;1626    } & Struct;
1662    readonly isEquippablesUpdated: boolean;1627    readonly isBurnFrom: boolean;
1663    readonly asEquippablesUpdated: {1628    readonly asBurnFrom: {
1664      readonly baseId: u32;1629      readonly collectionId: u32;
1665      readonly slotId: u32;1630      readonly from: PalletEvmAccountBasicCrossAccountIdRepr;
1631      readonly itemId: u32;
1632      readonly value: u128;
1666    } & Struct;1633    } & Struct;
1667    readonly type: 'BaseCreated' | 'EquippablesUpdated';
1668  }
1669
1670  /** @name PalletEvmEvent (103) */
1671  interface PalletEvmEvent extends Enum {
1672    readonly isLog: boolean;
1673    readonly asLog: EthereumLog;
1674    readonly isCreated: boolean;
1675    readonly asCreated: H160;
1676    readonly isCreatedFailed: boolean;
1677    readonly asCreatedFailed: H160;
1678    readonly isExecuted: boolean;
1679    readonly asExecuted: H160;
1680    readonly isExecutedFailed: boolean;
1681    readonly asExecutedFailed: H160;
1682    readonly isBalanceDeposit: boolean;
1683    readonly asBalanceDeposit: ITuple<[AccountId32, H160, U256]>;
1684    readonly isBalanceWithdraw: boolean;
1685    readonly asBalanceWithdraw: ITuple<[AccountId32, H160, U256]>;
1686    readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw';
1687  }
1688
1689  /** @name EthereumLog (104) */
1690  interface EthereumLog extends Struct {
1691    readonly address: H160;
1692    readonly topics: Vec<H256>;
1693    readonly data: Bytes;
1694  }
1695
1696  /** @name PalletEthereumEvent (108) */
1697  interface PalletEthereumEvent extends Enum {
1698    readonly isExecuted: boolean;
1699    readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>;
1700    readonly type: 'Executed';
1701  }
1702
1703  /** @name EvmCoreErrorExitReason (109) */
1704  interface EvmCoreErrorExitReason extends Enum {
1705    readonly isSucceed: boolean;
1706    readonly asSucceed: EvmCoreErrorExitSucceed;
1707    readonly isError: boolean;
1708    readonly asError: EvmCoreErrorExitError;
1709    readonly isRevert: boolean;
1710    readonly asRevert: EvmCoreErrorExitRevert;
1711    readonly isFatal: boolean;
1712    readonly asFatal: EvmCoreErrorExitFatal;
1713    readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal';
1714  }
1715
1716  /** @name EvmCoreErrorExitSucceed (110) */
1717  interface EvmCoreErrorExitSucceed extends Enum {
1718    readonly isStopped: boolean;
1719    readonly isReturned: boolean;
1720    readonly isSuicided: boolean;
1721    readonly type: 'Stopped' | 'Returned' | 'Suicided';
1722  }
1723
1724  /** @name EvmCoreErrorExitError (111) */
1725  interface EvmCoreErrorExitError extends Enum {
1726    readonly isStackUnderflow: boolean;
1727    readonly isStackOverflow: boolean;
1728    readonly isInvalidJump: boolean;
1729    readonly isInvalidRange: boolean;
1730    readonly isDesignatedInvalid: boolean;
1731    readonly isCallTooDeep: boolean;
1732    readonly isCreateCollision: boolean;
1733    readonly isCreateContractLimit: boolean;
1734    readonly isOutOfOffset: boolean;
1735    readonly isOutOfGas: boolean;
1736    readonly isOutOfFund: boolean;
1737    readonly isPcUnderflow: boolean;
1738    readonly isCreateEmpty: boolean;
1739    readonly isOther: boolean;
1740    readonly asOther: Text;
1741    readonly isInvalidCode: boolean;
1742    readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode';
1743  }
1744
1745  /** @name EvmCoreErrorExitRevert (114) */
1746  interface EvmCoreErrorExitRevert extends Enum {
1747    readonly isReverted: boolean;
1748    readonly type: 'Reverted';
1749  }
1750
1751  /** @name EvmCoreErrorExitFatal (115) */
1752  interface EvmCoreErrorExitFatal extends Enum {
1753    readonly isNotSupported: boolean;
1754    readonly isUnhandledInterrupt: boolean;
1755    readonly isCallErrorAsFatal: boolean;
1756    readonly asCallErrorAsFatal: EvmCoreErrorExitError;
1757    readonly isOther: boolean;
1758    readonly asOther: Text;
1759    readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other';
1760  }
1761
1762  /** @name FrameSystemPhase (116) */
1763  interface FrameSystemPhase extends Enum {
1764    readonly isApplyExtrinsic: boolean;
1765    readonly asApplyExtrinsic: u32;
1766    readonly isFinalization: boolean;
1767    readonly isInitialization: boolean;
1768    readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization';
1769  }
1770
1771  /** @name FrameSystemLastRuntimeUpgradeInfo (118) */
1772  interface FrameSystemLastRuntimeUpgradeInfo extends Struct {
1773    readonly specVersion: Compact<u32>;
1774    readonly specName: Text;
1775  }
1776
1777  /** @name FrameSystemCall (119) */
1778  interface FrameSystemCall extends Enum {
1779    readonly isFillBlock: boolean;
1780    readonly asFillBlock: {
1781      readonly ratio: Perbill;
1782    } & Struct;
1783    readonly isRemark: boolean;
1784    readonly asRemark: {
1785      readonly remark: Bytes;
1786    } & Struct;
1787    readonly isSetHeapPages: boolean;
1788    readonly asSetHeapPages: {
1789      readonly pages: u64;
1790    } & Struct;
1791    readonly isSetCode: boolean;1634    readonly isSetCode: boolean;
1792    readonly asSetCode: {1635    readonly asSetCode: {
1793      readonly code: Bytes;1636      readonly code: Bytes;
1813    readonly asRemarkWithEvent: {1656    readonly asRemarkWithEvent: {
1814      readonly remark: Bytes;1657      readonly remark: Bytes;
1815    } & Struct;1658    } & Struct;
1816    readonly type: 'FillBlock' | 'Remark' | 'SetHeapPages' | 'SetCode' | 'SetCodeWithoutChecks' | 'SetStorage' | 'KillStorage' | 'KillPrefix' | 'RemarkWithEvent';1659    readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition';
1817  }1660  }
18181661
1819  /** @name FrameSystemLimitsBlockWeights (124) */
1820  interface FrameSystemLimitsBlockWeights extends Struct {
1821    readonly baseBlock: u64;
1822    readonly maxBlock: u64;
1823    readonly perClass: FrameSupportWeightsPerDispatchClassWeightsPerClass;
1824  }
1825
1826  /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (125) */
1827  interface FrameSupportWeightsPerDispatchClassWeightsPerClass extends Struct {
1828    readonly normal: FrameSystemLimitsWeightsPerClass;
1829    readonly operational: FrameSystemLimitsWeightsPerClass;
1830    readonly mandatory: FrameSystemLimitsWeightsPerClass;
1831  }
1832
1833  /** @name UpDataStructsCollectionMode (155) */1662  /** @name UpDataStructsCollectionMode (155) */
1834  export interface UpDataStructsCollectionMode extends Enum {1663  export interface UpDataStructsCollectionMode extends Enum {
1835    readonly isNft: boolean;1664    readonly isNft: boolean;
1839    readonly type: 'Nft' | 'Fungible' | 'ReFungible';1668    readonly type: 'Nft' | 'Fungible' | 'ReFungible';
1840  }1669  }
18411670
1842  /** @name UpDataStructsCreateCollectionData (156) */1671  /** @name UpDataStructsCreateCollectionData (155) */
1843  export interface UpDataStructsCreateCollectionData extends Struct {1672  export interface UpDataStructsCreateCollectionData extends Struct {
1844    readonly mode: UpDataStructsCollectionMode;1673    readonly mode: UpDataStructsCollectionMode;
1845    readonly access: Option<UpDataStructsAccessMode>;1674    readonly access: Option<UpDataStructsAccessMode>;
1853    readonly properties: Vec<UpDataStructsProperty>;1682    readonly properties: Vec<UpDataStructsProperty>;
1854  }1683  }
18551684
1856  /** @name UpDataStructsAccessMode (158) */1685  /** @name UpDataStructsAccessMode (157) */
1857  export interface UpDataStructsAccessMode extends Enum {1686  export interface UpDataStructsAccessMode extends Enum {
1858    readonly isNormal: boolean;1687    readonly isNormal: boolean;
1859    readonly isAllowList: boolean;1688    readonly isAllowList: boolean;
1860    readonly type: 'Normal' | 'AllowList';1689    readonly type: 'Normal' | 'AllowList';
1861  }1690  }
18621691
1863  /** @name UpDataStructsCollectionLimits (161) */1692  /** @name UpDataStructsCollectionLimits (160) */
1864  export interface UpDataStructsCollectionLimits extends Struct {1693  export interface UpDataStructsCollectionLimits extends Struct {
1865    readonly accountTokenOwnershipLimit: Option<u32>;1694    readonly accountTokenOwnershipLimit: Option<u32>;
1866    readonly sponsoredDataSize: Option<u32>;1695    readonly sponsoredDataSize: Option<u32>;
1873    readonly transfersEnabled: Option<bool>;1702    readonly transfersEnabled: Option<bool>;
1874  }1703  }
18751704
1876  /** @name UpDataStructsSponsoringRateLimit (163) */1705  /** @name UpDataStructsSponsoringRateLimit (162) */
1877  export interface UpDataStructsSponsoringRateLimit extends Enum {1706  export interface UpDataStructsSponsoringRateLimit extends Enum {
1878    readonly isSponsoringDisabled: boolean;1707    readonly isSponsoringDisabled: boolean;
1879    readonly isBlocks: boolean;1708    readonly isBlocks: boolean;
1880    readonly asBlocks: u32;1709    readonly asBlocks: u32;
1881    readonly type: 'SponsoringDisabled' | 'Blocks';1710    readonly type: 'SponsoringDisabled' | 'Blocks';
1882  }1711  }
18831712
1884  /** @name UpDataStructsCollectionPermissions (166) */1713  /** @name UpDataStructsCollectionPermissions (165) */
1885  export interface UpDataStructsCollectionPermissions extends Struct {1714  export interface UpDataStructsCollectionPermissions extends Struct {
1886    readonly access: Option<UpDataStructsAccessMode>;1715    readonly access: Option<UpDataStructsAccessMode>;
1887    readonly mintMode: Option<bool>;1716    readonly mintMode: Option<bool>;
1888    readonly nesting: Option<UpDataStructsNestingPermissions>;1717    readonly nesting: Option<UpDataStructsNestingPermissions>;
1889  }1718  }
18901719
1891  /** @name UpDataStructsNestingPermissions (168) */1720  /** @name UpDataStructsNestingPermissions (167) */
1892  export interface UpDataStructsNestingPermissions extends Struct {1721  export interface UpDataStructsNestingPermissions extends Struct {
1893    readonly tokenOwner: bool;1722    readonly tokenOwner: bool;
1894    readonly collectionAdmin: bool;1723    readonly collectionAdmin: bool;
1895    readonly restricted: Option<UpDataStructsOwnerRestrictedSet>;1724    readonly restricted: Option<UpDataStructsOwnerRestrictedSet>;
1896  }1725  }
18971726
1898  /** @name UpDataStructsOwnerRestrictedSet (170) */1727  /** @name UpDataStructsOwnerRestrictedSet (169) */
1899  export interface UpDataStructsOwnerRestrictedSet extends BTreeSet<u32> {}1728  export interface UpDataStructsOwnerRestrictedSet extends BTreeSet<u32> {}
19001729
1901  /** @name UpDataStructsPropertyKeyPermission (176) */1730  /** @name UpDataStructsPropertyKeyPermission (175) */
1902  export interface UpDataStructsPropertyKeyPermission extends Struct {1731  export interface UpDataStructsPropertyKeyPermission extends Struct {
1903    readonly key: Bytes;1732    readonly key: Bytes;
1904    readonly permission: UpDataStructsPropertyPermission;1733    readonly permission: UpDataStructsPropertyPermission;
1905  }1734  }
19061735
1907  /** @name UpDataStructsPropertyPermission (178) */1736  /** @name UpDataStructsPropertyPermission (177) */
1908  export interface UpDataStructsPropertyPermission extends Struct {1737  export interface UpDataStructsPropertyPermission extends Struct {
1909    readonly mutable: bool;1738    readonly mutable: bool;
1910    readonly collectionAdmin: bool;1739    readonly collectionAdmin: bool;
1911    readonly tokenOwner: bool;1740    readonly tokenOwner: bool;
1912  }1741  }
19131742
1914  /** @name UpDataStructsProperty (181) */1743  /** @name UpDataStructsProperty (180) */
1915  export interface UpDataStructsProperty extends Struct {1744  export interface UpDataStructsProperty extends Struct {
1916    readonly key: Bytes;1745    readonly key: Bytes;
1917    readonly value: Bytes;1746    readonly value: Bytes;
1918  }1747  }
19191748
1920  /** @name PalletEvmAccountBasicCrossAccountIdRepr (184) */1749  /** @name PalletEvmAccountBasicCrossAccountIdRepr (183) */
1921  export interface PalletEvmAccountBasicCrossAccountIdRepr extends Enum {1750  export interface PalletEvmAccountBasicCrossAccountIdRepr extends Enum {
1922    readonly isSubstrate: boolean;1751    readonly isSubstrate: boolean;
1923    readonly asSubstrate: AccountId32;1752    readonly asSubstrate: AccountId32;
1926    readonly type: 'Substrate' | 'Ethereum';1755    readonly type: 'Substrate' | 'Ethereum';
1927  }1756  }
19281757
1929  /** @name UpDataStructsCreateItemData (186) */1758  /** @name UpDataStructsCreateItemData (185) */
1930  export interface UpDataStructsCreateItemData extends Enum {1759  export interface UpDataStructsCreateItemData extends Enum {
1931    readonly isNft: boolean;1760    readonly isNft: boolean;
1932    readonly asNft: UpDataStructsCreateNftData;1761    readonly asNft: UpDataStructsCreateNftData;
1937    readonly type: 'Nft' | 'Fungible' | 'ReFungible';1766    readonly type: 'Nft' | 'Fungible' | 'ReFungible';
1938  }1767  }
19391768
1940  /** @name UpDataStructsCreateNftData (187) */1769  /** @name UpDataStructsCreateNftData (186) */
1941  export interface UpDataStructsCreateNftData extends Struct {1770  export interface UpDataStructsCreateNftData extends Struct {
1942    readonly properties: Vec<UpDataStructsProperty>;1771    readonly properties: Vec<UpDataStructsProperty>;
1943  }1772  }
19441773
1945  /** @name UpDataStructsCreateFungibleData (188) */1774  /** @name UpDataStructsCreateFungibleData (187) */
1946  export interface UpDataStructsCreateFungibleData extends Struct {1775  export interface UpDataStructsCreateFungibleData extends Struct {
1947    readonly value: u128;1776    readonly value: u128;
1948  }1777  }
19491778
1950  /** @name UpDataStructsCreateReFungibleData (189) */1779  /** @name UpDataStructsCreateReFungibleData (188) */
1951  export interface UpDataStructsCreateReFungibleData extends Struct {1780  export interface UpDataStructsCreateReFungibleData extends Struct {
1952    readonly pieces: u128;1781    readonly pieces: u128;
1953    readonly properties: Vec<UpDataStructsProperty>;1782    readonly properties: Vec<UpDataStructsProperty>;
2028    readonly properties: Vec<UpDataStructsProperty>;1857    readonly properties: Vec<UpDataStructsProperty>;
2029  }1858  }
20301859
2031  /** @name PalletUniqueSchedulerCall (205) */1860  /** @name PalletUniqueSchedulerCall (204) */
2032  export interface PalletUniqueSchedulerCall extends Enum {1861  export interface PalletUniqueSchedulerCall extends Enum {
2033    readonly isScheduleNamed: boolean;1862    readonly isScheduleNamed: boolean;
2034    readonly asScheduleNamed: {1863    readonly asScheduleNamed: {
2053    readonly type: 'ScheduleNamed' | 'CancelNamed' | 'ScheduleNamedAfter';1882    readonly type: 'ScheduleNamed' | 'CancelNamed' | 'ScheduleNamedAfter';
2054  }1883  }
20551884
2056  /** @name FrameSupportScheduleMaybeHashed (207) */1885  /** @name FrameSupportScheduleMaybeHashed (206) */
2057  export interface FrameSupportScheduleMaybeHashed extends Enum {1886  export interface FrameSupportScheduleMaybeHashed extends Enum {
2058    readonly isValue: boolean;1887    readonly isValue: boolean;
2059    readonly asValue: Call;1888    readonly asValue: Call;
2062    readonly type: 'Value' | 'Hash';1891    readonly type: 'Value' | 'Hash';
2063  }1892  }
20641893
2065  /** @name PalletTemplateTransactionPaymentCall (208) */1894  /** @name PalletTemplateTransactionPaymentCall (207) */
2066  export type PalletTemplateTransactionPaymentCall = Null;1895  export type PalletTemplateTransactionPaymentCall = Null;
20671896
2068  /** @name PalletStructureCall (209) */1897  /** @name PalletStructureCall (208) */
2069  export type PalletStructureCall = Null;1898  export type PalletStructureCall = Null;
20701899
2071  /** @name PalletRmrkCoreCall (210) */1900  /** @name PalletRmrkCoreCall (209) */
2072  export interface PalletRmrkCoreCall extends Enum {1901  export interface PalletRmrkCoreCall extends Enum {
2073    readonly isCreateCollection: boolean;1902    readonly isCreateCollection: boolean;
2074    readonly asCreateCollection: {1903    readonly asCreateCollection: {
2174    readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'Send' | 'AcceptNft' | 'RejectNft' | 'AcceptResource' | 'AcceptResourceRemoval' | 'SetProperty' | 'SetPriority' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource' | 'RemoveResource';2003    readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'Send' | 'AcceptNft' | 'RejectNft' | 'AcceptResource' | 'AcceptResourceRemoval' | 'SetProperty' | 'SetPriority' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource' | 'RemoveResource';
2175  }2004  }
21762005
2177  /** @name RmrkTraitsResourceResourceTypes (216) */2006  /** @name RmrkTraitsResourceResourceTypes (215) */
2178  export interface RmrkTraitsResourceResourceTypes extends Enum {2007  export interface RmrkTraitsResourceResourceTypes extends Enum {
2179    readonly isBasic: boolean;2008    readonly isBasic: boolean;
2180    readonly asBasic: RmrkTraitsResourceBasicResource;2009    readonly asBasic: RmrkTraitsResourceBasicResource;
2185    readonly type: 'Basic' | 'Composable' | 'Slot';2014    readonly type: 'Basic' | 'Composable' | 'Slot';
2186  }2015  }
21872016
2188  /** @name RmrkTraitsResourceBasicResource (218) */2017  /** @name RmrkTraitsResourceBasicResource (217) */
2189  export interface RmrkTraitsResourceBasicResource extends Struct {2018  export interface RmrkTraitsResourceBasicResource extends Struct {
2190    readonly src: Option<Bytes>;2019    readonly src: Option<Bytes>;
2191    readonly metadata: Option<Bytes>;2020    readonly metadata: Option<Bytes>;
2192    readonly license: Option<Bytes>;2021    readonly license: Option<Bytes>;
2193    readonly thumb: Option<Bytes>;2022    readonly thumb: Option<Bytes>;
2194  }2023  }
21952024
2196  /** @name RmrkTraitsResourceComposableResource (220) */2025  /** @name RmrkTraitsResourceComposableResource (219) */
2197  export interface RmrkTraitsResourceComposableResource extends Struct {2026  export interface RmrkTraitsResourceComposableResource extends Struct {
2198    readonly parts: Vec<u32>;2027    readonly parts: Vec<u32>;
2199    readonly base: u32;2028    readonly base: u32;
2203    readonly thumb: Option<Bytes>;2032    readonly thumb: Option<Bytes>;
2204  }2033  }
22052034
2206  /** @name RmrkTraitsResourceSlotResource (221) */2035  /** @name RmrkTraitsResourceSlotResource (220) */
2207  export interface RmrkTraitsResourceSlotResource extends Struct {2036  export interface RmrkTraitsResourceSlotResource extends Struct {
2208    readonly base: u32;2037    readonly base: u32;
2209    readonly src: Option<Bytes>;2038    readonly src: Option<Bytes>;
2213    readonly thumb: Option<Bytes>;2042    readonly thumb: Option<Bytes>;
2214  }2043  }
22152044
2216  /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (223) */2045  /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (222) */
2217  export interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum {2046  export interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum {
2218    readonly isAccountId: boolean;2047    readonly isAccountId: boolean;
2219    readonly asAccountId: AccountId32;2048    readonly asAccountId: AccountId32;
2222    readonly type: 'AccountId' | 'CollectionAndNftTuple';2051    readonly type: 'AccountId' | 'CollectionAndNftTuple';
2223  }2052  }
22242053
2225  /** @name PalletRmrkEquipCall (227) */2054  /** @name PalletRmrkEquipCall (226) */
2226  export interface PalletRmrkEquipCall extends Enum {2055  export interface PalletRmrkEquipCall extends Enum {
2227    readonly isCreateBase: boolean;2056    readonly isCreateBase: boolean;
2228    readonly asCreateBase: {2057    readonly asCreateBase: {
2244    readonly type: 'CreateBase' | 'ThemeAdd' | 'Equippable';2073    readonly type: 'CreateBase' | 'ThemeAdd' | 'Equippable';
2245  }2074  }
22462075
2247  /** @name RmrkTraitsPartPartType (230) */2076  /** @name RmrkTraitsPartPartType (229) */
2248  export interface RmrkTraitsPartPartType extends Enum {2077  export interface RmrkTraitsPartPartType extends Enum {
2249    readonly isFixedPart: boolean;2078    readonly isFixedPart: boolean;
2250    readonly asFixedPart: RmrkTraitsPartFixedPart;2079    readonly asFixedPart: RmrkTraitsPartFixedPart;
2253    readonly type: 'FixedPart' | 'SlotPart';2082    readonly type: 'FixedPart' | 'SlotPart';
2254  }2083  }
22552084
2256  /** @name RmrkTraitsPartFixedPart (232) */2085  /** @name RmrkTraitsPartFixedPart (231) */
2257  export interface RmrkTraitsPartFixedPart extends Struct {2086  export interface RmrkTraitsPartFixedPart extends Struct {
2258    readonly id: u32;2087    readonly id: u32;
2259    readonly z: u32;2088    readonly z: u32;
2260    readonly src: Bytes;2089    readonly src: Bytes;
2261  }2090  }
22622091
2263  /** @name RmrkTraitsPartSlotPart (233) */2092  /** @name RmrkTraitsPartSlotPart (232) */
2264  export interface RmrkTraitsPartSlotPart extends Struct {2093  export interface RmrkTraitsPartSlotPart extends Struct {
2265    readonly id: u32;2094    readonly id: u32;
2266    readonly equippable: RmrkTraitsPartEquippableList;2095    readonly equippable: RmrkTraitsPartEquippableList;
2267    readonly src: Bytes;2096    readonly src: Bytes;
2268    readonly z: u32;2097    readonly z: u32;
2269  }2098  }
22702099
2271  /** @name RmrkTraitsPartEquippableList (234) */2100  /** @name RmrkTraitsPartEquippableList (233) */
2272  export interface RmrkTraitsPartEquippableList extends Enum {2101  export interface RmrkTraitsPartEquippableList extends Enum {
2273    readonly isAll: boolean;2102    readonly isAll: boolean;
2274    readonly type: 'Fee' | 'Misc' | 'All';2103    readonly type: 'Fee' | 'Misc' | 'All';
2275  }2104  }
22762105
2277  /** @name RmrkTraitsTheme (236) */2106  /** @name RmrkTraitsTheme (235) */
2278  export interface RmrkTraitsTheme extends Struct {2107  export interface RmrkTraitsTheme extends Struct {
2279    readonly name: Bytes;2108    readonly name: Bytes;
2280    readonly properties: Vec<RmrkTraitsThemeThemeProperty>;2109    readonly properties: Vec<RmrkTraitsThemeThemeProperty>;
2281    readonly inherit: bool;2110    readonly inherit: bool;
2282  }2111  }
22832112
2284  /** @name RmrkTraitsThemeThemeProperty (238) */2113  /** @name RmrkTraitsThemeThemeProperty (237) */
2285  export interface RmrkTraitsThemeThemeProperty extends Struct {2114  export interface RmrkTraitsThemeThemeProperty extends Struct {
2286    readonly key: Bytes;2115    readonly key: Bytes;
2287    readonly value: Bytes;2116    readonly value: Bytes;
2117  }
2118
2119  /** @name PalletAppPromotionCall (239) */
2120  export interface PalletAppPromotionCall extends Enum {
2121    readonly isSetAdminAddress: boolean;
2122    readonly asSetAdminAddress: {
2123      readonly admin: AccountId32;
2124    } & Struct;
2125    readonly isStartAppPromotion: boolean;
2126    readonly asStartAppPromotion: {
2127      readonly promotionStartRelayBlock: u32;
2128    } & Struct;
2129    readonly isStake: boolean;
2130    readonly asStake: {
2131      readonly amount: u128;
2132    } & Struct;
2133    readonly isUnstake: boolean;
2134    readonly asUnstake: {
2135      readonly amount: u128;
2136    } & Struct;
2137    readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake';
2288  }2138  }
22892139
2290  /** @name PalletEvmCall (240) */2140  /** @name PalletEvmCall (240) */
3213    readonly type: 'Unknown' | 'OverLimit';3063    readonly type: 'Unknown' | 'OverLimit';
3214  }3064  }
32153065
3216  /** @name PalletUniqueError (346) */3066  /** @name PalletUniqueError (345) */
3217  export interface PalletUniqueError extends Enum {3067  export interface PalletUniqueError extends Enum {
3218    readonly isCollectionDecimalPointLimitExceeded: boolean;3068    readonly isCollectionDecimalPointLimitExceeded: boolean;
3219    readonly isConfirmUnsetSponsorFail: boolean;3069    readonly isConfirmUnsetSponsorFail: boolean;
3222    readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument' | 'RepartitionCalledOnNonRefungibleCollection';3072    readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument' | 'RepartitionCalledOnNonRefungibleCollection';
3223  }3073  }
32243074
3225  /** @name PalletUniqueSchedulerScheduledV3 (349) */3075  /** @name PalletUniqueSchedulerScheduledV3 (348) */
3226  export interface PalletUniqueSchedulerScheduledV3 extends Struct {3076  export interface PalletUniqueSchedulerScheduledV3 extends Struct {
3227    readonly maybeId: Option<U8aFixed>;3077    readonly maybeId: Option<U8aFixed>;
3228    readonly priority: u8;3078    readonly priority: u8;
3231    readonly origin: OpalRuntimeOriginCaller;3081    readonly origin: OpalRuntimeOriginCaller;
3232  }3082  }
32333083
3234  /** @name OpalRuntimeOriginCaller (350) */3084  /** @name OpalRuntimeOriginCaller (349) */
3235  export interface OpalRuntimeOriginCaller extends Enum {3085  export interface OpalRuntimeOriginCaller extends Enum {
3236    readonly isVoid: boolean;3086    readonly isVoid: boolean;
3237    readonly isSystem: boolean;3087    readonly isSystem: boolean;
3246    readonly type: 'System' | 'Void' | 'PolkadotXcm' | 'CumulusXcm' | 'Ethereum';3096    readonly type: 'System' | 'Void' | 'PolkadotXcm' | 'CumulusXcm' | 'Ethereum';
3247  }3097  }
32483098
3249  /** @name FrameSupportDispatchRawOrigin (351) */3099  /** @name FrameSupportDispatchRawOrigin (350) */
3250  export interface FrameSupportDispatchRawOrigin extends Enum {3100  export interface FrameSupportDispatchRawOrigin extends Enum {
3251    readonly isRoot: boolean;3101    readonly isRoot: boolean;
3252    readonly isSigned: boolean;3102    readonly isSigned: boolean;
3255    readonly type: 'Root' | 'Signed' | 'None';3105    readonly type: 'Root' | 'Signed' | 'None';
3256  }3106  }
32573107
3258  /** @name PalletXcmOrigin (352) */3108  /** @name PalletXcmOrigin (351) */
3259  export interface PalletXcmOrigin extends Enum {3109  export interface PalletXcmOrigin extends Enum {
3260    readonly isXcm: boolean;3110    readonly isXcm: boolean;
3261    readonly asXcm: XcmV1MultiLocation;3111    readonly asXcm: XcmV1MultiLocation;
3264    readonly type: 'Xcm' | 'Response';3114    readonly type: 'Xcm' | 'Response';
3265  }3115  }
32663116
3267  /** @name CumulusPalletXcmOrigin (353) */3117  /** @name CumulusPalletXcmOrigin (352) */
3268  export interface CumulusPalletXcmOrigin extends Enum {3118  export interface CumulusPalletXcmOrigin extends Enum {
3269    readonly isRelay: boolean;3119    readonly isRelay: boolean;
3270    readonly isSiblingParachain: boolean;3120    readonly isSiblingParachain: boolean;
3271    readonly asSiblingParachain: u32;3121    readonly asSiblingParachain: u32;
3272    readonly type: 'Relay' | 'SiblingParachain';3122    readonly type: 'Relay' | 'SiblingParachain';
3273  }3123  }
32743124
3275  /** @name PalletEthereumRawOrigin (354) */3125  /** @name PalletEthereumRawOrigin (353) */
3276  export interface PalletEthereumRawOrigin extends Enum {3126  export interface PalletEthereumRawOrigin extends Enum {
3277    readonly isEthereumTransaction: boolean;3127    readonly isEthereumTransaction: boolean;
3278    readonly asEthereumTransaction: H160;3128    readonly asEthereumTransaction: H160;
3279    readonly type: 'EthereumTransaction';3129    readonly type: 'EthereumTransaction';
3280  }3130  }
32813131
3282  /** @name SpCoreVoid (355) */3132  /** @name SpCoreVoid (354) */
3283  export type SpCoreVoid = Null;3133  export type SpCoreVoid = Null;
32843134
3285  /** @name PalletUniqueSchedulerError (356) */3135  /** @name PalletUniqueSchedulerError (355) */
3286  export interface PalletUniqueSchedulerError extends Enum {3136  export interface PalletUniqueSchedulerError extends Enum {
3287    readonly isFailedToSchedule: boolean;3137    readonly isFailedToSchedule: boolean;
3288    readonly isNotFound: boolean;3138    readonly isNotFound: boolean;
3291    readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange';3141    readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange';
3292  }3142  }
32933143
3294  /** @name UpDataStructsCollection (357) */3144  /** @name UpDataStructsCollection (356) */
3295  export interface UpDataStructsCollection extends Struct {3145  export interface UpDataStructsCollection extends Struct {
3296    readonly owner: AccountId32;3146    readonly owner: AccountId32;
3297    readonly mode: UpDataStructsCollectionMode;3147    readonly mode: UpDataStructsCollectionMode;
3304    readonly externalCollection: bool;3154    readonly externalCollection: bool;
3305  }3155  }
33063156
3307  /** @name UpDataStructsSponsorshipState (358) */3157  /** @name UpDataStructsSponsorshipState (357) */
3308  export interface UpDataStructsSponsorshipState extends Enum {3158  export interface UpDataStructsSponsorshipState extends Enum {
3309    readonly isDisabled: boolean;3159    readonly isDisabled: boolean;
3310    readonly isUnconfirmed: boolean;3160    readonly isUnconfirmed: boolean;
3314    readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed';3164    readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed';
3315  }3165  }
33163166
3317  /** @name UpDataStructsProperties (359) */3167  /** @name UpDataStructsProperties (358) */
3318  export interface UpDataStructsProperties extends Struct {3168  export interface UpDataStructsProperties extends Struct {
3319    readonly map: UpDataStructsPropertiesMapBoundedVec;3169    readonly map: UpDataStructsPropertiesMapBoundedVec;
3320    readonly consumedSpace: u32;3170    readonly consumedSpace: u32;
3321    readonly spaceLimit: u32;3171    readonly spaceLimit: u32;
3322  }3172  }
33233173
3324  /** @name UpDataStructsPropertiesMapBoundedVec (360) */3174  /** @name UpDataStructsPropertiesMapBoundedVec (359) */
3325  export interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap<Bytes, Bytes> {}3175  export interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap<Bytes, Bytes> {}
33263176
3327  /** @name UpDataStructsPropertiesMapPropertyPermission (365) */3177  /** @name UpDataStructsPropertiesMapPropertyPermission (364) */
3328  export interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap<Bytes, UpDataStructsPropertyPermission> {}3178  export interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap<Bytes, UpDataStructsPropertyPermission> {}
33293179
3330  /** @name UpDataStructsCollectionStats (372) */3180  /** @name UpDataStructsCollectionStats (371) */
3331  export interface UpDataStructsCollectionStats extends Struct {3181  export interface UpDataStructsCollectionStats extends Struct {
3332    readonly created: u32;3182    readonly created: u32;
3333    readonly destroyed: u32;3183    readonly destroyed: u32;
3334    readonly alive: u32;3184    readonly alive: u32;
3335  }3185  }
33363186
3337  /** @name UpDataStructsTokenChild (373) */3187  /** @name UpDataStructsTokenChild (372) */
3338  export interface UpDataStructsTokenChild extends Struct {3188  export interface UpDataStructsTokenChild extends Struct {
3339    readonly token: u32;3189    readonly token: u32;
3340    readonly collection: u32;3190    readonly collection: u32;
3341  }3191  }
33423192
3343  /** @name PhantomTypeUpDataStructs (374) */3193  /** @name PhantomTypeUpDataStructs (373) */
3344  export interface PhantomTypeUpDataStructs extends Vec<ITuple<[UpDataStructsTokenData, UpDataStructsRpcCollection, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftNftInfo, RmrkTraitsResourceResourceInfo, RmrkTraitsPropertyPropertyInfo, RmrkTraitsBaseBaseInfo, RmrkTraitsPartPartType, RmrkTraitsTheme, RmrkTraitsNftNftChild]>> {}3194  export interface PhantomTypeUpDataStructs extends Vec<ITuple<[UpDataStructsTokenData, UpDataStructsRpcCollection, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftNftInfo, RmrkTraitsResourceResourceInfo, RmrkTraitsPropertyPropertyInfo, RmrkTraitsBaseBaseInfo, RmrkTraitsPartPartType, RmrkTraitsTheme, RmrkTraitsNftNftChild]>> {}
33453195
3346  /** @name UpDataStructsTokenData (376) */3196  /** @name UpDataStructsTokenData (375) */
3347  export interface UpDataStructsTokenData extends Struct {3197  export interface UpDataStructsTokenData extends Struct {
3348    readonly properties: Vec<UpDataStructsProperty>;3198    readonly properties: Vec<UpDataStructsProperty>;
3349    readonly owner: Option<PalletEvmAccountBasicCrossAccountIdRepr>;3199    readonly owner: Option<PalletEvmAccountBasicCrossAccountIdRepr>;
3350    readonly pieces: u128;3200    readonly pieces: u128;
3351  }3201  }
33523202
3353  /** @name UpDataStructsRpcCollection (378) */3203  /** @name UpDataStructsRpcCollection (377) */
3354  export interface UpDataStructsRpcCollection extends Struct {3204  export interface UpDataStructsRpcCollection extends Struct {
3355    readonly owner: AccountId32;3205    readonly owner: AccountId32;
3356    readonly mode: UpDataStructsCollectionMode;3206    readonly mode: UpDataStructsCollectionMode;
3365    readonly readOnly: bool;3215    readonly readOnly: bool;
3366  }3216  }
33673217
3368  /** @name RmrkTraitsCollectionCollectionInfo (379) */3218  /** @name RmrkTraitsCollectionCollectionInfo (378) */
3369  export interface RmrkTraitsCollectionCollectionInfo extends Struct {3219  export interface RmrkTraitsCollectionCollectionInfo extends Struct {
3370    readonly issuer: AccountId32;3220    readonly issuer: AccountId32;
3371    readonly metadata: Bytes;3221    readonly metadata: Bytes;
3374    readonly nftsCount: u32;3224    readonly nftsCount: u32;
3375  }3225  }
33763226
3377  /** @name RmrkTraitsNftNftInfo (380) */3227  /** @name RmrkTraitsNftNftInfo (379) */
3378  export interface RmrkTraitsNftNftInfo extends Struct {3228  export interface RmrkTraitsNftNftInfo extends Struct {
3379    readonly owner: RmrkTraitsNftAccountIdOrCollectionNftTuple;3229    readonly owner: RmrkTraitsNftAccountIdOrCollectionNftTuple;
3380    readonly royalty: Option<RmrkTraitsNftRoyaltyInfo>;3230    readonly royalty: Option<RmrkTraitsNftRoyaltyInfo>;
3383    readonly pending: bool;3233    readonly pending: bool;
3384  }3234  }
33853235
3386  /** @name RmrkTraitsNftRoyaltyInfo (382) */3236  /** @name RmrkTraitsNftRoyaltyInfo (381) */
3387  export interface RmrkTraitsNftRoyaltyInfo extends Struct {3237  export interface RmrkTraitsNftRoyaltyInfo extends Struct {
3388    readonly recipient: AccountId32;3238    readonly recipient: AccountId32;
3389    readonly amount: Permill;3239    readonly amount: Permill;
3390  }3240  }
33913241
3392  /** @name RmrkTraitsResourceResourceInfo (383) */3242  /** @name RmrkTraitsResourceResourceInfo (382) */
3393  export interface RmrkTraitsResourceResourceInfo extends Struct {3243  export interface RmrkTraitsResourceResourceInfo extends Struct {
3394    readonly id: u32;3244    readonly id: u32;
3395    readonly resource: RmrkTraitsResourceResourceTypes;3245    readonly resource: RmrkTraitsResourceResourceTypes;
3396    readonly pending: bool;3246    readonly pending: bool;
3397    readonly pendingRemoval: bool;3247    readonly pendingRemoval: bool;
3398  }3248  }
33993249
3400  /** @name RmrkTraitsPropertyPropertyInfo (384) */3250  /** @name RmrkTraitsPropertyPropertyInfo (383) */
3401  export interface RmrkTraitsPropertyPropertyInfo extends Struct {3251  export interface RmrkTraitsPropertyPropertyInfo extends Struct {
3402    readonly key: Bytes;3252    readonly key: Bytes;
3403    readonly value: Bytes;3253    readonly value: Bytes;
3404  }3254  }
34053255
3406  /** @name RmrkTraitsBaseBaseInfo (385) */3256  /** @name RmrkTraitsBaseBaseInfo (384) */
3407  export interface RmrkTraitsBaseBaseInfo extends Struct {3257  export interface RmrkTraitsBaseBaseInfo extends Struct {
3408    readonly issuer: AccountId32;3258    readonly issuer: AccountId32;
3409    readonly baseType: Bytes;3259    readonly baseType: Bytes;
3410    readonly symbol: Bytes;3260    readonly symbol: Bytes;
3411  }3261  }
34123262
3413  /** @name RmrkTraitsNftNftChild (386) */3263  /** @name RmrkTraitsNftNftChild (385) */
3414  export interface RmrkTraitsNftNftChild extends Struct {3264  export interface RmrkTraitsNftNftChild extends Struct {
3415    readonly collectionId: u32;3265    readonly collectionId: u32;
3416    readonly nftId: u32;3266    readonly nftId: u32;
3417  }3267  }
34183268
3419  /** @name PalletCommonError (388) */3269  /** @name PalletCommonError (387) */
3420  export interface PalletCommonError extends Enum {3270  export interface PalletCommonError extends Enum {
3421    readonly isCollectionNotFound: boolean;3271    readonly isCollectionNotFound: boolean;
3422    readonly isMustBeTokenOwner: boolean;3272    readonly isMustBeTokenOwner: boolean;
3455    readonly type: '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';3305    readonly type: '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';
3456  }3306  }
34573307
3458  /** @name PalletFungibleError (390) */3308  /** @name PalletFungibleError (389) */
3459  export interface PalletFungibleError extends Enum {3309  export interface PalletFungibleError extends Enum {
3460    readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean;3310    readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean;
3461    readonly isFungibleItemsHaveNoId: boolean;3311    readonly isFungibleItemsHaveNoId: boolean;
3465    readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';3315    readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
3466  }3316  }
34673317
3468  /** @name PalletRefungibleItemData (391) */3318  /** @name PalletRefungibleItemData (390) */
3469  export interface PalletRefungibleItemData extends Struct {3319  export interface PalletRefungibleItemData extends Struct {
3470    readonly constData: Bytes;3320    readonly constData: Bytes;
3471  }3321  }
34723322
3473  /** @name PalletRefungibleError (397) */3323  /** @name PalletRefungibleError (394) */
3474  interface PalletRefungibleError extends Enum {3324  export interface PalletRefungibleError extends Enum {
3475    readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean;3325    readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean;
3476    readonly isWrongRefungiblePieces: boolean;3326    readonly isWrongRefungiblePieces: boolean;
3477    readonly isRepartitionWhileNotOwningAllPieces: boolean;3327    readonly isRepartitionWhileNotOwningAllPieces: boolean;
3480    readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RepartitionWhileNotOwningAllPieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';3330    readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RepartitionWhileNotOwningAllPieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
3481  }3331  }
34823332
3483  /** @name PalletNonfungibleItemData (398) */3333  /** @name PalletNonfungibleItemData (395) */
3484  interface PalletNonfungibleItemData extends Struct {3334  export interface PalletNonfungibleItemData extends Struct {
3485    readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;3335    readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
3486  }3336  }
34873337
3488  /** @name UpDataStructsPropertyScope (400) */3338  /** @name UpDataStructsPropertyScope (397) */
3489  interface UpDataStructsPropertyScope extends Enum {3339  export interface UpDataStructsPropertyScope extends Enum {
3490    readonly isNone: boolean;3340    readonly isNone: boolean;
3491    readonly isRmrk: boolean;3341    readonly isRmrk: boolean;
3492    readonly isEth: boolean;3342    readonly isEth: boolean;
3493    readonly type: 'None' | 'Rmrk' | 'Eth';3343    readonly type: 'None' | 'Rmrk' | 'Eth';
3494  }3344  }
34953345
3496  /** @name PalletNonfungibleError (402) */3346  /** @name PalletNonfungibleError (399) */
3497  interface PalletNonfungibleError extends Enum {3347  export interface PalletNonfungibleError extends Enum {
3498    readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean;3348    readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean;
3499    readonly isNonfungibleItemsHaveNoAmount: boolean;3349    readonly isNonfungibleItemsHaveNoAmount: boolean;
3500    readonly isCantBurnNftWithChildren: boolean;3350    readonly isCantBurnNftWithChildren: boolean;
3501    readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount' | 'CantBurnNftWithChildren';3351    readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount' | 'CantBurnNftWithChildren';
3502  }3352  }
35033353
3504  /** @name PalletStructureError (403) */3354  /** @name PalletStructureError (400) */
3505  interface PalletStructureError extends Enum {3355  export interface PalletStructureError extends Enum {
3506    readonly isOuroborosDetected: boolean;3356    readonly isOuroborosDetected: boolean;
3507    readonly isDepthLimit: boolean;3357    readonly isDepthLimit: boolean;
3508    readonly isBreadthLimit: boolean;3358    readonly isBreadthLimit: boolean;
3509    readonly isTokenNotFound: boolean;3359    readonly isTokenNotFound: boolean;
3510    readonly type: 'OuroborosDetected' | 'DepthLimit' | 'BreadthLimit' | 'TokenNotFound';3360    readonly type: 'OuroborosDetected' | 'DepthLimit' | 'BreadthLimit' | 'TokenNotFound';
3511  }3361  }
35123362
3513  /** @name PalletRmrkCoreError (404) */3363  /** @name PalletRmrkCoreError (401) */
3514  interface PalletRmrkCoreError extends Enum {3364  export interface PalletRmrkCoreError extends Enum {
3515    readonly isCorruptedCollectionType: boolean;3365    readonly isCorruptedCollectionType: boolean;
3516    readonly isRmrkPropertyKeyIsTooLong: boolean;3366    readonly isRmrkPropertyKeyIsTooLong: boolean;
3517    readonly isRmrkPropertyValueIsTooLong: boolean;3367    readonly isRmrkPropertyValueIsTooLong: boolean;
3534    readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';3384    readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';
3535  }3385  }
35363386
3537  /** @name PalletRmrkEquipError (406) */3387  /** @name PalletRmrkEquipError (403) */
3538  interface PalletRmrkEquipError extends Enum {3388  export interface PalletRmrkEquipError extends Enum {
3539    readonly isPermissionError: boolean;3389    readonly isPermissionError: boolean;
3540    readonly isNoAvailableBaseId: boolean;3390    readonly isNoAvailableBaseId: boolean;
3541    readonly isNoAvailablePartId: boolean;3391    readonly isNoAvailablePartId: boolean;
3546    readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart';3396    readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart';
3547  }3397  }
35483398
3549  /** @name PalletEvmError (409) */3399  /** @name PalletEvmError (406) */
3550  interface PalletEvmError extends Enum {3400  export interface PalletEvmError extends Enum {
3551    readonly isBalanceLow: boolean;3401    readonly isBalanceLow: boolean;
3552    readonly isFeeOverflow: boolean;3402    readonly isFeeOverflow: boolean;
3553    readonly isPaymentOverflow: boolean;3403    readonly isPaymentOverflow: boolean;
3557    readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';3407    readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';
3558  }3408  }
35593409
3560  /** @name FpRpcTransactionStatus (412) */3410  /** @name FpRpcTransactionStatus (409) */
3561  interface FpRpcTransactionStatus extends Struct {3411  export interface FpRpcTransactionStatus extends Struct {
3562    readonly transactionHash: H256;3412    readonly transactionHash: H256;
3563    readonly transactionIndex: u32;3413    readonly transactionIndex: u32;
3564    readonly from: H160;3414    readonly from: H160;
3568    readonly logsBloom: EthbloomBloom;3418    readonly logsBloom: EthbloomBloom;
3569  }3419  }
35703420
3571  /** @name EthbloomBloom (414) */3421  /** @name EthbloomBloom (411) */
3572  interface EthbloomBloom extends U8aFixed {}3422  export interface EthbloomBloom extends U8aFixed {}
35733423
3574  /** @name EthereumReceiptReceiptV3 (416) */3424  /** @name EthereumReceiptReceiptV3 (413) */
3575  interface EthereumReceiptReceiptV3 extends Enum {3425  export interface EthereumReceiptReceiptV3 extends Enum {
3576    readonly isLegacy: boolean;3426    readonly isLegacy: boolean;
3577    readonly asLegacy: EthereumReceiptEip658ReceiptData;3427    readonly asLegacy: EthereumReceiptEip658ReceiptData;
3578    readonly isEip2930: boolean;3428    readonly isEip2930: boolean;
3582    readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';3432    readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';
3583  }3433  }
35843434
3585  /** @name EthereumReceiptEip658ReceiptData (417) */3435  /** @name EthereumReceiptEip658ReceiptData (414) */
3586  interface EthereumReceiptEip658ReceiptData extends Struct {3436  export interface EthereumReceiptEip658ReceiptData extends Struct {
3587    readonly statusCode: u8;3437    readonly statusCode: u8;
3588    readonly usedGas: U256;3438    readonly usedGas: U256;
3589    readonly logsBloom: EthbloomBloom;3439    readonly logsBloom: EthbloomBloom;
3590    readonly logs: Vec<EthereumLog>;3440    readonly logs: Vec<EthereumLog>;
3591  }3441  }
35923442
3593  /** @name EthereumBlock (418) */3443  /** @name EthereumBlock (415) */
3594  interface EthereumBlock extends Struct {3444  export interface EthereumBlock extends Struct {
3595    readonly header: EthereumHeader;3445    readonly header: EthereumHeader;
3596    readonly transactions: Vec<EthereumTransactionTransactionV2>;3446    readonly transactions: Vec<EthereumTransactionTransactionV2>;
3597    readonly ommers: Vec<EthereumHeader>;3447    readonly ommers: Vec<EthereumHeader>;
3598  }3448  }
35993449
3600  /** @name EthereumHeader (419) */3450  /** @name EthereumHeader (416) */
3601  interface EthereumHeader extends Struct {3451  export interface EthereumHeader extends Struct {
3602    readonly parentHash: H256;3452    readonly parentHash: H256;
3603    readonly ommersHash: H256;3453    readonly ommersHash: H256;
3604    readonly beneficiary: H160;3454    readonly beneficiary: H160;
3616    readonly nonce: EthereumTypesHashH64;3466    readonly nonce: EthereumTypesHashH64;
3617  }3467  }
36183468
3619  /** @name EthereumTypesHashH64 (420) */3469  /** @name EthereumTypesHashH64 (417) */
3620  interface EthereumTypesHashH64 extends U8aFixed {}3470  export interface EthereumTypesHashH64 extends U8aFixed {}
36213471
3622  /** @name PalletEthereumError (425) */3472  /** @name PalletEthereumError (422) */
3623  interface PalletEthereumError extends Enum {3473  export interface PalletEthereumError extends Enum {
3624    readonly isInvalidSignature: boolean;3474    readonly isInvalidSignature: boolean;
3625    readonly isPreLogExists: boolean;3475    readonly isPreLogExists: boolean;
3626    readonly type: 'InvalidSignature' | 'PreLogExists';3476    readonly type: 'InvalidSignature' | 'PreLogExists';
3627  }3477  }
36283478
3629  /** @name PalletEvmCoderSubstrateError (426) */3479  /** @name PalletEvmCoderSubstrateError (423) */
3630  interface PalletEvmCoderSubstrateError extends Enum {3480  export interface PalletEvmCoderSubstrateError extends Enum {
3631    readonly isOutOfGas: boolean;3481    readonly isOutOfGas: boolean;
3632    readonly isOutOfFund: boolean;3482    readonly isOutOfFund: boolean;
3633    readonly type: 'OutOfGas' | 'OutOfFund';3483    readonly type: 'OutOfGas' | 'OutOfFund';
3634  }3484  }
36353485
3636  /** @name PalletEvmContractHelpersSponsoringModeT (427) */3486  /** @name PalletEvmContractHelpersSponsoringModeT (424) */
3637  interface PalletEvmContractHelpersSponsoringModeT extends Enum {3487  export interface PalletEvmContractHelpersSponsoringModeT extends Enum {
3638    readonly isDisabled: boolean;3488    readonly isDisabled: boolean;
3639    readonly isAllowlisted: boolean;3489    readonly isAllowlisted: boolean;
3640    readonly isGenerous: boolean;3490    readonly isGenerous: boolean;
3641    readonly type: 'Disabled' | 'Allowlisted' | 'Generous';3491    readonly type: 'Disabled' | 'Allowlisted' | 'Generous';
3642  }3492  }
36433493
3644  /** @name PalletEvmContractHelpersError (429) */3494  /** @name PalletEvmContractHelpersError (426) */
3645  interface PalletEvmContractHelpersError extends Enum {3495  export interface PalletEvmContractHelpersError extends Enum {
3646    readonly isNoPermission: boolean;3496    readonly isNoPermission: boolean;
3647    readonly type: 'NoPermission';3497    readonly type: 'NoPermission';
3648  }3498  }
36493499
3650  /** @name PalletEvmMigrationError (430) */3500  /** @name PalletEvmMigrationError (427) */
3651  interface PalletEvmMigrationError extends Enum {3501  export interface PalletEvmMigrationError extends Enum {
3652    readonly isAccountNotEmpty: boolean;3502    readonly isAccountNotEmpty: boolean;
3653    readonly isAccountIsNotMigrating: boolean;3503    readonly isAccountIsNotMigrating: boolean;
3654    readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';3504    readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';
3655  }3505  }
36563506
3657  /** @name SpRuntimeMultiSignature (432) */3507  /** @name SpRuntimeMultiSignature (429) */
3658  interface SpRuntimeMultiSignature extends Enum {3508  export interface SpRuntimeMultiSignature extends Enum {
3659    readonly isEd25519: boolean;3509    readonly isEd25519: boolean;
3660    readonly asEd25519: SpCoreEd25519Signature;3510    readonly asEd25519: SpCoreEd25519Signature;
3661    readonly isSr25519: boolean;3511    readonly isSr25519: boolean;
3665    readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';3515    readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';
3666  }3516  }
36673517
3668  /** @name SpCoreEd25519Signature (433) */3518  /** @name SpCoreEd25519Signature (430) */
3669  interface SpCoreEd25519Signature extends U8aFixed {}3519  export interface SpCoreEd25519Signature extends U8aFixed {}
36703520
3671  /** @name SpCoreSr25519Signature (435) */3521  /** @name SpCoreSr25519Signature (434) */
3672  interface SpCoreSr25519Signature extends U8aFixed {}3522  export interface SpCoreSr25519Signature extends U8aFixed {}
36733523
3674  /** @name SpCoreEcdsaSignature (436) */3524  /** @name SpCoreEcdsaSignature (435) */
3675  interface SpCoreEcdsaSignature extends U8aFixed {}3525  export interface SpCoreEcdsaSignature extends U8aFixed {}
36763526
3677  /** @name FrameSystemExtensionsCheckSpecVersion (439) */3527  /** @name FrameSystemExtensionsCheckSpecVersion (438) */
3678  type FrameSystemExtensionsCheckSpecVersion = Null;3528  export type FrameSystemExtensionsCheckSpecVersion = Null;
36793529
3680  /** @name FrameSystemExtensionsCheckGenesis (440) */3530  /** @name FrameSystemExtensionsCheckGenesis (439) */
3681  type FrameSystemExtensionsCheckGenesis = Null;3531  export type FrameSystemExtensionsCheckGenesis = Null;
36823532
3683  /** @name FrameSystemExtensionsCheckNonce (443) */3533  /** @name FrameSystemExtensionsCheckNonce (442) */
3684  interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}3534  export interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}
36853535
3686  /** @name FrameSystemExtensionsCheckWeight (444) */3536  /** @name FrameSystemExtensionsCheckWeight (443) */
3687  type FrameSystemExtensionsCheckWeight = Null;3537  export type FrameSystemExtensionsCheckWeight = Null;
36883538
3689  /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (445) */3539  /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (444) */
3690  interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}3540  export interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}
36913541
3692  /** @name OpalRuntimeRuntime (446) */3542  /** @name OpalRuntimeRuntime (445) */
3693  type OpalRuntimeRuntime = Null;3543  export type OpalRuntimeRuntime = Null;
36943544
3695  /** @name PalletEthereumFakeTransactionFinalizer (447) */3545  /** @name PalletEthereumFakeTransactionFinalizer (444) */
3696  type PalletEthereumFakeTransactionFinalizer = Null;3546  export type PalletEthereumFakeTransactionFinalizer = Null;
36973547
3698} // declare module3548} // declare module
36993549