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

263	fn total_staking_locked(&self, staker: CrossAccountId, at: Option<BlockHash>)263	fn total_staking_locked(&self, staker: CrossAccountId, at: Option<BlockHash>)
264		-> Result<String>;264		-> Result<String>;
265
266	/// Return the total amount locked by staking tokens.
267	#[method(name = "unique_pendingUnstake")]
268	fn pending_unstake(
269		&self,
270		staker: Option<CrossAccountId>,
271		at: Option<BlockHash>,
272	) -> Result<String>;
265}273}
266274
267mod rmrk_unique_rpc {275mod rmrk_unique_rpc {
548		.map(|(b, a)| (b, a.to_string()))556		.map(|(b, a)| (b, a.to_string()))
549		.collect::<Vec<_>>(), unique_api);557		.collect::<Vec<_>>(), unique_api);
550	pass_method!(total_staking_locked(staker: CrossAccountId) -> String => |v| v.to_string(), unique_api);558	pass_method!(total_staking_locked(staker: CrossAccountId) -> String => |v| v.to_string(), unique_api);
559	pass_method!(pending_unstake(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), unique_api);
551}560}
552561
553#[allow(deprecated)]562#[allow(deprecated)]

63use fc_rpc_core::types::FilterPool;63use fc_rpc_core::types::FilterPool;
64use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};64use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};
6565
66use unique_runtime_common::types::{66use up_common::types::opaque::{
67	AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block, BlockNumber,67	AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block, BlockNumber,
68};68};
6969

3131
32#[cfg(feature = "runtime-benchmarks")]32#[cfg(feature = "runtime-benchmarks")]
33mod benchmarking;33mod benchmarking;
34pub mod types;
35
36#[cfg(test)]34#[cfg(test)]
37mod tests;35mod tests;
36pub mod types;
37pub mod weights;
3838
39use sp_std::vec::Vec;39use sp_std::{vec::Vec, iter::Sum};
40use codec::EncodeLike;40use codec::EncodeLike;
41use pallet_balances::BalanceLock;41use pallet_balances::BalanceLock;
42pub use types::ExtendedLockableCurrency;42pub use types::ExtendedLockableCurrency;
49	ensure,49	ensure,
50};50};
51
52use weights::WeightInfo;
53
51pub use pallet::*;54pub use pallet::*;
52use pallet_evm::account::CrossAccountId;55use pallet_evm::account::CrossAccountId;
7982
80		type TreasuryAccountId: Get<Self::AccountId>;83		type TreasuryAccountId: Get<Self::AccountId>;
84
85		/// Weight information for extrinsics in this pallet.
86		type WeightInfo: WeightInfo;
8187
82		// The block number provider88		// The block number provider
83		type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;89		type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
136		fn on_initialize(current_block: T::BlockNumber) -> Weight142		fn on_initialize(current_block: T::BlockNumber) -> Weight
137		where143		where
138			<T as frame_system::Config>::BlockNumber: From<u32>,144			<T as frame_system::Config>::BlockNumber: From<u32>,
145			// <<T as pallet::Config>::Currency as Currency<T::AccountId>>::Balance: Sum,
139		{146		{
140			PendingUnstake::<T>::iter()147			PendingUnstake::<T>::iter()
141				.filter_map(|((staker, block), amount)| {148				.filter_map(|((staker, block), amount)| {
172179
173	#[pallet::call]180	#[pallet::call]
174	impl<T: Config> Pallet<T> {181	impl<T: Config> Pallet<T> {
175		#[pallet::weight(0)]182		#[pallet::weight(T::WeightInfo::set_admin_address())]
176		pub fn set_admin_address(origin: OriginFor<T>, admin: T::AccountId) -> DispatchResult {183		pub fn set_admin_address(origin: OriginFor<T>, admin: T::AccountId) -> DispatchResult {
177			ensure_root(origin)?;184			ensure_root(origin)?;
178			<Admin<T>>::set(Some(admin));185			<Admin<T>>::set(Some(admin));
179186
180			Ok(())187			Ok(())
181		}188		}
182189
183		#[pallet::weight(0)]190		#[pallet::weight(T::WeightInfo::start_app_promotion())]
184		pub fn start_app_promotion(191		pub fn start_app_promotion(
185			origin: OriginFor<T>,192			origin: OriginFor<T>,
186			promotion_start_relay_block: T::BlockNumber,193			promotion_start_relay_block: T::BlockNumber,
201			Ok(())208			Ok(())
202		}209		}
203210
204		#[pallet::weight(0)]211		#[pallet::weight(T::WeightInfo::stake())]
205		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {212		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
206			let staker_id = ensure_signed(staker)?;213			let staker_id = ensure_signed(staker)?;
207214
210217
211			ensure!(balance >= amount, ArithmeticError::Underflow);218			ensure!(balance >= amount, ArithmeticError::Underflow);
219
220			<<T as Config>::Currency as Currency<T::AccountId>>::ensure_can_withdraw(
221				&staker_id,
222				amount,
223				WithdrawReasons::all(),
224				balance - amount,
225			)?;
212226
213			Self::set_lock_unchecked(&staker_id, amount);227			Self::add_lock_balance(&staker_id, amount)?;
214228
215			let block_number =229			let block_number = frame_system::Pallet::<T>::block_number();
216				<T::BlockNumberProvider as BlockNumberProvider>::current_block_number();
217230
218			<Staked<T>>::insert(231			<Staked<T>>::insert(
219				(&staker_id, block_number),232				(&staker_id, block_number),
231			Ok(())244			Ok(())
232		}245		}
233246
234		#[pallet::weight(0)]247		#[pallet::weight(T::WeightInfo::unstake())]
235		pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {248		pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
236			let staker_id = ensure_signed(staker)?;249			let staker_id = ensure_signed(staker)?;
237250
249					.ok_or(ArithmeticError::Underflow)?,262					.ok_or(ArithmeticError::Underflow)?,
250			);263			);
251264
252			let block = <T::BlockNumberProvider>::current_block_number() + WEEK.into();265			let block = frame_system::Pallet::<T>::block_number() + WEEK.into();
253			<PendingUnstake<T>>::insert(266			<PendingUnstake<T>>::insert(
254				(&staker_id, block),267				(&staker_id, block),
255				<PendingUnstake<T>>::get((&staker_id, block))268				<PendingUnstake<T>>::get((&staker_id, block))
400413
401	fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {414	fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
402		Self::get_locked_balance(staker)415		Self::get_locked_balance(staker)
403			.map(|l| l.amount)416			.map_or(<BalanceOf<T>>::default(), |l| l.amount)
404			.and_then(|b| b.checked_add(&amount))417			.checked_add(&amount)
405			.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))418			.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))
406			.ok_or(ArithmeticError::Overflow.into())419			.ok_or(ArithmeticError::Overflow.into())
407	}420	}
437	pub fn total_staked_by_id_per_block(450	pub fn total_staked_by_id_per_block(
438		staker: impl EncodeLike<T::AccountId>,451		staker: impl EncodeLike<T::AccountId>,
439	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {452	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {
440		let staked = Staked::<T>::iter_prefix((staker,))453		let mut staked = Staked::<T>::iter_prefix((staker,))
441			.into_iter()454			.into_iter()
442			.map(|(block, amount)| (block, amount))455			.map(|(block, amount)| (block, amount))
443			.collect::<Vec<_>>();456			.collect::<Vec<_>>();
457		staked.sort_by_key(|(block, _)| *block);
444		if !staked.is_empty() {458		if !staked.is_empty() {
445			Some(staked)459			Some(staked)
446		} else {460		} else {
496	}510	}
497}511}
512
513impl<T: Config> Pallet<T>
514where
515	<<T as pallet::Config>::Currency as Currency<T::AccountId>>::Balance: Sum,
516{
517	pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {
518		staker.map_or(PendingUnstake::<T>::iter_values().sum(), |s| {
519			PendingUnstake::<T>::iter_prefix_values((s.as_sub(),)).sum()
520		})
521	}
522}
498523

129		fn total_staked(staker: Option<CrossAccountId>) -> Result<u128>;129		fn total_staked(staker: Option<CrossAccountId>) -> Result<u128>;
130		fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>>;130		fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>>;
131		fn total_staking_locked(staker: CrossAccountId) -> Result<u128>;131		fn total_staking_locked(staker: CrossAccountId) -> Result<u128>;
132		fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128>;
132	}133	}
133}134}
134135

40#[cfg(feature = "scheduler")]40#[cfg(feature = "scheduler")]
41pub mod scheduler;41pub mod scheduler;
42
43#[cfg(feature = "app-promotion")]
44pub mod app_promotion;
4245
43parameter_types! {46parameter_types! {
44	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();47	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();

77                #[runtimes(opal)]77                #[runtimes(opal)]
78                RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,78                RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,
79
80                #[runtimes(opal)]
81                Promotion: pallet_app_promotion::{Pallet, Call, Storage} = 73,
7982
80                // Frontier83                // Frontier
81                EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,84                EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,

190190
191                fn total_staked(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {191                fn total_staked(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {
192                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked(staker).unwrap_or_default())192                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked(staker).unwrap_or_default())
193                    // Ok(0)
194                }193                }
195194
196                fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>, DispatchError> {195                fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>, DispatchError> {
197                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked_per_block(staker))196                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked_per_block(staker))
198                }197                }
199198
200                fn total_staking_locked(staker: CrossAccountId) -> Result<u128, DispatchError> {199                fn total_staking_locked(staker: CrossAccountId) -> Result<u128, DispatchError> {
201                    // Ok(0)
202                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_locked_balance(staker))200                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_locked_balance(staker))
203                }201                }
202
203                fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {
204                    Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_pending_unstake(staker))
205                }
204            }206            }
205207
206            impl rmrk_rpc::RmrkApi<208            impl rmrk_rpc::RmrkApi<

