From c0afeb64e72926e2c31574aa47ecad00adf2bd4d Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Tue, 08 Nov 2022 09:01:49 +0000 Subject: [PATCH] Merge pull request #705 from UniqueNetwork/feature/maintenance-mode --- --- a/Cargo.lock +++ b/Cargo.lock @@ -5374,6 +5374,7 @@ "pallet-foreign-assets", "pallet-fungible", "pallet-inflation", + "pallet-maintenance", "pallet-nonfungible", "pallet-randomness-collective-flip", "pallet-refungible", @@ -6250,6 +6251,18 @@ ] [[package]] +name = "pallet-maintenance" +version = "0.1.0" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec 3.2.1", + "scale-info", + "sp-std", +] + +[[package]] name = "pallet-membership" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate?branch=polkadot-v0.9.30#a3ed0119c45cdd0d571ad34e5b3ee7518c8cef8d" @@ -8834,6 +8847,7 @@ "pallet-foreign-assets", "pallet-fungible", "pallet-inflation", + "pallet-maintenance", "pallet-nonfungible", "pallet-randomness-collective-flip", "pallet-refungible", @@ -12964,6 +12978,7 @@ "pallet-foreign-assets", "pallet-fungible", "pallet-inflation", + "pallet-maintenance", "pallet-nonfungible", "pallet-randomness-collective-flip", "pallet-refungible", --- /dev/null +++ b/pallets/maintenance/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = "pallet-maintenance" +version = "0.1.0" +authors = ["Unique Network "] +edition = "2021" +license = "GPLv3" +homepage = "https://unique.network" +repository = "https://github.com/UniqueNetwork/unique-chain" +description = "Unique Maintenance pallet" +readme = "README.md" + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.1.1", default-features = false, features = ["derive"] } +frame-support = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" } +frame-system = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" } +frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" } +sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" } + +[features] +default = ["std"] +std = [ + "codec/std", + "scale-info/std", + "frame-support/std", + "frame-system/std", + "frame-benchmarking/std", + "sp-std/std", +] +runtime-benchmarks = [ + "frame-benchmarking", + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", +] +try-runtime = ["frame-support/try-runtime"] --- /dev/null +++ b/pallets/maintenance/src/benchmarking.rs @@ -0,0 +1,37 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +use super::*; +use crate::{Pallet as Maintenance, Config}; + +use frame_benchmarking::benchmarks; +use frame_system::RawOrigin; +use frame_support::ensure; + +benchmarks! { + enable { + }: _(RawOrigin::Root) + verify { + ensure!(>::get(), "didn't enable the MM"); + } + + disable { + Maintenance::::enable(RawOrigin::Root.into())?; + }: _(RawOrigin::Root) + verify { + ensure!(!>::get(), "didn't disable the MM"); + } +} --- /dev/null +++ b/pallets/maintenance/src/lib.rs @@ -0,0 +1,80 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +#![cfg_attr(not(feature = "std"), no_std)] + +pub use pallet::*; + +#[cfg(feature = "runtime-benchmarks")] +pub mod benchmarking; + +pub mod weights; + +#[frame_support::pallet] +pub mod pallet { + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; + use crate::weights::WeightInfo; + + #[pallet::config] + pub trait Config: frame_system::Config { + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + type WeightInfo: WeightInfo; + } + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + MaintenanceEnabled, + MaintenanceDisabled, + } + + #[pallet::pallet] + #[pallet::generate_store(pub(super) trait Store)] + pub struct Pallet(_); + + #[pallet::storage] + #[pallet::getter(fn is_enabled)] + pub type Enabled = StorageValue<_, bool, ValueQuery>; + + #[pallet::error] + pub enum Error {} + + #[pallet::call] + impl Pallet { + #[pallet::weight(::WeightInfo::enable())] + pub fn enable(origin: OriginFor) -> DispatchResult { + ensure_root(origin)?; + + >::set(true); + + Self::deposit_event(Event::MaintenanceEnabled); + + Ok(()) + } + + #[pallet::weight(::WeightInfo::disable())] + pub fn disable(origin: OriginFor) -> DispatchResult { + ensure_root(origin)?; + + >::set(false); + + Self::deposit_event(Event::MaintenanceDisabled); + + Ok(()) + } + } +} --- /dev/null +++ b/pallets/maintenance/src/weights.rs @@ -0,0 +1,67 @@ +// Template adopted from https://github.com/paritytech/substrate/blob/master/.maintain/frame-weight-template.hbs + +//! Autogenerated weights for pallet_maintenance +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2022-11-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024 + +// Executed Command: +// target/release/unique-collator +// benchmark +// pallet +// --pallet +// pallet-maintenance +// --wasm-execution +// compiled +// --extrinsic +// * +// --template +// .maintain/frame-weight-template.hbs +// --steps=50 +// --repeat=80 +// --heap-pages=4096 +// --output=./pallets/maintenance/src/weights.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(clippy::unnecessary_cast)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_maintenance. +pub trait WeightInfo { + fn enable() -> Weight; + fn disable() -> Weight; +} + +/// Weights for pallet_maintenance using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl WeightInfo for SubstrateWeight { + // Storage: Maintenance Enabled (r:0 w:1) + fn enable() -> Weight { + Weight::from_ref_time(7_367_000) + .saturating_add(T::DbWeight::get().writes(1)) + } + // Storage: Maintenance Enabled (r:0 w:1) + fn disable() -> Weight { + Weight::from_ref_time(7_273_000) + .saturating_add(T::DbWeight::get().writes(1)) + } +} + +// For backwards compatibility and tests +impl WeightInfo for () { + // Storage: Maintenance Enabled (r:0 w:1) + fn enable() -> Weight { + Weight::from_ref_time(7_367_000) + .saturating_add(RocksDbWeight::get().writes(1)) + } + // Storage: Maintenance Enabled (r:0 w:1) + fn disable() -> Weight { + Weight::from_ref_time(7_273_000) + .saturating_add(RocksDbWeight::get().writes(1)) + } +} --- a/runtime/common/config/pallets/mod.rs +++ b/runtime/common/config/pallets/mod.rs @@ -103,3 +103,8 @@ type DefaultWeightToFeeCoefficient = ConstU32<{ up_common::constants::WEIGHT_TO_FEE_COEFF }>; type DefaultMinGasPrice = ConstU64<{ up_common::constants::MIN_GAS_PRICE }>; } + +impl pallet_maintenance::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = pallet_maintenance::weights::SubstrateWeight; +} --- a/runtime/common/construct_runtime/mod.rs +++ b/runtime/common/construct_runtime/mod.rs @@ -94,6 +94,8 @@ EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152, EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153, + Maintenance: pallet_maintenance::{Pallet, Call, Storage, Event} = 154, + #[runtimes(opal)] TestUtils: pallet_test_utils = 255, } --- a/runtime/common/ethereum/self_contained_call.rs +++ b/runtime/common/ethereum/self_contained_call.rs @@ -17,9 +17,9 @@ use sp_core::H160; use sp_runtime::{ traits::{Dispatchable, DispatchInfoOf, PostDispatchInfoOf}, - transaction_validity::{TransactionValidityError, TransactionValidity}, + transaction_validity::{TransactionValidityError, TransactionValidity, InvalidTransaction}, }; -use crate::{RuntimeOrigin, RuntimeCall}; +use crate::{RuntimeOrigin, RuntimeCall, Maintenance}; impl fp_self_contained::SelfContainedCall for RuntimeCall { type SignedInfo = H160; @@ -33,7 +33,15 @@ fn check_self_contained(&self) -> Option> { match self { - RuntimeCall::Ethereum(call) => call.check_self_contained(), + RuntimeCall::Ethereum(call) => { + if Maintenance::is_enabled() { + Some(Err(TransactionValidityError::Invalid( + InvalidTransaction::Call, + ))) + } else { + call.check_self_contained() + } + } _ => None, } } @@ -45,7 +53,15 @@ len: usize, ) -> Option { match self { - RuntimeCall::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len), + RuntimeCall::Ethereum(call) => { + if Maintenance::is_enabled() { + Some(Err(TransactionValidityError::Invalid( + InvalidTransaction::Call, + ))) + } else { + call.validate_self_contained(info, dispatch_info, len) + } + } _ => None, } } --- /dev/null +++ b/runtime/common/maintenance.rs @@ -0,0 +1,122 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +use scale_info::TypeInfo; +use codec::{Encode, Decode}; +use up_common::types::AccountId; +use crate::{RuntimeCall, Maintenance}; + +use sp_runtime::{ + traits::{DispatchInfoOf, SignedExtension}, + transaction_validity::{ + TransactionValidity, ValidTransaction, InvalidTransaction, TransactionValidityError, + }, +}; + +#[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)] +pub struct CheckMaintenance; + +impl SignedExtension for CheckMaintenance { + type AccountId = AccountId; + type Call = RuntimeCall; + type AdditionalSigned = (); + type Pre = (); + + const IDENTIFIER: &'static str = "CheckMaintenance"; + + fn additional_signed(&self) -> Result { + Ok(()) + } + + fn pre_dispatch( + self, + who: &Self::AccountId, + call: &Self::Call, + info: &DispatchInfoOf, + len: usize, + ) -> Result { + self.validate(who, call, info, len).map(|_| ()) + } + + fn validate( + &self, + _who: &Self::AccountId, + call: &Self::Call, + _info: &DispatchInfoOf, + _len: usize, + ) -> TransactionValidity { + if Maintenance::is_enabled() { + match call { + RuntimeCall::EvmMigration(_) + | RuntimeCall::EVM(_) + | RuntimeCall::Ethereum(_) + | RuntimeCall::Inflation(_) + | RuntimeCall::Structure(_) + | RuntimeCall::Unique(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)), + + #[cfg(feature = "scheduler")] + RuntimeCall::Scheduler(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)), + + #[cfg(feature = "rmrk")] + RuntimeCall::RmrkCore(_) | RuntimeCall::RmrkEquip(_) => { + Err(TransactionValidityError::Invalid(InvalidTransaction::Call)) + } + + #[cfg(feature = "app-promotion")] + RuntimeCall::AppPromotion(_) => { + Err(TransactionValidityError::Invalid(InvalidTransaction::Call)) + } + + #[cfg(feature = "foreign-assets")] + RuntimeCall::ForeignAssets(_) => { + Err(TransactionValidityError::Invalid(InvalidTransaction::Call)) + } + + #[cfg(feature = "pallet-test-utils")] + RuntimeCall::TestUtils(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)), + + _ => Ok(ValidTransaction::default()), + } + } else { + Ok(ValidTransaction::default()) + } + } + + fn pre_dispatch_unsigned( + call: &Self::Call, + info: &DispatchInfoOf, + len: usize, + ) -> Result<(), TransactionValidityError> { + Self::validate_unsigned(call, info, len).map(|_| ()) + } + + fn validate_unsigned( + call: &Self::Call, + _info: &DispatchInfoOf, + _len: usize, + ) -> TransactionValidity { + if Maintenance::is_enabled() { + match call { + RuntimeCall::EVM(_) | RuntimeCall::Ethereum(_) | RuntimeCall::EvmMigration(_) => { + Err(TransactionValidityError::Invalid(InvalidTransaction::Call)) + } + _ => Ok(ValidTransaction::default()), + } + } else { + Ok(ValidTransaction::default()) + } + } +} --- a/runtime/common/mod.rs +++ b/runtime/common/mod.rs @@ -19,6 +19,7 @@ pub mod dispatch; pub mod ethereum; pub mod instance; +pub mod maintenance; pub mod runtime_apis; #[cfg(feature = "scheduler")] @@ -90,6 +91,7 @@ frame_system::CheckEra, frame_system::CheckNonce, frame_system::CheckWeight, + maintenance::CheckMaintenance, ChargeTransactionPayment, //pallet_contract_helpers::ContractHelpersExtension, pallet_ethereum::FakeTransactionFinalizer, --- a/runtime/common/scheduler.rs +++ b/runtime/common/scheduler.rs @@ -25,7 +25,7 @@ DispatchErrorWithPostInfo, DispatchError, }; use codec::Encode; -use crate::{Runtime, RuntimeCall, RuntimeOrigin, Balances}; +use crate::{Runtime, RuntimeCall, RuntimeOrigin, Balances, maintenance}; use up_common::types::{AccountId, Balance}; use fp_self_contained::SelfContainedCall; use pallet_unique_scheduler::DispatchCall; @@ -41,6 +41,7 @@ frame_system::CheckEra, frame_system::CheckNonce, frame_system::CheckWeight, + maintenance::CheckMaintenance, ChargeTransactionPayment, ); @@ -53,6 +54,7 @@ from, )), frame_system::CheckWeight::::new(), + maintenance::CheckMaintenance, ChargeTransactionPayment::::from(0), ) } --- a/runtime/opal/Cargo.toml +++ b/runtime/opal/Cargo.toml @@ -45,6 +45,7 @@ 'pallet-xcm/runtime-benchmarks', 'sp-runtime/runtime-benchmarks', 'xcm-builder/runtime-benchmarks', + 'pallet-maintenance/runtime-benchmarks', ] try-runtime = [ 'frame-try-runtime', @@ -88,6 +89,7 @@ 'pallet-evm-contract-helpers/try-runtime', 'pallet-evm-transaction-payment/try-runtime', 'pallet-evm-migration/try-runtime', + 'pallet-maintenance/try-runtime', 'pallet-test-utils?/try-runtime', ] std = [ @@ -169,6 +171,7 @@ "orml-traits/std", "pallet-foreign-assets/std", + 'pallet-maintenance/std', 'pallet-test-utils?/std', ] limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing'] @@ -485,6 +488,7 @@ evm-coder = { default-features = false, path = '../../crates/evm-coder' } up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.30' } pallet-foreign-assets = { default-features = false, path = "../../pallets/foreign-assets" } +pallet-maintenance = { default-features = false, path = "../../pallets/maintenance" } ################################################################################ # Test dependencies --- a/runtime/quartz/Cargo.toml +++ b/runtime/quartz/Cargo.toml @@ -44,6 +44,7 @@ 'pallet-xcm/runtime-benchmarks', 'sp-runtime/runtime-benchmarks', 'xcm-builder/runtime-benchmarks', + 'pallet-maintenance/runtime-benchmarks', ] try-runtime = [ 'frame-try-runtime', @@ -87,6 +88,7 @@ 'pallet-evm-contract-helpers/try-runtime', 'pallet-evm-transaction-payment/try-runtime', 'pallet-evm-migration/try-runtime', + 'pallet-maintenance/try-runtime', ] std = [ 'codec/std', @@ -165,6 +167,7 @@ "orml-xtokens/std", "orml-traits/std", "pallet-foreign-assets/std", + "pallet-maintenance/std", ] limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing'] quartz-runtime = ['refungible'] @@ -487,6 +490,7 @@ evm-coder = { default-features = false, path = '../../crates/evm-coder' } up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.30' } pallet-foreign-assets = { default-features = false, path = "../../pallets/foreign-assets" } +pallet-maintenance = { default-features = false, path = "../../pallets/maintenance" } ################################################################################ # Other Dependencies --- a/runtime/unique/Cargo.toml +++ b/runtime/unique/Cargo.toml @@ -45,6 +45,7 @@ 'sp-runtime/runtime-benchmarks', 'xcm-builder/runtime-benchmarks', 'up-data-structs/runtime-benchmarks', + 'pallet-maintenance/runtime-benchmarks', ] try-runtime = [ 'frame-try-runtime', @@ -88,6 +89,7 @@ 'pallet-evm-contract-helpers/try-runtime', 'pallet-evm-transaction-payment/try-runtime', 'pallet-evm-migration/try-runtime', + 'pallet-maintenance/try-runtime', ] std = [ 'codec/std', @@ -166,6 +168,7 @@ "orml-xtokens/std", "orml-traits/std", "pallet-foreign-assets/std", + "pallet-maintenance/std", ] limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing'] unique-runtime = [] @@ -482,6 +485,7 @@ evm-coder = { default-features = false, path = '../../crates/evm-coder' } up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.30' } pallet-foreign-assets = { default-features = false, path = "../../pallets/foreign-assets" } +pallet-maintenance = { default-features = false, path = "../../pallets/maintenance" } ################################################################################ # Other Dependencies --- a/tests/package.json +++ b/tests/package.json @@ -70,7 +70,7 @@ "testBurnItem": "mocha --timeout 9999999 -r ts-node/register ./**/burnItem.test.ts", "testAdminTransferAndBurn": "mocha --timeout 9999999 -r ts-node/register ./**/adminTransferAndBurn.test.ts", "testSetPermissions": "mocha --timeout 9999999 -r ts-node/register ./**/setPermissions.test.ts", - "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts", + "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.seqtest.ts", "testContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/eth/contractSponsoring.test.ts", "testEnableContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/enableContractSponsoring.test.ts", "testRemoveFromContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractAllowList.test.ts", @@ -78,8 +78,9 @@ "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts", "testNextSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/nextSponsoring.test.ts", "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts", - "testInflation": "mocha --timeout 9999999 -r ts-node/register ./**/inflation.test.ts", - "testScheduler": "mocha --timeout 9999999 -r ts-node/register ./**/scheduler.test.ts", + "testMaintenance": "mocha --timeout 9999999 -r ts-node/register ./**/maintenanceMode.seqtest.ts", + "testInflation": "mocha --timeout 9999999 -r ts-node/register ./**/inflation.seqtest.ts", + "testScheduler": "mocha --timeout 9999999 -r ts-node/register ./**/scheduler.seqtest.ts", "testSchedulingEVM": "mocha --timeout 9999999 -r ts-node/register ./**/eth/scheduling.test.ts", "testPalletPresence": "mocha --timeout 9999999 -r ts-node/register ./**/pallet-presence.test.ts", "testBlockProduction": "mocha --timeout 9999999 -r ts-node/register ./**/block-production.test.ts", @@ -93,7 +94,7 @@ "testFT": "mocha --timeout 9999999 -r ts-node/register ./**/fungible.test.ts", "testEthFT": "mocha --timeout 9999999 -r ts-node/register ./**/eth/fungible.test.ts", "testRPC": "mocha --timeout 9999999 -r ts-node/register ./**/rpc.test.ts", - "testPromotion": "yarn setup && mocha --timeout 9999999 -r ts-node/register ./**/app-promotion.test.ts", + "testPromotion": "yarn setup && mocha --timeout 9999999 -r ts-node/register ./**/app-promotion.*test.ts", "testXcmUnique": "RUN_XCM_TESTS=1 mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmUnique.test.ts", "testXcmQuartz": "RUN_XCM_TESTS=1 mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmQuartz.test.ts", "testXcmOpal": "RUN_XCM_TESTS=1 mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmOpal.test.ts", --- a/tests/src/interfaces/augment-api-consts.ts +++ b/tests/src/interfaces/augment-api-consts.ts @@ -8,7 +8,7 @@ import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types'; import type { Option, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { Codec } from '@polkadot/types-codec/types'; -import type { Perbill, Permill } from '@polkadot/types/interfaces/runtime'; +import type { Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime'; import type { FrameSupportPalletId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, XcmV1MultiLocation } from '@polkadot/types/lookup'; export type __AugmentedConst = AugmentedConst; @@ -92,6 +92,22 @@ **/ [key: string]: Codec; }; + scheduler: { + /** + * The maximum weight that may be scheduled per block for any dispatchables of less + * priority than `schedule::HARD_DEADLINE`. + **/ + maximumWeight: Weight & AugmentedConst; + /** + * The maximum number of scheduled calls in the queue for a single block. + * Not strictly enforced, but used for weight estimation. + **/ + maxScheduledPerBlock: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; system: { /** * Maximum number of block number to block hash mappings to keep (oldest pruned first). --- a/tests/src/interfaces/augment-api-errors.ts +++ b/tests/src/interfaces/augment-api-errors.ts @@ -374,6 +374,12 @@ **/ [key: string]: AugmentedError; }; + maintenance: { + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; nonfungible: { /** * Unable to burn NFT with children @@ -636,6 +642,28 @@ **/ [key: string]: AugmentedError; }; + scheduler: { + /** + * Failed to schedule a call + **/ + FailedToSchedule: AugmentedError; + /** + * Cannot find the scheduled call. + **/ + NotFound: AugmentedError; + /** + * Reschedule failed because it does not change scheduled time. + **/ + RescheduleNoChange: AugmentedError; + /** + * Given target block number is in the past. + **/ + TargetBlockNumberInPast: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; structure: { /** * While nesting, reached the breadth limit of nesting, exceeding the provided budget. @@ -702,6 +730,14 @@ **/ [key: string]: AugmentedError; }; + testUtils: { + TestPalletDisabled: AugmentedError; + TriggerRollback: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; tokens: { /** * Cannot convert Amount into Balance type --- a/tests/src/interfaces/augment-api-events.ts +++ b/tests/src/interfaces/augment-api-events.ts @@ -7,8 +7,9 @@ import type { ApiTypes, AugmentedEvent } from '@polkadot/api-base/types'; import type { Bytes, Null, Option, Result, U256, U8aFixed, bool, u128, u32, u64, u8 } from '@polkadot/types-codec'; +import type { ITuple } from '@polkadot/types-codec/types'; import type { AccountId32, H160, H256, Weight } from '@polkadot/types/interfaces/runtime'; -import type { EthereumLog, EvmCoreErrorExitReason, FrameSupportDispatchDispatchInfo, FrameSupportTokensMiscBalanceStatus, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, SpRuntimeDispatchError, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetMultiAssets, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; +import type { EthereumLog, EvmCoreErrorExitReason, FrameSupportDispatchDispatchInfo, FrameSupportScheduleLookupError, FrameSupportTokensMiscBalanceStatus, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, SpRuntimeDispatchError, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetMultiAssets, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; export type __AugmentedEvent = AugmentedEvent; @@ -285,6 +286,14 @@ **/ [key: string]: AugmentedEvent; }; + maintenance: { + MaintenanceDisabled: AugmentedEvent; + MaintenanceEnabled: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; parachainSystem: { /** * Downward messages were processed using the given weight. @@ -466,6 +475,32 @@ **/ [key: string]: AugmentedEvent; }; + scheduler: { + /** + * The call for the provided hash was not found so the task has been aborted. + **/ + CallLookupFailed: AugmentedEvent, id: Option, error: FrameSupportScheduleLookupError], { task: ITuple<[u32, u32]>, id: Option, error: FrameSupportScheduleLookupError }>; + /** + * Canceled some task. + **/ + Canceled: AugmentedEvent; + /** + * Dispatched some task. + **/ + Dispatched: AugmentedEvent, id: Option, result: Result], { task: ITuple<[u32, u32]>, id: Option, result: Result }>; + /** + * Scheduled task's priority has changed + **/ + PriorityChanged: AugmentedEvent; + /** + * Scheduled some task. + **/ + Scheduled: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; structure: { /** * Executed call on behalf of the token. @@ -524,6 +559,14 @@ **/ [key: string]: AugmentedEvent; }; + testUtils: { + ShouldRollback: AugmentedEvent; + ValueIsSet: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; tokens: { /** * A balance was set by root. --- a/tests/src/interfaces/augment-api-query.ts +++ b/tests/src/interfaces/augment-api-query.ts @@ -6,10 +6,10 @@ import '@polkadot/api-base/types/storage'; import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types'; -import type { BTreeMap, Bytes, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { BTreeMap, Bytes, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; import type { AccountId32, H160, H256, Weight } from '@polkadot/types/interfaces/runtime'; -import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, XcmV1MultiLocation } from '@polkadot/types/lookup'; +import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletUniqueSchedulerScheduledV3, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, XcmV1MultiLocation } from '@polkadot/types/lookup'; import type { Observable } from '@polkadot/types/types'; export type __AugmentedQuery = AugmentedQuery unknown>; @@ -389,6 +389,13 @@ **/ [key: string]: QueryableStorageEntry; }; + maintenance: { + enabled: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; nonfungible: { /** * Amount of tokens owned by an account in a collection. @@ -670,6 +677,20 @@ **/ [key: string]: QueryableStorageEntry; }; + scheduler: { + /** + * Items to be executed, indexed by the block number that they should be executed on. + **/ + agenda: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + /** + * Lookup from identity to the block number and index of the task. + **/ + lookup: AugmentedQuery Observable>>, [U8aFixed]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; structure: { /** * Generic query @@ -772,6 +793,14 @@ **/ [key: string]: QueryableStorageEntry; }; + testUtils: { + enabled: AugmentedQuery Observable, []> & QueryableStorageEntry; + testValue: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; timestamp: { /** * Did the timestamp get updated in this block? --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -6,10 +6,10 @@ import '@polkadot/api-base/types/submittable'; import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types'; -import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types'; import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime'; -import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; +import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>; export type __SubmittableExtrinsic = SubmittableExtrinsic; @@ -332,6 +332,14 @@ **/ [key: string]: SubmittableExtrinsicFunction; }; + maintenance: { + disable: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + enable: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; parachainSystem: { authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; @@ -821,6 +829,29 @@ **/ [key: string]: SubmittableExtrinsicFunction; }; + scheduler: { + /** + * Cancel a named scheduled task. + **/ + cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic, [U8aFixed]>; + changeNamedPriority: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [U8aFixed, u8]>; + /** + * Schedule a named task. + **/ + scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: Option | null | Uint8Array | u8 | AnyNumber, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [U8aFixed, u32, Option>, Option, FrameSupportScheduleMaybeHashed]>; + /** + * Schedule a named task after a delay. + * + * # + * Same as [`schedule_named`](Self::schedule_named). + * # + **/ + scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: Option | null | Uint8Array | u8 | AnyNumber, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [U8aFixed, u32, Option>, Option, FrameSupportScheduleMaybeHashed]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; structure: { /** * Generic tx @@ -954,6 +985,18 @@ **/ [key: string]: SubmittableExtrinsicFunction; }; + testUtils: { + enable: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + selfCancelingInc: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, maxTestValue: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [U8aFixed, u32]>; + setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; timestamp: { /** * Set the current time. --- a/tests/src/interfaces/augment-types.ts +++ b/tests/src/interfaces/augment-types.ts @@ -5,7 +5,7 @@ // this is required to allow for ambient/previous definitions import '@polkadot/types/types/registry'; -import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchDispatchClass, FrameSupportDispatchDispatchInfo, FrameSupportDispatchPays, FrameSupportDispatchPerDispatchClassU32, FrameSupportDispatchPerDispatchClassWeight, FrameSupportDispatchPerDispatchClassWeightsPerClass, FrameSupportPalletId, FrameSupportTokensMiscBalanceStatus, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensModuleCall, OrmlTokensModuleError, OrmlTokensModuleEvent, OrmlTokensReserveData, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, OrmlXtokensModuleCall, OrmlXtokensModuleError, OrmlXtokensModuleEvent, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersEvent, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletForeignAssetsModuleCall, PalletForeignAssetsModuleError, PalletForeignAssetsModuleEvent, PalletForeignAssetsNativeCurrency, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsRpcCollectionFlags, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipStateAccountId32, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './default'; +import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchDispatchClass, FrameSupportDispatchDispatchInfo, FrameSupportDispatchPays, FrameSupportDispatchPerDispatchClassU32, FrameSupportDispatchPerDispatchClassWeight, FrameSupportDispatchPerDispatchClassWeightsPerClass, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensModuleCall, OrmlTokensModuleError, OrmlTokensModuleEvent, OrmlTokensReserveData, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, OrmlXtokensModuleCall, OrmlXtokensModuleError, OrmlXtokensModuleEvent, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersEvent, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletForeignAssetsModuleCall, PalletForeignAssetsModuleError, PalletForeignAssetsModuleEvent, PalletForeignAssetsNativeCurrency, PalletFungibleError, PalletInflationCall, PalletMaintenanceCall, PalletMaintenanceError, PalletMaintenanceEvent, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTestUtilsCall, PalletTestUtilsError, PalletTestUtilsEvent, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsRpcCollectionFlags, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipStateAccountId32, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './default'; import type { Data, StorageKey } from '@polkadot/types'; import type { BitVec, Bool, Bytes, F32, F64, I128, I16, I256, I32, I64, I8, Json, Null, OptionBool, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, f32, f64, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec'; import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets'; @@ -328,6 +328,7 @@ CumulusPalletXcmCall: CumulusPalletXcmCall; CumulusPalletXcmError: CumulusPalletXcmError; CumulusPalletXcmEvent: CumulusPalletXcmEvent; + CumulusPalletXcmOrigin: CumulusPalletXcmOrigin; CumulusPalletXcmpQueueCall: CumulusPalletXcmpQueueCall; CumulusPalletXcmpQueueError: CumulusPalletXcmpQueueError; CumulusPalletXcmpQueueEvent: CumulusPalletXcmpQueueEvent; @@ -523,7 +524,10 @@ FrameSupportDispatchPerDispatchClassU32: FrameSupportDispatchPerDispatchClassU32; FrameSupportDispatchPerDispatchClassWeight: FrameSupportDispatchPerDispatchClassWeight; FrameSupportDispatchPerDispatchClassWeightsPerClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; + FrameSupportDispatchRawOrigin: FrameSupportDispatchRawOrigin; FrameSupportPalletId: FrameSupportPalletId; + FrameSupportScheduleLookupError: FrameSupportScheduleLookupError; + FrameSupportScheduleMaybeHashed: FrameSupportScheduleMaybeHashed; FrameSupportTokensMiscBalanceStatus: FrameSupportTokensMiscBalanceStatus; FrameSystemAccountInfo: FrameSystemAccountInfo; FrameSystemCall: FrameSystemCall; @@ -769,7 +773,9 @@ OffenceDetails: OffenceDetails; Offender: Offender; OldV1SessionInfo: OldV1SessionInfo; + OpalRuntimeOriginCaller: OpalRuntimeOriginCaller; OpalRuntimeRuntime: OpalRuntimeRuntime; + OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance: OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance; OpaqueCall: OpaqueCall; OpaqueKeyOwnershipProof: OpaqueKeyOwnershipProof; OpaqueMetadata: OpaqueMetadata; @@ -835,6 +841,7 @@ PalletEthereumError: PalletEthereumError; PalletEthereumEvent: PalletEthereumEvent; PalletEthereumFakeTransactionFinalizer: PalletEthereumFakeTransactionFinalizer; + PalletEthereumRawOrigin: PalletEthereumRawOrigin; PalletEventMetadataLatest: PalletEventMetadataLatest; PalletEventMetadataV14: PalletEventMetadataV14; PalletEvmAccountBasicCrossAccountIdRepr: PalletEvmAccountBasicCrossAccountIdRepr; @@ -856,6 +863,9 @@ PalletFungibleError: PalletFungibleError; PalletId: PalletId; PalletInflationCall: PalletInflationCall; + PalletMaintenanceCall: PalletMaintenanceCall; + PalletMaintenanceError: PalletMaintenanceError; + PalletMaintenanceEvent: PalletMaintenanceEvent; PalletMetadataLatest: PalletMetadataLatest; PalletMetadataV14: PalletMetadataV14; PalletNonfungibleError: PalletNonfungibleError; @@ -879,6 +889,9 @@ PalletSudoEvent: PalletSudoEvent; PalletTemplateTransactionPaymentCall: PalletTemplateTransactionPaymentCall; PalletTemplateTransactionPaymentChargeTransactionPayment: PalletTemplateTransactionPaymentChargeTransactionPayment; + PalletTestUtilsCall: PalletTestUtilsCall; + PalletTestUtilsError: PalletTestUtilsError; + PalletTestUtilsEvent: PalletTestUtilsEvent; PalletTimestampCall: PalletTimestampCall; PalletTransactionPaymentEvent: PalletTransactionPaymentEvent; PalletTransactionPaymentReleases: PalletTransactionPaymentReleases; @@ -889,10 +902,15 @@ PalletUniqueCall: PalletUniqueCall; PalletUniqueError: PalletUniqueError; PalletUniqueRawEvent: PalletUniqueRawEvent; + PalletUniqueSchedulerCall: PalletUniqueSchedulerCall; + PalletUniqueSchedulerError: PalletUniqueSchedulerError; + PalletUniqueSchedulerEvent: PalletUniqueSchedulerEvent; + PalletUniqueSchedulerScheduledV3: PalletUniqueSchedulerScheduledV3; PalletVersion: PalletVersion; PalletXcmCall: PalletXcmCall; PalletXcmError: PalletXcmError; PalletXcmEvent: PalletXcmEvent; + PalletXcmOrigin: PalletXcmOrigin; ParachainDispatchOrigin: ParachainDispatchOrigin; ParachainInherentData: ParachainInherentData; ParachainProposal: ParachainProposal; @@ -1166,6 +1184,7 @@ SpCoreEcdsaSignature: SpCoreEcdsaSignature; SpCoreEd25519Signature: SpCoreEd25519Signature; SpCoreSr25519Signature: SpCoreSr25519Signature; + SpCoreVoid: SpCoreVoid; SpecVersion: SpecVersion; SpRuntimeArithmeticError: SpRuntimeArithmeticError; SpRuntimeDigest: SpRuntimeDigest; --- a/tests/src/interfaces/default/types.ts +++ b/tests/src/interfaces/default/types.ts @@ -153,6 +153,14 @@ readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward'; } +/** @name CumulusPalletXcmOrigin */ +export interface CumulusPalletXcmOrigin extends Enum { + readonly isRelay: boolean; + readonly isSiblingParachain: boolean; + readonly asSiblingParachain: u32; + readonly type: 'Relay' | 'SiblingParachain'; +} + /** @name CumulusPalletXcmpQueueCall */ export interface CumulusPalletXcmpQueueCall extends Enum { readonly isServiceOverweight: boolean; @@ -536,9 +544,34 @@ readonly mandatory: FrameSystemLimitsWeightsPerClass; } +/** @name FrameSupportDispatchRawOrigin */ +export interface FrameSupportDispatchRawOrigin extends Enum { + readonly isRoot: boolean; + readonly isSigned: boolean; + readonly asSigned: AccountId32; + readonly isNone: boolean; + readonly type: 'Root' | 'Signed' | 'None'; +} + /** @name FrameSupportPalletId */ export interface FrameSupportPalletId extends U8aFixed {} +/** @name FrameSupportScheduleLookupError */ +export interface FrameSupportScheduleLookupError extends Enum { + readonly isUnknown: boolean; + readonly isBadFormat: boolean; + readonly type: 'Unknown' | 'BadFormat'; +} + +/** @name FrameSupportScheduleMaybeHashed */ +export interface FrameSupportScheduleMaybeHashed extends Enum { + readonly isValue: boolean; + readonly asValue: Call; + readonly isHash: boolean; + readonly asHash: H256; + readonly type: 'Value' | 'Hash'; +} + /** @name FrameSupportTokensMiscBalanceStatus */ export interface FrameSupportTokensMiscBalanceStatus extends Enum { readonly isFree: boolean; @@ -693,9 +726,27 @@ readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization'; } +/** @name OpalRuntimeOriginCaller */ +export interface OpalRuntimeOriginCaller extends Enum { + readonly isSystem: boolean; + readonly asSystem: FrameSupportDispatchRawOrigin; + readonly isVoid: boolean; + readonly asVoid: SpCoreVoid; + readonly isPolkadotXcm: boolean; + readonly asPolkadotXcm: PalletXcmOrigin; + readonly isCumulusXcm: boolean; + readonly asCumulusXcm: CumulusPalletXcmOrigin; + readonly isEthereum: boolean; + readonly asEthereum: PalletEthereumRawOrigin; + readonly type: 'System' | 'Void' | 'PolkadotXcm' | 'CumulusXcm' | 'Ethereum'; +} + /** @name OpalRuntimeRuntime */ export interface OpalRuntimeRuntime extends Null {} +/** @name OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance */ +export interface OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance extends Null {} + /** @name OrmlTokensAccountData */ export interface OrmlTokensAccountData extends Struct { readonly free: u128; @@ -1303,6 +1354,13 @@ /** @name PalletEthereumFakeTransactionFinalizer */ export interface PalletEthereumFakeTransactionFinalizer extends Null {} +/** @name PalletEthereumRawOrigin */ +export interface PalletEthereumRawOrigin extends Enum { + readonly isEthereumTransaction: boolean; + readonly asEthereumTransaction: H160; + readonly type: 'EthereumTransaction'; +} + /** @name PalletEvmAccountBasicCrossAccountIdRepr */ export interface PalletEvmAccountBasicCrossAccountIdRepr extends Enum { readonly isSubstrate: boolean; @@ -1543,6 +1601,23 @@ readonly type: 'StartInflation'; } +/** @name PalletMaintenanceCall */ +export interface PalletMaintenanceCall extends Enum { + readonly isEnable: boolean; + readonly isDisable: boolean; + readonly type: 'Enable' | 'Disable'; +} + +/** @name PalletMaintenanceError */ +export interface PalletMaintenanceError extends Null {} + +/** @name PalletMaintenanceEvent */ +export interface PalletMaintenanceEvent extends Enum { + readonly isMaintenanceEnabled: boolean; + readonly isMaintenanceDisabled: boolean; + readonly type: 'MaintenanceEnabled' | 'MaintenanceDisabled'; +} + /** @name PalletNonfungibleError */ export interface PalletNonfungibleError extends Enum { readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean; @@ -1911,6 +1986,41 @@ /** @name PalletTemplateTransactionPaymentChargeTransactionPayment */ export interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact {} +/** @name PalletTestUtilsCall */ +export interface PalletTestUtilsCall extends Enum { + readonly isEnable: boolean; + readonly isSetTestValue: boolean; + readonly asSetTestValue: { + readonly value: u32; + } & Struct; + readonly isSetTestValueAndRollback: boolean; + readonly asSetTestValueAndRollback: { + readonly value: u32; + } & Struct; + readonly isIncTestValue: boolean; + readonly isSelfCancelingInc: boolean; + readonly asSelfCancelingInc: { + readonly id: U8aFixed; + readonly maxTestValue: u32; + } & Struct; + readonly isJustTakeFee: boolean; + readonly type: 'Enable' | 'SetTestValue' | 'SetTestValueAndRollback' | 'IncTestValue' | 'SelfCancelingInc' | 'JustTakeFee'; +} + +/** @name PalletTestUtilsError */ +export interface PalletTestUtilsError extends Enum { + readonly isTestPalletDisabled: boolean; + readonly isTriggerRollback: boolean; + readonly type: 'TestPalletDisabled' | 'TriggerRollback'; +} + +/** @name PalletTestUtilsEvent */ +export interface PalletTestUtilsEvent extends Enum { + readonly isValueIsSet: boolean; + readonly isShouldRollback: boolean; + readonly type: 'ValueIsSet' | 'ShouldRollback'; +} + /** @name PalletTimestampCall */ export interface PalletTimestampCall extends Enum { readonly isSet: boolean; @@ -2217,6 +2327,87 @@ readonly type: 'CollectionSponsorRemoved' | 'CollectionAdminAdded' | 'CollectionOwnedChanged' | 'CollectionSponsorSet' | 'SponsorshipConfirmed' | 'CollectionAdminRemoved' | 'AllowListAddressRemoved' | 'AllowListAddressAdded' | 'CollectionLimitSet' | 'CollectionPermissionSet'; } +/** @name PalletUniqueSchedulerCall */ +export interface PalletUniqueSchedulerCall extends Enum { + readonly isScheduleNamed: boolean; + readonly asScheduleNamed: { + readonly id: U8aFixed; + readonly when: u32; + readonly maybePeriodic: Option>; + readonly priority: Option; + readonly call: FrameSupportScheduleMaybeHashed; + } & Struct; + readonly isCancelNamed: boolean; + readonly asCancelNamed: { + readonly id: U8aFixed; + } & Struct; + readonly isScheduleNamedAfter: boolean; + readonly asScheduleNamedAfter: { + readonly id: U8aFixed; + readonly after: u32; + readonly maybePeriodic: Option>; + readonly priority: Option; + readonly call: FrameSupportScheduleMaybeHashed; + } & Struct; + readonly isChangeNamedPriority: boolean; + readonly asChangeNamedPriority: { + readonly id: U8aFixed; + readonly priority: u8; + } & Struct; + readonly type: 'ScheduleNamed' | 'CancelNamed' | 'ScheduleNamedAfter' | 'ChangeNamedPriority'; +} + +/** @name PalletUniqueSchedulerError */ +export interface PalletUniqueSchedulerError extends Enum { + readonly isFailedToSchedule: boolean; + readonly isNotFound: boolean; + readonly isTargetBlockNumberInPast: boolean; + readonly isRescheduleNoChange: boolean; + readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange'; +} + +/** @name PalletUniqueSchedulerEvent */ +export interface PalletUniqueSchedulerEvent extends Enum { + readonly isScheduled: boolean; + readonly asScheduled: { + readonly when: u32; + readonly index: u32; + } & Struct; + readonly isCanceled: boolean; + readonly asCanceled: { + readonly when: u32; + readonly index: u32; + } & Struct; + readonly isPriorityChanged: boolean; + readonly asPriorityChanged: { + readonly when: u32; + readonly index: u32; + readonly priority: u8; + } & Struct; + readonly isDispatched: boolean; + readonly asDispatched: { + readonly task: ITuple<[u32, u32]>; + readonly id: Option; + readonly result: Result; + } & Struct; + readonly isCallLookupFailed: boolean; + readonly asCallLookupFailed: { + readonly task: ITuple<[u32, u32]>; + readonly id: Option; + readonly error: FrameSupportScheduleLookupError; + } & Struct; + readonly type: 'Scheduled' | 'Canceled' | 'PriorityChanged' | 'Dispatched' | 'CallLookupFailed'; +} + +/** @name PalletUniqueSchedulerScheduledV3 */ +export interface PalletUniqueSchedulerScheduledV3 extends Struct { + readonly maybeId: Option; + readonly priority: u8; + readonly call: FrameSupportScheduleMaybeHashed; + readonly maybePeriodic: Option>; + readonly origin: OpalRuntimeOriginCaller; +} + /** @name PalletXcmCall */ export interface PalletXcmCall extends Enum { readonly isSend: boolean; @@ -2334,6 +2525,15 @@ readonly type: 'Attempted' | 'Sent' | 'UnexpectedResponse' | 'ResponseReady' | 'Notified' | 'NotifyOverweight' | 'NotifyDispatchError' | 'NotifyDecodeFailed' | 'InvalidResponder' | 'InvalidResponderVersion' | 'ResponseTaken' | 'AssetsTrapped' | 'VersionChangeNotified' | 'SupportedVersionChanged' | 'NotifyTargetSendFail' | 'NotifyTargetMigrationFail'; } +/** @name PalletXcmOrigin */ +export interface PalletXcmOrigin extends Enum { + readonly isXcm: boolean; + readonly asXcm: XcmV1MultiLocation; + readonly isResponse: boolean; + readonly asResponse: XcmV1MultiLocation; + readonly type: 'Xcm' | 'Response'; +} + /** @name PhantomTypeUpDataStructs */ export interface PhantomTypeUpDataStructs extends Vec> {} @@ -2554,6 +2754,9 @@ /** @name SpCoreSr25519Signature */ export interface SpCoreSr25519Signature extends U8aFixed {} +/** @name SpCoreVoid */ +export interface SpCoreVoid extends Null {} + /** @name SpRuntimeArithmeticError */ export interface SpRuntimeArithmeticError extends Enum { readonly isUnderflow: boolean; --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -1004,8 +1004,44 @@ } }, /** - * Lookup93: pallet_common::pallet::Event + * Lookup93: pallet_unique_scheduler::pallet::Event **/ + PalletUniqueSchedulerEvent: { + _enum: { + Scheduled: { + when: 'u32', + index: 'u32', + }, + Canceled: { + when: 'u32', + index: 'u32', + }, + PriorityChanged: { + when: 'u32', + index: 'u32', + priority: 'u8', + }, + Dispatched: { + task: '(u32,u32)', + id: 'Option<[u8;16]>', + result: 'Result', + }, + CallLookupFailed: { + task: '(u32,u32)', + id: 'Option<[u8;16]>', + error: 'FrameSupportScheduleLookupError' + } + } + }, + /** + * Lookup96: frame_support::traits::schedule::LookupError + **/ + FrameSupportScheduleLookupError: { + _enum: ['Unknown', 'BadFormat'] + }, + /** + * Lookup97: pallet_common::pallet::Event + **/ PalletCommonEvent: { _enum: { CollectionCreated: '(u32,u8,AccountId32)', @@ -1022,7 +1058,7 @@ } }, /** - * Lookup96: pallet_structure::pallet::Event + * Lookup100: pallet_structure::pallet::Event **/ PalletStructureEvent: { _enum: { @@ -1030,7 +1066,7 @@ } }, /** - * Lookup97: pallet_rmrk_core::pallet::Event + * Lookup101: pallet_rmrk_core::pallet::Event **/ PalletRmrkCoreEvent: { _enum: { @@ -1107,7 +1143,7 @@ } }, /** - * Lookup98: rmrk_traits::nft::AccountIdOrCollectionNftTuple + * Lookup102: rmrk_traits::nft::AccountIdOrCollectionNftTuple **/ RmrkTraitsNftAccountIdOrCollectionNftTuple: { _enum: { @@ -1116,7 +1152,7 @@ } }, /** - * Lookup103: pallet_rmrk_equip::pallet::Event + * Lookup107: pallet_rmrk_equip::pallet::Event **/ PalletRmrkEquipEvent: { _enum: { @@ -1131,7 +1167,7 @@ } }, /** - * Lookup104: pallet_app_promotion::pallet::Event + * Lookup108: pallet_app_promotion::pallet::Event **/ PalletAppPromotionEvent: { _enum: { @@ -1142,7 +1178,7 @@ } }, /** - * Lookup105: pallet_foreign_assets::module::Event + * Lookup109: pallet_foreign_assets::module::Event **/ PalletForeignAssetsModuleEvent: { _enum: { @@ -1167,7 +1203,7 @@ } }, /** - * Lookup106: pallet_foreign_assets::module::AssetMetadata + * Lookup110: pallet_foreign_assets::module::AssetMetadata **/ PalletForeignAssetsModuleAssetMetadata: { name: 'Bytes', @@ -1176,7 +1212,7 @@ minimalBalance: 'u128' }, /** - * Lookup107: pallet_evm::pallet::Event + * Lookup111: pallet_evm::pallet::Event **/ PalletEvmEvent: { _enum: { @@ -1190,7 +1226,7 @@ } }, /** - * Lookup108: ethereum::log::Log + * Lookup112: ethereum::log::Log **/ EthereumLog: { address: 'H160', @@ -1198,7 +1234,7 @@ data: 'Bytes' }, /** - * Lookup112: pallet_ethereum::pallet::Event + * Lookup116: pallet_ethereum::pallet::Event **/ PalletEthereumEvent: { _enum: { @@ -1206,7 +1242,7 @@ } }, /** - * Lookup113: evm_core::error::ExitReason + * Lookup117: evm_core::error::ExitReason **/ EvmCoreErrorExitReason: { _enum: { @@ -1217,13 +1253,13 @@ } }, /** - * Lookup114: evm_core::error::ExitSucceed + * Lookup118: evm_core::error::ExitSucceed **/ EvmCoreErrorExitSucceed: { _enum: ['Stopped', 'Returned', 'Suicided'] }, /** - * Lookup115: evm_core::error::ExitError + * Lookup119: evm_core::error::ExitError **/ EvmCoreErrorExitError: { _enum: { @@ -1245,13 +1281,13 @@ } }, /** - * Lookup118: evm_core::error::ExitRevert + * Lookup122: evm_core::error::ExitRevert **/ EvmCoreErrorExitRevert: { _enum: ['Reverted'] }, /** - * Lookup119: evm_core::error::ExitFatal + * Lookup123: evm_core::error::ExitFatal **/ EvmCoreErrorExitFatal: { _enum: { @@ -1262,7 +1298,7 @@ } }, /** - * Lookup120: pallet_evm_contract_helpers::pallet::Event + * Lookup124: pallet_evm_contract_helpers::pallet::Event **/ PalletEvmContractHelpersEvent: { _enum: { @@ -1272,8 +1308,20 @@ } }, /** - * Lookup121: frame_system::Phase + * Lookup125: pallet_maintenance::pallet::Event **/ + PalletMaintenanceEvent: { + _enum: ['MaintenanceEnabled', 'MaintenanceDisabled'] + }, + /** + * Lookup126: pallet_test_utils::pallet::Event + **/ + PalletTestUtilsEvent: { + _enum: ['ValueIsSet', 'ShouldRollback'] + }, + /** + * Lookup127: frame_system::Phase + **/ FrameSystemPhase: { _enum: { ApplyExtrinsic: 'u32', @@ -1282,14 +1330,14 @@ } }, /** - * Lookup124: frame_system::LastRuntimeUpgradeInfo + * Lookup129: frame_system::LastRuntimeUpgradeInfo **/ FrameSystemLastRuntimeUpgradeInfo: { specVersion: 'Compact', specName: 'Text' }, /** - * Lookup125: frame_system::pallet::Call + * Lookup130: frame_system::pallet::Call **/ FrameSystemCall: { _enum: { @@ -1327,7 +1375,7 @@ } }, /** - * Lookup130: frame_system::limits::BlockWeights + * Lookup135: frame_system::limits::BlockWeights **/ FrameSystemLimitsBlockWeights: { baseBlock: 'Weight', @@ -1335,7 +1383,7 @@ perClass: 'FrameSupportDispatchPerDispatchClassWeightsPerClass' }, /** - * Lookup131: frame_support::dispatch::PerDispatchClass + * Lookup136: frame_support::dispatch::PerDispatchClass **/ FrameSupportDispatchPerDispatchClassWeightsPerClass: { normal: 'FrameSystemLimitsWeightsPerClass', @@ -1343,7 +1391,7 @@ mandatory: 'FrameSystemLimitsWeightsPerClass' }, /** - * Lookup132: frame_system::limits::WeightsPerClass + * Lookup137: frame_system::limits::WeightsPerClass **/ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: 'Weight', @@ -1352,13 +1400,13 @@ reserved: 'Option' }, /** - * Lookup134: frame_system::limits::BlockLength + * Lookup139: frame_system::limits::BlockLength **/ FrameSystemLimitsBlockLength: { max: 'FrameSupportDispatchPerDispatchClassU32' }, /** - * Lookup135: frame_support::dispatch::PerDispatchClass + * Lookup140: frame_support::dispatch::PerDispatchClass **/ FrameSupportDispatchPerDispatchClassU32: { normal: 'u32', @@ -1366,14 +1414,14 @@ mandatory: 'u32' }, /** - * Lookup136: sp_weights::RuntimeDbWeight + * Lookup141: sp_weights::RuntimeDbWeight **/ SpWeightsRuntimeDbWeight: { read: 'u64', write: 'u64' }, /** - * Lookup137: sp_version::RuntimeVersion + * Lookup142: sp_version::RuntimeVersion **/ SpVersionRuntimeVersion: { specName: 'Text', @@ -1386,13 +1434,13 @@ stateVersion: 'u8' }, /** - * Lookup142: frame_system::pallet::Error + * Lookup147: frame_system::pallet::Error **/ FrameSystemError: { _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered'] }, /** - * Lookup143: polkadot_primitives::v2::PersistedValidationData + * Lookup148: polkadot_primitives::v2::PersistedValidationData **/ PolkadotPrimitivesV2PersistedValidationData: { parentHead: 'Bytes', @@ -1401,19 +1449,19 @@ maxPovSize: 'u32' }, /** - * Lookup146: polkadot_primitives::v2::UpgradeRestriction + * Lookup151: polkadot_primitives::v2::UpgradeRestriction **/ PolkadotPrimitivesV2UpgradeRestriction: { _enum: ['Present'] }, /** - * Lookup147: sp_trie::storage_proof::StorageProof + * Lookup152: sp_trie::storage_proof::StorageProof **/ SpTrieStorageProof: { trieNodes: 'BTreeSet' }, /** - * Lookup149: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot + * Lookup154: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot **/ CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: { dmqMqcHead: 'H256', @@ -1422,7 +1470,7 @@ egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>' }, /** - * Lookup152: polkadot_primitives::v2::AbridgedHrmpChannel + * Lookup157: polkadot_primitives::v2::AbridgedHrmpChannel **/ PolkadotPrimitivesV2AbridgedHrmpChannel: { maxCapacity: 'u32', @@ -1433,7 +1481,7 @@ mqcHead: 'Option' }, /** - * Lookup153: polkadot_primitives::v2::AbridgedHostConfiguration + * Lookup158: polkadot_primitives::v2::AbridgedHostConfiguration **/ PolkadotPrimitivesV2AbridgedHostConfiguration: { maxCodeSize: 'u32', @@ -1447,14 +1495,14 @@ validationUpgradeDelay: 'u32' }, /** - * Lookup159: polkadot_core_primitives::OutboundHrmpMessage + * Lookup164: polkadot_core_primitives::OutboundHrmpMessage **/ PolkadotCorePrimitivesOutboundHrmpMessage: { recipient: 'u32', data: 'Bytes' }, /** - * Lookup160: cumulus_pallet_parachain_system::pallet::Call + * Lookup165: cumulus_pallet_parachain_system::pallet::Call **/ CumulusPalletParachainSystemCall: { _enum: { @@ -1473,7 +1521,7 @@ } }, /** - * Lookup161: cumulus_primitives_parachain_inherent::ParachainInherentData + * Lookup166: cumulus_primitives_parachain_inherent::ParachainInherentData **/ CumulusPrimitivesParachainInherentParachainInherentData: { validationData: 'PolkadotPrimitivesV2PersistedValidationData', @@ -1482,27 +1530,27 @@ horizontalMessages: 'BTreeMap>' }, /** - * Lookup163: polkadot_core_primitives::InboundDownwardMessage + * Lookup168: polkadot_core_primitives::InboundDownwardMessage **/ PolkadotCorePrimitivesInboundDownwardMessage: { sentAt: 'u32', msg: 'Bytes' }, /** - * Lookup166: polkadot_core_primitives::InboundHrmpMessage + * Lookup171: polkadot_core_primitives::InboundHrmpMessage **/ PolkadotCorePrimitivesInboundHrmpMessage: { sentAt: 'u32', data: 'Bytes' }, /** - * Lookup169: cumulus_pallet_parachain_system::pallet::Error + * Lookup174: cumulus_pallet_parachain_system::pallet::Error **/ CumulusPalletParachainSystemError: { _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized'] }, /** - * Lookup171: pallet_balances::BalanceLock + * Lookup176: pallet_balances::BalanceLock **/ PalletBalancesBalanceLock: { id: '[u8;8]', @@ -1510,26 +1558,26 @@ reasons: 'PalletBalancesReasons' }, /** - * Lookup172: pallet_balances::Reasons + * Lookup177: pallet_balances::Reasons **/ PalletBalancesReasons: { _enum: ['Fee', 'Misc', 'All'] }, /** - * Lookup175: pallet_balances::ReserveData + * Lookup180: pallet_balances::ReserveData **/ PalletBalancesReserveData: { id: '[u8;16]', amount: 'u128' }, /** - * Lookup177: pallet_balances::Releases + * Lookup182: pallet_balances::Releases **/ PalletBalancesReleases: { _enum: ['V1_0_0', 'V2_0_0'] }, /** - * Lookup178: pallet_balances::pallet::Call + * Lookup183: pallet_balances::pallet::Call **/ PalletBalancesCall: { _enum: { @@ -1562,13 +1610,13 @@ } }, /** - * Lookup181: pallet_balances::pallet::Error + * Lookup186: pallet_balances::pallet::Error **/ PalletBalancesError: { _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'KeepAlive', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves'] }, /** - * Lookup183: pallet_timestamp::pallet::Call + * Lookup188: pallet_timestamp::pallet::Call **/ PalletTimestampCall: { _enum: { @@ -1578,13 +1626,13 @@ } }, /** - * Lookup185: pallet_transaction_payment::Releases + * Lookup190: pallet_transaction_payment::Releases **/ PalletTransactionPaymentReleases: { _enum: ['V1Ancient', 'V2'] }, /** - * Lookup186: pallet_treasury::Proposal + * Lookup191: pallet_treasury::Proposal **/ PalletTreasuryProposal: { proposer: 'AccountId32', @@ -1593,7 +1641,7 @@ bond: 'u128' }, /** - * Lookup189: pallet_treasury::pallet::Call + * Lookup194: pallet_treasury::pallet::Call **/ PalletTreasuryCall: { _enum: { @@ -1617,17 +1665,17 @@ } }, /** - * Lookup192: frame_support::PalletId + * Lookup197: frame_support::PalletId **/ FrameSupportPalletId: '[u8;8]', /** - * Lookup193: pallet_treasury::pallet::Error + * Lookup198: pallet_treasury::pallet::Error **/ PalletTreasuryError: { _enum: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved'] }, /** - * Lookup194: pallet_sudo::pallet::Call + * Lookup199: pallet_sudo::pallet::Call **/ PalletSudoCall: { _enum: { @@ -1651,7 +1699,7 @@ } }, /** - * Lookup196: orml_vesting::module::Call + * Lookup201: orml_vesting::module::Call **/ OrmlVestingModuleCall: { _enum: { @@ -1670,7 +1718,7 @@ } }, /** - * Lookup198: orml_xtokens::module::Call + * Lookup203: orml_xtokens::module::Call **/ OrmlXtokensModuleCall: { _enum: { @@ -1713,7 +1761,7 @@ } }, /** - * Lookup199: xcm::VersionedMultiAsset + * Lookup204: xcm::VersionedMultiAsset **/ XcmVersionedMultiAsset: { _enum: { @@ -1722,7 +1770,7 @@ } }, /** - * Lookup202: orml_tokens::module::Call + * Lookup207: orml_tokens::module::Call **/ OrmlTokensModuleCall: { _enum: { @@ -1756,7 +1804,7 @@ } }, /** - * Lookup203: cumulus_pallet_xcmp_queue::pallet::Call + * Lookup208: cumulus_pallet_xcmp_queue::pallet::Call **/ CumulusPalletXcmpQueueCall: { _enum: { @@ -1805,7 +1853,7 @@ } }, /** - * Lookup204: pallet_xcm::pallet::Call + * Lookup209: pallet_xcm::pallet::Call **/ PalletXcmCall: { _enum: { @@ -1859,7 +1907,7 @@ } }, /** - * Lookup205: xcm::VersionedXcm + * Lookup210: xcm::VersionedXcm **/ XcmVersionedXcm: { _enum: { @@ -1869,7 +1917,7 @@ } }, /** - * Lookup206: xcm::v0::Xcm + * Lookup211: xcm::v0::Xcm **/ XcmV0Xcm: { _enum: { @@ -1923,7 +1971,7 @@ } }, /** - * Lookup208: xcm::v0::order::Order + * Lookup213: xcm::v0::order::Order **/ XcmV0Order: { _enum: { @@ -1966,7 +2014,7 @@ } }, /** - * Lookup210: xcm::v0::Response + * Lookup215: xcm::v0::Response **/ XcmV0Response: { _enum: { @@ -1974,7 +2022,7 @@ } }, /** - * Lookup211: xcm::v1::Xcm + * Lookup216: xcm::v1::Xcm **/ XcmV1Xcm: { _enum: { @@ -2033,7 +2081,7 @@ } }, /** - * Lookup213: xcm::v1::order::Order + * Lookup218: xcm::v1::order::Order **/ XcmV1Order: { _enum: { @@ -2078,7 +2126,7 @@ } }, /** - * Lookup215: xcm::v1::Response + * Lookup220: xcm::v1::Response **/ XcmV1Response: { _enum: { @@ -2087,11 +2135,11 @@ } }, /** - * Lookup229: cumulus_pallet_xcm::pallet::Call + * Lookup234: cumulus_pallet_xcm::pallet::Call **/ CumulusPalletXcmCall: 'Null', /** - * Lookup230: cumulus_pallet_dmp_queue::pallet::Call + * Lookup235: cumulus_pallet_dmp_queue::pallet::Call **/ CumulusPalletDmpQueueCall: { _enum: { @@ -2102,7 +2150,7 @@ } }, /** - * Lookup231: pallet_inflation::pallet::Call + * Lookup236: pallet_inflation::pallet::Call **/ PalletInflationCall: { _enum: { @@ -2112,7 +2160,7 @@ } }, /** - * Lookup232: pallet_unique::Call + * Lookup237: pallet_unique::Call **/ PalletUniqueCall: { _enum: { @@ -2244,7 +2292,7 @@ } }, /** - * Lookup237: up_data_structs::CollectionMode + * Lookup242: up_data_structs::CollectionMode **/ UpDataStructsCollectionMode: { _enum: { @@ -2254,7 +2302,7 @@ } }, /** - * Lookup238: up_data_structs::CreateCollectionData + * Lookup243: up_data_structs::CreateCollectionData **/ UpDataStructsCreateCollectionData: { mode: 'UpDataStructsCollectionMode', @@ -2269,13 +2317,13 @@ properties: 'Vec' }, /** - * Lookup240: up_data_structs::AccessMode + * Lookup245: up_data_structs::AccessMode **/ UpDataStructsAccessMode: { _enum: ['Normal', 'AllowList'] }, /** - * Lookup242: up_data_structs::CollectionLimits + * Lookup247: up_data_structs::CollectionLimits **/ UpDataStructsCollectionLimits: { accountTokenOwnershipLimit: 'Option', @@ -2289,7 +2337,7 @@ transfersEnabled: 'Option' }, /** - * Lookup244: up_data_structs::SponsoringRateLimit + * Lookup249: up_data_structs::SponsoringRateLimit **/ UpDataStructsSponsoringRateLimit: { _enum: { @@ -2298,7 +2346,7 @@ } }, /** - * Lookup247: up_data_structs::CollectionPermissions + * Lookup252: up_data_structs::CollectionPermissions **/ UpDataStructsCollectionPermissions: { access: 'Option', @@ -2306,7 +2354,7 @@ nesting: 'Option' }, /** - * Lookup249: up_data_structs::NestingPermissions + * Lookup254: up_data_structs::NestingPermissions **/ UpDataStructsNestingPermissions: { tokenOwner: 'bool', @@ -2314,18 +2362,18 @@ restricted: 'Option' }, /** - * Lookup251: up_data_structs::OwnerRestrictedSet + * Lookup256: up_data_structs::OwnerRestrictedSet **/ UpDataStructsOwnerRestrictedSet: 'BTreeSet', /** - * Lookup256: up_data_structs::PropertyKeyPermission + * Lookup261: up_data_structs::PropertyKeyPermission **/ UpDataStructsPropertyKeyPermission: { key: 'Bytes', permission: 'UpDataStructsPropertyPermission' }, /** - * Lookup257: up_data_structs::PropertyPermission + * Lookup262: up_data_structs::PropertyPermission **/ UpDataStructsPropertyPermission: { mutable: 'bool', @@ -2333,14 +2381,14 @@ tokenOwner: 'bool' }, /** - * Lookup260: up_data_structs::Property + * Lookup265: up_data_structs::Property **/ UpDataStructsProperty: { key: 'Bytes', value: 'Bytes' }, /** - * Lookup263: up_data_structs::CreateItemData + * Lookup268: up_data_structs::CreateItemData **/ UpDataStructsCreateItemData: { _enum: { @@ -2350,26 +2398,26 @@ } }, /** - * Lookup264: up_data_structs::CreateNftData + * Lookup269: up_data_structs::CreateNftData **/ UpDataStructsCreateNftData: { properties: 'Vec' }, /** - * Lookup265: up_data_structs::CreateFungibleData + * Lookup270: up_data_structs::CreateFungibleData **/ UpDataStructsCreateFungibleData: { value: 'u128' }, /** - * Lookup266: up_data_structs::CreateReFungibleData + * Lookup271: up_data_structs::CreateReFungibleData **/ UpDataStructsCreateReFungibleData: { pieces: 'u128', properties: 'Vec' }, /** - * Lookup269: up_data_structs::CreateItemExData> + * Lookup274: up_data_structs::CreateItemExData> **/ UpDataStructsCreateItemExData: { _enum: { @@ -2380,14 +2428,14 @@ } }, /** - * Lookup271: up_data_structs::CreateNftExData> + * Lookup276: up_data_structs::CreateNftExData> **/ UpDataStructsCreateNftExData: { properties: 'Vec', owner: 'PalletEvmAccountBasicCrossAccountIdRepr' }, /** - * Lookup278: up_data_structs::CreateRefungibleExSingleOwner> + * Lookup283: up_data_structs::CreateRefungibleExSingleOwner> **/ UpDataStructsCreateRefungibleExSingleOwner: { user: 'PalletEvmAccountBasicCrossAccountIdRepr', @@ -2395,15 +2443,52 @@ properties: 'Vec' }, /** - * Lookup280: up_data_structs::CreateRefungibleExMultipleOwners> + * Lookup285: up_data_structs::CreateRefungibleExMultipleOwners> **/ UpDataStructsCreateRefungibleExMultipleOwners: { users: 'BTreeMap', properties: 'Vec' }, /** - * Lookup281: pallet_configuration::pallet::Call + * Lookup286: pallet_unique_scheduler::pallet::Call + **/ + PalletUniqueSchedulerCall: { + _enum: { + schedule_named: { + id: '[u8;16]', + when: 'u32', + maybePeriodic: 'Option<(u32,u32)>', + priority: 'Option', + call: 'FrameSupportScheduleMaybeHashed', + }, + cancel_named: { + id: '[u8;16]', + }, + schedule_named_after: { + id: '[u8;16]', + after: 'u32', + maybePeriodic: 'Option<(u32,u32)>', + priority: 'Option', + call: 'FrameSupportScheduleMaybeHashed', + }, + change_named_priority: { + id: '[u8;16]', + priority: 'u8' + } + } + }, + /** + * Lookup289: frame_support::traits::schedule::MaybeHashed **/ + FrameSupportScheduleMaybeHashed: { + _enum: { + Value: 'Call', + Hash: 'H256' + } + }, + /** + * Lookup290: pallet_configuration::pallet::Call + **/ PalletConfigurationCall: { _enum: { set_weight_to_fee_coefficient_override: { @@ -2415,15 +2500,15 @@ } }, /** - * Lookup283: pallet_template_transaction_payment::Call + * Lookup292: pallet_template_transaction_payment::Call **/ PalletTemplateTransactionPaymentCall: 'Null', /** - * Lookup284: pallet_structure::pallet::Call + * Lookup293: pallet_structure::pallet::Call **/ PalletStructureCall: 'Null', /** - * Lookup285: pallet_rmrk_core::pallet::Call + * Lookup294: pallet_rmrk_core::pallet::Call **/ PalletRmrkCoreCall: { _enum: { @@ -2514,7 +2599,7 @@ } }, /** - * Lookup291: rmrk_traits::resource::ResourceTypes, sp_core::bounded::bounded_vec::BoundedVec> + * Lookup300: rmrk_traits::resource::ResourceTypes, sp_core::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsResourceResourceTypes: { _enum: { @@ -2524,7 +2609,7 @@ } }, /** - * Lookup293: rmrk_traits::resource::BasicResource> + * Lookup302: rmrk_traits::resource::BasicResource> **/ RmrkTraitsResourceBasicResource: { src: 'Option', @@ -2533,7 +2618,7 @@ thumb: 'Option' }, /** - * Lookup295: rmrk_traits::resource::ComposableResource, sp_core::bounded::bounded_vec::BoundedVec> + * Lookup304: rmrk_traits::resource::ComposableResource, sp_core::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsResourceComposableResource: { parts: 'Vec', @@ -2544,7 +2629,7 @@ thumb: 'Option' }, /** - * Lookup296: rmrk_traits::resource::SlotResource> + * Lookup305: rmrk_traits::resource::SlotResource> **/ RmrkTraitsResourceSlotResource: { base: 'u32', @@ -2555,7 +2640,7 @@ thumb: 'Option' }, /** - * Lookup299: pallet_rmrk_equip::pallet::Call + * Lookup308: pallet_rmrk_equip::pallet::Call **/ PalletRmrkEquipCall: { _enum: { @@ -2576,7 +2661,7 @@ } }, /** - * Lookup302: rmrk_traits::part::PartType, sp_core::bounded::bounded_vec::BoundedVec> + * Lookup311: rmrk_traits::part::PartType, sp_core::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsPartPartType: { _enum: { @@ -2585,7 +2670,7 @@ } }, /** - * Lookup304: rmrk_traits::part::FixedPart> + * Lookup313: rmrk_traits::part::FixedPart> **/ RmrkTraitsPartFixedPart: { id: 'u32', @@ -2593,7 +2678,7 @@ src: 'Bytes' }, /** - * Lookup305: rmrk_traits::part::SlotPart, sp_core::bounded::bounded_vec::BoundedVec> + * Lookup314: rmrk_traits::part::SlotPart, sp_core::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsPartSlotPart: { id: 'u32', @@ -2602,7 +2687,7 @@ z: 'u32' }, /** - * Lookup306: rmrk_traits::part::EquippableList> + * Lookup315: rmrk_traits::part::EquippableList> **/ RmrkTraitsPartEquippableList: { _enum: { @@ -2612,7 +2697,7 @@ } }, /** - * Lookup308: rmrk_traits::theme::Theme, sp_core::bounded::bounded_vec::BoundedVec>, S>> + * Lookup317: rmrk_traits::theme::Theme, sp_core::bounded::bounded_vec::BoundedVec>, S>> **/ RmrkTraitsTheme: { name: 'Bytes', @@ -2620,14 +2705,14 @@ inherit: 'bool' }, /** - * Lookup310: rmrk_traits::theme::ThemeProperty> + * Lookup319: rmrk_traits::theme::ThemeProperty> **/ RmrkTraitsThemeThemeProperty: { key: 'Bytes', value: 'Bytes' }, /** - * Lookup312: pallet_app_promotion::pallet::Call + * Lookup321: pallet_app_promotion::pallet::Call **/ PalletAppPromotionCall: { _enum: { @@ -2656,7 +2741,7 @@ } }, /** - * Lookup314: pallet_foreign_assets::module::Call + * Lookup322: pallet_foreign_assets::module::Call **/ PalletForeignAssetsModuleCall: { _enum: { @@ -2673,7 +2758,7 @@ } }, /** - * Lookup315: pallet_evm::pallet::Call + * Lookup323: pallet_evm::pallet::Call **/ PalletEvmCall: { _enum: { @@ -2716,7 +2801,7 @@ } }, /** - * Lookup319: pallet_ethereum::pallet::Call + * Lookup327: pallet_ethereum::pallet::Call **/ PalletEthereumCall: { _enum: { @@ -2726,7 +2811,7 @@ } }, /** - * Lookup320: ethereum::transaction::TransactionV2 + * Lookup328: ethereum::transaction::TransactionV2 **/ EthereumTransactionTransactionV2: { _enum: { @@ -2736,7 +2821,7 @@ } }, /** - * Lookup321: ethereum::transaction::LegacyTransaction + * Lookup329: ethereum::transaction::LegacyTransaction **/ EthereumTransactionLegacyTransaction: { nonce: 'U256', @@ -2748,7 +2833,7 @@ signature: 'EthereumTransactionTransactionSignature' }, /** - * Lookup322: ethereum::transaction::TransactionAction + * Lookup330: ethereum::transaction::TransactionAction **/ EthereumTransactionTransactionAction: { _enum: { @@ -2757,7 +2842,7 @@ } }, /** - * Lookup323: ethereum::transaction::TransactionSignature + * Lookup331: ethereum::transaction::TransactionSignature **/ EthereumTransactionTransactionSignature: { v: 'u64', @@ -2765,7 +2850,7 @@ s: 'H256' }, /** - * Lookup325: ethereum::transaction::EIP2930Transaction + * Lookup333: ethereum::transaction::EIP2930Transaction **/ EthereumTransactionEip2930Transaction: { chainId: 'u64', @@ -2781,14 +2866,14 @@ s: 'H256' }, /** - * Lookup327: ethereum::transaction::AccessListItem + * Lookup335: ethereum::transaction::AccessListItem **/ EthereumTransactionAccessListItem: { address: 'H160', storageKeys: 'Vec' }, /** - * Lookup328: ethereum::transaction::EIP1559Transaction + * Lookup336: ethereum::transaction::EIP1559Transaction **/ EthereumTransactionEip1559Transaction: { chainId: 'u64', @@ -2805,7 +2890,7 @@ s: 'H256' }, /** - * Lookup329: pallet_evm_migration::pallet::Call + * Lookup337: pallet_evm_migration::pallet::Call **/ PalletEvmMigrationCall: { _enum: { @@ -2823,32 +2908,58 @@ } }, /** - * Lookup332: pallet_sudo::pallet::Error + * Lookup340: pallet_maintenance::pallet::Call + **/ + PalletMaintenanceCall: { + _enum: ['enable', 'disable'] + }, + /** + * Lookup341: pallet_test_utils::pallet::Call + **/ + PalletTestUtilsCall: { + _enum: { + enable: 'Null', + set_test_value: { + value: 'u32', + }, + set_test_value_and_rollback: { + value: 'u32', + }, + inc_test_value: 'Null', + self_canceling_inc: { + id: '[u8;16]', + maxTestValue: 'u32', + }, + just_take_fee: 'Null' + } + }, + /** + * Lookup342: pallet_sudo::pallet::Error **/ PalletSudoError: { _enum: ['RequireSudo'] }, /** - * Lookup334: orml_vesting::module::Error + * Lookup344: orml_vesting::module::Error **/ OrmlVestingModuleError: { _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded'] }, /** - * Lookup335: orml_xtokens::module::Error + * Lookup345: orml_xtokens::module::Error **/ OrmlXtokensModuleError: { _enum: ['AssetHasNoReserve', 'NotCrossChainTransfer', 'InvalidDest', 'NotCrossChainTransferableCurrency', 'UnweighableMessage', 'XcmExecutionFailed', 'CannotReanchor', 'InvalidAncestry', 'InvalidAsset', 'DestinationNotInvertible', 'BadVersion', 'DistinctReserveForAssetAndFee', 'ZeroFee', 'ZeroAmount', 'TooManyAssetsBeingSent', 'AssetIndexNonExistent', 'FeeNotEnough', 'NotSupportedMultiLocation', 'MinXcmFeeNotDefined'] }, /** - * Lookup338: orml_tokens::BalanceLock + * Lookup348: orml_tokens::BalanceLock **/ OrmlTokensBalanceLock: { id: '[u8;8]', amount: 'u128' }, /** - * Lookup340: orml_tokens::AccountData + * Lookup350: orml_tokens::AccountData **/ OrmlTokensAccountData: { free: 'u128', @@ -2856,20 +2967,20 @@ frozen: 'u128' }, /** - * Lookup342: orml_tokens::ReserveData + * Lookup352: orml_tokens::ReserveData **/ OrmlTokensReserveData: { id: 'Null', amount: 'u128' }, /** - * Lookup344: orml_tokens::module::Error + * Lookup354: orml_tokens::module::Error **/ OrmlTokensModuleError: { _enum: ['BalanceTooLow', 'AmountIntoBalanceFailed', 'LiquidityRestrictions', 'MaxLocksExceeded', 'KeepAlive', 'ExistentialDeposit', 'DeadAccount', 'TooManyReserves'] }, /** - * Lookup346: cumulus_pallet_xcmp_queue::InboundChannelDetails + * Lookup356: cumulus_pallet_xcmp_queue::InboundChannelDetails **/ CumulusPalletXcmpQueueInboundChannelDetails: { sender: 'u32', @@ -2877,19 +2988,19 @@ messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>' }, /** - * Lookup347: cumulus_pallet_xcmp_queue::InboundState + * Lookup357: cumulus_pallet_xcmp_queue::InboundState **/ CumulusPalletXcmpQueueInboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup350: polkadot_parachain::primitives::XcmpMessageFormat + * Lookup360: polkadot_parachain::primitives::XcmpMessageFormat **/ PolkadotParachainPrimitivesXcmpMessageFormat: { _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals'] }, /** - * Lookup353: cumulus_pallet_xcmp_queue::OutboundChannelDetails + * Lookup363: cumulus_pallet_xcmp_queue::OutboundChannelDetails **/ CumulusPalletXcmpQueueOutboundChannelDetails: { recipient: 'u32', @@ -2899,13 +3010,13 @@ lastIndex: 'u16' }, /** - * Lookup354: cumulus_pallet_xcmp_queue::OutboundState + * Lookup364: cumulus_pallet_xcmp_queue::OutboundState **/ CumulusPalletXcmpQueueOutboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup356: cumulus_pallet_xcmp_queue::QueueConfigData + * Lookup366: cumulus_pallet_xcmp_queue::QueueConfigData **/ CumulusPalletXcmpQueueQueueConfigData: { suspendThreshold: 'u32', @@ -2916,29 +3027,29 @@ xcmpMaxIndividualWeight: 'Weight' }, /** - * Lookup358: cumulus_pallet_xcmp_queue::pallet::Error + * Lookup368: cumulus_pallet_xcmp_queue::pallet::Error **/ CumulusPalletXcmpQueueError: { _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit'] }, /** - * Lookup359: pallet_xcm::pallet::Error + * Lookup369: pallet_xcm::pallet::Error **/ PalletXcmError: { _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed'] }, /** - * Lookup360: cumulus_pallet_xcm::pallet::Error + * Lookup370: cumulus_pallet_xcm::pallet::Error **/ CumulusPalletXcmError: 'Null', /** - * Lookup361: cumulus_pallet_dmp_queue::ConfigData + * Lookup371: cumulus_pallet_dmp_queue::ConfigData **/ CumulusPalletDmpQueueConfigData: { maxIndividual: 'Weight' }, /** - * Lookup362: cumulus_pallet_dmp_queue::PageIndexData + * Lookup372: cumulus_pallet_dmp_queue::PageIndexData **/ CumulusPalletDmpQueuePageIndexData: { beginUsed: 'u32', @@ -2946,20 +3057,185 @@ overweightCount: 'u64' }, /** - * Lookup365: cumulus_pallet_dmp_queue::pallet::Error + * Lookup375: cumulus_pallet_dmp_queue::pallet::Error **/ CumulusPalletDmpQueueError: { _enum: ['Unknown', 'OverLimit'] }, /** - * Lookup369: pallet_unique::Error + * Lookup379: pallet_unique::Error **/ PalletUniqueError: { _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection'] }, /** - * Lookup370: up_data_structs::Collection + * Lookup382: pallet_unique_scheduler::ScheduledV3, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32> **/ + PalletUniqueSchedulerScheduledV3: { + maybeId: 'Option<[u8;16]>', + priority: 'u8', + call: 'FrameSupportScheduleMaybeHashed', + maybePeriodic: 'Option<(u32,u32)>', + origin: 'OpalRuntimeOriginCaller' + }, + /** + * Lookup383: opal_runtime::OriginCaller + **/ + OpalRuntimeOriginCaller: { + _enum: { + system: 'FrameSupportDispatchRawOrigin', + __Unused1: 'Null', + __Unused2: 'Null', + __Unused3: 'Null', + Void: 'SpCoreVoid', + __Unused5: 'Null', + __Unused6: 'Null', + __Unused7: 'Null', + __Unused8: 'Null', + __Unused9: 'Null', + __Unused10: 'Null', + __Unused11: 'Null', + __Unused12: 'Null', + __Unused13: 'Null', + __Unused14: 'Null', + __Unused15: 'Null', + __Unused16: 'Null', + __Unused17: 'Null', + __Unused18: 'Null', + __Unused19: 'Null', + __Unused20: 'Null', + __Unused21: 'Null', + __Unused22: 'Null', + __Unused23: 'Null', + __Unused24: 'Null', + __Unused25: 'Null', + __Unused26: 'Null', + __Unused27: 'Null', + __Unused28: 'Null', + __Unused29: 'Null', + __Unused30: 'Null', + __Unused31: 'Null', + __Unused32: 'Null', + __Unused33: 'Null', + __Unused34: 'Null', + __Unused35: 'Null', + __Unused36: 'Null', + __Unused37: 'Null', + __Unused38: 'Null', + __Unused39: 'Null', + __Unused40: 'Null', + __Unused41: 'Null', + __Unused42: 'Null', + __Unused43: 'Null', + __Unused44: 'Null', + __Unused45: 'Null', + __Unused46: 'Null', + __Unused47: 'Null', + __Unused48: 'Null', + __Unused49: 'Null', + __Unused50: 'Null', + PolkadotXcm: 'PalletXcmOrigin', + CumulusXcm: 'CumulusPalletXcmOrigin', + __Unused53: 'Null', + __Unused54: 'Null', + __Unused55: 'Null', + __Unused56: 'Null', + __Unused57: 'Null', + __Unused58: 'Null', + __Unused59: 'Null', + __Unused60: 'Null', + __Unused61: 'Null', + __Unused62: 'Null', + __Unused63: 'Null', + __Unused64: 'Null', + __Unused65: 'Null', + __Unused66: 'Null', + __Unused67: 'Null', + __Unused68: 'Null', + __Unused69: 'Null', + __Unused70: 'Null', + __Unused71: 'Null', + __Unused72: 'Null', + __Unused73: 'Null', + __Unused74: 'Null', + __Unused75: 'Null', + __Unused76: 'Null', + __Unused77: 'Null', + __Unused78: 'Null', + __Unused79: 'Null', + __Unused80: 'Null', + __Unused81: 'Null', + __Unused82: 'Null', + __Unused83: 'Null', + __Unused84: 'Null', + __Unused85: 'Null', + __Unused86: 'Null', + __Unused87: 'Null', + __Unused88: 'Null', + __Unused89: 'Null', + __Unused90: 'Null', + __Unused91: 'Null', + __Unused92: 'Null', + __Unused93: 'Null', + __Unused94: 'Null', + __Unused95: 'Null', + __Unused96: 'Null', + __Unused97: 'Null', + __Unused98: 'Null', + __Unused99: 'Null', + __Unused100: 'Null', + Ethereum: 'PalletEthereumRawOrigin' + } + }, + /** + * Lookup384: frame_support::dispatch::RawOrigin + **/ + FrameSupportDispatchRawOrigin: { + _enum: { + Root: 'Null', + Signed: 'AccountId32', + None: 'Null' + } + }, + /** + * Lookup385: pallet_xcm::pallet::Origin + **/ + PalletXcmOrigin: { + _enum: { + Xcm: 'XcmV1MultiLocation', + Response: 'XcmV1MultiLocation' + } + }, + /** + * Lookup386: cumulus_pallet_xcm::pallet::Origin + **/ + CumulusPalletXcmOrigin: { + _enum: { + Relay: 'Null', + SiblingParachain: 'u32' + } + }, + /** + * Lookup387: pallet_ethereum::RawOrigin + **/ + PalletEthereumRawOrigin: { + _enum: { + EthereumTransaction: 'H160' + } + }, + /** + * Lookup388: sp_core::Void + **/ + SpCoreVoid: 'Null', + /** + * Lookup389: pallet_unique_scheduler::pallet::Error + **/ + PalletUniqueSchedulerError: { + _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange'] + }, + /** + * Lookup390: up_data_structs::Collection + **/ UpDataStructsCollection: { owner: 'AccountId32', mode: 'UpDataStructsCollectionMode', @@ -2972,7 +3248,7 @@ flags: '[u8;1]' }, /** - * Lookup371: up_data_structs::SponsorshipState + * Lookup391: up_data_structs::SponsorshipState **/ UpDataStructsSponsorshipStateAccountId32: { _enum: { @@ -2982,7 +3258,7 @@ } }, /** - * Lookup373: up_data_structs::Properties + * Lookup393: up_data_structs::Properties **/ UpDataStructsProperties: { map: 'UpDataStructsPropertiesMapBoundedVec', @@ -2990,15 +3266,15 @@ spaceLimit: 'u32' }, /** - * Lookup374: up_data_structs::PropertiesMap> + * Lookup394: up_data_structs::PropertiesMap> **/ UpDataStructsPropertiesMapBoundedVec: 'BTreeMap', /** - * Lookup379: up_data_structs::PropertiesMap + * Lookup399: up_data_structs::PropertiesMap **/ UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap', /** - * Lookup386: up_data_structs::CollectionStats + * Lookup406: up_data_structs::CollectionStats **/ UpDataStructsCollectionStats: { created: 'u32', @@ -3006,18 +3282,18 @@ alive: 'u32' }, /** - * Lookup387: up_data_structs::TokenChild + * Lookup407: up_data_structs::TokenChild **/ UpDataStructsTokenChild: { token: 'u32', collection: 'u32' }, /** - * Lookup388: PhantomType::up_data_structs + * Lookup408: PhantomType::up_data_structs **/ PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]', /** - * Lookup390: up_data_structs::TokenData> + * Lookup410: up_data_structs::TokenData> **/ UpDataStructsTokenData: { properties: 'Vec', @@ -3025,7 +3301,7 @@ pieces: 'u128' }, /** - * Lookup392: up_data_structs::RpcCollection + * Lookup412: up_data_structs::RpcCollection **/ UpDataStructsRpcCollection: { owner: 'AccountId32', @@ -3042,14 +3318,14 @@ flags: 'UpDataStructsRpcCollectionFlags' }, /** - * Lookup393: up_data_structs::RpcCollectionFlags + * Lookup413: up_data_structs::RpcCollectionFlags **/ UpDataStructsRpcCollectionFlags: { foreign: 'bool', erc721metadata: 'bool' }, /** - * Lookup394: rmrk_traits::collection::CollectionInfo, sp_core::bounded::bounded_vec::BoundedVec, sp_core::crypto::AccountId32> + * Lookup414: rmrk_traits::collection::CollectionInfo, sp_core::bounded::bounded_vec::BoundedVec, sp_core::crypto::AccountId32> **/ RmrkTraitsCollectionCollectionInfo: { issuer: 'AccountId32', @@ -3059,7 +3335,7 @@ nftsCount: 'u32' }, /** - * Lookup395: rmrk_traits::nft::NftInfo> + * Lookup415: rmrk_traits::nft::NftInfo> **/ RmrkTraitsNftNftInfo: { owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple', @@ -3069,14 +3345,14 @@ pending: 'bool' }, /** - * Lookup397: rmrk_traits::nft::RoyaltyInfo + * Lookup417: rmrk_traits::nft::RoyaltyInfo **/ RmrkTraitsNftRoyaltyInfo: { recipient: 'AccountId32', amount: 'Permill' }, /** - * Lookup398: rmrk_traits::resource::ResourceInfo, sp_core::bounded::bounded_vec::BoundedVec> + * Lookup418: rmrk_traits::resource::ResourceInfo, sp_core::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsResourceResourceInfo: { id: 'u32', @@ -3085,14 +3361,14 @@ pendingRemoval: 'bool' }, /** - * Lookup399: rmrk_traits::property::PropertyInfo, sp_core::bounded::bounded_vec::BoundedVec> + * Lookup419: rmrk_traits::property::PropertyInfo, sp_core::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsPropertyPropertyInfo: { key: 'Bytes', value: 'Bytes' }, /** - * Lookup400: rmrk_traits::base::BaseInfo> + * Lookup420: rmrk_traits::base::BaseInfo> **/ RmrkTraitsBaseBaseInfo: { issuer: 'AccountId32', @@ -3100,92 +3376,92 @@ symbol: 'Bytes' }, /** - * Lookup401: rmrk_traits::nft::NftChild + * Lookup421: rmrk_traits::nft::NftChild **/ RmrkTraitsNftNftChild: { collectionId: 'u32', nftId: 'u32' }, /** - * Lookup403: pallet_common::pallet::Error + * Lookup423: pallet_common::pallet::Error **/ 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'] }, /** - * Lookup405: pallet_fungible::pallet::Error + * Lookup425: pallet_fungible::pallet::Error **/ PalletFungibleError: { _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed'] }, /** - * Lookup406: pallet_refungible::ItemData + * Lookup426: pallet_refungible::ItemData **/ PalletRefungibleItemData: { constData: 'Bytes' }, /** - * Lookup411: pallet_refungible::pallet::Error + * Lookup431: pallet_refungible::pallet::Error **/ PalletRefungibleError: { _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed'] }, /** - * Lookup412: pallet_nonfungible::ItemData> + * Lookup432: pallet_nonfungible::ItemData> **/ PalletNonfungibleItemData: { owner: 'PalletEvmAccountBasicCrossAccountIdRepr' }, /** - * Lookup414: up_data_structs::PropertyScope + * Lookup434: up_data_structs::PropertyScope **/ UpDataStructsPropertyScope: { _enum: ['None', 'Rmrk'] }, /** - * Lookup416: pallet_nonfungible::pallet::Error + * Lookup436: pallet_nonfungible::pallet::Error **/ PalletNonfungibleError: { _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren'] }, /** - * Lookup417: pallet_structure::pallet::Error + * Lookup437: pallet_structure::pallet::Error **/ PalletStructureError: { _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound'] }, /** - * Lookup418: pallet_rmrk_core::pallet::Error + * Lookup438: pallet_rmrk_core::pallet::Error **/ PalletRmrkCoreError: { _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId'] }, /** - * Lookup420: pallet_rmrk_equip::pallet::Error + * Lookup440: pallet_rmrk_equip::pallet::Error **/ PalletRmrkEquipError: { _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart'] }, /** - * Lookup426: pallet_app_promotion::pallet::Error + * Lookup446: pallet_app_promotion::pallet::Error **/ PalletAppPromotionError: { _enum: ['AdminNotSet', 'NoPermission', 'NotSufficientFunds', 'PendingForBlockOverflow', 'SponsorNotSet', 'IncorrectLockedBalanceOperation'] }, /** - * Lookup427: pallet_foreign_assets::module::Error + * Lookup447: pallet_foreign_assets::module::Error **/ PalletForeignAssetsModuleError: { _enum: ['BadLocation', 'MultiLocationExisted', 'AssetIdNotExists', 'AssetIdExisted'] }, /** - * Lookup430: pallet_evm::pallet::Error + * Lookup450: pallet_evm::pallet::Error **/ PalletEvmError: { _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce'] }, /** - * Lookup433: fp_rpc::TransactionStatus + * Lookup453: fp_rpc::TransactionStatus **/ FpRpcTransactionStatus: { transactionHash: 'H256', @@ -3197,11 +3473,11 @@ logsBloom: 'EthbloomBloom' }, /** - * Lookup435: ethbloom::Bloom + * Lookup455: ethbloom::Bloom **/ EthbloomBloom: '[u8;256]', /** - * Lookup437: ethereum::receipt::ReceiptV3 + * Lookup457: ethereum::receipt::ReceiptV3 **/ EthereumReceiptReceiptV3: { _enum: { @@ -3211,7 +3487,7 @@ } }, /** - * Lookup438: ethereum::receipt::EIP658ReceiptData + * Lookup458: ethereum::receipt::EIP658ReceiptData **/ EthereumReceiptEip658ReceiptData: { statusCode: 'u8', @@ -3220,7 +3496,7 @@ logs: 'Vec' }, /** - * Lookup439: ethereum::block::Block + * Lookup459: ethereum::block::Block **/ EthereumBlock: { header: 'EthereumHeader', @@ -3228,7 +3504,7 @@ ommers: 'Vec' }, /** - * Lookup440: ethereum::header::Header + * Lookup460: ethereum::header::Header **/ EthereumHeader: { parentHash: 'H256', @@ -3248,23 +3524,23 @@ nonce: 'EthereumTypesHashH64' }, /** - * Lookup441: ethereum_types::hash::H64 + * Lookup461: ethereum_types::hash::H64 **/ EthereumTypesHashH64: '[u8;8]', /** - * Lookup446: pallet_ethereum::pallet::Error + * Lookup466: pallet_ethereum::pallet::Error **/ PalletEthereumError: { _enum: ['InvalidSignature', 'PreLogExists'] }, /** - * Lookup447: pallet_evm_coder_substrate::pallet::Error + * Lookup467: pallet_evm_coder_substrate::pallet::Error **/ PalletEvmCoderSubstrateError: { _enum: ['OutOfGas', 'OutOfFund'] }, /** - * Lookup448: up_data_structs::SponsorshipState> + * Lookup468: up_data_structs::SponsorshipState> **/ UpDataStructsSponsorshipStateBasicCrossAccountIdRepr: { _enum: { @@ -3274,26 +3550,36 @@ } }, /** - * Lookup449: pallet_evm_contract_helpers::SponsoringModeT + * Lookup469: pallet_evm_contract_helpers::SponsoringModeT **/ PalletEvmContractHelpersSponsoringModeT: { _enum: ['Disabled', 'Allowlisted', 'Generous'] }, /** - * Lookup455: pallet_evm_contract_helpers::pallet::Error + * Lookup475: pallet_evm_contract_helpers::pallet::Error **/ PalletEvmContractHelpersError: { _enum: ['NoPermission', 'NoPendingSponsor', 'TooManyMethodsHaveSponsoredLimit'] }, /** - * Lookup456: pallet_evm_migration::pallet::Error + * Lookup476: pallet_evm_migration::pallet::Error **/ PalletEvmMigrationError: { _enum: ['AccountNotEmpty', 'AccountIsNotMigrating'] }, /** - * Lookup458: sp_runtime::MultiSignature + * Lookup477: pallet_maintenance::pallet::Error **/ + PalletMaintenanceError: 'Null', + /** + * Lookup478: pallet_test_utils::pallet::Error + **/ + PalletTestUtilsError: { + _enum: ['TestPalletDisabled', 'TriggerRollback'] + }, + /** + * Lookup480: sp_runtime::MultiSignature + **/ SpRuntimeMultiSignature: { _enum: { Ed25519: 'SpCoreEd25519Signature', @@ -3302,47 +3588,51 @@ } }, /** - * Lookup459: sp_core::ed25519::Signature + * Lookup481: sp_core::ed25519::Signature **/ SpCoreEd25519Signature: '[u8;64]', /** - * Lookup461: sp_core::sr25519::Signature + * Lookup483: sp_core::sr25519::Signature **/ SpCoreSr25519Signature: '[u8;64]', /** - * Lookup462: sp_core::ecdsa::Signature + * Lookup484: sp_core::ecdsa::Signature **/ SpCoreEcdsaSignature: '[u8;65]', /** - * Lookup465: frame_system::extensions::check_spec_version::CheckSpecVersion + * Lookup487: frame_system::extensions::check_spec_version::CheckSpecVersion **/ FrameSystemExtensionsCheckSpecVersion: 'Null', /** - * Lookup466: frame_system::extensions::check_tx_version::CheckTxVersion + * Lookup488: frame_system::extensions::check_tx_version::CheckTxVersion **/ FrameSystemExtensionsCheckTxVersion: 'Null', /** - * Lookup467: frame_system::extensions::check_genesis::CheckGenesis + * Lookup489: frame_system::extensions::check_genesis::CheckGenesis **/ FrameSystemExtensionsCheckGenesis: 'Null', /** - * Lookup470: frame_system::extensions::check_nonce::CheckNonce + * Lookup492: frame_system::extensions::check_nonce::CheckNonce **/ FrameSystemExtensionsCheckNonce: 'Compact', /** - * Lookup471: frame_system::extensions::check_weight::CheckWeight + * Lookup493: frame_system::extensions::check_weight::CheckWeight **/ FrameSystemExtensionsCheckWeight: 'Null', /** - * Lookup472: pallet_template_transaction_payment::ChargeTransactionPayment + * Lookup494: opal_runtime::runtime_common::maintenance::CheckMaintenance + **/ + OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance: 'Null', + /** + * Lookup495: pallet_template_transaction_payment::ChargeTransactionPayment **/ PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact', /** - * Lookup473: opal_runtime::Runtime + * Lookup496: opal_runtime::Runtime **/ OpalRuntimeRuntime: 'Null', /** - * Lookup474: pallet_ethereum::FakeTransactionFinalizer + * Lookup497: pallet_ethereum::FakeTransactionFinalizer **/ PalletEthereumFakeTransactionFinalizer: 'Null' }; --- a/tests/src/interfaces/registry.ts +++ b/tests/src/interfaces/registry.ts @@ -5,7 +5,7 @@ // this is required to allow for ambient/previous definitions import '@polkadot/types/types/registry'; -import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchDispatchClass, FrameSupportDispatchDispatchInfo, FrameSupportDispatchPays, FrameSupportDispatchPerDispatchClassU32, FrameSupportDispatchPerDispatchClassWeight, FrameSupportDispatchPerDispatchClassWeightsPerClass, FrameSupportPalletId, FrameSupportTokensMiscBalanceStatus, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensModuleCall, OrmlTokensModuleError, OrmlTokensModuleEvent, OrmlTokensReserveData, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, OrmlXtokensModuleCall, OrmlXtokensModuleError, OrmlXtokensModuleEvent, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersEvent, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletForeignAssetsModuleCall, PalletForeignAssetsModuleError, PalletForeignAssetsModuleEvent, PalletForeignAssetsNativeCurrency, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsRpcCollectionFlags, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipStateAccountId32, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; +import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchDispatchClass, FrameSupportDispatchDispatchInfo, FrameSupportDispatchPays, FrameSupportDispatchPerDispatchClassU32, FrameSupportDispatchPerDispatchClassWeight, FrameSupportDispatchPerDispatchClassWeightsPerClass, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensModuleCall, OrmlTokensModuleError, OrmlTokensModuleEvent, OrmlTokensReserveData, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, OrmlXtokensModuleCall, OrmlXtokensModuleError, OrmlXtokensModuleEvent, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersEvent, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletForeignAssetsModuleCall, PalletForeignAssetsModuleError, PalletForeignAssetsModuleEvent, PalletForeignAssetsNativeCurrency, PalletFungibleError, PalletInflationCall, PalletMaintenanceCall, PalletMaintenanceError, PalletMaintenanceEvent, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTestUtilsCall, PalletTestUtilsError, PalletTestUtilsEvent, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsRpcCollectionFlags, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipStateAccountId32, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; declare module '@polkadot/types/types/registry' { interface InterfaceTypes { @@ -21,6 +21,7 @@ CumulusPalletXcmCall: CumulusPalletXcmCall; CumulusPalletXcmError: CumulusPalletXcmError; CumulusPalletXcmEvent: CumulusPalletXcmEvent; + CumulusPalletXcmOrigin: CumulusPalletXcmOrigin; CumulusPalletXcmpQueueCall: CumulusPalletXcmpQueueCall; CumulusPalletXcmpQueueError: CumulusPalletXcmpQueueError; CumulusPalletXcmpQueueEvent: CumulusPalletXcmpQueueEvent; @@ -56,7 +57,10 @@ FrameSupportDispatchPerDispatchClassU32: FrameSupportDispatchPerDispatchClassU32; FrameSupportDispatchPerDispatchClassWeight: FrameSupportDispatchPerDispatchClassWeight; FrameSupportDispatchPerDispatchClassWeightsPerClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; + FrameSupportDispatchRawOrigin: FrameSupportDispatchRawOrigin; FrameSupportPalletId: FrameSupportPalletId; + FrameSupportScheduleLookupError: FrameSupportScheduleLookupError; + FrameSupportScheduleMaybeHashed: FrameSupportScheduleMaybeHashed; FrameSupportTokensMiscBalanceStatus: FrameSupportTokensMiscBalanceStatus; FrameSystemAccountInfo: FrameSystemAccountInfo; FrameSystemCall: FrameSystemCall; @@ -73,7 +77,9 @@ FrameSystemLimitsBlockWeights: FrameSystemLimitsBlockWeights; FrameSystemLimitsWeightsPerClass: FrameSystemLimitsWeightsPerClass; FrameSystemPhase: FrameSystemPhase; + OpalRuntimeOriginCaller: OpalRuntimeOriginCaller; OpalRuntimeRuntime: OpalRuntimeRuntime; + OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance: OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance; OrmlTokensAccountData: OrmlTokensAccountData; OrmlTokensBalanceLock: OrmlTokensBalanceLock; OrmlTokensModuleCall: OrmlTokensModuleCall; @@ -105,6 +111,7 @@ PalletEthereumError: PalletEthereumError; PalletEthereumEvent: PalletEthereumEvent; PalletEthereumFakeTransactionFinalizer: PalletEthereumFakeTransactionFinalizer; + PalletEthereumRawOrigin: PalletEthereumRawOrigin; PalletEvmAccountBasicCrossAccountIdRepr: PalletEvmAccountBasicCrossAccountIdRepr; PalletEvmCall: PalletEvmCall; PalletEvmCoderSubstrateError: PalletEvmCoderSubstrateError; @@ -123,6 +130,9 @@ PalletForeignAssetsNativeCurrency: PalletForeignAssetsNativeCurrency; PalletFungibleError: PalletFungibleError; PalletInflationCall: PalletInflationCall; + PalletMaintenanceCall: PalletMaintenanceCall; + PalletMaintenanceError: PalletMaintenanceError; + PalletMaintenanceEvent: PalletMaintenanceEvent; PalletNonfungibleError: PalletNonfungibleError; PalletNonfungibleItemData: PalletNonfungibleItemData; PalletRefungibleError: PalletRefungibleError; @@ -141,6 +151,9 @@ PalletSudoEvent: PalletSudoEvent; PalletTemplateTransactionPaymentCall: PalletTemplateTransactionPaymentCall; PalletTemplateTransactionPaymentChargeTransactionPayment: PalletTemplateTransactionPaymentChargeTransactionPayment; + PalletTestUtilsCall: PalletTestUtilsCall; + PalletTestUtilsError: PalletTestUtilsError; + PalletTestUtilsEvent: PalletTestUtilsEvent; PalletTimestampCall: PalletTimestampCall; PalletTransactionPaymentEvent: PalletTransactionPaymentEvent; PalletTransactionPaymentReleases: PalletTransactionPaymentReleases; @@ -151,9 +164,14 @@ PalletUniqueCall: PalletUniqueCall; PalletUniqueError: PalletUniqueError; PalletUniqueRawEvent: PalletUniqueRawEvent; + PalletUniqueSchedulerCall: PalletUniqueSchedulerCall; + PalletUniqueSchedulerError: PalletUniqueSchedulerError; + PalletUniqueSchedulerEvent: PalletUniqueSchedulerEvent; + PalletUniqueSchedulerScheduledV3: PalletUniqueSchedulerScheduledV3; PalletXcmCall: PalletXcmCall; PalletXcmError: PalletXcmError; PalletXcmEvent: PalletXcmEvent; + PalletXcmOrigin: PalletXcmOrigin; PhantomTypeUpDataStructs: PhantomTypeUpDataStructs; PolkadotCorePrimitivesInboundDownwardMessage: PolkadotCorePrimitivesInboundDownwardMessage; PolkadotCorePrimitivesInboundHrmpMessage: PolkadotCorePrimitivesInboundHrmpMessage; @@ -184,6 +202,7 @@ SpCoreEcdsaSignature: SpCoreEcdsaSignature; SpCoreEd25519Signature: SpCoreEd25519Signature; SpCoreSr25519Signature: SpCoreSr25519Signature; + SpCoreVoid: SpCoreVoid; SpRuntimeArithmeticError: SpRuntimeArithmeticError; SpRuntimeDigest: SpRuntimeDigest; SpRuntimeDigestDigestItem: SpRuntimeDigestDigestItem; --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -1132,7 +1132,47 @@ readonly type: 'Substrate' | 'Ethereum'; } - /** @name PalletCommonEvent (93) */ + /** @name PalletUniqueSchedulerEvent (93) */ + interface PalletUniqueSchedulerEvent extends Enum { + readonly isScheduled: boolean; + readonly asScheduled: { + readonly when: u32; + readonly index: u32; + } & Struct; + readonly isCanceled: boolean; + readonly asCanceled: { + readonly when: u32; + readonly index: u32; + } & Struct; + readonly isPriorityChanged: boolean; + readonly asPriorityChanged: { + readonly when: u32; + readonly index: u32; + readonly priority: u8; + } & Struct; + readonly isDispatched: boolean; + readonly asDispatched: { + readonly task: ITuple<[u32, u32]>; + readonly id: Option; + readonly result: Result; + } & Struct; + readonly isCallLookupFailed: boolean; + readonly asCallLookupFailed: { + readonly task: ITuple<[u32, u32]>; + readonly id: Option; + readonly error: FrameSupportScheduleLookupError; + } & Struct; + readonly type: 'Scheduled' | 'Canceled' | 'PriorityChanged' | 'Dispatched' | 'CallLookupFailed'; + } + + /** @name FrameSupportScheduleLookupError (96) */ + interface FrameSupportScheduleLookupError extends Enum { + readonly isUnknown: boolean; + readonly isBadFormat: boolean; + readonly type: 'Unknown' | 'BadFormat'; + } + + /** @name PalletCommonEvent (97) */ interface PalletCommonEvent extends Enum { readonly isCollectionCreated: boolean; readonly asCollectionCreated: ITuple<[u32, u8, AccountId32]>; @@ -1159,14 +1199,14 @@ readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet'; } - /** @name PalletStructureEvent (96) */ + /** @name PalletStructureEvent (100) */ interface PalletStructureEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: Result; readonly type: 'Executed'; } - /** @name PalletRmrkCoreEvent (97) */ + /** @name PalletRmrkCoreEvent (101) */ interface PalletRmrkCoreEvent extends Enum { readonly isCollectionCreated: boolean; readonly asCollectionCreated: { @@ -1256,7 +1296,7 @@ readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'NftSent' | 'NftAccepted' | 'NftRejected' | 'PropertySet' | 'ResourceAdded' | 'ResourceRemoval' | 'ResourceAccepted' | 'ResourceRemovalAccepted' | 'PrioritySet'; } - /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (98) */ + /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (102) */ interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum { readonly isAccountId: boolean; readonly asAccountId: AccountId32; @@ -1265,7 +1305,7 @@ readonly type: 'AccountId' | 'CollectionAndNftTuple'; } - /** @name PalletRmrkEquipEvent (103) */ + /** @name PalletRmrkEquipEvent (107) */ interface PalletRmrkEquipEvent extends Enum { readonly isBaseCreated: boolean; readonly asBaseCreated: { @@ -1280,7 +1320,7 @@ readonly type: 'BaseCreated' | 'EquippablesUpdated'; } - /** @name PalletAppPromotionEvent (104) */ + /** @name PalletAppPromotionEvent (108) */ interface PalletAppPromotionEvent extends Enum { readonly isStakingRecalculation: boolean; readonly asStakingRecalculation: ITuple<[AccountId32, u128, u128]>; @@ -1293,7 +1333,7 @@ readonly type: 'StakingRecalculation' | 'Stake' | 'Unstake' | 'SetAdmin'; } - /** @name PalletForeignAssetsModuleEvent (105) */ + /** @name PalletForeignAssetsModuleEvent (109) */ interface PalletForeignAssetsModuleEvent extends Enum { readonly isForeignAssetRegistered: boolean; readonly asForeignAssetRegistered: { @@ -1320,7 +1360,7 @@ readonly type: 'ForeignAssetRegistered' | 'ForeignAssetUpdated' | 'AssetRegistered' | 'AssetUpdated'; } - /** @name PalletForeignAssetsModuleAssetMetadata (106) */ + /** @name PalletForeignAssetsModuleAssetMetadata (110) */ interface PalletForeignAssetsModuleAssetMetadata extends Struct { readonly name: Bytes; readonly symbol: Bytes; @@ -1328,7 +1368,7 @@ readonly minimalBalance: u128; } - /** @name PalletEvmEvent (107) */ + /** @name PalletEvmEvent (111) */ interface PalletEvmEvent extends Enum { readonly isLog: boolean; readonly asLog: EthereumLog; @@ -1347,21 +1387,21 @@ readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw'; } - /** @name EthereumLog (108) */ + /** @name EthereumLog (112) */ interface EthereumLog extends Struct { readonly address: H160; readonly topics: Vec; readonly data: Bytes; } - /** @name PalletEthereumEvent (112) */ + /** @name PalletEthereumEvent (116) */ interface PalletEthereumEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>; readonly type: 'Executed'; } - /** @name EvmCoreErrorExitReason (113) */ + /** @name EvmCoreErrorExitReason (117) */ interface EvmCoreErrorExitReason extends Enum { readonly isSucceed: boolean; readonly asSucceed: EvmCoreErrorExitSucceed; @@ -1374,7 +1414,7 @@ readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal'; } - /** @name EvmCoreErrorExitSucceed (114) */ + /** @name EvmCoreErrorExitSucceed (118) */ interface EvmCoreErrorExitSucceed extends Enum { readonly isStopped: boolean; readonly isReturned: boolean; @@ -1382,7 +1422,7 @@ readonly type: 'Stopped' | 'Returned' | 'Suicided'; } - /** @name EvmCoreErrorExitError (115) */ + /** @name EvmCoreErrorExitError (119) */ interface EvmCoreErrorExitError extends Enum { readonly isStackUnderflow: boolean; readonly isStackOverflow: boolean; @@ -1403,13 +1443,13 @@ readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode'; } - /** @name EvmCoreErrorExitRevert (118) */ + /** @name EvmCoreErrorExitRevert (122) */ interface EvmCoreErrorExitRevert extends Enum { readonly isReverted: boolean; readonly type: 'Reverted'; } - /** @name EvmCoreErrorExitFatal (119) */ + /** @name EvmCoreErrorExitFatal (123) */ interface EvmCoreErrorExitFatal extends Enum { readonly isNotSupported: boolean; readonly isUnhandledInterrupt: boolean; @@ -1420,7 +1460,7 @@ readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other'; } - /** @name PalletEvmContractHelpersEvent (120) */ + /** @name PalletEvmContractHelpersEvent (124) */ interface PalletEvmContractHelpersEvent extends Enum { readonly isContractSponsorSet: boolean; readonly asContractSponsorSet: ITuple<[H160, AccountId32]>; @@ -1431,7 +1471,21 @@ readonly type: 'ContractSponsorSet' | 'ContractSponsorshipConfirmed' | 'ContractSponsorRemoved'; } - /** @name FrameSystemPhase (121) */ + /** @name PalletMaintenanceEvent (125) */ + interface PalletMaintenanceEvent extends Enum { + readonly isMaintenanceEnabled: boolean; + readonly isMaintenanceDisabled: boolean; + readonly type: 'MaintenanceEnabled' | 'MaintenanceDisabled'; + } + + /** @name PalletTestUtilsEvent (126) */ + interface PalletTestUtilsEvent extends Enum { + readonly isValueIsSet: boolean; + readonly isShouldRollback: boolean; + readonly type: 'ValueIsSet' | 'ShouldRollback'; + } + + /** @name FrameSystemPhase (127) */ interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -1440,13 +1494,13 @@ readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization'; } - /** @name FrameSystemLastRuntimeUpgradeInfo (124) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (129) */ interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemCall (125) */ + /** @name FrameSystemCall (130) */ interface FrameSystemCall extends Enum { readonly isFillBlock: boolean; readonly asFillBlock: { @@ -1488,21 +1542,21 @@ readonly type: 'FillBlock' | 'Remark' | 'SetHeapPages' | 'SetCode' | 'SetCodeWithoutChecks' | 'SetStorage' | 'KillStorage' | 'KillPrefix' | 'RemarkWithEvent'; } - /** @name FrameSystemLimitsBlockWeights (130) */ + /** @name FrameSystemLimitsBlockWeights (135) */ interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: Weight; readonly maxBlock: Weight; readonly perClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; } - /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (131) */ + /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (136) */ interface FrameSupportDispatchPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (132) */ + /** @name FrameSystemLimitsWeightsPerClass (137) */ interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: Weight; readonly maxExtrinsic: Option; @@ -1510,25 +1564,25 @@ readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (134) */ + /** @name FrameSystemLimitsBlockLength (139) */ interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportDispatchPerDispatchClassU32; } - /** @name FrameSupportDispatchPerDispatchClassU32 (135) */ + /** @name FrameSupportDispatchPerDispatchClassU32 (140) */ interface FrameSupportDispatchPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name SpWeightsRuntimeDbWeight (136) */ + /** @name SpWeightsRuntimeDbWeight (141) */ interface SpWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (137) */ + /** @name SpVersionRuntimeVersion (142) */ interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -1540,7 +1594,7 @@ readonly stateVersion: u8; } - /** @name FrameSystemError (142) */ + /** @name FrameSystemError (147) */ interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -1551,7 +1605,7 @@ readonly type: 'InvalidSpecName' | 'SpecVersionNeedsToIncrease' | 'FailedToExtractRuntimeVersion' | 'NonDefaultComposite' | 'NonZeroRefCount' | 'CallFiltered'; } - /** @name PolkadotPrimitivesV2PersistedValidationData (143) */ + /** @name PolkadotPrimitivesV2PersistedValidationData (148) */ interface PolkadotPrimitivesV2PersistedValidationData extends Struct { readonly parentHead: Bytes; readonly relayParentNumber: u32; @@ -1559,18 +1613,18 @@ readonly maxPovSize: u32; } - /** @name PolkadotPrimitivesV2UpgradeRestriction (146) */ + /** @name PolkadotPrimitivesV2UpgradeRestriction (151) */ interface PolkadotPrimitivesV2UpgradeRestriction extends Enum { readonly isPresent: boolean; readonly type: 'Present'; } - /** @name SpTrieStorageProof (147) */ + /** @name SpTrieStorageProof (152) */ interface SpTrieStorageProof extends Struct { readonly trieNodes: BTreeSet; } - /** @name CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot (149) */ + /** @name CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot (154) */ interface CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot extends Struct { readonly dmqMqcHead: H256; readonly relayDispatchQueueSize: ITuple<[u32, u32]>; @@ -1578,7 +1632,7 @@ readonly egressChannels: Vec>; } - /** @name PolkadotPrimitivesV2AbridgedHrmpChannel (152) */ + /** @name PolkadotPrimitivesV2AbridgedHrmpChannel (157) */ interface PolkadotPrimitivesV2AbridgedHrmpChannel extends Struct { readonly maxCapacity: u32; readonly maxTotalSize: u32; @@ -1588,7 +1642,7 @@ readonly mqcHead: Option; } - /** @name PolkadotPrimitivesV2AbridgedHostConfiguration (153) */ + /** @name PolkadotPrimitivesV2AbridgedHostConfiguration (158) */ interface PolkadotPrimitivesV2AbridgedHostConfiguration extends Struct { readonly maxCodeSize: u32; readonly maxHeadDataSize: u32; @@ -1601,13 +1655,13 @@ readonly validationUpgradeDelay: u32; } - /** @name PolkadotCorePrimitivesOutboundHrmpMessage (159) */ + /** @name PolkadotCorePrimitivesOutboundHrmpMessage (164) */ interface PolkadotCorePrimitivesOutboundHrmpMessage extends Struct { readonly recipient: u32; readonly data: Bytes; } - /** @name CumulusPalletParachainSystemCall (160) */ + /** @name CumulusPalletParachainSystemCall (165) */ interface CumulusPalletParachainSystemCall extends Enum { readonly isSetValidationData: boolean; readonly asSetValidationData: { @@ -1628,7 +1682,7 @@ readonly type: 'SetValidationData' | 'SudoSendUpwardMessage' | 'AuthorizeUpgrade' | 'EnactAuthorizedUpgrade'; } - /** @name CumulusPrimitivesParachainInherentParachainInherentData (161) */ + /** @name CumulusPrimitivesParachainInherentParachainInherentData (166) */ interface CumulusPrimitivesParachainInherentParachainInherentData extends Struct { readonly validationData: PolkadotPrimitivesV2PersistedValidationData; readonly relayChainState: SpTrieStorageProof; @@ -1636,19 +1690,19 @@ readonly horizontalMessages: BTreeMap>; } - /** @name PolkadotCorePrimitivesInboundDownwardMessage (163) */ + /** @name PolkadotCorePrimitivesInboundDownwardMessage (168) */ interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct { readonly sentAt: u32; readonly msg: Bytes; } - /** @name PolkadotCorePrimitivesInboundHrmpMessage (166) */ + /** @name PolkadotCorePrimitivesInboundHrmpMessage (171) */ interface PolkadotCorePrimitivesInboundHrmpMessage extends Struct { readonly sentAt: u32; readonly data: Bytes; } - /** @name CumulusPalletParachainSystemError (169) */ + /** @name CumulusPalletParachainSystemError (174) */ interface CumulusPalletParachainSystemError extends Enum { readonly isOverlappingUpgrades: boolean; readonly isProhibitedByPolkadot: boolean; @@ -1661,14 +1715,14 @@ readonly type: 'OverlappingUpgrades' | 'ProhibitedByPolkadot' | 'TooBig' | 'ValidationDataNotAvailable' | 'HostConfigurationNotAvailable' | 'NotScheduled' | 'NothingAuthorized' | 'Unauthorized'; } - /** @name PalletBalancesBalanceLock (171) */ + /** @name PalletBalancesBalanceLock (176) */ interface PalletBalancesBalanceLock extends Struct { readonly id: U8aFixed; readonly amount: u128; readonly reasons: PalletBalancesReasons; } - /** @name PalletBalancesReasons (172) */ + /** @name PalletBalancesReasons (177) */ interface PalletBalancesReasons extends Enum { readonly isFee: boolean; readonly isMisc: boolean; @@ -1676,20 +1730,20 @@ readonly type: 'Fee' | 'Misc' | 'All'; } - /** @name PalletBalancesReserveData (175) */ + /** @name PalletBalancesReserveData (180) */ interface PalletBalancesReserveData extends Struct { readonly id: U8aFixed; readonly amount: u128; } - /** @name PalletBalancesReleases (177) */ + /** @name PalletBalancesReleases (182) */ interface PalletBalancesReleases extends Enum { readonly isV100: boolean; readonly isV200: boolean; readonly type: 'V100' | 'V200'; } - /** @name PalletBalancesCall (178) */ + /** @name PalletBalancesCall (183) */ interface PalletBalancesCall extends Enum { readonly isTransfer: boolean; readonly asTransfer: { @@ -1726,7 +1780,7 @@ readonly type: 'Transfer' | 'SetBalance' | 'ForceTransfer' | 'TransferKeepAlive' | 'TransferAll' | 'ForceUnreserve'; } - /** @name PalletBalancesError (181) */ + /** @name PalletBalancesError (186) */ interface PalletBalancesError extends Enum { readonly isVestingBalance: boolean; readonly isLiquidityRestrictions: boolean; @@ -1739,7 +1793,7 @@ readonly type: 'VestingBalance' | 'LiquidityRestrictions' | 'InsufficientBalance' | 'ExistentialDeposit' | 'KeepAlive' | 'ExistingVestingSchedule' | 'DeadAccount' | 'TooManyReserves'; } - /** @name PalletTimestampCall (183) */ + /** @name PalletTimestampCall (188) */ interface PalletTimestampCall extends Enum { readonly isSet: boolean; readonly asSet: { @@ -1748,14 +1802,14 @@ readonly type: 'Set'; } - /** @name PalletTransactionPaymentReleases (185) */ + /** @name PalletTransactionPaymentReleases (190) */ interface PalletTransactionPaymentReleases extends Enum { readonly isV1Ancient: boolean; readonly isV2: boolean; readonly type: 'V1Ancient' | 'V2'; } - /** @name PalletTreasuryProposal (186) */ + /** @name PalletTreasuryProposal (191) */ interface PalletTreasuryProposal extends Struct { readonly proposer: AccountId32; readonly value: u128; @@ -1763,7 +1817,7 @@ readonly bond: u128; } - /** @name PalletTreasuryCall (189) */ + /** @name PalletTreasuryCall (194) */ interface PalletTreasuryCall extends Enum { readonly isProposeSpend: boolean; readonly asProposeSpend: { @@ -1790,10 +1844,10 @@ readonly type: 'ProposeSpend' | 'RejectProposal' | 'ApproveProposal' | 'Spend' | 'RemoveApproval'; } - /** @name FrameSupportPalletId (192) */ + /** @name FrameSupportPalletId (197) */ interface FrameSupportPalletId extends U8aFixed {} - /** @name PalletTreasuryError (193) */ + /** @name PalletTreasuryError (198) */ interface PalletTreasuryError extends Enum { readonly isInsufficientProposersBalance: boolean; readonly isInvalidIndex: boolean; @@ -1803,7 +1857,7 @@ readonly type: 'InsufficientProposersBalance' | 'InvalidIndex' | 'TooManyApprovals' | 'InsufficientPermission' | 'ProposalNotApproved'; } - /** @name PalletSudoCall (194) */ + /** @name PalletSudoCall (199) */ interface PalletSudoCall extends Enum { readonly isSudo: boolean; readonly asSudo: { @@ -1826,7 +1880,7 @@ readonly type: 'Sudo' | 'SudoUncheckedWeight' | 'SetKey' | 'SudoAs'; } - /** @name OrmlVestingModuleCall (196) */ + /** @name OrmlVestingModuleCall (201) */ interface OrmlVestingModuleCall extends Enum { readonly isClaim: boolean; readonly isVestedTransfer: boolean; @@ -1846,7 +1900,7 @@ readonly type: 'Claim' | 'VestedTransfer' | 'UpdateVestingSchedules' | 'ClaimFor'; } - /** @name OrmlXtokensModuleCall (198) */ + /** @name OrmlXtokensModuleCall (203) */ interface OrmlXtokensModuleCall extends Enum { readonly isTransfer: boolean; readonly asTransfer: { @@ -1893,7 +1947,7 @@ readonly type: 'Transfer' | 'TransferMultiasset' | 'TransferWithFee' | 'TransferMultiassetWithFee' | 'TransferMulticurrencies' | 'TransferMultiassets'; } - /** @name XcmVersionedMultiAsset (199) */ + /** @name XcmVersionedMultiAsset (204) */ interface XcmVersionedMultiAsset extends Enum { readonly isV0: boolean; readonly asV0: XcmV0MultiAsset; @@ -1902,7 +1956,7 @@ readonly type: 'V0' | 'V1'; } - /** @name OrmlTokensModuleCall (202) */ + /** @name OrmlTokensModuleCall (207) */ interface OrmlTokensModuleCall extends Enum { readonly isTransfer: boolean; readonly asTransfer: { @@ -1939,7 +1993,7 @@ readonly type: 'Transfer' | 'TransferAll' | 'TransferKeepAlive' | 'ForceTransfer' | 'SetBalance'; } - /** @name CumulusPalletXcmpQueueCall (203) */ + /** @name CumulusPalletXcmpQueueCall (208) */ interface CumulusPalletXcmpQueueCall extends Enum { readonly isServiceOverweight: boolean; readonly asServiceOverweight: { @@ -1975,7 +2029,7 @@ readonly type: 'ServiceOverweight' | 'SuspendXcmExecution' | 'ResumeXcmExecution' | 'UpdateSuspendThreshold' | 'UpdateDropThreshold' | 'UpdateResumeThreshold' | 'UpdateThresholdWeight' | 'UpdateWeightRestrictDecay' | 'UpdateXcmpMaxIndividualWeight'; } - /** @name PalletXcmCall (204) */ + /** @name PalletXcmCall (209) */ interface PalletXcmCall extends Enum { readonly isSend: boolean; readonly asSend: { @@ -2037,7 +2091,7 @@ readonly type: 'Send' | 'TeleportAssets' | 'ReserveTransferAssets' | 'Execute' | 'ForceXcmVersion' | 'ForceDefaultXcmVersion' | 'ForceSubscribeVersionNotify' | 'ForceUnsubscribeVersionNotify' | 'LimitedReserveTransferAssets' | 'LimitedTeleportAssets'; } - /** @name XcmVersionedXcm (205) */ + /** @name XcmVersionedXcm (210) */ interface XcmVersionedXcm extends Enum { readonly isV0: boolean; readonly asV0: XcmV0Xcm; @@ -2048,7 +2102,7 @@ readonly type: 'V0' | 'V1' | 'V2'; } - /** @name XcmV0Xcm (206) */ + /** @name XcmV0Xcm (211) */ interface XcmV0Xcm extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: { @@ -2111,7 +2165,7 @@ readonly type: 'WithdrawAsset' | 'ReserveAssetDeposit' | 'TeleportAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'RelayedFrom'; } - /** @name XcmV0Order (208) */ + /** @name XcmV0Order (213) */ interface XcmV0Order extends Enum { readonly isNull: boolean; readonly isDepositAsset: boolean; @@ -2159,14 +2213,14 @@ readonly type: 'Null' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution'; } - /** @name XcmV0Response (210) */ + /** @name XcmV0Response (215) */ interface XcmV0Response extends Enum { readonly isAssets: boolean; readonly asAssets: Vec; readonly type: 'Assets'; } - /** @name XcmV1Xcm (211) */ + /** @name XcmV1Xcm (216) */ interface XcmV1Xcm extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: { @@ -2235,7 +2289,7 @@ readonly type: 'WithdrawAsset' | 'ReserveAssetDeposited' | 'ReceiveTeleportedAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'RelayedFrom' | 'SubscribeVersion' | 'UnsubscribeVersion'; } - /** @name XcmV1Order (213) */ + /** @name XcmV1Order (218) */ interface XcmV1Order extends Enum { readonly isNoop: boolean; readonly isDepositAsset: boolean; @@ -2285,7 +2339,7 @@ readonly type: 'Noop' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution'; } - /** @name XcmV1Response (215) */ + /** @name XcmV1Response (220) */ interface XcmV1Response extends Enum { readonly isAssets: boolean; readonly asAssets: XcmV1MultiassetMultiAssets; @@ -2294,10 +2348,10 @@ readonly type: 'Assets' | 'Version'; } - /** @name CumulusPalletXcmCall (229) */ + /** @name CumulusPalletXcmCall (234) */ type CumulusPalletXcmCall = Null; - /** @name CumulusPalletDmpQueueCall (230) */ + /** @name CumulusPalletDmpQueueCall (235) */ interface CumulusPalletDmpQueueCall extends Enum { readonly isServiceOverweight: boolean; readonly asServiceOverweight: { @@ -2307,7 +2361,7 @@ readonly type: 'ServiceOverweight'; } - /** @name PalletInflationCall (231) */ + /** @name PalletInflationCall (236) */ interface PalletInflationCall extends Enum { readonly isStartInflation: boolean; readonly asStartInflation: { @@ -2316,7 +2370,7 @@ readonly type: 'StartInflation'; } - /** @name PalletUniqueCall (232) */ + /** @name PalletUniqueCall (237) */ interface PalletUniqueCall extends Enum { readonly isCreateCollection: boolean; readonly asCreateCollection: { @@ -2474,7 +2528,7 @@ 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'; } - /** @name UpDataStructsCollectionMode (237) */ + /** @name UpDataStructsCollectionMode (242) */ interface UpDataStructsCollectionMode extends Enum { readonly isNft: boolean; readonly isFungible: boolean; @@ -2483,7 +2537,7 @@ readonly type: 'Nft' | 'Fungible' | 'ReFungible'; } - /** @name UpDataStructsCreateCollectionData (238) */ + /** @name UpDataStructsCreateCollectionData (243) */ interface UpDataStructsCreateCollectionData extends Struct { readonly mode: UpDataStructsCollectionMode; readonly access: Option; @@ -2497,14 +2551,14 @@ readonly properties: Vec; } - /** @name UpDataStructsAccessMode (240) */ + /** @name UpDataStructsAccessMode (245) */ interface UpDataStructsAccessMode extends Enum { readonly isNormal: boolean; readonly isAllowList: boolean; readonly type: 'Normal' | 'AllowList'; } - /** @name UpDataStructsCollectionLimits (242) */ + /** @name UpDataStructsCollectionLimits (247) */ interface UpDataStructsCollectionLimits extends Struct { readonly accountTokenOwnershipLimit: Option; readonly sponsoredDataSize: Option; @@ -2517,7 +2571,7 @@ readonly transfersEnabled: Option; } - /** @name UpDataStructsSponsoringRateLimit (244) */ + /** @name UpDataStructsSponsoringRateLimit (249) */ interface UpDataStructsSponsoringRateLimit extends Enum { readonly isSponsoringDisabled: boolean; readonly isBlocks: boolean; @@ -2525,43 +2579,43 @@ readonly type: 'SponsoringDisabled' | 'Blocks'; } - /** @name UpDataStructsCollectionPermissions (247) */ + /** @name UpDataStructsCollectionPermissions (252) */ interface UpDataStructsCollectionPermissions extends Struct { readonly access: Option; readonly mintMode: Option; readonly nesting: Option; } - /** @name UpDataStructsNestingPermissions (249) */ + /** @name UpDataStructsNestingPermissions (254) */ interface UpDataStructsNestingPermissions extends Struct { readonly tokenOwner: bool; readonly collectionAdmin: bool; readonly restricted: Option; } - /** @name UpDataStructsOwnerRestrictedSet (251) */ + /** @name UpDataStructsOwnerRestrictedSet (256) */ interface UpDataStructsOwnerRestrictedSet extends BTreeSet {} - /** @name UpDataStructsPropertyKeyPermission (256) */ + /** @name UpDataStructsPropertyKeyPermission (261) */ interface UpDataStructsPropertyKeyPermission extends Struct { readonly key: Bytes; readonly permission: UpDataStructsPropertyPermission; } - /** @name UpDataStructsPropertyPermission (257) */ + /** @name UpDataStructsPropertyPermission (262) */ interface UpDataStructsPropertyPermission extends Struct { readonly mutable: bool; readonly collectionAdmin: bool; readonly tokenOwner: bool; } - /** @name UpDataStructsProperty (260) */ + /** @name UpDataStructsProperty (265) */ interface UpDataStructsProperty extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name UpDataStructsCreateItemData (263) */ + /** @name UpDataStructsCreateItemData (268) */ interface UpDataStructsCreateItemData extends Enum { readonly isNft: boolean; readonly asNft: UpDataStructsCreateNftData; @@ -2572,23 +2626,23 @@ readonly type: 'Nft' | 'Fungible' | 'ReFungible'; } - /** @name UpDataStructsCreateNftData (264) */ + /** @name UpDataStructsCreateNftData (269) */ interface UpDataStructsCreateNftData extends Struct { readonly properties: Vec; } - /** @name UpDataStructsCreateFungibleData (265) */ + /** @name UpDataStructsCreateFungibleData (270) */ interface UpDataStructsCreateFungibleData extends Struct { readonly value: u128; } - /** @name UpDataStructsCreateReFungibleData (266) */ + /** @name UpDataStructsCreateReFungibleData (271) */ interface UpDataStructsCreateReFungibleData extends Struct { readonly pieces: u128; readonly properties: Vec; } - /** @name UpDataStructsCreateItemExData (269) */ + /** @name UpDataStructsCreateItemExData (274) */ interface UpDataStructsCreateItemExData extends Enum { readonly isNft: boolean; readonly asNft: Vec; @@ -2601,26 +2655,65 @@ readonly type: 'Nft' | 'Fungible' | 'RefungibleMultipleItems' | 'RefungibleMultipleOwners'; } - /** @name UpDataStructsCreateNftExData (271) */ + /** @name UpDataStructsCreateNftExData (276) */ interface UpDataStructsCreateNftExData extends Struct { readonly properties: Vec; readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } - /** @name UpDataStructsCreateRefungibleExSingleOwner (278) */ + /** @name UpDataStructsCreateRefungibleExSingleOwner (283) */ interface UpDataStructsCreateRefungibleExSingleOwner extends Struct { readonly user: PalletEvmAccountBasicCrossAccountIdRepr; readonly pieces: u128; readonly properties: Vec; } - /** @name UpDataStructsCreateRefungibleExMultipleOwners (280) */ + /** @name UpDataStructsCreateRefungibleExMultipleOwners (285) */ interface UpDataStructsCreateRefungibleExMultipleOwners extends Struct { readonly users: BTreeMap; readonly properties: Vec; } - /** @name PalletConfigurationCall (281) */ + /** @name PalletUniqueSchedulerCall (286) */ + interface PalletUniqueSchedulerCall extends Enum { + readonly isScheduleNamed: boolean; + readonly asScheduleNamed: { + readonly id: U8aFixed; + readonly when: u32; + readonly maybePeriodic: Option>; + readonly priority: Option; + readonly call: FrameSupportScheduleMaybeHashed; + } & Struct; + readonly isCancelNamed: boolean; + readonly asCancelNamed: { + readonly id: U8aFixed; + } & Struct; + readonly isScheduleNamedAfter: boolean; + readonly asScheduleNamedAfter: { + readonly id: U8aFixed; + readonly after: u32; + readonly maybePeriodic: Option>; + readonly priority: Option; + readonly call: FrameSupportScheduleMaybeHashed; + } & Struct; + readonly isChangeNamedPriority: boolean; + readonly asChangeNamedPriority: { + readonly id: U8aFixed; + readonly priority: u8; + } & Struct; + readonly type: 'ScheduleNamed' | 'CancelNamed' | 'ScheduleNamedAfter' | 'ChangeNamedPriority'; + } + + /** @name FrameSupportScheduleMaybeHashed (289) */ + interface FrameSupportScheduleMaybeHashed extends Enum { + readonly isValue: boolean; + readonly asValue: Call; + readonly isHash: boolean; + readonly asHash: H256; + readonly type: 'Value' | 'Hash'; + } + + /** @name PalletConfigurationCall (290) */ interface PalletConfigurationCall extends Enum { readonly isSetWeightToFeeCoefficientOverride: boolean; readonly asSetWeightToFeeCoefficientOverride: { @@ -2633,13 +2726,13 @@ readonly type: 'SetWeightToFeeCoefficientOverride' | 'SetMinGasPriceOverride'; } - /** @name PalletTemplateTransactionPaymentCall (283) */ + /** @name PalletTemplateTransactionPaymentCall (292) */ type PalletTemplateTransactionPaymentCall = Null; - /** @name PalletStructureCall (284) */ + /** @name PalletStructureCall (293) */ type PalletStructureCall = Null; - /** @name PalletRmrkCoreCall (285) */ + /** @name PalletRmrkCoreCall (294) */ interface PalletRmrkCoreCall extends Enum { readonly isCreateCollection: boolean; readonly asCreateCollection: { @@ -2745,7 +2838,7 @@ readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'Send' | 'AcceptNft' | 'RejectNft' | 'AcceptResource' | 'AcceptResourceRemoval' | 'SetProperty' | 'SetPriority' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource' | 'RemoveResource'; } - /** @name RmrkTraitsResourceResourceTypes (291) */ + /** @name RmrkTraitsResourceResourceTypes (300) */ interface RmrkTraitsResourceResourceTypes extends Enum { readonly isBasic: boolean; readonly asBasic: RmrkTraitsResourceBasicResource; @@ -2756,7 +2849,7 @@ readonly type: 'Basic' | 'Composable' | 'Slot'; } - /** @name RmrkTraitsResourceBasicResource (293) */ + /** @name RmrkTraitsResourceBasicResource (302) */ interface RmrkTraitsResourceBasicResource extends Struct { readonly src: Option; readonly metadata: Option; @@ -2764,7 +2857,7 @@ readonly thumb: Option; } - /** @name RmrkTraitsResourceComposableResource (295) */ + /** @name RmrkTraitsResourceComposableResource (304) */ interface RmrkTraitsResourceComposableResource extends Struct { readonly parts: Vec; readonly base: u32; @@ -2774,7 +2867,7 @@ readonly thumb: Option; } - /** @name RmrkTraitsResourceSlotResource (296) */ + /** @name RmrkTraitsResourceSlotResource (305) */ interface RmrkTraitsResourceSlotResource extends Struct { readonly base: u32; readonly src: Option; @@ -2784,7 +2877,7 @@ readonly thumb: Option; } - /** @name PalletRmrkEquipCall (299) */ + /** @name PalletRmrkEquipCall (308) */ interface PalletRmrkEquipCall extends Enum { readonly isCreateBase: boolean; readonly asCreateBase: { @@ -2806,7 +2899,7 @@ readonly type: 'CreateBase' | 'ThemeAdd' | 'Equippable'; } - /** @name RmrkTraitsPartPartType (302) */ + /** @name RmrkTraitsPartPartType (311) */ interface RmrkTraitsPartPartType extends Enum { readonly isFixedPart: boolean; readonly asFixedPart: RmrkTraitsPartFixedPart; @@ -2815,14 +2908,14 @@ readonly type: 'FixedPart' | 'SlotPart'; } - /** @name RmrkTraitsPartFixedPart (304) */ + /** @name RmrkTraitsPartFixedPart (313) */ interface RmrkTraitsPartFixedPart extends Struct { readonly id: u32; readonly z: u32; readonly src: Bytes; } - /** @name RmrkTraitsPartSlotPart (305) */ + /** @name RmrkTraitsPartSlotPart (314) */ interface RmrkTraitsPartSlotPart extends Struct { readonly id: u32; readonly equippable: RmrkTraitsPartEquippableList; @@ -2830,7 +2923,7 @@ readonly z: u32; } - /** @name RmrkTraitsPartEquippableList (306) */ + /** @name RmrkTraitsPartEquippableList (315) */ interface RmrkTraitsPartEquippableList extends Enum { readonly isAll: boolean; readonly isEmpty: boolean; @@ -2839,20 +2932,20 @@ readonly type: 'All' | 'Empty' | 'Custom'; } - /** @name RmrkTraitsTheme (308) */ + /** @name RmrkTraitsTheme (317) */ interface RmrkTraitsTheme extends Struct { readonly name: Bytes; readonly properties: Vec; readonly inherit: bool; } - /** @name RmrkTraitsThemeThemeProperty (310) */ + /** @name RmrkTraitsThemeThemeProperty (319) */ interface RmrkTraitsThemeThemeProperty extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name PalletAppPromotionCall (312) */ + /** @name PalletAppPromotionCall (321) */ interface PalletAppPromotionCall extends Enum { readonly isSetAdminAddress: boolean; readonly asSetAdminAddress: { @@ -2886,7 +2979,7 @@ readonly type: 'SetAdminAddress' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsoringCollection' | 'SponsorContract' | 'StopSponsoringContract' | 'PayoutStakers'; } - /** @name PalletForeignAssetsModuleCall (314) */ + /** @name PalletForeignAssetsModuleCall (322) */ interface PalletForeignAssetsModuleCall extends Enum { readonly isRegisterForeignAsset: boolean; readonly asRegisterForeignAsset: { @@ -2903,7 +2996,7 @@ readonly type: 'RegisterForeignAsset' | 'UpdateForeignAsset'; } - /** @name PalletEvmCall (315) */ + /** @name PalletEvmCall (323) */ interface PalletEvmCall extends Enum { readonly isWithdraw: boolean; readonly asWithdraw: { @@ -2948,7 +3041,7 @@ readonly type: 'Withdraw' | 'Call' | 'Create' | 'Create2'; } - /** @name PalletEthereumCall (319) */ + /** @name PalletEthereumCall (327) */ interface PalletEthereumCall extends Enum { readonly isTransact: boolean; readonly asTransact: { @@ -2957,7 +3050,7 @@ readonly type: 'Transact'; } - /** @name EthereumTransactionTransactionV2 (320) */ + /** @name EthereumTransactionTransactionV2 (328) */ interface EthereumTransactionTransactionV2 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumTransactionLegacyTransaction; @@ -2968,7 +3061,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumTransactionLegacyTransaction (321) */ + /** @name EthereumTransactionLegacyTransaction (329) */ interface EthereumTransactionLegacyTransaction extends Struct { readonly nonce: U256; readonly gasPrice: U256; @@ -2979,7 +3072,7 @@ readonly signature: EthereumTransactionTransactionSignature; } - /** @name EthereumTransactionTransactionAction (322) */ + /** @name EthereumTransactionTransactionAction (330) */ interface EthereumTransactionTransactionAction extends Enum { readonly isCall: boolean; readonly asCall: H160; @@ -2987,14 +3080,14 @@ readonly type: 'Call' | 'Create'; } - /** @name EthereumTransactionTransactionSignature (323) */ + /** @name EthereumTransactionTransactionSignature (331) */ interface EthereumTransactionTransactionSignature extends Struct { readonly v: u64; readonly r: H256; readonly s: H256; } - /** @name EthereumTransactionEip2930Transaction (325) */ + /** @name EthereumTransactionEip2930Transaction (333) */ interface EthereumTransactionEip2930Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -3009,13 +3102,13 @@ readonly s: H256; } - /** @name EthereumTransactionAccessListItem (327) */ + /** @name EthereumTransactionAccessListItem (335) */ interface EthereumTransactionAccessListItem extends Struct { readonly address: H160; readonly storageKeys: Vec; } - /** @name EthereumTransactionEip1559Transaction (328) */ + /** @name EthereumTransactionEip1559Transaction (336) */ interface EthereumTransactionEip1559Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -3031,7 +3124,7 @@ readonly s: H256; } - /** @name PalletEvmMigrationCall (329) */ + /** @name PalletEvmMigrationCall (337) */ interface PalletEvmMigrationCall extends Enum { readonly isBegin: boolean; readonly asBegin: { @@ -3050,13 +3143,41 @@ readonly type: 'Begin' | 'SetData' | 'Finish'; } - /** @name PalletSudoError (332) */ + /** @name PalletMaintenanceCall (340) */ + interface PalletMaintenanceCall extends Enum { + readonly isEnable: boolean; + readonly isDisable: boolean; + readonly type: 'Enable' | 'Disable'; + } + + /** @name PalletTestUtilsCall (341) */ + interface PalletTestUtilsCall extends Enum { + readonly isEnable: boolean; + readonly isSetTestValue: boolean; + readonly asSetTestValue: { + readonly value: u32; + } & Struct; + readonly isSetTestValueAndRollback: boolean; + readonly asSetTestValueAndRollback: { + readonly value: u32; + } & Struct; + readonly isIncTestValue: boolean; + readonly isSelfCancelingInc: boolean; + readonly asSelfCancelingInc: { + readonly id: U8aFixed; + readonly maxTestValue: u32; + } & Struct; + readonly isJustTakeFee: boolean; + readonly type: 'Enable' | 'SetTestValue' | 'SetTestValueAndRollback' | 'IncTestValue' | 'SelfCancelingInc' | 'JustTakeFee'; + } + + /** @name PalletSudoError (342) */ interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: 'RequireSudo'; } - /** @name OrmlVestingModuleError (334) */ + /** @name OrmlVestingModuleError (344) */ interface OrmlVestingModuleError extends Enum { readonly isZeroVestingPeriod: boolean; readonly isZeroVestingPeriodCount: boolean; @@ -3067,7 +3188,7 @@ readonly type: 'ZeroVestingPeriod' | 'ZeroVestingPeriodCount' | 'InsufficientBalanceToLock' | 'TooManyVestingSchedules' | 'AmountLow' | 'MaxVestingSchedulesExceeded'; } - /** @name OrmlXtokensModuleError (335) */ + /** @name OrmlXtokensModuleError (345) */ interface OrmlXtokensModuleError extends Enum { readonly isAssetHasNoReserve: boolean; readonly isNotCrossChainTransfer: boolean; @@ -3091,26 +3212,26 @@ readonly type: 'AssetHasNoReserve' | 'NotCrossChainTransfer' | 'InvalidDest' | 'NotCrossChainTransferableCurrency' | 'UnweighableMessage' | 'XcmExecutionFailed' | 'CannotReanchor' | 'InvalidAncestry' | 'InvalidAsset' | 'DestinationNotInvertible' | 'BadVersion' | 'DistinctReserveForAssetAndFee' | 'ZeroFee' | 'ZeroAmount' | 'TooManyAssetsBeingSent' | 'AssetIndexNonExistent' | 'FeeNotEnough' | 'NotSupportedMultiLocation' | 'MinXcmFeeNotDefined'; } - /** @name OrmlTokensBalanceLock (338) */ + /** @name OrmlTokensBalanceLock (348) */ interface OrmlTokensBalanceLock extends Struct { readonly id: U8aFixed; readonly amount: u128; } - /** @name OrmlTokensAccountData (340) */ + /** @name OrmlTokensAccountData (350) */ interface OrmlTokensAccountData extends Struct { readonly free: u128; readonly reserved: u128; readonly frozen: u128; } - /** @name OrmlTokensReserveData (342) */ + /** @name OrmlTokensReserveData (352) */ interface OrmlTokensReserveData extends Struct { readonly id: Null; readonly amount: u128; } - /** @name OrmlTokensModuleError (344) */ + /** @name OrmlTokensModuleError (354) */ interface OrmlTokensModuleError extends Enum { readonly isBalanceTooLow: boolean; readonly isAmountIntoBalanceFailed: boolean; @@ -3123,21 +3244,21 @@ readonly type: 'BalanceTooLow' | 'AmountIntoBalanceFailed' | 'LiquidityRestrictions' | 'MaxLocksExceeded' | 'KeepAlive' | 'ExistentialDeposit' | 'DeadAccount' | 'TooManyReserves'; } - /** @name CumulusPalletXcmpQueueInboundChannelDetails (346) */ + /** @name CumulusPalletXcmpQueueInboundChannelDetails (356) */ interface CumulusPalletXcmpQueueInboundChannelDetails extends Struct { readonly sender: u32; readonly state: CumulusPalletXcmpQueueInboundState; readonly messageMetadata: Vec>; } - /** @name CumulusPalletXcmpQueueInboundState (347) */ + /** @name CumulusPalletXcmpQueueInboundState (357) */ interface CumulusPalletXcmpQueueInboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name PolkadotParachainPrimitivesXcmpMessageFormat (350) */ + /** @name PolkadotParachainPrimitivesXcmpMessageFormat (360) */ interface PolkadotParachainPrimitivesXcmpMessageFormat extends Enum { readonly isConcatenatedVersionedXcm: boolean; readonly isConcatenatedEncodedBlob: boolean; @@ -3145,7 +3266,7 @@ readonly type: 'ConcatenatedVersionedXcm' | 'ConcatenatedEncodedBlob' | 'Signals'; } - /** @name CumulusPalletXcmpQueueOutboundChannelDetails (353) */ + /** @name CumulusPalletXcmpQueueOutboundChannelDetails (363) */ interface CumulusPalletXcmpQueueOutboundChannelDetails extends Struct { readonly recipient: u32; readonly state: CumulusPalletXcmpQueueOutboundState; @@ -3154,14 +3275,14 @@ readonly lastIndex: u16; } - /** @name CumulusPalletXcmpQueueOutboundState (354) */ + /** @name CumulusPalletXcmpQueueOutboundState (364) */ interface CumulusPalletXcmpQueueOutboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name CumulusPalletXcmpQueueQueueConfigData (356) */ + /** @name CumulusPalletXcmpQueueQueueConfigData (366) */ interface CumulusPalletXcmpQueueQueueConfigData extends Struct { readonly suspendThreshold: u32; readonly dropThreshold: u32; @@ -3171,7 +3292,7 @@ readonly xcmpMaxIndividualWeight: Weight; } - /** @name CumulusPalletXcmpQueueError (358) */ + /** @name CumulusPalletXcmpQueueError (368) */ interface CumulusPalletXcmpQueueError extends Enum { readonly isFailedToSend: boolean; readonly isBadXcmOrigin: boolean; @@ -3181,7 +3302,7 @@ readonly type: 'FailedToSend' | 'BadXcmOrigin' | 'BadXcm' | 'BadOverweightIndex' | 'WeightOverLimit'; } - /** @name PalletXcmError (359) */ + /** @name PalletXcmError (369) */ interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -3199,29 +3320,29 @@ readonly type: 'Unreachable' | 'SendFailure' | 'Filtered' | 'UnweighableMessage' | 'DestinationNotInvertible' | 'Empty' | 'CannotReanchor' | 'TooManyAssets' | 'InvalidOrigin' | 'BadVersion' | 'BadLocation' | 'NoSubscription' | 'AlreadySubscribed'; } - /** @name CumulusPalletXcmError (360) */ + /** @name CumulusPalletXcmError (370) */ type CumulusPalletXcmError = Null; - /** @name CumulusPalletDmpQueueConfigData (361) */ + /** @name CumulusPalletDmpQueueConfigData (371) */ interface CumulusPalletDmpQueueConfigData extends Struct { readonly maxIndividual: Weight; } - /** @name CumulusPalletDmpQueuePageIndexData (362) */ + /** @name CumulusPalletDmpQueuePageIndexData (372) */ interface CumulusPalletDmpQueuePageIndexData extends Struct { readonly beginUsed: u32; readonly endUsed: u32; readonly overweightCount: u64; } - /** @name CumulusPalletDmpQueueError (365) */ + /** @name CumulusPalletDmpQueueError (375) */ interface CumulusPalletDmpQueueError extends Enum { readonly isUnknown: boolean; readonly isOverLimit: boolean; readonly type: 'Unknown' | 'OverLimit'; } - /** @name PalletUniqueError (369) */ + /** @name PalletUniqueError (379) */ interface PalletUniqueError extends Enum { readonly isCollectionDecimalPointLimitExceeded: boolean; readonly isConfirmUnsetSponsorFail: boolean; @@ -3230,7 +3351,75 @@ readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument' | 'RepartitionCalledOnNonRefungibleCollection'; } - /** @name UpDataStructsCollection (370) */ + /** @name PalletUniqueSchedulerScheduledV3 (382) */ + interface PalletUniqueSchedulerScheduledV3 extends Struct { + readonly maybeId: Option; + readonly priority: u8; + readonly call: FrameSupportScheduleMaybeHashed; + readonly maybePeriodic: Option>; + readonly origin: OpalRuntimeOriginCaller; + } + + /** @name OpalRuntimeOriginCaller (383) */ + interface OpalRuntimeOriginCaller extends Enum { + readonly isSystem: boolean; + readonly asSystem: FrameSupportDispatchRawOrigin; + readonly isVoid: boolean; + readonly isPolkadotXcm: boolean; + readonly asPolkadotXcm: PalletXcmOrigin; + readonly isCumulusXcm: boolean; + readonly asCumulusXcm: CumulusPalletXcmOrigin; + readonly isEthereum: boolean; + readonly asEthereum: PalletEthereumRawOrigin; + readonly type: 'System' | 'Void' | 'PolkadotXcm' | 'CumulusXcm' | 'Ethereum'; + } + + /** @name FrameSupportDispatchRawOrigin (384) */ + interface FrameSupportDispatchRawOrigin extends Enum { + readonly isRoot: boolean; + readonly isSigned: boolean; + readonly asSigned: AccountId32; + readonly isNone: boolean; + readonly type: 'Root' | 'Signed' | 'None'; + } + + /** @name PalletXcmOrigin (385) */ + interface PalletXcmOrigin extends Enum { + readonly isXcm: boolean; + readonly asXcm: XcmV1MultiLocation; + readonly isResponse: boolean; + readonly asResponse: XcmV1MultiLocation; + readonly type: 'Xcm' | 'Response'; + } + + /** @name CumulusPalletXcmOrigin (386) */ + interface CumulusPalletXcmOrigin extends Enum { + readonly isRelay: boolean; + readonly isSiblingParachain: boolean; + readonly asSiblingParachain: u32; + readonly type: 'Relay' | 'SiblingParachain'; + } + + /** @name PalletEthereumRawOrigin (387) */ + interface PalletEthereumRawOrigin extends Enum { + readonly isEthereumTransaction: boolean; + readonly asEthereumTransaction: H160; + readonly type: 'EthereumTransaction'; + } + + /** @name SpCoreVoid (388) */ + type SpCoreVoid = Null; + + /** @name PalletUniqueSchedulerError (389) */ + interface PalletUniqueSchedulerError extends Enum { + readonly isFailedToSchedule: boolean; + readonly isNotFound: boolean; + readonly isTargetBlockNumberInPast: boolean; + readonly isRescheduleNoChange: boolean; + readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange'; + } + + /** @name UpDataStructsCollection (390) */ interface UpDataStructsCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -3243,7 +3432,7 @@ readonly flags: U8aFixed; } - /** @name UpDataStructsSponsorshipStateAccountId32 (371) */ + /** @name UpDataStructsSponsorshipStateAccountId32 (391) */ interface UpDataStructsSponsorshipStateAccountId32 extends Enum { readonly isDisabled: boolean; readonly isUnconfirmed: boolean; @@ -3253,43 +3442,43 @@ readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed'; } - /** @name UpDataStructsProperties (373) */ + /** @name UpDataStructsProperties (393) */ interface UpDataStructsProperties extends Struct { readonly map: UpDataStructsPropertiesMapBoundedVec; readonly consumedSpace: u32; readonly spaceLimit: u32; } - /** @name UpDataStructsPropertiesMapBoundedVec (374) */ + /** @name UpDataStructsPropertiesMapBoundedVec (394) */ interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap {} - /** @name UpDataStructsPropertiesMapPropertyPermission (379) */ + /** @name UpDataStructsPropertiesMapPropertyPermission (399) */ interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap {} - /** @name UpDataStructsCollectionStats (386) */ + /** @name UpDataStructsCollectionStats (406) */ interface UpDataStructsCollectionStats extends Struct { readonly created: u32; readonly destroyed: u32; readonly alive: u32; } - /** @name UpDataStructsTokenChild (387) */ + /** @name UpDataStructsTokenChild (407) */ interface UpDataStructsTokenChild extends Struct { readonly token: u32; readonly collection: u32; } - /** @name PhantomTypeUpDataStructs (388) */ + /** @name PhantomTypeUpDataStructs (408) */ interface PhantomTypeUpDataStructs extends Vec> {} - /** @name UpDataStructsTokenData (390) */ + /** @name UpDataStructsTokenData (410) */ interface UpDataStructsTokenData extends Struct { readonly properties: Vec; readonly owner: Option; readonly pieces: u128; } - /** @name UpDataStructsRpcCollection (392) */ + /** @name UpDataStructsRpcCollection (412) */ interface UpDataStructsRpcCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -3305,13 +3494,13 @@ readonly flags: UpDataStructsRpcCollectionFlags; } - /** @name UpDataStructsRpcCollectionFlags (393) */ + /** @name UpDataStructsRpcCollectionFlags (413) */ interface UpDataStructsRpcCollectionFlags extends Struct { readonly foreign: bool; readonly erc721metadata: bool; } - /** @name RmrkTraitsCollectionCollectionInfo (394) */ + /** @name RmrkTraitsCollectionCollectionInfo (414) */ interface RmrkTraitsCollectionCollectionInfo extends Struct { readonly issuer: AccountId32; readonly metadata: Bytes; @@ -3320,7 +3509,7 @@ readonly nftsCount: u32; } - /** @name RmrkTraitsNftNftInfo (395) */ + /** @name RmrkTraitsNftNftInfo (415) */ interface RmrkTraitsNftNftInfo extends Struct { readonly owner: RmrkTraitsNftAccountIdOrCollectionNftTuple; readonly royalty: Option; @@ -3329,13 +3518,13 @@ readonly pending: bool; } - /** @name RmrkTraitsNftRoyaltyInfo (397) */ + /** @name RmrkTraitsNftRoyaltyInfo (417) */ interface RmrkTraitsNftRoyaltyInfo extends Struct { readonly recipient: AccountId32; readonly amount: Permill; } - /** @name RmrkTraitsResourceResourceInfo (398) */ + /** @name RmrkTraitsResourceResourceInfo (418) */ interface RmrkTraitsResourceResourceInfo extends Struct { readonly id: u32; readonly resource: RmrkTraitsResourceResourceTypes; @@ -3343,26 +3532,26 @@ readonly pendingRemoval: bool; } - /** @name RmrkTraitsPropertyPropertyInfo (399) */ + /** @name RmrkTraitsPropertyPropertyInfo (419) */ interface RmrkTraitsPropertyPropertyInfo extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name RmrkTraitsBaseBaseInfo (400) */ + /** @name RmrkTraitsBaseBaseInfo (420) */ interface RmrkTraitsBaseBaseInfo extends Struct { readonly issuer: AccountId32; readonly baseType: Bytes; readonly symbol: Bytes; } - /** @name RmrkTraitsNftNftChild (401) */ + /** @name RmrkTraitsNftNftChild (421) */ interface RmrkTraitsNftNftChild extends Struct { readonly collectionId: u32; readonly nftId: u32; } - /** @name PalletCommonError (403) */ + /** @name PalletCommonError (423) */ interface PalletCommonError extends Enum { readonly isCollectionNotFound: boolean; readonly isMustBeTokenOwner: boolean; @@ -3401,7 +3590,7 @@ 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'; } - /** @name PalletFungibleError (405) */ + /** @name PalletFungibleError (425) */ interface PalletFungibleError extends Enum { readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isFungibleItemsHaveNoId: boolean; @@ -3411,12 +3600,12 @@ readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } - /** @name PalletRefungibleItemData (406) */ + /** @name PalletRefungibleItemData (426) */ interface PalletRefungibleItemData extends Struct { readonly constData: Bytes; } - /** @name PalletRefungibleError (411) */ + /** @name PalletRefungibleError (431) */ interface PalletRefungibleError extends Enum { readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isWrongRefungiblePieces: boolean; @@ -3426,19 +3615,19 @@ readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RepartitionWhileNotOwningAllPieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } - /** @name PalletNonfungibleItemData (412) */ + /** @name PalletNonfungibleItemData (432) */ interface PalletNonfungibleItemData extends Struct { readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } - /** @name UpDataStructsPropertyScope (414) */ + /** @name UpDataStructsPropertyScope (434) */ interface UpDataStructsPropertyScope extends Enum { readonly isNone: boolean; readonly isRmrk: boolean; readonly type: 'None' | 'Rmrk'; } - /** @name PalletNonfungibleError (416) */ + /** @name PalletNonfungibleError (436) */ interface PalletNonfungibleError extends Enum { readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isNonfungibleItemsHaveNoAmount: boolean; @@ -3446,7 +3635,7 @@ readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount' | 'CantBurnNftWithChildren'; } - /** @name PalletStructureError (417) */ + /** @name PalletStructureError (437) */ interface PalletStructureError extends Enum { readonly isOuroborosDetected: boolean; readonly isDepthLimit: boolean; @@ -3455,7 +3644,7 @@ readonly type: 'OuroborosDetected' | 'DepthLimit' | 'BreadthLimit' | 'TokenNotFound'; } - /** @name PalletRmrkCoreError (418) */ + /** @name PalletRmrkCoreError (438) */ interface PalletRmrkCoreError extends Enum { readonly isCorruptedCollectionType: boolean; readonly isRmrkPropertyKeyIsTooLong: boolean; @@ -3479,7 +3668,7 @@ readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId'; } - /** @name PalletRmrkEquipError (420) */ + /** @name PalletRmrkEquipError (440) */ interface PalletRmrkEquipError extends Enum { readonly isPermissionError: boolean; readonly isNoAvailableBaseId: boolean; @@ -3491,7 +3680,7 @@ readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart'; } - /** @name PalletAppPromotionError (426) */ + /** @name PalletAppPromotionError (446) */ interface PalletAppPromotionError extends Enum { readonly isAdminNotSet: boolean; readonly isNoPermission: boolean; @@ -3502,7 +3691,7 @@ readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFunds' | 'PendingForBlockOverflow' | 'SponsorNotSet' | 'IncorrectLockedBalanceOperation'; } - /** @name PalletForeignAssetsModuleError (427) */ + /** @name PalletForeignAssetsModuleError (447) */ interface PalletForeignAssetsModuleError extends Enum { readonly isBadLocation: boolean; readonly isMultiLocationExisted: boolean; @@ -3511,7 +3700,7 @@ readonly type: 'BadLocation' | 'MultiLocationExisted' | 'AssetIdNotExists' | 'AssetIdExisted'; } - /** @name PalletEvmError (430) */ + /** @name PalletEvmError (450) */ interface PalletEvmError extends Enum { readonly isBalanceLow: boolean; readonly isFeeOverflow: boolean; @@ -3522,7 +3711,7 @@ readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce'; } - /** @name FpRpcTransactionStatus (433) */ + /** @name FpRpcTransactionStatus (453) */ interface FpRpcTransactionStatus extends Struct { readonly transactionHash: H256; readonly transactionIndex: u32; @@ -3533,10 +3722,10 @@ readonly logsBloom: EthbloomBloom; } - /** @name EthbloomBloom (435) */ + /** @name EthbloomBloom (455) */ interface EthbloomBloom extends U8aFixed {} - /** @name EthereumReceiptReceiptV3 (437) */ + /** @name EthereumReceiptReceiptV3 (457) */ interface EthereumReceiptReceiptV3 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumReceiptEip658ReceiptData; @@ -3547,7 +3736,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumReceiptEip658ReceiptData (438) */ + /** @name EthereumReceiptEip658ReceiptData (458) */ interface EthereumReceiptEip658ReceiptData extends Struct { readonly statusCode: u8; readonly usedGas: U256; @@ -3555,14 +3744,14 @@ readonly logs: Vec; } - /** @name EthereumBlock (439) */ + /** @name EthereumBlock (459) */ interface EthereumBlock extends Struct { readonly header: EthereumHeader; readonly transactions: Vec; readonly ommers: Vec; } - /** @name EthereumHeader (440) */ + /** @name EthereumHeader (460) */ interface EthereumHeader extends Struct { readonly parentHash: H256; readonly ommersHash: H256; @@ -3581,24 +3770,24 @@ readonly nonce: EthereumTypesHashH64; } - /** @name EthereumTypesHashH64 (441) */ + /** @name EthereumTypesHashH64 (461) */ interface EthereumTypesHashH64 extends U8aFixed {} - /** @name PalletEthereumError (446) */ + /** @name PalletEthereumError (466) */ interface PalletEthereumError extends Enum { readonly isInvalidSignature: boolean; readonly isPreLogExists: boolean; readonly type: 'InvalidSignature' | 'PreLogExists'; } - /** @name PalletEvmCoderSubstrateError (447) */ + /** @name PalletEvmCoderSubstrateError (467) */ interface PalletEvmCoderSubstrateError extends Enum { readonly isOutOfGas: boolean; readonly isOutOfFund: boolean; readonly type: 'OutOfGas' | 'OutOfFund'; } - /** @name UpDataStructsSponsorshipStateBasicCrossAccountIdRepr (448) */ + /** @name UpDataStructsSponsorshipStateBasicCrossAccountIdRepr (468) */ interface UpDataStructsSponsorshipStateBasicCrossAccountIdRepr extends Enum { readonly isDisabled: boolean; readonly isUnconfirmed: boolean; @@ -3608,7 +3797,7 @@ readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed'; } - /** @name PalletEvmContractHelpersSponsoringModeT (449) */ + /** @name PalletEvmContractHelpersSponsoringModeT (469) */ interface PalletEvmContractHelpersSponsoringModeT extends Enum { readonly isDisabled: boolean; readonly isAllowlisted: boolean; @@ -3616,7 +3805,7 @@ readonly type: 'Disabled' | 'Allowlisted' | 'Generous'; } - /** @name PalletEvmContractHelpersError (455) */ + /** @name PalletEvmContractHelpersError (475) */ interface PalletEvmContractHelpersError extends Enum { readonly isNoPermission: boolean; readonly isNoPendingSponsor: boolean; @@ -3624,14 +3813,24 @@ readonly type: 'NoPermission' | 'NoPendingSponsor' | 'TooManyMethodsHaveSponsoredLimit'; } - /** @name PalletEvmMigrationError (456) */ + /** @name PalletEvmMigrationError (476) */ interface PalletEvmMigrationError extends Enum { readonly isAccountNotEmpty: boolean; readonly isAccountIsNotMigrating: boolean; readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating'; } - /** @name SpRuntimeMultiSignature (458) */ + /** @name PalletMaintenanceError (477) */ + type PalletMaintenanceError = Null; + + /** @name PalletTestUtilsError (478) */ + interface PalletTestUtilsError extends Enum { + readonly isTestPalletDisabled: boolean; + readonly isTriggerRollback: boolean; + readonly type: 'TestPalletDisabled' | 'TriggerRollback'; + } + + /** @name SpRuntimeMultiSignature (480) */ interface SpRuntimeMultiSignature extends Enum { readonly isEd25519: boolean; readonly asEd25519: SpCoreEd25519Signature; @@ -3642,37 +3841,40 @@ readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa'; } - /** @name SpCoreEd25519Signature (459) */ + /** @name SpCoreEd25519Signature (481) */ interface SpCoreEd25519Signature extends U8aFixed {} - /** @name SpCoreSr25519Signature (461) */ + /** @name SpCoreSr25519Signature (483) */ interface SpCoreSr25519Signature extends U8aFixed {} - /** @name SpCoreEcdsaSignature (462) */ + /** @name SpCoreEcdsaSignature (484) */ interface SpCoreEcdsaSignature extends U8aFixed {} - /** @name FrameSystemExtensionsCheckSpecVersion (465) */ + /** @name FrameSystemExtensionsCheckSpecVersion (487) */ type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckTxVersion (466) */ + /** @name FrameSystemExtensionsCheckTxVersion (488) */ type FrameSystemExtensionsCheckTxVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (467) */ + /** @name FrameSystemExtensionsCheckGenesis (489) */ type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (470) */ + /** @name FrameSystemExtensionsCheckNonce (492) */ interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (471) */ + /** @name FrameSystemExtensionsCheckWeight (493) */ type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (472) */ + /** @name OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance (494) */ + type OpalRuntimeRuntimeCommonMaintenanceCheckMaintenance = Null; + + /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (495) */ interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name OpalRuntimeRuntime (473) */ + /** @name OpalRuntimeRuntime (496) */ type OpalRuntimeRuntime = Null; - /** @name PalletEthereumFakeTransactionFinalizer (474) */ + /** @name PalletEthereumFakeTransactionFinalizer (497) */ type PalletEthereumFakeTransactionFinalizer = Null; } // declare module --- /dev/null +++ b/tests/src/maintenanceMode.seqtest.ts @@ -0,0 +1,266 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import {IKeyringPair} from '@polkadot/types/types'; +import {ApiPromise} from '@polkadot/api'; +import {expect, itSub, Pallets, usingPlaygrounds} from './util'; +import {itEth} from './eth/util'; + +async function maintenanceEnabled(api: ApiPromise): Promise { + return (await api.query.maintenance.enabled()).toJSON() as boolean; +} + +describe('Integration Test: Maintenance Mode', () => { + let superuser: IKeyringPair; + let donor: IKeyringPair; + let bob: IKeyringPair; + + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + superuser = await privateKey('//Alice'); + donor = await privateKey({filename: __filename}); + [bob] = await helper.arrange.createAccounts([100n], donor); + + if (await maintenanceEnabled(helper.getApi())) { + console.warn('\tMaintenance mode was left enabled BEFORE the test suite! Disabling it now.'); + await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', [])).to.be.fulfilled; + } + }); + }); + + itSub('Allows superuser to enable and disable maintenance mode - and disallows anyone else', async ({helper}) => { + // Make sure non-sudo can't enable maintenance mode + await expect(helper.executeExtrinsic(superuser, 'api.tx.maintenance.enable', []), 'on commoner enabling MM') + .to.be.rejectedWith(/BadOrigin/); + + // Set maintenance mode + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + // Make sure non-sudo can't disable maintenance mode + await expect(helper.executeExtrinsic(bob, 'api.tx.maintenance.disable', []), 'on commoner disabling MM') + .to.be.rejectedWith(/BadOrigin/); + + // Disable maintenance mode + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + }); + + itSub('MM blocks unique pallet calls', async ({helper}) => { + // Can create an NFT collection before enabling the MM + const nftCollection = await helper.nft.mintCollection(bob, { + tokenPropertyPermissions: [{key: 'test', permission: { + collectionAdmin: true, + tokenOwner: true, + mutable: true, + }}], + }); + + // Can mint an NFT before enabling the MM + const nft = await nftCollection.mintToken(bob); + + // Can create an FT collection before enabling the MM + const ftCollection = await helper.ft.mintCollection(superuser); + + // Can mint an FT before enabling the MM + await expect(ftCollection.mint(superuser)).to.be.fulfilled; + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + // Unable to create a collection when the MM is enabled + await expect(helper.nft.mintCollection(superuser), 'cudo forbidden stuff') + .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/); + + // Unable to set token properties when the MM is enabled + await expect(nft.setProperties( + bob, + [{key: 'test', value: 'test-val'}], + )).to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/); + + // Unable to mint an NFT when the MM is enabled + await expect(nftCollection.mintToken(superuser)) + .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/); + + // Unable to mint an FT when the MM is enabled + await expect(ftCollection.mint(superuser)) + .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/); + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + + // Can create a collection after disabling the MM + await expect(helper.nft.mintCollection(bob), 'MM is disabled, the collection should be created').to.be.fulfilled; + + // Can set token properties after disabling the MM + await nft.setProperties(bob, [{key: 'test', value: 'test-val'}]); + + // Can mint an NFT after disabling the MM + await nftCollection.mintToken(bob); + + // Can mint an FT after disabling the MM + await ftCollection.mint(superuser); + }); + + itSub.ifWithPallets('MM blocks unique pallet calls (Re-Fungible)', [Pallets.ReFungible], async ({helper}) => { + // Can create an RFT collection before enabling the MM + const rftCollection = await helper.rft.mintCollection(superuser); + + // Can mint an RFT before enabling the MM + await expect(rftCollection.mintToken(superuser)).to.be.fulfilled; + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + // Unable to mint an RFT when the MM is enabled + await expect(rftCollection.mintToken(superuser)) + .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/); + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + + // Can mint an RFT after disabling the MM + await rftCollection.mintToken(superuser); + }); + + itSub('MM allows native token transfers and RPC calls', async ({helper}) => { + // We can use RPC before the MM is enabled + const totalCount = await helper.collection.getTotalCount(); + + // We can transfer funds before the MM is enabled + await expect(helper.balance.transferToSubstrate(superuser, bob.address, 2n)).to.be.fulfilled; + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + // RPCs work while in maintenance + expect(await helper.collection.getTotalCount()).to.be.deep.equal(totalCount); + + // We still able to transfer funds + await expect(helper.balance.transferToSubstrate(bob, superuser.address, 1n)).to.be.fulfilled; + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + + // RPCs work after maintenance + expect(await helper.collection.getTotalCount()).to.be.deep.equal(totalCount); + + // Transfers work after maintenance + await expect(helper.balance.transferToSubstrate(bob, superuser.address, 1n)).to.be.fulfilled; + }); + + itSub.ifWithPallets('MM blocks scheduled calls and the scheduler itself', [Pallets.Scheduler], async ({helper}) => { + const collection = await helper.nft.mintCollection(bob); + + const nftBeforeMM = await collection.mintToken(bob); + const nftDuringMM = await collection.mintToken(bob); + const nftAfterMM = await collection.mintToken(bob); + + const scheduledIdBeforeMM = '0x' + '0'.repeat(31) + '0'; + const scheduledIdDuringMM = '0x' + '0'.repeat(31) + '1'; + const scheduledIdBunkerThroughMM = '0x' + '0'.repeat(31) + '2'; + const scheduledIdAttemptDuringMM = '0x' + '0'.repeat(31) + '3'; + const scheduledIdAfterMM = '0x' + '0'.repeat(31) + '4'; + + const blocksToWait = 6; + + // Scheduling works before the maintenance + await nftBeforeMM.scheduleAfter(scheduledIdBeforeMM, blocksToWait) + .transfer(bob, {Substrate: superuser.address}); + + await helper.wait.newBlocks(blocksToWait + 1); + expect(await nftBeforeMM.getOwner()).to.be.deep.equal({Substrate: superuser.address}); + + // Schedule a transaction that should occur *during* the maintenance + await nftDuringMM.scheduleAfter(scheduledIdDuringMM, blocksToWait) + .transfer(bob, {Substrate: superuser.address}); + + // Schedule a transaction that should occur *after* the maintenance + await nftDuringMM.scheduleAfter(scheduledIdBunkerThroughMM, blocksToWait * 2) + .transfer(bob, {Substrate: superuser.address}); + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + await helper.wait.newBlocks(blocksToWait + 1); + // The owner should NOT change since the scheduled transaction should be rejected + expect(await nftDuringMM.getOwner()).to.be.deep.equal({Substrate: bob.address}); + + // Any attempts to schedule a tx during the MM should be rejected + await expect(nftDuringMM.scheduleAfter(scheduledIdAttemptDuringMM, blocksToWait) + .transfer(bob, {Substrate: superuser.address})) + .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/); + + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + + // Scheduling works after the maintenance + await nftAfterMM.scheduleAfter(scheduledIdAfterMM, blocksToWait) + .transfer(bob, {Substrate: superuser.address}); + + await helper.wait.newBlocks(blocksToWait + 1); + + expect(await nftAfterMM.getOwner()).to.be.deep.equal({Substrate: superuser.address}); + // The owner of the token scheduled for transaction *before* maintenance should now change *after* maintenance + expect(await nftDuringMM.getOwner()).to.be.deep.equal({Substrate: superuser.address}); + }); + + itEth('Disallows Ethereum transactions to execute while in maintenance', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const receiver = helper.eth.createAccount(); + + const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'A', 'B', 'C', ''); + + // Set maintenance mode + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner); + const tokenId = await contract.methods.nextTokenId().call(); + expect(tokenId).to.be.equal('1'); + + await expect(contract.methods.mintWithTokenURI(receiver, 'Test URI').send()) + .to.be.rejectedWith(/submit transaction to pool failed: Pool\(InvalidTransaction\(InvalidTransaction::Call\)\)/); + + await expect(contract.methods.ownerOf(tokenId).call()).rejectedWith(/token not found/); + + // Disable maintenance mode + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + }); + + itSub('Allows to enable and disable MM repeatedly', async ({helper}) => { + // Set maintenance mode + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true; + + // Disable maintenance mode + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false; + }); + + afterEach(async () => { + await usingPlaygrounds(async helper => { + if (await maintenanceEnabled(helper.getApi())) { + console.warn('\tMaintenance mode was left enabled AFTER a test has finished! Be careful. Disabling it now.'); + await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []); + } + expect(await maintenanceEnabled(helper.getApi()), 'Disastrous! Exited the test suite with maintenance mode on.').to.be.false; + }); + }); +}); --- a/tests/src/pallet-presence.test.ts +++ b/tests/src/pallet-presence.test.ts @@ -47,6 +47,7 @@ 'configuration', 'tokens', 'xtokens', + 'maintenance', ]; // Pallets that depend on consensus and governance configuration --- a/tests/src/util/playgrounds/unique.dev.ts +++ b/tests/src/util/playgrounds/unique.dev.ts @@ -86,6 +86,10 @@ extrinsic: {}, payload: {}, }, + CheckMaintenance: { + extrinsic: {}, + payload: {}, + }, FakeTransactionFinalizer: { extrinsic: {}, payload: {}, -- gitstuff