124    "orml-vesting/std",124    "orml-vesting/std",
125]125]
126limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']126limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']
127opal-runtime = ['refungible', 'scheduler', 'rmrk']127opal-runtime = ['refungible', 'scheduler', 'rmrk', 'app-promotion']
128128
129refungible = []129refungible = []
130scheduler = []130scheduler = []
131rmrk = []131rmrk = []
132app-promotion = []
132133
133################################################################################134################################################################################
134# Substrate Dependencies135# Substrate Dependencies

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {default as usingApi, submitTransactionAsync} from './substrate/substrate-api';17import {default as usingApi, submitTransactionAsync} from './substrate/substrate-api';
18import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair, ITuple} from '@polkadot/types/types';
19import {19import {
20  20  
21  createMultipleItemsExpectSuccess,21  createMultipleItemsExpectSuccess,
33  U128_MAX,33  U128_MAX,
34  burnFromExpectSuccess,34  burnFromExpectSuccess,
35  UNIQUE,35  UNIQUE,
36  getModuleNames,
37  Pallets,
38  getBlockNumber,
36} from './util/helpers';39} from './util/helpers';
3740
38import chai from 'chai';41import chai, {use} from 'chai';
39import chaiAsPromised from 'chai-as-promised';42import chaiAsPromised from 'chai-as-promised';
40import getBalance from './substrate/get-balance';43import getBalance, {getBalanceSingle} from './substrate/get-balance';
41import { unique } from './interfaces/definitions';44import {unique} from './interfaces/definitions';
45import {usingPlaygrounds} from './util/playgrounds';
46import {default as waitNewBlocks} from './substrate/wait-new-blocks';
47
48import BN from 'bn.js';
49import {mnemonicGenerate} from '@polkadot/util-crypto';
50import {UniqueHelper} from './util/playgrounds/unique';
42chai.use(chaiAsPromised);51chai.use(chaiAsPromised);
43const expect = chai.expect;52const expect = chai.expect;
4453
45let alice: IKeyringPair;54let alice: IKeyringPair;
46let bob: IKeyringPair;55let bob: IKeyringPair;
47let palletAdmin: IKeyringPair;56let palletAdmin: IKeyringPair;
57let nominal: bigint; 
4858
49describe('integration test: AppPromotion', () => {59describe('integration test: AppPromotion', () => {
50  before(async () => {60  before(async function() {
51    await usingApi(async (api, privateKeyWrapper) => {61    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
62      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
52      alice = privateKeyWrapper('//Alice');63      alice = privateKeyWrapper('//Alice');
53      bob = privateKeyWrapper('//Bob');64      bob = privateKeyWrapper('//Bob');
54      palletAdmin = privateKeyWrapper('//palletAdmin');65      palletAdmin = privateKeyWrapper('//palletAdmin');
55      const tx = api.tx.sudo.sudo(api.tx.promotion.setAdminAddress(palletAdmin.addressRaw));66      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
67      nominal = helper.balance.getOneTokenNominal();
56      await submitTransactionAsync(alice, tx);68      await submitTransactionAsync(alice, tx);
57    });69    });
58  });70  });
69    // assert:  query appPromotion.staked(Alice) equal [100, 200]81    // assert:  query appPromotion.staked(Alice) equal [100, 200]
70    // assert:  query appPromotion.totalStaked() increased by 20082    // assert:  query appPromotion.totalStaked() increased by 200
71    83    
72    await usingApi(async (api, privateKeyWrapper) => {84    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
73      await submitTransactionAsync(alice, api.tx.balances.transfer(bob.addressRaw, 10n * UNIQUE));85      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
74      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alice.address, bob.address]);86      const staker = await createUser();
75      87   
76      console.log(`alice: ${alicesBalanceBefore} \n bob: ${bobsBalanceBefore}`);88      const firstStakedBlock = await helper.chain.getLatestBlockNumber();
77      89      
78      await submitTransactionAsync(alice, api.tx.promotion.stake(1n * UNIQUE));90      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
91      expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);
92      expect(9n * nominal - await helper.balance.getSubstrate(staker.address) <= nominal / 2n).to.be.true;
93      expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);
94      expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + nominal);
95      
96      await waitNewBlocks(helper.api!, 1);
97      const secondStakedBlock = await helper.chain.getLatestBlockNumber();
98      
79      await submitTransactionAsync(bob, api.tx.promotion.stake(1n * UNIQUE));99      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
80      const alice_total_staked = (await (api.rpc.unique.totalStaked(normalizeAccountId(alice)))).toBigInt();100      expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(3n * nominal);
101      
81      const bob_total_staked = (await api.rpc.unique.totalStaked(normalizeAccountId(bob))).toBigInt();102      const stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]);
82       
83      console.log(`alice staked: ${alice_total_staked} \n bob staked: ${bob_total_staked}, total staked: ${(await api.rpc.unique.totalStaked()).toBigInt()}`);103      expect(stakedPerBlock.map((x) => x[1])).to.be.deep.equal([nominal, 2n * nominal]);
84      
85      
86      
87    });104    });
88  });105  });
106  
107  it('will throws if stake amount is more than total free balance', async () => {
108    // arrange: Alice balance = 1000
109    // assert:  Alice calls appPromotion.stake(1000) throws /// because Alice needs some fee
110
111    // act:     Alice calls appPromotion.stake(700)
112    // assert:  Alice calls appPromotion.stake(400) throws /// because Alice has ~300 free QTZ and 700 locked
113
114    await usingPlaygrounds(async helper => { 
115      
116      const staker = await createUser();
117      
118      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected;
119      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled;
120      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected;
121      
122    });
123  });
124  
125  it.skip('for different accounts in one block is possible', async () => {
126    // arrange: Alice, Bob, Charlie, Dave balance = 1000
127    // arrange: Alice, Bob, Charlie, Dave calls appPromotion.stake(100) in the same time
128
129    // assert:  query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]
130    await usingPlaygrounds(async helper => {
131      const crowd = await creteAccounts([10n, 10n, 10n, 10n], alice, helper);
132      // const promises = crowd.map(async user => submitTransactionAsync(user, helper.api!.tx.promotion.stake(nominal)));
133      // await expect(Promise.all(promises)).to.be.eventually.fulfilled;
134    });
135  });
89136
90});137});
138
139describe.skip('unstake balance extrinsic', () => {
140  before(async function() {
141    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
142      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
143      alice = privateKeyWrapper('//Alice');
144      bob = privateKeyWrapper('//Bob');
145      palletAdmin = privateKeyWrapper('//palletAdmin');
146      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
147      nominal = helper.balance.getOneTokenNominal();
148      await submitTransactionAsync(alice, tx);
149    });
150  });
151  it('will change balance state to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {
152    // arrange: Alice balance = 1000
153    // arrange: Alice calls appPromotion.stake(Alice, 500)
154
155    // act:     Alice calls appPromotion.unstake(300)
156    // assert:  Alice reserved balance to equal 300
157    // assert:  query appPromotion.staked(Alice) equal [200] /// 500 - 300
158    // assert:  query appPromotion.pendingUnstake(Alice) to equal [300]
159    // assert:  query appPromotion.totalStaked() decreased by 300
160  });
161});
162
163
164
165async function createUser(amount?: bigint) {
166  return await usingPlaygrounds(async (helper, privateKeyWrapper) => {
167    const user: IKeyringPair = privateKeyWrapper(`//Alice+${(new Date()).getTime()}`);
168    await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());
169    return user;
170  });
171}
172
173const creteAccounts = async (balances: bigint[], donor: IKeyringPair, helper: UniqueHelper) => {
174  let nonce = await helper.chain.getNonce(donor.address);
175  const tokenNominal = helper.balance.getOneTokenNominal();
176  const transactions = [];
177  const accounts = [];
178  for (const balance of balances) {
179    const recepient = helper.util.fromSeed(mnemonicGenerate());
180    accounts.push(recepient);
181    if (balance !== 0n){
182      const tx = helper.constructApiCall('api.tx.balances.transfer', [{Id: recepient.address}, balance * tokenNominal]);
183      transactions.push(helper.signTransaction(donor, tx, 'account generation', {nonce}));
184      nonce++;
185    }
186  }
187
188  await Promise.all(transactions);
189  return accounts;
190};

702       * Get the number of blocks until sponsoring a transaction is available702       * Get the number of blocks until sponsoring a transaction is available
703       **/703       **/
704      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>>>;704      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>>>;
705      /**
706       * Returns the total amount of unstaked tokens
707       **/
708      pendingUnstake: AugmentedRpc<(staker?: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;
705      /**709      /**
706       * Get property permissions, optionally limited to the provided keys710       * Get property permissions, optionally limited to the provided keys
707       **/711       **/

55
6export default {6export default {
7  /**7  /**
8   * Lookup3: frame_system::AccountInfo<Index, pallet_balances::AccountData<Balance>>8   * Lookup2: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>
9   **/9   **/
10  FrameSystemAccountInfo: {
11    nonce: 'u32',
12    consumers: 'u32',
13    providers: 'u32',
14    sufficients: 'u32',
15    data: 'PalletBalancesAccountData'
16  },
17  /**
18   * Lookup5: pallet_balances::AccountData<Balance>
19   **/
20  PalletBalancesAccountData: {
21    free: 'u128',
22    reserved: 'u128',
23    miscFrozen: 'u128',
24    feeFrozen: 'u128'
25  },
26  /**
27   * Lookup7: frame_support::weights::PerDispatchClass<T>
28   **/
29  FrameSupportWeightsPerDispatchClassU64: {
30    normal: 'u64',
31    operational: 'u64',
32    mandatory: 'u64'
33  },
34  /**
35   * Lookup11: sp_runtime::generic::digest::Digest
36   **/
37  SpRuntimeDigest: {
38    logs: 'Vec<SpRuntimeDigestDigestItem>'
39  },
40  /**
41   * Lookup13: sp_runtime::generic::digest::DigestItem
42   **/
43  SpRuntimeDigestDigestItem: {
44    _enum: {
45      Other: 'Bytes',
46      __Unused1: 'Null',
47      __Unused2: 'Null',
48      __Unused3: 'Null',
49      Consensus: '([u8;4],Bytes)',
50      Seal: '([u8;4],Bytes)',
51      PreRuntime: '([u8;4],Bytes)',
52      __Unused7: 'Null',
53      RuntimeEnvironmentUpdated: 'Null'
54    }
55  },
56  /**
57   * Lookup16: frame_system::EventRecord<opal_runtime::Event, primitive_types::H256>
58   **/
59  FrameSystemEventRecord: {
60    phase: 'FrameSystemPhase',
61    event: 'Event',
62    topics: 'Vec<H256>'
63  },
64  /**
65   * Lookup18: frame_system::pallet::Event<T>
66   **/
67  FrameSystemEvent: {
68    _enum: {
69      ExtrinsicSuccess: {
70        dispatchInfo: 'FrameSupportWeightsDispatchInfo',
71      },
72      ExtrinsicFailed: {
73        dispatchError: 'SpRuntimeDispatchError',
74        dispatchInfo: 'FrameSupportWeightsDispatchInfo',
75      },
76      CodeUpdated: 'Null',
77      NewAccount: {
78        account: 'AccountId32',
79      },
80      KilledAccount: {
81        account: 'AccountId32',
82      },
83      Remarked: {
84        _alias: {
85          hash_: 'hash',
86        },
87        sender: 'AccountId32',
88        hash_: 'H256'
89      }
90    }
91  },
92  /**
93   * Lookup19: frame_support::weights::DispatchInfo
94   **/
95  FrameSupportWeightsDispatchInfo: {
96    weight: 'u64',
97    class: 'FrameSupportWeightsDispatchClass',
98    paysFee: 'FrameSupportWeightsPays'
99  },
100  /**
101   * Lookup20: frame_support::weights::DispatchClass
102   **/
103  FrameSupportWeightsDispatchClass: {
104    _enum: ['Normal', 'Operational', 'Mandatory']
105  },
106  /**
107   * Lookup21: frame_support::weights::Pays
108   **/
109  FrameSupportWeightsPays: {
110    _enum: ['Yes', 'No']
111  },
112  /**
113   * Lookup22: sp_runtime::DispatchError
114   **/
115  SpRuntimeDispatchError: {
116    _enum: {
117      Other: 'Null',
118      CannotLookup: 'Null',
119      BadOrigin: 'Null',
120      Module: 'SpRuntimeModuleError',
121      ConsumerRemaining: 'Null',
122      NoProviders: 'Null',
123      TooManyConsumers: 'Null',
124      Token: 'SpRuntimeTokenError',
125      Arithmetic: 'SpRuntimeArithmeticError',
126      Transactional: 'SpRuntimeTransactionalError'
127    }
128  },
129  /**
130   * Lookup23: sp_runtime::ModuleError
131   **/
132  SpRuntimeModuleError: {
133    index: 'u8',
134    error: '[u8;4]'
135  },
136  /**
137   * Lookup24: sp_runtime::TokenError
138   **/
139  SpRuntimeTokenError: {
140    _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported']
141  },
142  /**
143   * Lookup25: sp_runtime::ArithmeticError
144   **/
145  SpRuntimeArithmeticError: {
146    _enum: ['Underflow', 'Overflow', 'DivisionByZero']
147  },
148  /**
149   * Lookup26: sp_runtime::TransactionalError
150   **/
151  SpRuntimeTransactionalError: {
152    _enum: ['LimitReached', 'NoLayer']
153  },
154  /**
155   * Lookup27: cumulus_pallet_parachain_system::pallet::Event<T>
156   **/
157  CumulusPalletParachainSystemEvent: {
158    _enum: {
159      ValidationFunctionStored: 'Null',
160      ValidationFunctionApplied: {
161        relayChainBlockNum: 'u32',
162      },
163      ValidationFunctionDiscarded: 'Null',
164      UpgradeAuthorized: {
165        codeHash: 'H256',
166      },
167      DownwardMessagesReceived: {
168        count: 'u32',
169      },
170      DownwardMessagesProcessed: {
171        weightUsed: 'u64',
172        dmqHead: 'H256'
173      }
174    }
175  },
176  /**
177   * Lookup28: pallet_balances::pallet::Event<T, I>
178   **/
179  PalletBalancesEvent: {
180    _enum: {
181      Endowed: {
182        account: 'AccountId32',
183        freeBalance: 'u128',
184      },
185      DustLost: {
186        account: 'AccountId32',
187        amount: 'u128',
188      },
189      Transfer: {
190        from: 'AccountId32',
191        to: 'AccountId32',
192        amount: 'u128',
193      },
194      BalanceSet: {
195        who: 'AccountId32',
196        free: 'u128',
197        reserved: 'u128',
198      },
199      Reserved: {
200        who: 'AccountId32',
201        amount: 'u128',
202      },
203      Unreserved: {
204        who: 'AccountId32',
205        amount: 'u128',
206      },
207      ReserveRepatriated: {
208        from: 'AccountId32',
209        to: 'AccountId32',
210        amount: 'u128',
211        destinationStatus: 'FrameSupportTokensMiscBalanceStatus',
212      },
213      Deposit: {
214        who: 'AccountId32',
215        amount: 'u128',
216      },
217      Withdraw: {
218        who: 'AccountId32',
219        amount: 'u128',
220      },
221      Slashed: {
222        who: 'AccountId32',
223        amount: 'u128'
224      }
225    }
226  },
227  /**
228   * Lookup29: frame_support::traits::tokens::misc::BalanceStatus
229   **/
230  FrameSupportTokensMiscBalanceStatus: {
231    _enum: ['Free', 'Reserved']
232  },
233  /**
234   * Lookup30: pallet_transaction_payment::pallet::Event<T>
235   **/
236  PalletTransactionPaymentEvent: {
237    _enum: {
238      TransactionFeePaid: {
239        who: 'AccountId32',
240        actualFee: 'u128',
241        tip: 'u128'
242      }
243    }
244  },
245  /**
246   * Lookup31: pallet_treasury::pallet::Event<T, I>
247   **/
248  PalletTreasuryEvent: {
249    _enum: {
250      Proposed: {
251        proposalIndex: 'u32',
252      },
253      Spending: {
254        budgetRemaining: 'u128',
255      },
256      Awarded: {
257        proposalIndex: 'u32',
258        award: 'u128',
259        account: 'AccountId32',
260      },
261      Rejected: {
262        proposalIndex: 'u32',
263        slashed: 'u128',
264      },
265      Burnt: {
266        burntFunds: 'u128',
267      },
268      Rollover: {
269        rolloverBalance: 'u128',
270      },
271      Deposit: {
272        value: 'u128',
273      },
274      SpendApproved: {
275        proposalIndex: 'u32',
276        amount: 'u128',
277        beneficiary: 'AccountId32'
278      }
279    }
280  },
281  /**
282   * Lookup32: pallet_sudo::pallet::Event<T>
283   **/
284  PalletSudoEvent: {
285    _enum: {
286      Sudid: {
287        sudoResult: 'Result<Null, SpRuntimeDispatchError>',
288      },
289      KeyChanged: {
290        oldSudoer: 'Option<AccountId32>',
291      },
292      SudoAsDone: {
293        sudoResult: 'Result<Null, SpRuntimeDispatchError>'
294      }
295    }
296  },
297  /**
298   * Lookup36: orml_vesting::module::Event<T>
299   **/
300  OrmlVestingModuleEvent: {
301    _enum: {
302      VestingScheduleAdded: {
303        from: 'AccountId32',
304        to: 'AccountId32',
305        vestingSchedule: 'OrmlVestingVestingSchedule',
306      },
307      Claimed: {
308        who: 'AccountId32',
309        amount: 'u128',
310      },
311      VestingSchedulesUpdated: {
312        who: 'AccountId32'
313      }
314    }
315  },
316  /**
317   * Lookup37: orml_vesting::VestingSchedule<BlockNumber, Balance>
318   **/
319  OrmlVestingVestingSchedule: {
320    start: 'u32',
321    period: 'u32',
322    periodCount: 'u32',
323    perPeriod: 'Compact<u128>'
324  },
325  /**
326   * Lookup39: cumulus_pallet_xcmp_queue::pallet::Event<T>
327   **/
328  CumulusPalletXcmpQueueEvent: {
329    _enum: {
330      Success: {
331        messageHash: 'Option<H256>',
332        weight: 'u64',
333      },
334      Fail: {
335        messageHash: 'Option<H256>',
336        error: 'XcmV2TraitsError',
337        weight: 'u64',
338      },
339      BadVersion: {
340        messageHash: 'Option<H256>',
341      },
342      BadFormat: {
343        messageHash: 'Option<H256>',
344      },
345      UpwardMessageSent: {
346        messageHash: 'Option<H256>',
347      },
348      XcmpMessageSent: {
349        messageHash: 'Option<H256>',
350      },
351      OverweightEnqueued: {
352        sender: 'u32',
353        sentAt: 'u32',
354        index: 'u64',
355        required: 'u64',
356      },
357      OverweightServiced: {
358        index: 'u64',
359        used: 'u64'
360      }
361    }
362  },
363  /**
364   * Lookup41: xcm::v2::traits::Error
365   **/
366  XcmV2TraitsError: {
367    _enum: {
368      Overflow: 'Null',
369      Unimplemented: 'Null',
370      UntrustedReserveLocation: 'Null',
371      UntrustedTeleportLocation: 'Null',
372      MultiLocationFull: 'Null',
373      MultiLocationNotInvertible: 'Null',
374      BadOrigin: 'Null',
375      InvalidLocation: 'Null',
376      AssetNotFound: 'Null',
377      FailedToTransactAsset: 'Null',
378      NotWithdrawable: 'Null',
379      LocationCannotHold: 'Null',
380      ExceedsMaxMessageSize: 'Null',
381      DestinationUnsupported: 'Null',
382      Transport: 'Null',
383      Unroutable: 'Null',
384      UnknownClaim: 'Null',
385      FailedToDecode: 'Null',
386      MaxWeightInvalid: 'Null',
387      NotHoldingFees: 'Null',
388      TooExpensive: 'Null',
389      Trap: 'u64',
390      UnhandledXcmVersion: 'Null',
391      WeightLimitReached: 'u64',
392      Barrier: 'Null',
393      WeightNotComputable: 'Null'
394    }
395  },
396  /**
397   * Lookup43: pallet_xcm::pallet::Event<T>
398   **/
399  PalletXcmEvent: {
400    _enum: {
401      Attempted: 'XcmV2TraitsOutcome',
402      Sent: '(XcmV1MultiLocation,XcmV1MultiLocation,XcmV2Xcm)',
403      UnexpectedResponse: '(XcmV1MultiLocation,u64)',
404      ResponseReady: '(u64,XcmV2Response)',
405      Notified: '(u64,u8,u8)',
406      NotifyOverweight: '(u64,u8,u8,u64,u64)',
407      NotifyDispatchError: '(u64,u8,u8)',
408      NotifyDecodeFailed: '(u64,u8,u8)',
409      InvalidResponder: '(XcmV1MultiLocation,u64,Option<XcmV1MultiLocation>)',
410      InvalidResponderVersion: '(XcmV1MultiLocation,u64)',
411      ResponseTaken: 'u64',
412      AssetsTrapped: '(H256,XcmV1MultiLocation,XcmVersionedMultiAssets)',
413      VersionChangeNotified: '(XcmV1MultiLocation,u32)',
414      SupportedVersionChanged: '(XcmV1MultiLocation,u32)',
415      NotifyTargetSendFail: '(XcmV1MultiLocation,u64,XcmV2TraitsError)',
416      NotifyTargetMigrationFail: '(XcmVersionedMultiLocation,u64)'
417    }
418  },
419  /**
420   * Lookup44: xcm::v2::traits::Outcome
421   **/
422  XcmV2TraitsOutcome: {
423    _enum: {
424      Complete: 'u64',
425      Incomplete: '(u64,XcmV2TraitsError)',
426      Error: 'XcmV2TraitsError'
427    }
428  },
429  /**
430   * Lookup45: xcm::v1::multilocation::MultiLocation
431   **/
432  XcmV1MultiLocation: {
433    parents: 'u8',
434    interior: 'XcmV1MultilocationJunctions'
435  },
436  /**
437   * Lookup46: xcm::v1::multilocation::Junctions
438   **/
439  XcmV1MultilocationJunctions: {
440    _enum: {
441      Here: 'Null',
442      X1: 'XcmV1Junction',
443      X2: '(XcmV1Junction,XcmV1Junction)',
444      X3: '(XcmV1Junction,XcmV1Junction,XcmV1Junction)',
445      X4: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
446      X5: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
447      X6: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
448      X7: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
449      X8: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)'
450    }
451  },
452  /**
453   * Lookup47: xcm::v1::junction::Junction
454   **/
455  XcmV1Junction: {
456    _enum: {
457      Parachain: 'Compact<u32>',
458      AccountId32: {
459        network: 'XcmV0JunctionNetworkId',
460        id: '[u8;32]',
461      },
462      AccountIndex64: {
463        network: 'XcmV0JunctionNetworkId',
464        index: 'Compact<u64>',
465      },
466      AccountKey20: {
467        network: 'XcmV0JunctionNetworkId',
468        key: '[u8;20]',
469      },
470      PalletInstance: 'u8',
471      GeneralIndex: 'Compact<u128>',
472      GeneralKey: 'Bytes',
473      OnlyChild: 'Null',
474      Plurality: {
475        id: 'XcmV0JunctionBodyId',
476        part: 'XcmV0JunctionBodyPart'
477      }
478    }
479  },
480  /**
481   * Lookup49: xcm::v0::junction::NetworkId
482   **/
483  XcmV0JunctionNetworkId: {
484    _enum: {
485      Any: 'Null',
486      Named: 'Bytes',
487      Polkadot: 'Null',
488      Kusama: 'Null'
489    }
490  },
491  /**
492   * Lookup53: xcm::v0::junction::BodyId
493   **/
494  XcmV0JunctionBodyId: {
495    _enum: {
496      Unit: 'Null',
497      Named: 'Bytes',
498      Index: 'Compact<u32>',
499      Executive: 'Null',
500      Technical: 'Null',
501      Legislative: 'Null',
502      Judicial: 'Null'
503    }
504  },
505  /**
506   * Lookup54: xcm::v0::junction::BodyPart
507   **/
508  XcmV0JunctionBodyPart: {
509    _enum: {
510      Voice: 'Null',
511      Members: {
512        count: 'Compact<u32>',
513      },
514      Fraction: {
515        nom: 'Compact<u32>',
516        denom: 'Compact<u32>',
517      },
518      AtLeastProportion: {
519        nom: 'Compact<u32>',
520        denom: 'Compact<u32>',
521      },
522      MoreThanProportion: {
523        nom: 'Compact<u32>',
524        denom: 'Compact<u32>'
525      }
526    }
527  },
528  /**
529   * Lookup55: xcm::v2::Xcm<Call>
530   **/
531  XcmV2Xcm: 'Vec<XcmV2Instruction>',
532  /**
533   * Lookup57: xcm::v2::Instruction<Call>
534   **/
535  XcmV2Instruction: {
536    _enum: {
537      WithdrawAsset: 'XcmV1MultiassetMultiAssets',
538      ReserveAssetDeposited: 'XcmV1MultiassetMultiAssets',
539      ReceiveTeleportedAsset: 'XcmV1MultiassetMultiAssets',
540      QueryResponse: {
541        queryId: 'Compact<u64>',
542        response: 'XcmV2Response',
543        maxWeight: 'Compact<u64>',
544      },
545      TransferAsset: {
546        assets: 'XcmV1MultiassetMultiAssets',
547        beneficiary: 'XcmV1MultiLocation',
548      },
549      TransferReserveAsset: {
550        assets: 'XcmV1MultiassetMultiAssets',
551        dest: 'XcmV1MultiLocation',
552        xcm: 'XcmV2Xcm',
553      },
554      Transact: {
555        originType: 'XcmV0OriginKind',
556        requireWeightAtMost: 'Compact<u64>',
557        call: 'XcmDoubleEncoded',
558      },
559      HrmpNewChannelOpenRequest: {
560        sender: 'Compact<u32>',
561        maxMessageSize: 'Compact<u32>',
562        maxCapacity: 'Compact<u32>',
563      },
564      HrmpChannelAccepted: {
565        recipient: 'Compact<u32>',
566      },
567      HrmpChannelClosing: {
568        initiator: 'Compact<u32>',
569        sender: 'Compact<u32>',
570        recipient: 'Compact<u32>',
571      },
572      ClearOrigin: 'Null',
573      DescendOrigin: 'XcmV1MultilocationJunctions',
574      ReportError: {
575        queryId: 'Compact<u64>',
576        dest: 'XcmV1MultiLocation',
577        maxResponseWeight: 'Compact<u64>',
578      },
579      DepositAsset: {
580        assets: 'XcmV1MultiassetMultiAssetFilter',
581        maxAssets: 'Compact<u32>',
582        beneficiary: 'XcmV1MultiLocation',
583      },
584      DepositReserveAsset: {
585        assets: 'XcmV1MultiassetMultiAssetFilter',
586        maxAssets: 'Compact<u32>',
587        dest: 'XcmV1MultiLocation',
588        xcm: 'XcmV2Xcm',
589      },
590      ExchangeAsset: {
591        give: 'XcmV1MultiassetMultiAssetFilter',
592        receive: 'XcmV1MultiassetMultiAssets',
593      },
594      InitiateReserveWithdraw: {
595        assets: 'XcmV1MultiassetMultiAssetFilter',
596        reserve: 'XcmV1MultiLocation',
597        xcm: 'XcmV2Xcm',
598      },
599      InitiateTeleport: {
600        assets: 'XcmV1MultiassetMultiAssetFilter',
601        dest: 'XcmV1MultiLocation',
602        xcm: 'XcmV2Xcm',
603      },
604      QueryHolding: {
605        queryId: 'Compact<u64>',
606        dest: 'XcmV1MultiLocation',
607        assets: 'XcmV1MultiassetMultiAssetFilter',
608        maxResponseWeight: 'Compact<u64>',
609      },
610      BuyExecution: {
611        fees: 'XcmV1MultiAsset',
612        weightLimit: 'XcmV2WeightLimit',
613      },
614      RefundSurplus: 'Null',
615      SetErrorHandler: 'XcmV2Xcm',
616      SetAppendix: 'XcmV2Xcm',
617      ClearError: 'Null',
618      ClaimAsset: {
619        assets: 'XcmV1MultiassetMultiAssets',
620        ticket: 'XcmV1MultiLocation',
621      },
622      Trap: 'Compact<u64>',
623      SubscribeVersion: {
624        queryId: 'Compact<u64>',
625        maxResponseWeight: 'Compact<u64>',
626      },
627      UnsubscribeVersion: 'Null'
628    }
629  },
630  /**
631   * Lookup58: xcm::v1::multiasset::MultiAssets
632   **/
633  XcmV1MultiassetMultiAssets: 'Vec<XcmV1MultiAsset>',
634  /**
635   * Lookup60: xcm::v1::multiasset::MultiAsset
636   **/
637  XcmV1MultiAsset: {
638    id: 'XcmV1MultiassetAssetId',
639    fun: 'XcmV1MultiassetFungibility'
640  },
641  /**
642   * Lookup61: xcm::v1::multiasset::AssetId
643   **/
644  XcmV1MultiassetAssetId: {
645    _enum: {
646      Concrete: 'XcmV1MultiLocation',
647      Abstract: 'Bytes'
648    }
649  },
650  /**
651   * Lookup62: xcm::v1::multiasset::Fungibility
652   **/
653  XcmV1MultiassetFungibility: {
654    _enum: {
655      Fungible: 'Compact<u128>',
656      NonFungible: 'XcmV1MultiassetAssetInstance'
657    }
658  },
659  /**
660   * Lookup63: xcm::v1::multiasset::AssetInstance
661   **/
662  XcmV1MultiassetAssetInstance: {
663    _enum: {
664      Undefined: 'Null',
665      Index: 'Compact<u128>',
666      Array4: '[u8;4]',
667      Array8: '[u8;8]',
668      Array16: '[u8;16]',
669      Array32: '[u8;32]',
670      Blob: 'Bytes'
671    }
672  },
673  /**
674   * Lookup66: xcm::v2::Response
675   **/
676  XcmV2Response: {
677    _enum: {
678      Null: 'Null',
679      Assets: 'XcmV1MultiassetMultiAssets',
680      ExecutionResult: 'Option<(u32,XcmV2TraitsError)>',
681      Version: 'u32'
682    }
683  },
684  /**
685   * Lookup69: xcm::v0::OriginKind
686   **/
687  XcmV0OriginKind: {
688    _enum: ['Native', 'SovereignAccount', 'Superuser', 'Xcm']
689  },
690  /**
691   * Lookup70: xcm::double_encoded::DoubleEncoded<T>
692   **/
693  XcmDoubleEncoded: {
694    encoded: 'Bytes'
695  },
696  /**
697   * Lookup71: xcm::v1::multiasset::MultiAssetFilter
698   **/
699  XcmV1MultiassetMultiAssetFilter: {
700    _enum: {
701      Definite: 'XcmV1MultiassetMultiAssets',
702      Wild: 'XcmV1MultiassetWildMultiAsset'
703    }
704  },
705  /**
706   * Lookup72: xcm::v1::multiasset::WildMultiAsset
707   **/
708  XcmV1MultiassetWildMultiAsset: {
709    _enum: {
710      All: 'Null',
711      AllOf: {
712        id: 'XcmV1MultiassetAssetId',
713        fun: 'XcmV1MultiassetWildFungibility'
714      }
715    }
716  },
717  /**
718   * Lookup73: xcm::v1::multiasset::WildFungibility
719   **/
720  XcmV1MultiassetWildFungibility: {
721    _enum: ['Fungible', 'NonFungible']
722  },
723  /**
724   * Lookup74: xcm::v2::WeightLimit
725   **/
726  XcmV2WeightLimit: {
727    _enum: {
728      Unlimited: 'Null',
729      Limited: 'Compact<u64>'
730    }
731  },
732  /**
733   * Lookup76: xcm::VersionedMultiAssets
734   **/
735  XcmVersionedMultiAssets: {
736    _enum: {
737      V0: 'Vec<XcmV0MultiAsset>',
738      V1: 'XcmV1MultiassetMultiAssets'
739    }
740  },
741  /**
742   * Lookup78: xcm::v0::multi_asset::MultiAsset
743   **/
744  XcmV0MultiAsset: {
745    _enum: {
746      None: 'Null',
747      All: 'Null',
748      AllFungible: 'Null',
749      AllNonFungible: 'Null',
750      AllAbstractFungible: {
751        id: 'Bytes',
752      },
753      AllAbstractNonFungible: {
754        class: 'Bytes',
755      },
756      AllConcreteFungible: {
757        id: 'XcmV0MultiLocation',
758      },
759      AllConcreteNonFungible: {
760        class: 'XcmV0MultiLocation',
761      },
762      AbstractFungible: {
763        id: 'Bytes',
764        amount: 'Compact<u128>',
765      },
766      AbstractNonFungible: {
767        class: 'Bytes',
768        instance: 'XcmV1MultiassetAssetInstance',
769      },
770      ConcreteFungible: {
771        id: 'XcmV0MultiLocation',
772        amount: 'Compact<u128>',
773      },
774      ConcreteNonFungible: {
775        class: 'XcmV0MultiLocation',
776        instance: 'XcmV1MultiassetAssetInstance'
777      }
778    }
779  },
780  /**
781   * Lookup79: xcm::v0::multi_location::MultiLocation
782   **/
783  XcmV0MultiLocation: {
784    _enum: {
785      Null: 'Null',
786      X1: 'XcmV0Junction',
787      X2: '(XcmV0Junction,XcmV0Junction)',
788      X3: '(XcmV0Junction,XcmV0Junction,XcmV0Junction)',
789      X4: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
790      X5: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
791      X6: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
792      X7: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
793      X8: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)'
794    }
795  },
796  /**
797   * Lookup80: xcm::v0::junction::Junction
798   **/
799  XcmV0Junction: {
800    _enum: {
801      Parent: 'Null',
802      Parachain: 'Compact<u32>',
803      AccountId32: {
804        network: 'XcmV0JunctionNetworkId',
805        id: '[u8;32]',
806      },
807      AccountIndex64: {
808        network: 'XcmV0JunctionNetworkId',
809        index: 'Compact<u64>',
810      },
811      AccountKey20: {
812        network: 'XcmV0JunctionNetworkId',
813        key: '[u8;20]',
814      },
815      PalletInstance: 'u8',
816      GeneralIndex: 'Compact<u128>',
817      GeneralKey: 'Bytes',
818      OnlyChild: 'Null',
819      Plurality: {
820        id: 'XcmV0JunctionBodyId',
821        part: 'XcmV0JunctionBodyPart'
822      }
823    }
824  },
825  /**
826   * Lookup81: xcm::VersionedMultiLocation
827   **/
828  XcmVersionedMultiLocation: {
829    _enum: {
830      V0: 'XcmV0MultiLocation',
831      V1: 'XcmV1MultiLocation'
832    }
833  },
834  /**
835   * Lookup82: cumulus_pallet_xcm::pallet::Event<T>
836   **/
837  CumulusPalletXcmEvent: {
838    _enum: {
839      InvalidFormat: '[u8;8]',
840      UnsupportedVersion: '[u8;8]',
841      ExecutedDownward: '([u8;8],XcmV2TraitsOutcome)'
842    }
843  },
844  /**
845   * Lookup83: cumulus_pallet_dmp_queue::pallet::Event<T>
846   **/
847  CumulusPalletDmpQueueEvent: {
848    _enum: {
849      InvalidFormat: {
850        messageId: '[u8;32]',
851      },
852      UnsupportedVersion: {
853        messageId: '[u8;32]',
854      },
855      ExecutedDownward: {
856        messageId: '[u8;32]',
857        outcome: 'XcmV2TraitsOutcome',
858      },
859      WeightExhausted: {
860        messageId: '[u8;32]',
861        remainingWeight: 'u64',
862        requiredWeight: 'u64',
863      },
864      OverweightEnqueued: {
865        messageId: '[u8;32]',
866        overweightIndex: 'u64',
867        requiredWeight: 'u64',
868      },
869      OverweightServiced: {
870        overweightIndex: 'u64',
871        weightUsed: 'u64'
872      }
873    }
874  },
875  /**
876   * Lookup84: pallet_unique::RawEvent<sp_core::crypto::AccountId32, pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
877   **/
878  PalletUniqueRawEvent: {
879    _enum: {
880      CollectionSponsorRemoved: 'u32',
881      CollectionAdminAdded: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
882      CollectionOwnedChanged: '(u32,AccountId32)',
883      CollectionSponsorSet: '(u32,AccountId32)',
884      SponsorshipConfirmed: '(u32,AccountId32)',
885      CollectionAdminRemoved: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
886      AllowListAddressRemoved: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
887      AllowListAddressAdded: '(u32,PalletEvmAccountBasicCrossAccountIdRepr)',
888      CollectionLimitSet: 'u32',
889      CollectionPermissionSet: 'u32'
890    }
891  },
892  /**
893   * Lookup85: pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>
894   **/
895  PalletEvmAccountBasicCrossAccountIdRepr: {
896    _enum: {
897      Substrate: 'AccountId32',
898      Ethereum: 'H160'
899    }
900  },
901  /**
902   * Lookup88: pallet_unique_scheduler::pallet::Event<T>
903   **/
904  PalletUniqueSchedulerEvent: {
905    _enum: {
906      Scheduled: {
907        when: 'u32',
908        index: 'u32',
909      },
910      Canceled: {
911        when: 'u32',
912        index: 'u32',
913      },
914      Dispatched: {
915        task: '(u32,u32)',
916        id: 'Option<[u8;16]>',
917        result: 'Result<Null, SpRuntimeDispatchError>',
918      },
919      CallLookupFailed: {
920        task: '(u32,u32)',
921        id: 'Option<[u8;16]>',
922        error: 'FrameSupportScheduleLookupError'
923      }
924    }
925  },
926  /**
927   * Lookup91: frame_support::traits::schedule::LookupError
928   **/
929  FrameSupportScheduleLookupError: {
930    _enum: ['Unknown', 'BadFormat']
931  },
932  /**
933   * Lookup92: pallet_common::pallet::Event<T>
934   **/
935  PalletCommonEvent: {
936    _enum: {
937      CollectionCreated: '(u32,u8,AccountId32)',
938      CollectionDestroyed: 'u32',
939      ItemCreated: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
940      ItemDestroyed: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
941      Transfer: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
942      Approved: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
943      CollectionPropertySet: '(u32,Bytes)',
944      CollectionPropertyDeleted: '(u32,Bytes)',
945      TokenPropertySet: '(u32,u32,Bytes)',
946      TokenPropertyDeleted: '(u32,u32,Bytes)',
947      PropertyPermissionSet: '(u32,Bytes)'
948    }
949  },
950  /**
951   * Lookup95: pallet_structure::pallet::Event<T>
952   **/
953  PalletStructureEvent: {
954    _enum: {
955      Executed: 'Result<Null, SpRuntimeDispatchError>'
956    }
957  },
958  /**
959   * Lookup96: pallet_rmrk_core::pallet::Event<T>
960   **/
961  PalletRmrkCoreEvent: {
962    _enum: {
963      CollectionCreated: {
964        issuer: 'AccountId32',
965        collectionId: 'u32',
966      },
967      CollectionDestroyed: {
968        issuer: 'AccountId32',
969        collectionId: 'u32',
970      },
971      IssuerChanged: {
972        oldIssuer: 'AccountId32',
973        newIssuer: 'AccountId32',
974        collectionId: 'u32',
975      },
976      CollectionLocked: {
977        issuer: 'AccountId32',
978        collectionId: 'u32',
979      },
980      NftMinted: {
981        owner: 'AccountId32',
982        collectionId: 'u32',
983        nftId: 'u32',
984      },
985      NFTBurned: {
986        owner: 'AccountId32',
987        nftId: 'u32',
988      },
989      NFTSent: {
990        sender: 'AccountId32',
991        recipient: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
992        collectionId: 'u32',
993        nftId: 'u32',
994        approvalRequired: 'bool',
995      },
996      NFTAccepted: {
997        sender: 'AccountId32',
998        recipient: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
999        collectionId: 'u32',
1000        nftId: 'u32',
1001      },
1002      NFTRejected: {
1003        sender: 'AccountId32',
1004        collectionId: 'u32',
1005        nftId: 'u32',
1006      },
1007      PropertySet: {
1008        collectionId: 'u32',
1009        maybeNftId: 'Option<u32>',
1010        key: 'Bytes',
1011        value: 'Bytes',
1012      },
1013      ResourceAdded: {
1014        nftId: 'u32',
1015        resourceId: 'u32',
1016      },
1017      ResourceRemoval: {
1018        nftId: 'u32',
1019        resourceId: 'u32',
1020      },
1021      ResourceAccepted: {
1022        nftId: 'u32',
1023        resourceId: 'u32',
1024      },
1025      ResourceRemovalAccepted: {
1026        nftId: 'u32',
1027        resourceId: 'u32',
1028      },
1029      PrioritySet: {
1030        collectionId: 'u32',
1031        nftId: 'u32'
1032      }
1033    }
1034  },
1035  /**
1036   * Lookup97: rmrk_traits::nft::AccountIdOrCollectionNftTuple<sp_core::crypto::AccountId32>
1037   **/
1038  RmrkTraitsNftAccountIdOrCollectionNftTuple: {
1039    _enum: {
1040      AccountId: 'AccountId32',
1041      CollectionAndNftTuple: '(u32,u32)'
1042    }
1043  },
1044  /**
1045   * Lookup102: pallet_rmrk_equip::pallet::Event<T>
1046   **/
1047  PalletRmrkEquipEvent: {
1048    _enum: {
1049      BaseCreated: {
1050        issuer: 'AccountId32',
1051        baseId: 'u32',
1052      },
1053      EquippablesUpdated: {
1054        baseId: 'u32',
1055        slotId: 'u32'
1056      }
1057    }
1058  },
1059  /**
1060   * Lookup103: pallet_evm::pallet::Event<T>
1061   **/
1062  PalletEvmEvent: {
1063    _enum: {
1064      Log: 'EthereumLog',
1065      Created: 'H160',
1066      CreatedFailed: 'H160',
1067      Executed: 'H160',
1068      ExecutedFailed: 'H160',
1069      BalanceDeposit: '(AccountId32,H160,U256)',
1070      BalanceWithdraw: '(AccountId32,H160,U256)'
1071    }
1072  },
1073  /**
1074   * Lookup104: ethereum::log::Log
1075   **/
1076  EthereumLog: {
1077    address: 'H160',
1078    topics: 'Vec<H256>',
1079    data: 'Bytes'
1080  },
1081  /**
1082   * Lookup108: pallet_ethereum::pallet::Event
1083   **/
1084  PalletEthereumEvent: {
1085    _enum: {
1086      Executed: '(H160,H160,H256,EvmCoreErrorExitReason)'
1087    }
1088  },
1089  /**
1090   * Lookup109: evm_core::error::ExitReason
1091   **/
1092  EvmCoreErrorExitReason: {
1093    _enum: {
1094      Succeed: 'EvmCoreErrorExitSucceed',
1095      Error: 'EvmCoreErrorExitError',
1096      Revert: 'EvmCoreErrorExitRevert',
1097      Fatal: 'EvmCoreErrorExitFatal'
1098    }
1099  },
1100  /**
1101   * Lookup110: evm_core::error::ExitSucceed
1102   **/
1103  EvmCoreErrorExitSucceed: {
1104    _enum: ['Stopped', 'Returned', 'Suicided']
1105  },
1106  /**
1107   * Lookup111: evm_core::error::ExitError
1108   **/
1109  EvmCoreErrorExitError: {
1110    _enum: {
1111      StackUnderflow: 'Null',
1112      StackOverflow: 'Null',
1113      InvalidJump: 'Null',
1114      InvalidRange: 'Null',
1115      DesignatedInvalid: 'Null',
1116      CallTooDeep: 'Null',
1117      CreateCollision: 'Null',
1118      CreateContractLimit: 'Null',
1119      OutOfOffset: 'Null',
1120      OutOfGas: 'Null',
1121      OutOfFund: 'Null',
1122      PCUnderflow: 'Null',
1123      CreateEmpty: 'Null',
1124      Other: 'Text',
1125      InvalidCode: 'Null'
1126    }
1127  },
1128  /**
1129   * Lookup114: evm_core::error::ExitRevert
1130   **/
1131  EvmCoreErrorExitRevert: {
1132    _enum: ['Reverted']
1133  },
1134  /**
1135   * Lookup115: evm_core::error::ExitFatal
1136   **/
1137  EvmCoreErrorExitFatal: {
1138    _enum: {
1139      NotSupported: 'Null',
1140      UnhandledInterrupt: 'Null',
1141      CallErrorAsFatal: 'EvmCoreErrorExitError',
1142      Other: 'Text'
1143    }
1144  },
1145  /**
1146   * Lookup116: frame_system::Phase
1147   **/
1148  FrameSystemPhase: {
1149    _enum: {
1150      ApplyExtrinsic: 'u32',
1151      Finalization: 'Null',
1152      Initialization: 'Null'
1153    }
1154  },
1155  /**
1156   * Lookup118: frame_system::LastRuntimeUpgradeInfo
1157   **/
1158  FrameSystemLastRuntimeUpgradeInfo: {
1159    specVersion: 'Compact<u32>',
1160    specName: 'Text'
1161  },
1162  /**
1163   * Lookup119: frame_system::pallet::Call<T>
1164   **/
1165  FrameSystemCall: {
1166    _enum: {
1167      fill_block: {
1168        ratio: 'Perbill',
1169      },
1170      remark: {
1171        remark: 'Bytes',
1172      },
1173      set_heap_pages: {
1174        pages: 'u64',
1175      },
1176      set_code: {
1177        code: 'Bytes',
1178      },
1179      set_code_without_checks: {
1180        code: 'Bytes',
1181      },
1182      set_storage: {
1183        items: 'Vec<(Bytes,Bytes)>',
1184      },
1185      kill_storage: {
1186        _alias: {
1187          keys_: 'keys',
1188        },
1189        keys_: 'Vec<Bytes>',
1190      },
1191      kill_prefix: {
1192        prefix: 'Bytes',
1193        subkeys: 'u32',
1194      },
1195      remark_with_event: {
1196        remark: 'Bytes'
1197      }
1198    }
1199  },
1200  /**
1201   * Lookup124: frame_system::limits::BlockWeights
1202   **/
1203  FrameSystemLimitsBlockWeights: {
1204    baseBlock: 'u64',
1205    maxBlock: 'u64',
1206    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'
1207  },
1208  /**
1209   * Lookup125: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>
1210   **/
1211  FrameSupportWeightsPerDispatchClassWeightsPerClass: {
1212    normal: 'FrameSystemLimitsWeightsPerClass',
1213    operational: 'FrameSystemLimitsWeightsPerClass',
1214    mandatory: 'FrameSystemLimitsWeightsPerClass'
1215  },
1216  /**
1217   * Lookup126: frame_system::limits::WeightsPerClass
1218   **/
1219  FrameSystemLimitsWeightsPerClass: {
1220    baseExtrinsic: 'u64',
1221    maxExtrinsic: 'Option<u64>',
1222    maxTotal: 'Option<u64>',
1223    reserved: 'Option<u64>'
1224  },
1225  /**
1226   * Lookup128: frame_system::limits::BlockLength
1227   **/
1228  FrameSystemLimitsBlockLength: {
1229    max: 'FrameSupportWeightsPerDispatchClassU32'
1230  },
1231  /**
1232   * Lookup129: frame_support::weights::PerDispatchClass<T>
1233   **/
1234  FrameSupportWeightsPerDispatchClassU32: {
1235    normal: 'u32',
1236    operational: 'u32',
1237    mandatory: 'u32'
1238  },
1239  /**
1240   * Lookup130: frame_support::weights::RuntimeDbWeight
1241   **/
1242  FrameSupportWeightsRuntimeDbWeight: {
1243    read: 'u64',
1244    write: 'u64'
1245  },
1246  /**
1247   * Lookup131: sp_version::RuntimeVersion
1248   **/
1249  SpVersionRuntimeVersion: {
1250    specName: 'Text',
1251    implName: 'Text',
1252    authoringVersion: 'u32',
1253    specVersion: 'u32',
1254    implVersion: 'u32',
1255    apis: 'Vec<([u8;8],u32)>',
1256    transactionVersion: 'u32',
1257    stateVersion: 'u8'
1258  },
1259  /**
1260   * Lookup136: frame_system::pallet::Error<T>
1261   **/
1262  FrameSystemError: {
1263    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']
1264  },
1265  /**
1266   * Lookup137: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>
1267   **/
1268  PolkadotPrimitivesV2PersistedValidationData: {10  PolkadotPrimitivesV2PersistedValidationData: {
1269    parentHead: 'Bytes',11    parentHead: 'Bytes',
1270    relayParentNumber: 'u32',12    relayParentNumber: 'u32',
1271    relayParentStorageRoot: 'H256',13    relayParentStorageRoot: 'H256',
1272    maxPovSize: 'u32'14    maxPovSize: 'u32'
1273  },15  },
1274  /**16  /**
1275   * Lookup140: polkadot_primitives::v2::UpgradeRestriction17   * Lookup9: polkadot_primitives::v2::UpgradeRestriction
1276   **/18   **/
1277  PolkadotPrimitivesV2UpgradeRestriction: {19  PolkadotPrimitivesV2UpgradeRestriction: {
1278    _enum: ['Present']20    _enum: ['Present']
1279  },21  },
1280  /**22  /**
1281   * Lookup141: sp_trie::storage_proof::StorageProof23   * Lookup10: sp_trie::storage_proof::StorageProof
1282   **/24   **/
1283  SpTrieStorageProof: {25  SpTrieStorageProof: {
1284    trieNodes: 'BTreeSet<Bytes>'26    trieNodes: 'BTreeSet<Bytes>'
1285  },27  },
1286  /**28  /**
1287   * Lookup143: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot29   * Lookup13: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot
1288   **/30   **/
1289  CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {31  CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {
1290    dmqMqcHead: 'H256',32    dmqMqcHead: 'H256',
1293    egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>'35    egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>'
1294  },36  },
1295  /**37  /**
1296   * Lookup146: polkadot_primitives::v2::AbridgedHrmpChannel38   * Lookup18: polkadot_primitives::v2::AbridgedHrmpChannel
1297   **/39   **/
1298  PolkadotPrimitivesV2AbridgedHrmpChannel: {40  PolkadotPrimitivesV2AbridgedHrmpChannel: {
1299    maxCapacity: 'u32',41    maxCapacity: 'u32',
1304    mqcHead: 'Option<H256>'46    mqcHead: 'Option<H256>'
1305  },47  },
1306  /**48  /**
1307   * Lookup147: polkadot_primitives::v2::AbridgedHostConfiguration49   * Lookup20: polkadot_primitives::v2::AbridgedHostConfiguration
1308   **/50   **/
1309  PolkadotPrimitivesV2AbridgedHostConfiguration: {51  PolkadotPrimitivesV2AbridgedHostConfiguration: {
1310    maxCodeSize: 'u32',52    maxCodeSize: 'u32',
1318    validationUpgradeDelay: 'u32'60    validationUpgradeDelay: 'u32'
1319  },61  },
1320  /**62  /**
1321   * Lookup153: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>63   * Lookup26: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>
1322   **/64   **/
1323  PolkadotCorePrimitivesOutboundHrmpMessage: {65  PolkadotCorePrimitivesOutboundHrmpMessage: {
1324    recipient: 'u32',66    recipient: 'u32',
1325    data: 'Bytes'67    data: 'Bytes'
1326  },68  },
1327  /**69  /**
1328   * Lookup154: cumulus_pallet_parachain_system::pallet::Call<T>70   * Lookup28: cumulus_pallet_parachain_system::pallet::Call<T>
1329   **/71   **/
1330  CumulusPalletParachainSystemCall: {72  CumulusPalletParachainSystemCall: {
1331    _enum: {73    _enum: {
1344    }86    }
1345  },87  },
1346  /**88  /**
1347   * Lookup155: cumulus_primitives_parachain_inherent::ParachainInherentData89   * Lookup29: cumulus_primitives_parachain_inherent::ParachainInherentData
1348   **/90   **/
1349  CumulusPrimitivesParachainInherentParachainInherentData: {91  CumulusPrimitivesParachainInherentParachainInherentData: {
1350    validationData: 'PolkadotPrimitivesV2PersistedValidationData',92    validationData: 'PolkadotPrimitivesV2PersistedValidationData',
1353    horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'95    horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'
1354  },96  },
1355  /**97  /**
1356   * Lookup157: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>98   * Lookup31: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>
1357   **/99   **/
1358  PolkadotCorePrimitivesInboundDownwardMessage: {100  PolkadotCorePrimitivesInboundDownwardMessage: {
1359    sentAt: 'u32',101    sentAt: 'u32',
1360    msg: 'Bytes'102    msg: 'Bytes'
1361  },103  },
1362  /**104  /**
1363   * Lookup160: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>105   * Lookup34: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>
1364   **/106   **/
1365  PolkadotCorePrimitivesInboundHrmpMessage: {107  PolkadotCorePrimitivesInboundHrmpMessage: {
1366    sentAt: 'u32',108    sentAt: 'u32',
1367    data: 'Bytes'109    data: 'Bytes'
1368  },110  },
1369  /**111  /**
1370   * Lookup163: cumulus_pallet_parachain_system::pallet::Error<T>112   * Lookup37: cumulus_pallet_parachain_system::pallet::Event<T>
1371   **/113   **/
114  CumulusPalletParachainSystemEvent: {
115    _enum: {
116      ValidationFunctionStored: 'Null',
117      ValidationFunctionApplied: {
118        relayChainBlockNum: 'u32',
119      },
120      ValidationFunctionDiscarded: 'Null',
121      UpgradeAuthorized: {
122        codeHash: 'H256',
123      },
124      DownwardMessagesReceived: {
125        count: 'u32',
126      },
127      DownwardMessagesProcessed: {
128        weightUsed: 'u64',
129        dmqHead: 'H256'
130      }
131    }
132  },
133  /**
134   * Lookup38: cumulus_pallet_parachain_system::pallet::Error<T>
135   **/
1372  CumulusPalletParachainSystemError: {136  CumulusPalletParachainSystemError: {
1373    _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']137    _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']
138  },
139  /**
140   * Lookup41: pallet_balances::AccountData<Balance>
141   **/
142  PalletBalancesAccountData: {
143    free: 'u128',
144    reserved: 'u128',
145    miscFrozen: 'u128',
146    feeFrozen: 'u128'
1374  },147  },
1375  /**148  /**
1376   * Lookup165: pallet_balances::BalanceLock<Balance>149   * Lookup43: pallet_balances::BalanceLock<Balance>
1377   **/150   **/
1378  PalletBalancesBalanceLock: {151  PalletBalancesBalanceLock: {
1379    id: '[u8;8]',152    id: '[u8;8]',
1380    amount: 'u128',153    amount: 'u128',
1381    reasons: 'PalletBalancesReasons'154    reasons: 'PalletBalancesReasons'
1382  },155  },
1383  /**156  /**
1384   * Lookup166: pallet_balances::Reasons157   * Lookup45: pallet_balances::Reasons
1385   **/158   **/
1386  PalletBalancesReasons: {159  PalletBalancesReasons: {
1387    _enum: ['Fee', 'Misc', 'All']160    _enum: ['Fee', 'Misc', 'All']
1388  },161  },
1389  /**162  /**
1390   * Lookup169: pallet_balances::ReserveData<ReserveIdentifier, Balance>163   * Lookup48: pallet_balances::ReserveData<ReserveIdentifier, Balance>
1391   **/164   **/
1392  PalletBalancesReserveData: {165  PalletBalancesReserveData: {
1393    id: '[u8;16]',166    id: '[u8;16]',
2706    _enum: ['Unknown', 'OverLimit']1479    _enum: ['Unknown', 'OverLimit']
2707  },1480  },
2708  /**1481  /**
2709   * Lookup347: pallet_unique::Error<T>1482   * Lookup346: pallet_unique::Error<T>
2710   **/1483   **/
2711  PalletUniqueError: {1484  PalletUniqueError: {
2712    _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection']1485    _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection']
2713  },1486  },
2714  /**1487  /**
2715   * Lookup350: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>1488   * Lookup349: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>
2716   **/1489   **/
2717  PalletUniqueSchedulerScheduledV3: {1490  PalletUniqueSchedulerScheduledV3: {
2718    maybeId: 'Option<[u8;16]>',1491    maybeId: 'Option<[u8;16]>',
2722    origin: 'OpalRuntimeOriginCaller'1495    origin: 'OpalRuntimeOriginCaller'
2723  },1496  },
2724  /**1497  /**
2725   * Lookup351: opal_runtime::OriginCaller1498   * Lookup350: opal_runtime::OriginCaller
2726   **/1499   **/
2727  OpalRuntimeOriginCaller: {1500  OpalRuntimeOriginCaller: {
2728    _enum: {1501    _enum: {
2831    }1604    }
2832  },1605  },
2833  /**1606  /**
2834   * Lookup352: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>1607   * Lookup351: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
2835   **/1608   **/
2836  FrameSupportDispatchRawOrigin: {1609  FrameSupportDispatchRawOrigin: {
2837    _enum: {1610    _enum: {
2841    }1614    }
2842  },1615  },
2843  /**1616  /**
2844   * Lookup353: pallet_xcm::pallet::Origin1617   * Lookup352: pallet_xcm::pallet::Origin
2845   **/1618   **/
2846  PalletXcmOrigin: {1619  PalletXcmOrigin: {
2847    _enum: {1620    _enum: {
2850    }1623    }
2851  },1624  },
2852  /**1625  /**
2853   * Lookup354: cumulus_pallet_xcm::pallet::Origin1626   * Lookup353: cumulus_pallet_xcm::pallet::Origin
2854   **/1627   **/
2855  CumulusPalletXcmOrigin: {1628  CumulusPalletXcmOrigin: {
2856    _enum: {1629    _enum: {
2859    }1632    }
2860  },1633  },
2861  /**1634  /**
2862   * Lookup355: pallet_ethereum::RawOrigin1635   * Lookup354: pallet_ethereum::RawOrigin
2863   **/1636   **/
2864  PalletEthereumRawOrigin: {1637  PalletEthereumRawOrigin: {
2865    _enum: {1638    _enum: {
2866      EthereumTransaction: 'H160'1639      EthereumTransaction: 'H160'
2867    }1640    }
2868  },1641  },
2869  /**1642  /**
2870   * Lookup356: sp_core::Void1643   * Lookup355: sp_core::Void
2871   **/1644   **/
2872  SpCoreVoid: 'Null',1645  SpCoreVoid: 'Null',
2873  /**1646  /**
2874   * Lookup357: pallet_unique_scheduler::pallet::Error<T>1647   * Lookup356: pallet_unique_scheduler::pallet::Error<T>
2875   **/1648   **/
2876  PalletUniqueSchedulerError: {1649  PalletUniqueSchedulerError: {
2877    _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']1650    _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']
2878  },1651  },
2879  /**1652  /**
2880   * Lookup358: up_data_structs::Collection<sp_core::crypto::AccountId32>1653   * Lookup357: up_data_structs::Collection<sp_core::crypto::AccountId32>
2881   **/1654   **/
2882  UpDataStructsCollection: {1655  UpDataStructsCollection: {
2883    owner: 'AccountId32',1656    owner: 'AccountId32',
2891    externalCollection: 'bool'1664    externalCollection: 'bool'
2892  },1665  },
2893  /**1666  /**
2894   * Lookup359: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>1667   * Lookup358: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>
2895   **/1668   **/
2896  UpDataStructsSponsorshipState: {1669  UpDataStructsSponsorshipState: {
2897    _enum: {1670    _enum: {
2901    }1674    }
2902  },1675  },
2903  /**1676  /**
2904   * Lookup360: up_data_structs::Properties1677   * Lookup359: up_data_structs::Properties
2905   **/1678   **/
2906  UpDataStructsProperties: {1679  UpDataStructsProperties: {
2907    map: 'UpDataStructsPropertiesMapBoundedVec',1680    map: 'UpDataStructsPropertiesMapBoundedVec',
2908    consumedSpace: 'u32',1681    consumedSpace: 'u32',
2909    spaceLimit: 'u32'1682    spaceLimit: 'u32'
2910  },1683  },
2911  /**1684  /**
2912   * Lookup361: up_data_structs::PropertiesMap<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1685   * Lookup360: up_data_structs::PropertiesMap<frame_support::storage::bounded_vec::BoundedVec<T, S>>
2913   **/1686   **/
2914  UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',1687  UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',
2915  /**1688  /**
2916   * Lookup366: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>1689   * Lookup366: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>
2917   **/1690   **/
2918  UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',1691  UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',
2919  /**1692  /**
2920   * Lookup373: up_data_structs::CollectionStats1693   * Lookup372: up_data_structs::CollectionStats
2921   **/1694   **/
2922  UpDataStructsCollectionStats: {1695  UpDataStructsCollectionStats: {
2923    created: 'u32',1696    created: 'u32',
2924    destroyed: 'u32',1697    destroyed: 'u32',
2925    alive: 'u32'1698    alive: 'u32'
2926  },1699  },
2927  /**1700  /**
2928   * Lookup374: up_data_structs::TokenChild1701   * Lookup373: up_data_structs::TokenChild
2929   **/1702   **/
2930  UpDataStructsTokenChild: {1703  UpDataStructsTokenChild: {
2931    token: 'u32',1704    token: 'u32',
2932    collection: 'u32'1705    collection: 'u32'
2933  },1706  },
2934  /**1707  /**
2935   * Lookup375: PhantomType::up_data_structs<T>1708   * Lookup374: PhantomType::up_data_structs<T>
2936   **/1709   **/
2937  PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]',1710  PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]',
2938  /**1711  /**
2939   * Lookup377: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>1712   * Lookup376: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
2940   **/1713   **/
2941  UpDataStructsTokenData: {1714  UpDataStructsTokenData: {
2942    properties: 'Vec<UpDataStructsProperty>',1715    properties: 'Vec<UpDataStructsProperty>',
2943    owner: 'Option<PalletEvmAccountBasicCrossAccountIdRepr>',1716    owner: 'Option<PalletEvmAccountBasicCrossAccountIdRepr>',
2944    pieces: 'u128'1717    pieces: 'u128'
2945  },1718  },
2946  /**1719  /**
2947   * Lookup379: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>1720   * Lookup378: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>
2948   **/1721   **/
2949  UpDataStructsRpcCollection: {1722  UpDataStructsRpcCollection: {
2950    owner: 'AccountId32',1723    owner: 'AccountId32',
2960    readOnly: 'bool'1733    readOnly: 'bool'
2961  },1734  },
2962  /**1735  /**
2963   * 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>1736   * 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>
2964   **/1737   **/
2965  RmrkTraitsCollectionCollectionInfo: {1738  RmrkTraitsCollectionCollectionInfo: {
2966    issuer: 'AccountId32',1739    issuer: 'AccountId32',
2970    nftsCount: 'u32'1743    nftsCount: 'u32'
2971  },1744  },
2972  /**1745  /**
2973   * Lookup381: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1746   * Lookup380: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, frame_support::storage::bounded_vec::BoundedVec<T, S>>
2974   **/1747   **/
2975  RmrkTraitsNftNftInfo: {1748  RmrkTraitsNftNftInfo: {
2976    owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',1749    owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',
2980    pending: 'bool'1753    pending: 'bool'
2981  },1754  },
2982  /**1755  /**
2983   * Lookup383: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>1756   * Lookup382: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>
2984   **/1757   **/
2985  RmrkTraitsNftRoyaltyInfo: {1758  RmrkTraitsNftRoyaltyInfo: {
2986    recipient: 'AccountId32',1759    recipient: 'AccountId32',
2987    amount: 'Permill'1760    amount: 'Permill'
2988  },1761  },
2989  /**1762  /**
2990   * Lookup384: rmrk_traits::resource::ResourceInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1763   * Lookup383: rmrk_traits::resource::ResourceInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
2991   **/1764   **/
2992  RmrkTraitsResourceResourceInfo: {1765  RmrkTraitsResourceResourceInfo: {
2993    id: 'u32',1766    id: 'u32',
2996    pendingRemoval: 'bool'1769    pendingRemoval: 'bool'
2997  },1770  },
2998  /**1771  /**
2999   * Lookup385: rmrk_traits::property::PropertyInfo<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1772   * Lookup384: rmrk_traits::property::PropertyInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
3000   **/1773   **/
3001  RmrkTraitsPropertyPropertyInfo: {1774  RmrkTraitsPropertyPropertyInfo: {
3002    key: 'Bytes',1775    key: 'Bytes',
3003    value: 'Bytes'1776    value: 'Bytes'
3004  },1777  },
3005  /**1778  /**
3006   * Lookup386: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1779   * Lookup385: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, frame_support::storage::bounded_vec::BoundedVec<T, S>>
3007   **/1780   **/
3008  RmrkTraitsBaseBaseInfo: {1781  RmrkTraitsBaseBaseInfo: {
3009    issuer: 'AccountId32',1782    issuer: 'AccountId32',
3010    baseType: 'Bytes',1783    baseType: 'Bytes',
3011    symbol: 'Bytes'1784    symbol: 'Bytes'
3012  },1785  },
3013  /**1786  /**
3014   * Lookup387: rmrk_traits::nft::NftChild1787   * Lookup386: rmrk_traits::nft::NftChild
3015   **/1788   **/
3016  RmrkTraitsNftNftChild: {1789  RmrkTraitsNftNftChild: {
3017    collectionId: 'u32',1790    collectionId: 'u32',
3018    nftId: 'u32'1791    nftId: 'u32'
3019  },1792  },
3020  /**1793  /**
3021   * Lookup389: pallet_common::pallet::Error<T>1794   * Lookup388: pallet_common::pallet::Error<T>
3022   **/1795   **/
3023  PalletCommonError: {1796  PalletCommonError: {
3024    _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']1797    _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']
3025  },1798  },
3026  /**1799  /**
3027   * Lookup391: pallet_fungible::pallet::Error<T>1800   * Lookup390: pallet_fungible::pallet::Error<T>
3028   **/1801   **/
3029  PalletFungibleError: {1802  PalletFungibleError: {
3030    _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']1803    _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
3031  },1804  },
3032  /**1805  /**
3033   * Lookup392: pallet_refungible::ItemData1806   * Lookup391: pallet_refungible::ItemData
3034   **/1807   **/
3035  PalletRefungibleItemData: {1808  PalletRefungibleItemData: {
3036    constData: 'Bytes'1809    constData: 'Bytes'
3037  },1810  },
3038  /**1811  /**
3039   * Lookup397: pallet_refungible::pallet::Error<T>1812   * Lookup394: pallet_refungible::pallet::Error<T>
3040   **/1813   **/
3041  PalletRefungibleError: {1814  PalletRefungibleError: {
3042    _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']1815    _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
3043  },1816  },
3044  /**1817  /**
3045   * Lookup398: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>1818   * Lookup395: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
3046   **/1819   **/
3047  PalletNonfungibleItemData: {1820  PalletNonfungibleItemData: {
3048    owner: 'PalletEvmAccountBasicCrossAccountIdRepr'1821    owner: 'PalletEvmAccountBasicCrossAccountIdRepr'
3049  },1822  },
3050  /**1823  /**
3051   * Lookup400: up_data_structs::PropertyScope1824   * Lookup397: up_data_structs::PropertyScope
3052   **/1825   **/
3053  UpDataStructsPropertyScope: {1826  UpDataStructsPropertyScope: {
3054    _enum: ['None', 'Rmrk', 'Eth']1827    _enum: ['None', 'Rmrk', 'Eth']
3055  },1828  },
3056  /**1829  /**
3057   * Lookup402: pallet_nonfungible::pallet::Error<T>1830   * Lookup399: pallet_nonfungible::pallet::Error<T>
3058   **/1831   **/
3059  PalletNonfungibleError: {1832  PalletNonfungibleError: {
3060    _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren']1833    _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren']
3061  },1834  },
3062  /**1835  /**
3063   * Lookup403: pallet_structure::pallet::Error<T>1836   * Lookup400: pallet_structure::pallet::Error<T>
3064   **/1837   **/
3065  PalletStructureError: {1838  PalletStructureError: {
3066    _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound']1839    _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound']
3067  },1840  },
3068  /**1841  /**
3069   * Lookup404: pallet_rmrk_core::pallet::Error<T>1842   * Lookup401: pallet_rmrk_core::pallet::Error<T>
3070   **/1843   **/
3071  PalletRmrkCoreError: {1844  PalletRmrkCoreError: {
3072    _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']1845    _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']
3073  },1846  },
3074  /**1847  /**
3075   * Lookup406: pallet_rmrk_equip::pallet::Error<T>1848   * Lookup403: pallet_rmrk_equip::pallet::Error<T>
3076   **/1849   **/
3077  PalletRmrkEquipError: {1850  PalletRmrkEquipError: {
3078    _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']1851    _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']
3079  },1852  },
3080  /**1853  /**
3081   * Lookup409: pallet_evm::pallet::Error<T>1854   * Lookup406: pallet_evm::pallet::Error<T>
3082   **/1855   **/
3083  PalletEvmError: {1856  PalletEvmError: {
3084    _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']1857    _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']
3085  },1858  },
3086  /**1859  /**
3087   * Lookup412: fp_rpc::TransactionStatus1860   * Lookup409: fp_rpc::TransactionStatus
3088   **/1861   **/
3089  FpRpcTransactionStatus: {1862  FpRpcTransactionStatus: {
3090    transactionHash: 'H256',1863    transactionHash: 'H256',
3096    logsBloom: 'EthbloomBloom'1869    logsBloom: 'EthbloomBloom'
3097  },1870  },
3098  /**1871  /**
3099   * Lookup414: ethbloom::Bloom1872   * Lookup411: ethbloom::Bloom
3100   **/1873   **/
3101  EthbloomBloom: '[u8;256]',1874  EthbloomBloom: '[u8;256]',
3102  /**1875  /**
3103   * Lookup416: ethereum::receipt::ReceiptV31876   * Lookup413: ethereum::receipt::ReceiptV3
3104   **/1877   **/
3105  EthereumReceiptReceiptV3: {1878  EthereumReceiptReceiptV3: {
3106    _enum: {1879    _enum: {
3110    }1883    }
3111  },1884  },
3112  /**1885  /**
3113   * Lookup417: ethereum::receipt::EIP658ReceiptData1886   * Lookup414: ethereum::receipt::EIP658ReceiptData
3114   **/1887   **/
3115  EthereumReceiptEip658ReceiptData: {1888  EthereumReceiptEip658ReceiptData: {
3116    statusCode: 'u8',1889    statusCode: 'u8',
3119    logs: 'Vec<EthereumLog>'1892    logs: 'Vec<EthereumLog>'
3120  },1893  },
3121  /**1894  /**
3122   * Lookup418: ethereum::block::Block<ethereum::transaction::TransactionV2>1895   * Lookup415: ethereum::block::Block<ethereum::transaction::TransactionV2>
3123   **/1896   **/
3124  EthereumBlock: {1897  EthereumBlock: {
3125    header: 'EthereumHeader',1898    header: 'EthereumHeader',
3126    transactions: 'Vec<EthereumTransactionTransactionV2>',1899    transactions: 'Vec<EthereumTransactionTransactionV2>',
3127    ommers: 'Vec<EthereumHeader>'1900    ommers: 'Vec<EthereumHeader>'
3128  },1901  },
3129  /**1902  /**
3130   * Lookup419: ethereum::header::Header1903   * Lookup416: ethereum::header::Header
3131   **/1904   **/
3132  EthereumHeader: {1905  EthereumHeader: {
3133    parentHash: 'H256',1906    parentHash: 'H256',
3147    nonce: 'EthereumTypesHashH64'1920    nonce: 'EthereumTypesHashH64'
3148  },1921  },
3149  /**1922  /**
3150   * Lookup420: ethereum_types::hash::H641923   * Lookup417: ethereum_types::hash::H64
3151   **/1924   **/
3152  EthereumTypesHashH64: '[u8;8]',1925  EthereumTypesHashH64: '[u8;8]',
3153  /**1926  /**
3154   * Lookup425: pallet_ethereum::pallet::Error<T>1927   * Lookup422: pallet_ethereum::pallet::Error<T>
3155   **/1928   **/
3156  PalletEthereumError: {1929  PalletEthereumError: {
3157    _enum: ['InvalidSignature', 'PreLogExists']1930    _enum: ['InvalidSignature', 'PreLogExists']
3158  },1931  },
3159  /**1932  /**
3160   * Lookup426: pallet_evm_coder_substrate::pallet::Error<T>1933   * Lookup423: pallet_evm_coder_substrate::pallet::Error<T>
3161   **/1934   **/
3162  PalletEvmCoderSubstrateError: {1935  PalletEvmCoderSubstrateError: {
3163    _enum: ['OutOfGas', 'OutOfFund']1936    _enum: ['OutOfGas', 'OutOfFund']
3164  },1937  },
3165  /**1938  /**
3166   * Lookup427: pallet_evm_contract_helpers::SponsoringModeT1939   * Lookup424: pallet_evm_contract_helpers::SponsoringModeT
3167   **/1940   **/
3168  PalletEvmContractHelpersSponsoringModeT: {1941  PalletEvmContractHelpersSponsoringModeT: {
3169    _enum: ['Disabled', 'Allowlisted', 'Generous']1942    _enum: ['Disabled', 'Allowlisted', 'Generous']
3170  },1943  },
3171  /**1944  /**
3172   * Lookup429: pallet_evm_contract_helpers::pallet::Error<T>1945   * Lookup426: pallet_evm_contract_helpers::pallet::Error<T>
3173   **/1946   **/
3174  PalletEvmContractHelpersError: {1947  PalletEvmContractHelpersError: {
3175    _enum: ['NoPermission']1948    _enum: ['NoPermission']
3176  },1949  },
3177  /**1950  /**
3178   * Lookup430: pallet_evm_migration::pallet::Error<T>1951   * Lookup427: pallet_evm_migration::pallet::Error<T>
3179   **/1952   **/
3180  PalletEvmMigrationError: {1953  PalletEvmMigrationError: {
3181    _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']1954    _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']
3182  },1955  },
3183  /**1956  /**
3184   * Lookup432: sp_runtime::MultiSignature1957   * Lookup429: sp_runtime::MultiSignature
3185   **/1958   **/
3186  SpRuntimeMultiSignature: {1959  SpRuntimeMultiSignature: {
3187    _enum: {1960    _enum: {
3191    }1964    }
3192  },1965  },
3193  /**1966  /**
3194   * Lookup433: sp_core::ed25519::Signature1967   * Lookup430: sp_core::ed25519::Signature
3195   **/1968   **/
3196  SpCoreEd25519Signature: '[u8;64]',1969  SpCoreEd25519Signature: '[u8;64]',
3197  /**1970  /**
3198   * Lookup435: sp_core::sr25519::Signature1971   * Lookup434: sp_core::sr25519::Signature
3199   **/1972   **/
3200  SpCoreSr25519Signature: '[u8;64]',1973  SpCoreSr25519Signature: '[u8;64]',
3201  /**1974  /**
3202   * Lookup436: sp_core::ecdsa::Signature1975   * Lookup435: sp_core::ecdsa::Signature
3203   **/1976   **/
3204  SpCoreEcdsaSignature: '[u8;65]',1977  SpCoreEcdsaSignature: '[u8;65]',
3205  /**1978  /**
3206   * Lookup439: frame_system::extensions::check_spec_version::CheckSpecVersion<T>1979   * Lookup438: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
3207   **/1980   **/
3208  FrameSystemExtensionsCheckSpecVersion: 'Null',1981  FrameSystemExtensionsCheckSpecVersion: 'Null',
3209  /**1982  /**
3210   * Lookup440: frame_system::extensions::check_genesis::CheckGenesis<T>1983   * Lookup439: frame_system::extensions::check_genesis::CheckGenesis<T>
3211   **/1984   **/
3212  FrameSystemExtensionsCheckGenesis: 'Null',1985  FrameSystemExtensionsCheckGenesis: 'Null',
3213  /**1986  /**
3214   * Lookup443: frame_system::extensions::check_nonce::CheckNonce<T>1987   * Lookup442: frame_system::extensions::check_nonce::CheckNonce<T>
3215   **/1988   **/
3216  FrameSystemExtensionsCheckNonce: 'Compact<u32>',1989  FrameSystemExtensionsCheckNonce: 'Compact<u32>',
3217  /**1990  /**
3218   * Lookup444: frame_system::extensions::check_weight::CheckWeight<T>1991   * Lookup443: frame_system::extensions::check_weight::CheckWeight<T>
3219   **/1992   **/
3220  FrameSystemExtensionsCheckWeight: 'Null',1993  FrameSystemExtensionsCheckWeight: 'Null',
3221  /**1994  /**
3222   * Lookup445: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>1995   * Lookup444: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
3223   **/1996   **/
3224  PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',1997  PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
3225  /**1998  /**
3226   * Lookup446: opal_runtime::Runtime1999   * Lookup445: opal_runtime::Runtime
3227   **/2000   **/
3228  OpalRuntimeRuntime: 'Null',2001  OpalRuntimeRuntime: 'Null',
3229  /**2002  /**
3230   * Lookup447: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>2003   * Lookup444: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
3231   **/2004   **/
3232  PalletEthereumFakeTransactionFinalizer: 'Null'2005  PalletEthereumFakeTransactionFinalizer: 'Null'
3233};2006};