From f8b66f38f93dc8fb2a1bbe9d2e44d14d21cbd1ca Mon Sep 17 00:00:00 2001 From: girazoki Date: Tue, 5 Nov 2024 16:36:10 +0100 Subject: [PATCH] External operator slashes info pallet (#727) * Add pallet_external_validators, remove ValidatorManager * Rename extrinsics and add tests * Fix tests * Fix benchmarks * typescript-api * first version stored * Add traits * slowly add stuff * Some PR comments * Change era every n sessions * confirmed and unconfirmed, tests * rename pallet * WIP integration test and hooks * good tests for once * Benchmark new extrinsics * Migrate queued keys instead of current validators * typescript-api * Add era index to hook * impl for tuples * Make tests pass * adapt * continue progress * remove comments * Add integration tests * fixes but pallet incorporated to runtime * added sessionINterface * add offence handler * current era and active era * typescript-api * add invulnerables * Add one typescript test * a few more fixes * more tests * console log * benchmarks * benchmarks generated * a little bit of cleanup * a bit more cleanup * zepter * toml-maid * refactor tests * run_to_block not working * a few fixes2 * Unit tests still not working * Fix unit tests * test babe slashes * slashes tests ts * Start era 0 in session 0 * more slashing tests * one more test * Rewrite pallet logic, copy it from pallet_staking * Test hook calls * testing finished * typescript-api * Add era session start to trait * test cleanup * fmt and typescript api * a few fixes here and there * change a few things * pr comments * wip * typescript-api * typescript-api * new tests * typescript api * try now * Test migration * fix last test * clippy * slashes formatting * ts api * api * fix clippy * typescript api new * wip * fmt * first pr review fixes * more pr feedback * more fmt and pr fixes * remove weight * add doc * add correct typescript api --------- Co-authored-by: Tomasz Polaczyk --- Cargo.lock | 22 + Cargo.toml | 2 + pallets/external-validator-slashes/Cargo.toml | 68 ++ .../src/benchmarking.rs | 95 ++ pallets/external-validator-slashes/src/lib.rs | 510 ++++++++++ .../external-validator-slashes/src/mock.rs | 240 +++++ .../external-validator-slashes/src/tests.rs | 288 ++++++ .../external-validator-slashes/src/weights.rs | 129 +++ solo-chains/runtime/dancelight/Cargo.toml | 5 + solo-chains/runtime/dancelight/src/lib.rs | 41 +- .../dancelight/src/tests/common/mod.rs | 102 ++ .../runtime/dancelight/src/tests/mod.rs | 1 + .../runtime/dancelight/src/tests/slashes.rs | 396 ++++++++ .../runtime/dancelight/src/weights/mod.rs | 1 + .../pallet_external_validator_slashes.rs | 88 ++ ...lashes_are_confirmed_after_defer_period.ts | 98 ++ ...hes_are_not_applicable_to_invulnerables.ts | 70 ++ ...lashes_are_removed_after_bonding_period.ts | 99 ++ .../slashes/test_slashes_babe.ts | 79 ++ .../slashes/test_slashes_can_be_cancelled.ts | 89 ++ .../slashes/test_slashes_grandpa.ts | 76 ++ test/util/slashes.ts | 118 +++ .../interfaces/augment-api-consts.ts | 13 + .../interfaces/augment-api-errors.ts | 18 + .../interfaces/augment-api-events.ts | 12 +- .../interfaces/augment-api-query.ts | 31 + .../dancelight/interfaces/augment-api-tx.ts | 20 + .../src/dancelight/interfaces/lookup.ts | 894 +++++++++--------- .../src/dancelight/interfaces/registry.ts | 8 + .../src/dancelight/interfaces/types-lookup.ts | 887 +++++++++-------- 30 files changed, 3654 insertions(+), 846 deletions(-) create mode 100644 pallets/external-validator-slashes/Cargo.toml create mode 100644 pallets/external-validator-slashes/src/benchmarking.rs create mode 100644 pallets/external-validator-slashes/src/lib.rs create mode 100644 pallets/external-validator-slashes/src/mock.rs create mode 100644 pallets/external-validator-slashes/src/tests.rs create mode 100644 pallets/external-validator-slashes/src/weights.rs create mode 100644 solo-chains/runtime/dancelight/src/tests/slashes.rs create mode 100644 solo-chains/runtime/dancelight/src/weights/pallet_external_validator_slashes.rs create mode 100644 test/suites/dev-tanssi-relay/slashes/test_slashes_are_confirmed_after_defer_period.ts create mode 100644 test/suites/dev-tanssi-relay/slashes/test_slashes_are_not_applicable_to_invulnerables.ts create mode 100644 test/suites/dev-tanssi-relay/slashes/test_slashes_are_removed_after_bonding_period.ts create mode 100644 test/suites/dev-tanssi-relay/slashes/test_slashes_babe.ts create mode 100644 test/suites/dev-tanssi-relay/slashes/test_slashes_can_be_cancelled.ts create mode 100644 test/suites/dev-tanssi-relay/slashes/test_slashes_grandpa.ts create mode 100644 test/util/slashes.ts diff --git a/Cargo.lock b/Cargo.lock index 48c6a9396..9a57c9e06 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3219,6 +3219,7 @@ dependencies = [ "dancelight-runtime-constants", "dp-consensus", "dp-container-chain-genesis-data", + "finality-grandpa", "frame-benchmarking", "frame-executive", "frame-metadata-hash-extension", @@ -3249,6 +3250,7 @@ dependencies = [ "pallet-data-preservers", "pallet-democracy", "pallet-elections-phragmen", + "pallet-external-validator-slashes", "pallet-external-validators", "pallet-grandpa", "pallet-identity", @@ -9364,6 +9366,26 @@ dependencies = [ "xcm-primitives", ] +[[package]] +name = "pallet-external-validator-slashes" +version = "0.1.0" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-session", + "pallet-staking", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-staking", + "sp-std", + "tp-traits", +] + [[package]] name = "pallet-external-validators" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 9af1b85be..c434196d6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -60,6 +60,7 @@ pallet-collator-assignment-runtime-api = { path = "pallets/collator-assignment/r pallet-configuration = { path = "pallets/configuration", default-features = false } pallet-data-preservers = { path = "pallets/data-preservers", default-features = false } pallet-data-preservers-runtime-api = { path = "pallets/data-preservers/runtime-api", default-features = false } +pallet-external-validator-slashes = { path = "pallets/external-validator-slashes", default-features = false } pallet-external-validators = { path = "pallets/external-validators", default-features = false } pallet-inflation-rewards = { path = "pallets/inflation-rewards", default-features = false } pallet-initializer = { path = "pallets/initializer", default-features = false } @@ -325,6 +326,7 @@ fc-storage = { git = "https://github.com/moondance-labs/frontier", branch = "tan # General (wasm) bounded-collections = { version = "0.1.8", default-features = false } +finality-grandpa = { version = "0.16.2", default-features = false } hex-literal = { version = "0.3.4" } impl-trait-for-tuples = "0.2.2" impls = "1.0.3" diff --git a/pallets/external-validator-slashes/Cargo.toml b/pallets/external-validator-slashes/Cargo.toml new file mode 100644 index 000000000..32a3cd6e2 --- /dev/null +++ b/pallets/external-validator-slashes/Cargo.toml @@ -0,0 +1,68 @@ +[package] +name = "pallet-external-validator-slashes" +authors = { workspace = true } +description = "External validator info slashes" +edition = "2021" +license = "GPL-3.0-only" +version = "0.1.0" + +[package.metadata.docs.rs] +targets = [ "x86_64-unknown-linux-gnu" ] + +[lints] +workspace = true + +[dependencies] +frame-benchmarking = { workspace = true, optional = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +log = { workspace = true } +pallet-session = { workspace = true } +pallet-staking = { workspace = true } +parity-scale-codec = { workspace = true, features = [ "derive", "max-encoded-len" ] } +scale-info = { workspace = true } +sp-runtime = { workspace = true } +sp-staking = { workspace = true } +sp-std = { workspace = true } +tp-traits = { workspace = true } + +[dev-dependencies] +sp-core = { workspace = true } +sp-io = { workspace = true } + +[features] +default = [ "std" ] +std = [ + "frame-benchmarking/std", + "frame-support/std", + "frame-system/std", + "log/std", + "pallet-session/std", + "pallet-staking/std", + "parity-scale-codec/std", + "scale-info/std", + "sp-core/std", + "sp-io/std", + "sp-runtime/std", + "sp-staking/std", + "sp-std/std", + "tp-traits/std", +] +runtime-benchmarks = [ + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", + "pallet-staking/runtime-benchmarks", + "scale-info/std", + "sp-runtime/runtime-benchmarks", + "sp-staking/runtime-benchmarks", + "tp-traits/runtime-benchmarks", +] + +try-runtime = [ + "frame-support/try-runtime", + "frame-system/try-runtime", + "pallet-session/try-runtime", + "pallet-staking/try-runtime", + "sp-runtime/try-runtime", +] diff --git a/pallets/external-validator-slashes/src/benchmarking.rs b/pallets/external-validator-slashes/src/benchmarking.rs new file mode 100644 index 000000000..783b77687 --- /dev/null +++ b/pallets/external-validator-slashes/src/benchmarking.rs @@ -0,0 +1,95 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + +//! Benchmarking setup for pallet-external-validator-slashes + +use super::*; + +#[allow(unused)] +use crate::Pallet as ExternalValidatorSlashes; +use { + frame_benchmarking::{v2::*, BenchmarkError}, + frame_system::RawOrigin, + pallet_session::{self as session}, + sp_runtime::traits::TrailingZeroInput, + sp_std::prelude::*, +}; + +const MAX_SLASHES: u32 = 1000; + +#[allow(clippy::multiple_bound_locations)] +#[benchmarks(where T: session::Config)] +mod benchmarks { + use super::*; + + #[benchmark] + fn cancel_deferred_slash(s: Linear<1, MAX_SLASHES>) -> Result<(), BenchmarkError> { + let mut existing_slashes = Vec::new(); + let era = T::EraIndexProvider::active_era().index; + let dummy = || T::AccountId::decode(&mut TrailingZeroInput::zeroes()).unwrap(); + for _ in 0..MAX_SLASHES { + existing_slashes.push(Slash::::default_from(dummy())); + } + Slashes::::insert( + era.saturating_add(T::SlashDeferDuration::get()) + .saturating_add(One::one()), + &existing_slashes, + ); + let slash_indices: Vec = (0..s).collect(); + + #[extrinsic_call] + _( + RawOrigin::Root, + era.saturating_add(T::SlashDeferDuration::get()) + .saturating_add(One::one()), + slash_indices, + ); + + assert_eq!( + Slashes::::get( + &era.saturating_add(T::SlashDeferDuration::get()) + .saturating_add(One::one()) + ) + .len(), + (MAX_SLASHES - s) as usize + ); + Ok(()) + } + + #[benchmark] + fn force_inject_slash() -> Result<(), BenchmarkError> { + let era = T::EraIndexProvider::active_era().index; + let dummy = || T::AccountId::decode(&mut TrailingZeroInput::zeroes()).unwrap(); + #[extrinsic_call] + _(RawOrigin::Root, era, dummy(), Perbill::from_percent(50)); + + assert_eq!( + Slashes::::get( + &era.saturating_add(T::SlashDeferDuration::get()) + .saturating_add(One::one()) + ) + .len(), + 1_usize + ); + Ok(()) + } + + impl_benchmark_test_suite!( + ExternalValidatorSlashes, + crate::mock::new_test_ext(), + crate::mock::Test, + ); +} diff --git a/pallets/external-validator-slashes/src/lib.rs b/pallets/external-validator-slashes/src/lib.rs new file mode 100644 index 000000000..eff102f22 --- /dev/null +++ b/pallets/external-validator-slashes/src/lib.rs @@ -0,0 +1,510 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + +//! ExternalValidatorSlashes pallet. +//! +//! A pallet to store slashes based on offences committed by validators +//! Slashes can be cancelled during the DeferPeriod through cancel_deferred_slash +//! Slashes can also be forcedly injected via the force_inject_slash extrinsic +//! Slashes for a particular era are removed after the bondingPeriod has elapsed +//! +//! ## OnOffence trait +//! +//! The pallet also implements the OnOffence trait that reacts to offences being injected by other pallets +//! Invulnerables are not slashed and no slashing information is stored for them + +#![cfg_attr(not(feature = "std"), no_std)] + +use { + frame_support::{pallet_prelude::*, traits::DefensiveSaturating}, + frame_system::pallet_prelude::*, + log::log, + pallet_staking::SessionInterface, + parity_scale_codec::FullCodec, + parity_scale_codec::{Decode, Encode}, + sp_runtime::traits::{Convert, Debug, One, Saturating, Zero}, + sp_runtime::DispatchResult, + sp_runtime::Perbill, + sp_staking::{ + offence::{OffenceDetails, OnOffenceHandler}, + EraIndex, SessionIndex, + }, + sp_std::vec, + sp_std::vec::Vec, + tp_traits::{EraIndexProvider, InvulnerablesProvider, OnEraStart}, +}; + +pub use pallet::*; + +#[cfg(test)] +mod mock; + +#[cfg(test)] +mod tests; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +pub mod weights; + +#[frame_support::pallet] +pub mod pallet { + use super::*; + pub use crate::weights::WeightInfo; + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + /// Removed author data + SlashReported { + validator: T::ValidatorId, + fraction: Perbill, + slash_era: EraIndex, + }, + } + + #[pallet::config] + pub trait Config: frame_system::Config { + /// The overarching event type. + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + + /// A stable ID for a validator. + type ValidatorId: Member + + Parameter + + MaybeSerializeDeserialize + + MaxEncodedLen + + TryFrom; + + /// A conversion from account ID to validator ID. + type ValidatorIdOf: Convert>; + + /// Number of eras that slashes are deferred by, after computation. + /// + /// This should be less than the bonding duration. Set to 0 if slashes + /// should be applied immediately, without opportunity for intervention. + #[pallet::constant] + type SlashDeferDuration: Get; + + /// Number of eras that staked funds must remain bonded for. + #[pallet::constant] + type BondingDuration: Get; + + // SlashId type, used as a counter on the number of slashes + type SlashId: Default + + FullCodec + + TypeInfo + + Copy + + Clone + + Debug + + Eq + + Saturating + + One + + Ord + + MaxEncodedLen; + + /// Interface for interacting with a session pallet. + type SessionInterface: SessionInterface; + + /// Era index provider, used to fetch the active era among other things + type EraIndexProvider: EraIndexProvider; + + /// Invulnerable provider, used to get the invulnerables to know when not to slash + type InvulnerablesProvider: InvulnerablesProvider; + + /// The weight information of this pallet. + type WeightInfo: WeightInfo; + } + + #[pallet::error] + pub enum Error { + /// The era for which the slash wants to be cancelled has no slashes + EmptyTargets, + /// No slash was found to be cancelled at the given index + InvalidSlashIndex, + /// Slash indices to be cancelled are not sorted or unique + NotSortedAndUnique, + /// Provided an era in the future + ProvidedFutureEra, + /// Provided an era that is not slashable + ProvidedNonSlashableEra, + /// The slash to be cancelled has already elapsed the DeferPeriod + DeferPeriodIsOver, + /// There was an error computing the slash + ErrorComputingSlash, + } + + #[pallet::pallet] + pub struct Pallet(PhantomData); + + /// All slashing events on validators, mapped by era to the highest slash proportion + /// and slash value of the era. + #[pallet::storage] + pub(crate) type ValidatorSlashInEra = + StorageDoubleMap<_, Twox64Concat, EraIndex, Twox64Concat, T::AccountId, Perbill>; + + /// A mapping from still-bonded eras to the first session index of that era. + /// + /// Must contains information for eras for the range: + /// `[active_era - bounding_duration; active_era]` + #[pallet::storage] + #[pallet::unbounded] + pub type BondedEras = StorageValue<_, Vec<(EraIndex, SessionIndex)>, ValueQuery>; + + /// A counter on the number of slashes we have performed + #[pallet::storage] + #[pallet::getter(fn next_slash_id)] + pub type NextSlashId = StorageValue<_, T::SlashId, ValueQuery>; + + /// All unapplied slashes that are queued for later. + #[pallet::storage] + #[pallet::unbounded] + #[pallet::getter(fn slashes)] + pub type Slashes = + StorageMap<_, Twox64Concat, EraIndex, Vec>, ValueQuery>; + + #[pallet::call] + impl Pallet { + /// Cancel a slash that was deferred for a later era + #[pallet::call_index(0)] + #[pallet::weight(T::WeightInfo::cancel_deferred_slash(slash_indices.len() as u32))] + pub fn cancel_deferred_slash( + origin: OriginFor, + era: EraIndex, + slash_indices: Vec, + ) -> DispatchResult { + ensure_root(origin)?; + + let active_era = T::EraIndexProvider::active_era().index; + + // We need to be in the defer period + ensure!( + era <= active_era + .saturating_add(T::SlashDeferDuration::get().saturating_add(One::one())) + && era > active_era, + Error::::DeferPeriodIsOver + ); + + ensure!(!slash_indices.is_empty(), Error::::EmptyTargets); + ensure!( + is_sorted_and_unique(&slash_indices), + Error::::NotSortedAndUnique + ); + // fetch slashes for the era in which we want to defer + let mut era_slashes = Slashes::::get(&era); + + let last_item = slash_indices[slash_indices.len() - 1]; + ensure!( + (last_item as usize) < era_slashes.len(), + Error::::InvalidSlashIndex + ); + + // Remove elements starting from the highest index to avoid shifting issues. + for index in slash_indices.into_iter().rev() { + era_slashes.remove(index as usize); + } + // insert back slashes + Slashes::::insert(&era, &era_slashes); + Ok(()) + } + + #[pallet::call_index(1)] + #[pallet::weight(T::WeightInfo::force_inject_slash())] + pub fn force_inject_slash( + origin: OriginFor, + era: EraIndex, + validator: T::AccountId, + percentage: Perbill, + ) -> DispatchResult { + ensure_root(origin)?; + let active_era = T::EraIndexProvider::active_era().index; + + ensure!(era <= active_era, Error::::ProvidedFutureEra); + + let slash_defer_duration = T::SlashDeferDuration::get(); + + let _ = T::EraIndexProvider::era_to_session_start(era) + .ok_or(Error::::ProvidedNonSlashableEra)?; + + let next_slash_id = NextSlashId::::get(); + + let slash = compute_slash::( + percentage, + next_slash_id, + era, + validator, + slash_defer_duration, + ) + .ok_or(Error::::ErrorComputingSlash)?; + + // If we defer duration is 0, we immediately apply and confirm + let era_to_consider = if slash_defer_duration == 0 { + era + } else { + era.saturating_add(slash_defer_duration) + .saturating_add(One::one()) + }; + + Slashes::::mutate(&era_to_consider, |era_slashes| { + era_slashes.push(slash); + }); + + NextSlashId::::put(next_slash_id.saturating_add(One::one())); + Ok(()) + } + } +} + +/// This is intended to be used with `FilterHistoricalOffences`. +impl + OnOffenceHandler, Weight> + for Pallet +where + T: Config::AccountId>, + T: pallet_session::Config::AccountId>, + T: pallet_session::historical::Config, + T::SessionHandler: pallet_session::SessionHandler<::AccountId>, + T::SessionManager: pallet_session::SessionManager<::AccountId>, + ::ValidatorIdOf: Convert< + ::AccountId, + Option<::AccountId>, + >, +{ + fn on_offence( + offenders: &[OffenceDetails< + T::AccountId, + pallet_session::historical::IdentificationTuple, + >], + slash_fraction: &[Perbill], + slash_session: SessionIndex, + ) -> Weight { + let active_era = { + let active_era = T::EraIndexProvider::active_era().index; + active_era + }; + let active_era_start_session_index = T::EraIndexProvider::era_to_session_start(active_era) + .unwrap_or_else(|| { + frame_support::print("Error: start_session_index must be set for current_era"); + 0 + }); + + // Fast path for active-era report - most likely. + // `slash_session` cannot be in a future active era. It must be in `active_era` or before. + let slash_era = if slash_session >= active_era_start_session_index { + active_era + } else { + let eras = BondedEras::::get(); + + // Reverse because it's more likely to find reports from recent eras. + match eras.iter().rev().find(|&(_, sesh)| sesh <= &slash_session) { + Some((slash_era, _)) => *slash_era, + // Before bonding period. defensive - should be filtered out. + None => return Weight::default(), + } + }; + + let slash_defer_duration = T::SlashDeferDuration::get(); + + let invulnerables = T::InvulnerablesProvider::invulnerables(); + + let mut next_slash_id = NextSlashId::::get(); + + for (details, slash_fraction) in offenders.iter().zip(slash_fraction) { + let (stash, _) = &details.offender; + + // Skip if the validator is invulnerable. + if invulnerables.contains(stash) { + continue; + } + + let slash = compute_slash::( + *slash_fraction, + next_slash_id, + slash_era, + stash.clone(), + slash_defer_duration, + ); + + Self::deposit_event(Event::::SlashReported { + validator: stash.clone(), + fraction: *slash_fraction, + slash_era, + }); + + if let Some(mut slash) = slash { + slash.reporters = details.reporters.clone(); + + // Defer to end of some `slash_defer_duration` from now. + log!( + log::Level::Debug, + "deferring slash of {:?}% happened in {:?} (reported in {:?}) to {:?}", + slash_fraction, + slash_era, + active_era, + slash_era + slash_defer_duration + 1, + ); + + // Cover slash defer duration equal to 0 + if slash_defer_duration == 0 { + Slashes::::mutate(slash_era, move |for_now| for_now.push(slash)); + } else { + Slashes::::mutate( + slash_era + .saturating_add(slash_defer_duration) + .saturating_add(One::one()), + move |for_later| for_later.push(slash), + ); + } + + // Fix unwrap + next_slash_id = next_slash_id.saturating_add(One::one()); + } + } + NextSlashId::::put(next_slash_id); + Weight::default() + } +} + +impl OnEraStart for Pallet { + fn on_era_start(era_index: EraIndex, session_start: SessionIndex) { + // This should be small, as slashes are limited by the num of validators + // let's put 1000 as a conservative measure + const REMOVE_LIMIT: u32 = 1000; + + let bonding_duration = T::BondingDuration::get(); + + BondedEras::::mutate(|bonded| { + bonded.push((era_index, session_start)); + + if era_index > bonding_duration { + let first_kept = era_index.defensive_saturating_sub(bonding_duration); + + // Prune out everything that's from before the first-kept index. + let n_to_prune = bonded + .iter() + .take_while(|&&(era_idx, _)| era_idx < first_kept) + .count(); + + // Kill slashing metadata. + for (pruned_era, _) in bonded.drain(..n_to_prune) { + let removal_result = + ValidatorSlashInEra::::clear_prefix(&pruned_era, REMOVE_LIMIT, None); + if removal_result.maybe_cursor.is_some() { + log::error!( + "Not all validator slashes were remove for era {:?}", + pruned_era + ); + } + Slashes::::remove(&pruned_era); + } + + if let Some(&(_, first_session)) = bonded.first() { + T::SessionInterface::prune_historical_up_to(first_session); + } + } + }); + + Self::confirm_unconfirmed_slashes(era_index); + } +} + +impl Pallet { + /// Apply previously-unapplied slashes on the beginning of a new era, after a delay. + fn confirm_unconfirmed_slashes(active_era: EraIndex) { + Slashes::::mutate(&active_era, |era_slashes| { + log!( + log::Level::Debug, + "found {} slashes scheduled to be confirmed in era {:?}", + era_slashes.len(), + active_era, + ); + for slash in era_slashes { + slash.confirmed = true; + } + }); + } +} + +/// A pending slash record. The value of the slash has been computed but not applied yet, +/// rather deferred for several eras. +#[derive(Encode, Decode, RuntimeDebug, TypeInfo, Clone, PartialEq)] +pub struct Slash { + /// The stash ID of the offending validator. + pub validator: AccountId, + /// Reporters of the offence; bounty payout recipients. + pub reporters: Vec, + /// The amount of payout. + pub slash_id: SlashId, + pub percentage: Perbill, + // Whether the slash is confirmed or still needs to go through deferred period + pub confirmed: bool, +} + +impl Slash { + /// Initializes the default object using the given `validator`. + pub fn default_from(validator: AccountId) -> Self { + Self { + validator, + reporters: vec![], + slash_id: One::one(), + percentage: Perbill::from_percent(50), + confirmed: false, + } + } +} + +/// Computes a slash of a validator and nominators. It returns an unapplied +/// record to be applied at some later point. Slashing metadata is updated in storage, +/// since unapplied records are only rarely intended to be dropped. +/// +/// The pending slash record returned does not have initialized reporters. Those have +/// to be set at a higher level, if any. +pub(crate) fn compute_slash( + slash_fraction: Perbill, + slash_id: T::SlashId, + slash_era: EraIndex, + stash: T::AccountId, + slash_defer_duration: EraIndex, +) -> Option> { + let prior_slash_p = ValidatorSlashInEra::::get(&slash_era, &stash).unwrap_or(Zero::zero()); + + // compare slash proportions rather than slash values to avoid issues due to rounding + // error. + if slash_fraction.deconstruct() > prior_slash_p.deconstruct() { + ValidatorSlashInEra::::insert(&slash_era, &stash, &slash_fraction); + } else { + // we slash based on the max in era - this new event is not the max, + // so neither the validator or any nominators will need an update. + // + // this does lead to a divergence of our system from the paper, which + // pays out some reward even if the latest report is not max-in-era. + // we opt to avoid the nominator lookups and edits and leave more rewards + // for more drastic misbehavior. + return None; + } + + let confirmed = slash_defer_duration.is_zero(); + Some(Slash { + validator: stash.clone(), + percentage: slash_fraction, + slash_id, + reporters: Vec::new(), + confirmed, + }) +} + +/// Check that list is sorted and has no duplicates. +fn is_sorted_and_unique(list: &[u32]) -> bool { + list.windows(2).all(|w| w[0] < w[1]) +} diff --git a/pallets/external-validator-slashes/src/mock.rs b/pallets/external-validator-slashes/src/mock.rs new file mode 100644 index 000000000..4132e28e0 --- /dev/null +++ b/pallets/external-validator-slashes/src/mock.rs @@ -0,0 +1,240 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + +use { + crate as external_validator_slashes, + frame_support::{ + parameter_types, + traits::{ConstU16, ConstU64, Get}, + }, + frame_system as system, + sp_core::H256, + sp_runtime::{ + testing::UintAuthorityId, + traits::{BlakeTwo256, ConvertInto, IdentityLookup}, + BuildStorage, + }, + sp_staking::SessionIndex, + sp_std::cell::RefCell, + tp_traits::{ActiveEraInfo, EraIndex, EraIndexProvider, InvulnerablesProvider}, +}; + +type Block = frame_system::mocking::MockBlock; + +// Configure a mock runtime to test the pallet. +frame_support::construct_runtime!( + pub enum Test + { + System: frame_system, + Session: pallet_session, + Historical: pallet_session::historical, + ExternalValidatorSlashes: external_validator_slashes, + } +); + +impl system::Config for Test { + type BaseCallFilter = frame_support::traits::Everything; + type BlockWeights = (); + type BlockLength = (); + type DbWeight = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type Nonce = u64; + type Block = Block; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = u64; + type Lookup = IdentityLookup; + type RuntimeEvent = RuntimeEvent; + type BlockHashCount = ConstU64<250>; + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = (); + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = ConstU16<42>; + type OnSetCode = (); + type MaxConsumers = frame_support::traits::ConstU32<16>; + type RuntimeTask = (); + type SingleBlockMigrations = (); + type MultiBlockMigrator = (); + type PreInherents = (); + type PostInherents = (); + type PostTransactions = (); +} + +parameter_types! { + pub static Validators: Option> = Some(vec![ + 1, + 2, + 3, + ]); +} + +pub struct TestSessionManager; +impl pallet_session::SessionManager for TestSessionManager { + fn new_session(_new_index: SessionIndex) -> Option> { + Validators::get() + } + fn end_session(_: SessionIndex) {} + fn start_session(_: SessionIndex) {} +} + +impl pallet_session::historical::SessionManager for TestSessionManager { + fn new_session(_new_index: SessionIndex) -> Option> { + Validators::mutate(|l| { + l.take() + .map(|validators| validators.iter().map(|v| (*v, ())).collect()) + }) + } + fn end_session(_: SessionIndex) {} + fn start_session(_: SessionIndex) {} +} + +parameter_types! { + pub const Period: u64 = 1; + pub const Offset: u64 = 0; +} + +pub struct MockEraIndexProvider; + +thread_local! { + pub static ERA_INDEX: RefCell = const { RefCell::new(0) }; + pub static DEFER_PERIOD: RefCell = const { RefCell::new(2) }; +} + +impl MockEraIndexProvider { + pub fn with_era(era_index: EraIndex) { + ERA_INDEX.with(|r| *r.borrow_mut() = era_index); + } +} + +impl EraIndexProvider for MockEraIndexProvider { + fn active_era() -> ActiveEraInfo { + ActiveEraInfo { + index: ERA_INDEX.with(|q| *q.borrow()), + start: None, + } + } + fn era_to_session_start(era_index: EraIndex) -> Option { + let active_era = Self::active_era().index; + if era_index > active_era || era_index < active_era.saturating_sub(BondingDuration::get()) { + None + } else { + // Else we assume eras start at the same time as sessions + Some(era_index) + } + } +} + +impl pallet_session::Config for Test { + type SessionManager = pallet_session::historical::NoteHistoricalRoot; + type Keys = SessionKeys; + type ShouldEndSession = pallet_session::PeriodicSessions; + type SessionHandler = TestSessionHandler; + type RuntimeEvent = RuntimeEvent; + type ValidatorId = ::AccountId; + type ValidatorIdOf = ConvertInto; + type NextSessionRotation = pallet_session::PeriodicSessions; + type WeightInfo = (); +} + +sp_runtime::impl_opaque_keys! { + pub struct SessionKeys { + pub foo: sp_runtime::testing::UintAuthorityId, + } +} + +use sp_runtime::RuntimeAppPublic; +type AccountId = u64; +pub struct TestSessionHandler; +impl pallet_session::SessionHandler for TestSessionHandler { + const KEY_TYPE_IDS: &'static [sp_runtime::KeyTypeId] = &[UintAuthorityId::ID]; + + fn on_genesis_session(_validators: &[(AccountId, Ks)]) {} + + fn on_new_session( + _: bool, + _: &[(AccountId, Ks)], + _: &[(AccountId, Ks)], + ) { + } + fn on_disabled(_: u32) {} +} + +pub struct MockInvulnerableProvider; +impl InvulnerablesProvider for MockInvulnerableProvider { + fn invulnerables() -> Vec { + vec![1, 2] + } +} + +pub struct DeferPeriodGetter; +impl Get for DeferPeriodGetter { + fn get() -> EraIndex { + DEFER_PERIOD.with(|q| (*q.borrow())) + } +} + +impl DeferPeriodGetter { + pub fn with_defer_period(defer_period: EraIndex) { + DEFER_PERIOD.with(|r| *r.borrow_mut() = defer_period); + } +} + +parameter_types! { + pub const BondingDuration: u32 = 5u32; +} + +impl external_validator_slashes::Config for Test { + type RuntimeEvent = RuntimeEvent; + type ValidatorId = ::AccountId; + type ValidatorIdOf = IdentityValidator; + type SlashDeferDuration = DeferPeriodGetter; + type BondingDuration = BondingDuration; + type SlashId = u32; + type SessionInterface = (); + type EraIndexProvider = MockEraIndexProvider; + type InvulnerablesProvider = MockInvulnerableProvider; + type WeightInfo = (); +} + +pub struct FullIdentificationOf; +impl sp_runtime::traits::Convert> for FullIdentificationOf { + fn convert(_: AccountId) -> Option<()> { + Some(()) + } +} + +impl pallet_session::historical::Config for Test { + type FullIdentification = (); + type FullIdentificationOf = FullIdentificationOf; +} +// Build genesis storage according to the mock runtime. +pub fn new_test_ext() -> sp_io::TestExternalities { + system::GenesisConfig::::default() + .build_storage() + .unwrap() + .into() +} + +pub struct IdentityValidator; +impl sp_runtime::traits::Convert> for IdentityValidator { + fn convert(a: u64) -> Option { + Some(a) + } +} diff --git a/pallets/external-validator-slashes/src/tests.rs b/pallets/external-validator-slashes/src/tests.rs new file mode 100644 index 000000000..5609346e4 --- /dev/null +++ b/pallets/external-validator-slashes/src/tests.rs @@ -0,0 +1,288 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + +use { + super::*, + crate::mock::{new_test_ext, ExternalValidatorSlashes, RuntimeOrigin, Test}, + frame_support::{assert_noop, assert_ok}, +}; + +#[test] +fn root_can_inject_manual_offence() { + new_test_ext().execute_with(|| { + start_era(0, 0); + assert_ok!(ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 0, + 1u64, + Perbill::from_percent(75) + )); + assert_eq!( + Slashes::::get(3), + vec![Slash { + validator: 1, + percentage: Perbill::from_percent(75), + confirmed: false, + reporters: vec![], + slash_id: 0 + }] + ); + assert_eq!(NextSlashId::::get(), 1); + }); +} + +#[test] +fn cannot_inject_future_era_offence() { + new_test_ext().execute_with(|| { + start_era(0, 0); + assert_noop!( + ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 1, + 1u64, + Perbill::from_percent(75) + ), + Error::::ProvidedFutureEra + ); + }); +} + +#[test] +fn cannot_inject_era_offence_too_far_in_the_past() { + new_test_ext().execute_with(|| { + start_era(10, 0); + //Bonding period is 5, we cannot inject slash for era 4 + assert_noop!( + ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 1, + 4u64, + Perbill::from_percent(75) + ), + Error::::ProvidedNonSlashableEra + ); + }); +} + +#[test] +fn root_can_cance_deferred_slash() { + new_test_ext().execute_with(|| { + start_era(1, 0); + assert_ok!(ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 0, + 1u64, + Perbill::from_percent(75) + )); + assert_ok!(ExternalValidatorSlashes::cancel_deferred_slash( + RuntimeOrigin::root(), + 3, + vec![0] + )); + + assert_eq!(Slashes::::get(3), vec![]); + }); +} + +#[test] +fn root_cannot_cancel_deferred_slash_if_outside_deferring_period() { + new_test_ext().execute_with(|| { + start_era(1, 0); + assert_ok!(ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 0, + 1u64, + Perbill::from_percent(75) + )); + + start_era(4, 0); + + assert_noop!( + ExternalValidatorSlashes::cancel_deferred_slash(RuntimeOrigin::root(), 0, vec![0]), + Error::::DeferPeriodIsOver + ); + }); +} + +#[test] +fn test_after_bonding_period_we_can_remove_slashes() { + new_test_ext().execute_with(|| { + start_era(0, 0); + start_era(1, 1); + + // we are storing a tuple (era index, start_session_block) + assert_eq!(BondedEras::::get(), [(0, 0), (1, 1)]); + assert_ok!(ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 0, + 1u64, + Perbill::from_percent(75) + )); + + assert_eq!( + Slashes::::get(3), + vec![Slash { + validator: 1, + percentage: Perbill::from_percent(75), + confirmed: false, + reporters: vec![], + slash_id: 0 + }] + ); + + Pallet::::on_era_start(3, 3); + + start_era(8, 8); + + // whenever we start the 6th era, we can remove everything from era 3 + Pallet::::on_era_start(9, 9); + + assert_eq!(Slashes::::get(3), vec![]); + }); +} + +#[test] +fn test_on_offence_injects_offences() { + new_test_ext().execute_with(|| { + start_era(0, 0); + start_era(1, 1); + Pallet::::on_offence( + &[OffenceDetails { + // 1 and 2 are invulnerables + offender: (3, ()), + reporters: vec![], + }], + &[Perbill::from_percent(75)], + 0, + ); + // current era (1) + defer period + 1 + let slash_era = 0 + .saturating_add(crate::mock::DeferPeriodGetter::get()) + .saturating_add(One::one()); + + assert_eq!( + Slashes::::get(slash_era), + vec![Slash { + validator: 3, + percentage: Perbill::from_percent(75), + confirmed: false, + reporters: vec![], + slash_id: 0 + }] + ); + }); +} + +#[test] +fn test_on_offence_does_not_work_for_invulnerables() { + new_test_ext().execute_with(|| { + start_era(0, 0); + start_era(1, 1); + // account 1 invulnerable + Pallet::::on_offence( + &[OffenceDetails { + offender: (1, ()), + reporters: vec![], + }], + &[Perbill::from_percent(75)], + 0, + ); + // current era (1) + defer period + 1 + let slash_era = 1 + .saturating_add(crate::mock::DeferPeriodGetter::get()) + .saturating_add(One::one()); + + assert_eq!(Slashes::::get(slash_era), vec![]); + }); +} + +#[test] +fn defer_period_of_zero_confirms_immediately_slashes() { + new_test_ext().execute_with(|| { + crate::mock::DeferPeriodGetter::with_defer_period(0); + start_era(0, 0); + assert_ok!(ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 0, + 1u64, + Perbill::from_percent(75) + )); + assert_eq!( + Slashes::::get(0), + vec![Slash { + validator: 1, + percentage: Perbill::from_percent(75), + confirmed: true, + reporters: vec![], + slash_id: 0 + }] + ); + }); +} + +#[test] +fn we_cannot_cancel_anything_with_defer_period_zero() { + new_test_ext().execute_with(|| { + crate::mock::DeferPeriodGetter::with_defer_period(0); + start_era(0, 0); + assert_ok!(ExternalValidatorSlashes::force_inject_slash( + RuntimeOrigin::root(), + 0, + 1u64, + Perbill::from_percent(75) + )); + assert_noop!( + ExternalValidatorSlashes::cancel_deferred_slash(RuntimeOrigin::root(), 0, vec![0]), + Error::::DeferPeriodIsOver + ); + }); +} + +#[test] +fn test_on_offence_defer_period_0() { + new_test_ext().execute_with(|| { + crate::mock::DeferPeriodGetter::with_defer_period(0); + start_era(0, 0); + start_era(1, 1); + Pallet::::on_offence( + &[OffenceDetails { + // 1 and 2 are invulnerables + offender: (3, ()), + reporters: vec![], + }], + &[Perbill::from_percent(75)], + 0, + ); + + let slash_era = 0; + + assert_eq!( + Slashes::::get(slash_era), + vec![Slash { + validator: 3, + percentage: Perbill::from_percent(75), + confirmed: true, + reporters: vec![], + slash_id: 0 + }] + ); + }); +} + +fn start_era(era_index: EraIndex, session_index: SessionIndex) { + Pallet::::on_era_start(era_index, session_index); + crate::mock::MockEraIndexProvider::with_era(era_index); +} diff --git a/pallets/external-validator-slashes/src/weights.rs b/pallets/external-validator-slashes/src/weights.rs new file mode 100644 index 000000000..295087614 --- /dev/null +++ b/pallets/external-validator-slashes/src/weights.rs @@ -0,0 +1,129 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + + +//! Autogenerated weights for pallet_external_validator_slashes +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 42.0.0 +//! DATE: 2024-10-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `girazoki-XPS-15-9530`, CPU: `13th Gen Intel(R) Core(TM) i9-13900H` +//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/tanssi-relay +// benchmark +// pallet +// --execution=wasm +// --wasm-execution=compiled +// --pallet +// pallet_external_validator_slashes +// --extrinsic +// * +// --chain=dev +// --steps +// 50 +// --repeat +// 20 +// --template=./benchmarking/frame-weight-pallet-template.hbs +// --json-file +// raw.json +// --output +// tmp/pallet_external_validator_slashes.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_external_validator_slashes. +pub trait WeightInfo { + fn cancel_deferred_slash(s: u32, ) -> Weight; + fn force_inject_slash() -> Weight; +} + +/// Weights for pallet_external_validator_slashes using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl WeightInfo for SubstrateWeight { + /// Storage: `ExternalValidators::ActiveEra` (r:1 w:0) + /// Proof: `ExternalValidators::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::Slashes` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::Slashes` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `s` is `[1, 1000]`. + fn cancel_deferred_slash(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `42194` + // Estimated: `45659` + // Minimum execution time: 69_654_000 picoseconds. + Weight::from_parts(430_467_141, 45659) + // Standard Error: 25_862 + .saturating_add(Weight::from_parts(2_233_402, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: `ExternalValidators::ActiveEra` (r:1 w:0) + /// Proof: `ExternalValidators::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::NextSlashId` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::NextSlashId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::Slashes` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::Slashes` (`max_values`: None, `max_size`: None, mode: `Measured`) + fn force_inject_slash() -> Weight { + // Proof Size summary in bytes: + // Measured: `151` + // Estimated: `3616` + // Minimum execution time: 7_086_000 picoseconds. + Weight::from_parts(7_402_000, 3616) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) + } +} + +// For backwards compatibility and tests +impl WeightInfo for () { + /// Storage: `ExternalValidators::ActiveEra` (r:1 w:0) + /// Proof: `ExternalValidators::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::Slashes` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::Slashes` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `s` is `[1, 1000]`. + fn cancel_deferred_slash(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `42194` + // Estimated: `45659` + // Minimum execution time: 69_654_000 picoseconds. + Weight::from_parts(430_467_141, 45659) + // Standard Error: 25_862 + .saturating_add(Weight::from_parts(2_233_402, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + /// Storage: `ExternalValidators::ActiveEra` (r:1 w:0) + /// Proof: `ExternalValidators::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::NextSlashId` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::NextSlashId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::Slashes` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::Slashes` (`max_values`: None, `max_size`: None, mode: `Measured`) + fn force_inject_slash() -> Weight { + // Proof Size summary in bytes: + // Measured: `151` + // Estimated: `3616` + // Minimum execution time: 7_086_000 picoseconds. + Weight::from_parts(7_402_000, 3616) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) + } +} diff --git a/solo-chains/runtime/dancelight/Cargo.toml b/solo-chains/runtime/dancelight/Cargo.toml index 56da752ae..de0a9d816 100644 --- a/solo-chains/runtime/dancelight/Cargo.toml +++ b/solo-chains/runtime/dancelight/Cargo.toml @@ -71,6 +71,7 @@ pallet-collective = { workspace = true } pallet-conviction-voting = { workspace = true } pallet-democracy = { workspace = true } pallet-elections-phragmen = { workspace = true } +pallet-external-validator-slashes = { workspace = true } pallet-external-validators = { workspace = true } pallet-grandpa = { workspace = true } pallet-identity = { workspace = true } @@ -146,6 +147,7 @@ snowbridge-beacon-primitives = { workspace = true } snowbridge-pallet-ethereum-client = { workspace = true } [dev-dependencies] +finality-grandpa = { workspace = true, default-features = true, features = [ "derive-codec" ] } keyring = { workspace = true } milagro-bls = { workspace = true, features = [ "std" ] } rand = { workspace = true, features = [ "std", "std_rng" ] } @@ -208,6 +210,7 @@ std = [ "pallet-data-preservers/std", "pallet-democracy/std", "pallet-elections-phragmen/std", + "pallet-external-validator-slashes/std", "pallet-external-validators/std", "pallet-grandpa/std", "pallet-identity/std", @@ -309,6 +312,7 @@ runtime-benchmarks = [ "pallet-data-preservers/runtime-benchmarks", "pallet-democracy/runtime-benchmarks", "pallet-elections-phragmen/runtime-benchmarks", + "pallet-external-validator-slashes/runtime-benchmarks", "pallet-external-validators/runtime-benchmarks", "pallet-grandpa/runtime-benchmarks", "pallet-identity/runtime-benchmarks", @@ -376,6 +380,7 @@ try-runtime = [ "pallet-data-preservers/try-runtime", "pallet-democracy/try-runtime", "pallet-elections-phragmen/try-runtime", + "pallet-external-validator-slashes/try-runtime", "pallet-external-validators/try-runtime", "pallet-grandpa/try-runtime", "pallet-identity/try-runtime", diff --git a/solo-chains/runtime/dancelight/src/lib.rs b/solo-chains/runtime/dancelight/src/lib.rs index e6813e680..f073aa093 100644 --- a/solo-chains/runtime/dancelight/src/lib.rs +++ b/solo-chains/runtime/dancelight/src/lib.rs @@ -90,7 +90,7 @@ use { prelude::*, }, tp_traits::{ - apply, derive_storage_traits, GetHostConfiguration, GetSessionContainerChains, + apply, derive_storage_traits, EraIndex, GetHostConfiguration, GetSessionContainerChains, RegistrarHandler, RemoveParaIdsWithNoCredits, Slot, SlotFrequency, }, }; @@ -490,7 +490,7 @@ impl pallet_session::historical::Config for Runtime { } parameter_types! { - pub const BondingDuration: sp_staking::EraIndex = 28; + pub const BondingDuration: sp_staking::EraIndex = runtime_common::prod_or_fast!(28, 3); } parameter_types! { @@ -568,7 +568,7 @@ impl pallet_treasury::Config for Runtime { impl pallet_offences::Config for Runtime { type RuntimeEvent = RuntimeEvent; type IdentificationTuple = pallet_session::historical::IdentificationTuple; - type OnOffenceHandler = (); + type OnOffenceHandler = ExternalValidatorSlashes; } impl pallet_authority_discovery::Config for Runtime { @@ -1210,8 +1210,25 @@ impl pallet_beefy_mmr::Config for Runtime { impl paras_sudo_wrapper::Config for Runtime {} +use pallet_staking::SessionInterface; +pub struct DancelightSessionInterface; +impl SessionInterface for DancelightSessionInterface { + fn disable_validator(validator_index: u32) -> bool { + Session::disable_index(validator_index) + } + + fn validators() -> Vec { + Session::validators() + } + + fn prune_historical_up_to(up_to: SessionIndex) { + Historical::prune_up_to(up_to); + } +} + parameter_types! { pub const SessionsPerEra: SessionIndex = runtime_common::prod_or_fast!(6, 3); + pub const SlashDeferDuration: EraIndex = runtime_common::prod_or_fast!(27, 2); } impl pallet_external_validators::Config for Runtime { @@ -1225,13 +1242,26 @@ impl pallet_external_validators::Config for Runtime { type ValidatorRegistration = Session; type UnixTime = Timestamp; type SessionsPerEra = SessionsPerEra; - type OnEraStart = (); + type OnEraStart = ExternalValidatorSlashes; type OnEraEnd = (); type WeightInfo = weights::pallet_external_validators::SubstrateWeight; #[cfg(feature = "runtime-benchmarks")] type Currency = Balances; } +impl pallet_external_validator_slashes::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type ValidatorId = AccountId; + type ValidatorIdOf = ValidatorIdOf; + type SlashDeferDuration = SlashDeferDuration; + type BondingDuration = BondingDuration; + type SlashId = u32; + type SessionInterface = DancelightSessionInterface; + type EraIndexProvider = ExternalValidators; + type InvulnerablesProvider = ExternalValidators; + type WeightInfo = weights::pallet_external_validator_slashes::SubstrateWeight; +} + impl pallet_sudo::Config for Runtime { type RuntimeEvent = RuntimeEvent; type RuntimeCall = RuntimeCall; @@ -1542,6 +1572,7 @@ construct_runtime! { // Validator stuff ExternalValidators: pallet_external_validators = 20, + ExternalValidatorSlashes: pallet_external_validator_slashes = 21, // Session management Session: pallet_session = 30, @@ -1940,11 +1971,13 @@ mod benches { [pallet_registrar, ContainerRegistrar] [pallet_collator_assignment, TanssiCollatorAssignment] [pallet_external_validators, ExternalValidators] + [pallet_external_validator_slashes, ExternalValidatorSlashes] // XCM [pallet_xcm, PalletXcmExtrinsicsBenchmark::] [pallet_xcm_benchmarks::fungible, pallet_xcm_benchmarks::fungible::Pallet::] [pallet_xcm_benchmarks::generic, pallet_xcm_benchmarks::generic::Pallet::] + // Bridges [snowbridge_pallet_ethereum_client, EthereumBeaconClient] ); diff --git a/solo-chains/runtime/dancelight/src/tests/common/mod.rs b/solo-chains/runtime/dancelight/src/tests/common/mod.rs index 9be0b6bc7..4c9c13222 100644 --- a/solo-chains/runtime/dancelight/src/tests/common/mod.rs +++ b/solo-chains/runtime/dancelight/src/tests/common/mod.rs @@ -1213,3 +1213,105 @@ pub fn generate_ethereum_pub_keys(n: u32) -> Vec { } keys } + +use babe_primitives::AuthorityPair as BabeAuthorityPair; +use grandpa_primitives::{ + AuthorityPair as GrandpaAuthorityPair, Equivocation, EquivocationProof, RoundNumber, SetId, +}; +use sp_core::H256; +pub fn generate_grandpa_equivocation_proof( + set_id: SetId, + vote1: (RoundNumber, H256, u32, &GrandpaAuthorityPair), + vote2: (RoundNumber, H256, u32, &GrandpaAuthorityPair), +) -> EquivocationProof { + let signed_prevote = |round, hash, number, authority_pair: &GrandpaAuthorityPair| { + let prevote = finality_grandpa::Prevote { + target_hash: hash, + target_number: number, + }; + + let prevote_msg = finality_grandpa::Message::Prevote(prevote.clone()); + let payload = grandpa_primitives::localized_payload(round, set_id, &prevote_msg); + let signed = authority_pair.sign(&payload); + (prevote, signed) + }; + + let (prevote1, signed1) = signed_prevote(vote1.0, vote1.1, vote1.2, vote1.3); + let (prevote2, signed2) = signed_prevote(vote2.0, vote2.1, vote2.2, vote2.3); + + EquivocationProof::new( + set_id, + Equivocation::Prevote(finality_grandpa::Equivocation { + round_number: vote1.0, + identity: vote1.3.public(), + first: (prevote1, signed1), + second: (prevote2, signed2), + }), + ) +} + +/// Creates an equivocation at the current block, by generating two headers. +pub fn generate_babe_equivocation_proof( + offender_authority_pair: &BabeAuthorityPair, +) -> babe_primitives::EquivocationProof { + use babe_primitives::digests::CompatibleDigestItem; + + let current_digest = System::digest(); + let babe_predigest = current_digest + .clone() + .logs() + .iter() + .find_map(|log| log.as_babe_pre_digest()); + let slot_proof = babe_predigest.expect("babe should be presesnt").slot(); + + let make_headers = || { + ( + HeaderFor::::new( + 0, + H256::default(), + H256::default(), + H256::default(), + current_digest.clone(), + ), + HeaderFor::::new( + 1, + H256::default(), + H256::default(), + H256::default(), + current_digest.clone(), + ), + ) + }; + + // sign the header prehash and sign it, adding it to the block as the seal + // digest item + let seal_header = |header: &mut crate::Header| { + let prehash = header.hash(); + let seal = ::babe_seal( + offender_authority_pair.sign(prehash.as_ref()), + ); + header.digest_mut().push(seal); + }; + + // generate two headers at the current block + let (mut h1, mut h2) = make_headers(); + + seal_header(&mut h1); + seal_header(&mut h2); + + babe_primitives::EquivocationProof { + slot: slot_proof, + offender: offender_authority_pair.public(), + first_header: h1, + second_header: h2, + } +} + +use sp_core::Public; +/// Helper function to generate a crypto pair from seed +pub fn get_pair_from_seed(seed: &str) -> TPublic::Pair { + let secret_uri = format!("//{}", seed); + let pair = TPublic::Pair::from_string(&secret_uri, None).expect("static values are valid; qed"); + + pair +} diff --git a/solo-chains/runtime/dancelight/src/tests/mod.rs b/solo-chains/runtime/dancelight/src/tests/mod.rs index b74850346..a9c7af4ca 100644 --- a/solo-chains/runtime/dancelight/src/tests/mod.rs +++ b/solo-chains/runtime/dancelight/src/tests/mod.rs @@ -34,6 +34,7 @@ mod relay_configuration; mod relay_registrar; mod services_payment; mod session_keys; +mod slashes; mod sudo; #[test] diff --git a/solo-chains/runtime/dancelight/src/tests/slashes.rs b/solo-chains/runtime/dancelight/src/tests/slashes.rs new file mode 100644 index 000000000..8ee1214ba --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/slashes.rs @@ -0,0 +1,396 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + +use frame_support::traits::KeyOwnerProofSystem; +use sp_core::Pair; +use sp_runtime::Perbill; +use { + crate::tests::common::*, + crate::{ + BondingDuration, ExternalValidatorSlashes, ExternalValidators, Grandpa, Historical, + SessionsPerEra, SlashDeferDuration, + }, + frame_support::{assert_noop, assert_ok}, + sp_core::H256, + sp_std::vec, +}; + +#[test] +fn invulnerables_cannot_be_slashed() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + inject_babe_slash(&AccountId::from(ALICE).to_string()); + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let slashes = ExternalValidatorSlashes::slashes( + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1, + ); + assert_eq!(slashes.len(), 0); + }); +} + +#[test] +fn non_invulnerables_can_be_slashed_with_babe() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_babe_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let slashes = ExternalValidatorSlashes::slashes( + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1, + ); + assert_eq!(slashes.len(), 1); + assert_eq!(slashes[0].validator, AccountId::from(ALICE)); + //the formula is (3*offenders/num_validators)^2 + // since we have 1 offender, 2 validators, this makes it a maximum of 1 + assert_eq!(slashes[0].percentage, Perbill::from_percent(100)); + }); +} + +#[test] +fn non_invulnerables_can_be_slashed_with_grandpa() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_grandpa_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let slashes = ExternalValidatorSlashes::slashes( + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1, + ); + assert_eq!(slashes.len(), 1); + assert_eq!(slashes[0].validator, AccountId::from(ALICE)); + //the formula is (3*offenders/num_validators)^2 + // since we have 1 offender, 2 validators, this makes it a maximum of 1 + assert_eq!(slashes[0].percentage, Perbill::from_percent(100)); + }); +} + +#[test] +fn test_slashing_percentage_applied_correctly() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_validators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_babe_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let slashes = ExternalValidatorSlashes::slashes( + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1, + ); + assert_eq!(slashes.len(), 1); + assert_eq!(slashes[0].validator, AccountId::from(ALICE)); + //the formula is (3*offenders/num_validators)^2 + // since we have 1 offender, 4 validators, this makes it a maximum of 0.75^2=0.5625 + assert_eq!(slashes[0].percentage, Perbill::from_parts(562500000)); + }); +} + +#[test] +fn test_slashes_are_not_additive_in_percentage() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + (AccountId::from(EVE), 100_000 * UNIT), + ]) + .with_validators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + (AccountId::from(EVE), 100 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_babe_slash(&AccountId::from(ALICE).to_string()); + + inject_grandpa_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + + // we have 2 reports + assert_eq!(reports.len(), 2); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let slashes = ExternalValidatorSlashes::slashes( + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1, + ); + + // but a single slash + assert_eq!(slashes.len(), 1); + assert_eq!(slashes[0].validator, AccountId::from(ALICE)); + // the formula is (3*offenders/num_validators)^2 + // since we have 1 offender, 5 validators, this makes it 0.36 + // we injected 2 offences BUT THEY ARE NOT ADDITIVE + assert_eq!(slashes[0].percentage, Perbill::from_parts(360000000)); + }); +} +#[test] +fn test_slashes_are_cleaned_after_bonding_period() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_babe_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let slashes = ExternalValidatorSlashes::slashes( + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1, + ); + assert_eq!(slashes.len(), 1); + // The first session in which the era 3 will be pruned is + // (28+3+1)*sessionsPerEra + let fist_session_era_3_pruned = (ExternalValidators::current_era().unwrap() + + SlashDeferDuration::get() + + 1 + + BondingDuration::get() + + 1) + * SessionsPerEra::get(); + + let first_era_deferred = + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1; + + println!("first era deferred {:?}", first_era_deferred); + run_to_session(fist_session_era_3_pruned); + + let slashes_after_bonding_period = + ExternalValidatorSlashes::slashes(first_era_deferred); + assert_eq!(slashes_after_bonding_period.len(), 0); + }); +} + +#[test] +fn test_slashes_can_be_cleared_before_deferred_period_applies() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_babe_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let deferred_era = + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1; + let slashes = ExternalValidatorSlashes::slashes(deferred_era); + assert_eq!(slashes.len(), 1); + assert_eq!(slashes[0].validator, AccountId::from(ALICE)); + + // Now let's clean it up + assert_ok!(ExternalValidatorSlashes::cancel_deferred_slash( + RuntimeOrigin::root(), + deferred_era, + vec![0] + )); + let slashes_after_cancel = ExternalValidatorSlashes::slashes(deferred_era); + assert_eq!(slashes_after_cancel.len(), 0); + }); +} + +#[test] +fn test_slashes_cannot_be_cancelled_after_defer_period() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .build() + .execute_with(|| { + run_to_block(2); + assert_ok!(ExternalValidators::remove_whitelisted( + RuntimeOrigin::root(), + AccountId::from(ALICE) + )); + + inject_babe_slash(&AccountId::from(ALICE).to_string()); + + let reports = pallet_offences::Reports::::iter().collect::>(); + assert_eq!(reports.len(), 1); + assert_eq!(ExternalValidators::current_era().unwrap(), 0); + + let deferred_era = + ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1; + + let slashes = ExternalValidatorSlashes::slashes(deferred_era); + assert_eq!(slashes.len(), 1); + assert_eq!(slashes[0].validator, AccountId::from(ALICE)); + + // The first session in which the era 3 will be deferred is 18 + // 3 sessions per era + // (externalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1)*SessionsPerEra + // formula is: + + let first_deferred_session = + (ExternalValidators::current_era().unwrap() + SlashDeferDuration::get() + 1) + * SessionsPerEra::get(); + run_to_session(first_deferred_session); + + assert_eq!(ExternalValidators::current_era().unwrap(), deferred_era); + // Now let's clean it up + assert_noop!( + ExternalValidatorSlashes::cancel_deferred_slash( + RuntimeOrigin::root(), + deferred_era, + vec![0] + ), + pallet_external_validator_slashes::Error::::DeferPeriodIsOver + ); + }); +} + +fn inject_babe_slash(seed: &str) { + let babe_key = get_pair_from_seed::(seed); + let equivocation_proof = generate_babe_equivocation_proof(&babe_key); + + // create the key ownership proof + let key = (babe_primitives::KEY_TYPE, babe_key.public()); + let key_owner_proof = Historical::prove(key).unwrap(); + + // report the equivocation + assert_ok!(Babe::report_equivocation_unsigned( + RuntimeOrigin::none(), + Box::new(equivocation_proof), + key_owner_proof, + )); +} + +fn inject_grandpa_slash(seed: &str) { + let grandpa_key = get_pair_from_seed::(seed); + + let set_id = Grandpa::current_set_id(); + + let equivocation_proof = generate_grandpa_equivocation_proof( + set_id, + (1, H256::random(), 1, &grandpa_key), + (1, H256::random(), 1, &grandpa_key), + ); + // create the key ownership proof + let key = (grandpa_primitives::KEY_TYPE, grandpa_key.public()); + let key_owner_proof = Historical::prove(key).unwrap(); + + // report the equivocation + assert_ok!(Grandpa::report_equivocation_unsigned( + RuntimeOrigin::none(), + Box::new(equivocation_proof), + key_owner_proof, + )); +} diff --git a/solo-chains/runtime/dancelight/src/weights/mod.rs b/solo-chains/runtime/dancelight/src/weights/mod.rs index f8eb4f314..ee0098635 100644 --- a/solo-chains/runtime/dancelight/src/weights/mod.rs +++ b/solo-chains/runtime/dancelight/src/weights/mod.rs @@ -20,6 +20,7 @@ pub mod pallet_author_noting; pub mod pallet_balances; pub mod pallet_collator_assignment; pub mod pallet_conviction_voting; +pub mod pallet_external_validator_slashes; pub mod pallet_external_validators; pub mod pallet_identity; pub mod pallet_message_queue; diff --git a/solo-chains/runtime/dancelight/src/weights/pallet_external_validator_slashes.rs b/solo-chains/runtime/dancelight/src/weights/pallet_external_validator_slashes.rs new file mode 100644 index 000000000..f4dcd30ff --- /dev/null +++ b/solo-chains/runtime/dancelight/src/weights/pallet_external_validator_slashes.rs @@ -0,0 +1,88 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi 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. + +// Tanssi 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 Tanssi. If not, see + + +//! Autogenerated weights for pallet_external_validator_slashes +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 42.0.0 +//! DATE: 2024-10-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `girazoki-XPS-15-9530`, CPU: `13th Gen Intel(R) Core(TM) i9-13900H` +//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/tanssi-relay +// benchmark +// pallet +// --execution=wasm +// --wasm-execution=compiled +// --pallet +// pallet_external_validator_slashes +// --extrinsic +// * +// --chain=dev +// --steps +// 50 +// --repeat +// 20 +// --template=./benchmarking/frame-weight-runtime-template.hbs +// --json-file +// raw.json +// --output +// tmp/pallet_external_validator_slashes.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weights for pallet_external_validator_slashes using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl pallet_external_validator_slashes::WeightInfo for SubstrateWeight { + /// Storage: `ExternalValidators::ActiveEra` (r:1 w:0) + /// Proof: `ExternalValidators::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::Slashes` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::Slashes` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `s` is `[1, 1000]`. + fn cancel_deferred_slash(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `42194` + // Estimated: `45659` + // Minimum execution time: 67_311_000 picoseconds. + Weight::from_parts(536_999_990, 45659) + // Standard Error: 37_157 + .saturating_add(Weight::from_parts(3_022_012, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: `ExternalValidators::ActiveEra` (r:1 w:0) + /// Proof: `ExternalValidators::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::NextSlashId` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::NextSlashId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `ExternalValidatorSlashes::Slashes` (r:1 w:1) + /// Proof: `ExternalValidatorSlashes::Slashes` (`max_values`: None, `max_size`: None, mode: `Measured`) + fn force_inject_slash() -> Weight { + // Proof Size summary in bytes: + // Measured: `151` + // Estimated: `3616` + // Minimum execution time: 7_398_000 picoseconds. + Weight::from_parts(7_725_000, 3616) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) + } +} \ No newline at end of file diff --git a/test/suites/dev-tanssi-relay/slashes/test_slashes_are_confirmed_after_defer_period.ts b/test/suites/dev-tanssi-relay/slashes/test_slashes_are_confirmed_after_defer_period.ts new file mode 100644 index 000000000..9b27c56e7 --- /dev/null +++ b/test/suites/dev-tanssi-relay/slashes/test_slashes_are_confirmed_after_defer_period.ts @@ -0,0 +1,98 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { KeyringPair } from "@moonwall/util"; +import { Keyring } from "@polkadot/keyring"; +import { u8aToHex } from "@polkadot/util"; +import { jumpToSession } from "../../../util/block"; +import { generateBabeEquivocationProof } from "../../../util/slashes"; + +describeSuite({ + id: "DTR1304", + title: "Babe slashes defer period confirmation", + foundationMethods: "dev", + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let aliceBabePair: KeyringPair; + let aliceStash: KeyringPair; + beforeAll(async () => { + const keyringBabe = new Keyring({ type: "sr25519" }); + aliceBabePair = keyringBabe.addFromUri("//Alice"); + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + aliceStash = keyringBabe.addFromUri("//Alice//stash"); + }); + it({ + id: "E01", + title: "Babe offences should be confirmed after defer period", + test: async function () { + // we crate one block so that we at least have one seal. + await jumpToSession(context, 1); + + // Remove alice from invulnerables (just for the slash) + const removeAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.removeWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([removeAliceFromInvulnerables]); + + // let's inject the equivocation proof + const doubleVotingProof = await generateBabeEquivocationProof(polkadotJs, aliceBabePair); + + // generate key ownership proof + const keyOwnershipProof = ( + await polkadotJs.call.babeApi.generateKeyOwnershipProof( + doubleVotingProof.slotNumber, + u8aToHex(aliceBabePair.publicKey) + ) + ).unwrap(); + const keyOwnershipProofHex = `0x${keyOwnershipProof.toHuman().toString().slice(8)}`; + + const tx = polkadotJs.tx.sudo.sudoUncheckedWeight( + polkadotJs.tx.utility.dispatchAs( + { + system: { Signed: alice.address }, + } as any, + polkadotJs.tx.babe.reportEquivocation(doubleVotingProof, keyOwnershipProofHex) + ), + { + refTime: 1n, + proofSize: 1n, + } + ); + + const signedTx = await tx.signAsync(alice); + await context.createBlock(signedTx); + + // Slash item should be there + const DeferPeriod = (await polkadotJs.consts.externalValidatorSlashes.slashDeferDuration).toNumber(); + + // scheduled slashes + const expectedSlashes = await polkadotJs.query.externalValidatorSlashes.slashes(DeferPeriod + 1); + expect(expectedSlashes.length).to.be.eq(1); + expect(u8aToHex(expectedSlashes[0].validator)).to.be.eq(u8aToHex(aliceStash.addressRaw)); + + // Put alice back to invulnerables + const addAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.addWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([addAliceFromInvulnerables]); + + const sessionsPerEra = await polkadotJs.consts.externalValidators.sessionsPerEra; + + const currentIndex = await polkadotJs.query.session.currentIndex(); + + const targetSession = currentIndex * sessionsPerEra * (DeferPeriod + 1); + + await jumpToSession(context, targetSession); + + // scheduled slashes + const expectedSlashesAfterDefer = await polkadotJs.query.externalValidatorSlashes.slashes( + DeferPeriod + 1 + ); + expect(expectedSlashesAfterDefer.length).to.be.eq(1); + expect(expectedSlashesAfterDefer[0].confirmed.toHuman()).to.be.true; + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/slashes/test_slashes_are_not_applicable_to_invulnerables.ts b/test/suites/dev-tanssi-relay/slashes/test_slashes_are_not_applicable_to_invulnerables.ts new file mode 100644 index 000000000..e4c5b4ce6 --- /dev/null +++ b/test/suites/dev-tanssi-relay/slashes/test_slashes_are_not_applicable_to_invulnerables.ts @@ -0,0 +1,70 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { KeyringPair } from "@moonwall/util"; +import { Keyring } from "@polkadot/keyring"; +import { u8aToHex } from "@polkadot/util"; +import { jumpToSession } from "../../../util/block"; +import { generateBabeEquivocationProof } from "../../../util/slashes"; + +describeSuite({ + id: "DTR1302", + title: "Babe offences invulnerables", + foundationMethods: "dev", + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let aliceBabePair: KeyringPair; + beforeAll(async () => { + const keyringBabe = new Keyring({ type: "sr25519" }); + aliceBabePair = keyringBabe.addFromUri("//Alice"); + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + }); + it({ + id: "E01", + title: "Babe offences do not trigger a slash to invulnerables", + test: async function () { + // we crate one block so that we at least have one seal. + await jumpToSession(context, 1); + + // let's inject the equivocation proof + const doubleVotingProof = await generateBabeEquivocationProof(polkadotJs, aliceBabePair); + + // generate key ownership proof + const keyOwnershipProof = ( + await polkadotJs.call.babeApi.generateKeyOwnershipProof( + doubleVotingProof.slotNumber, + u8aToHex(aliceBabePair.publicKey) + ) + ).unwrap(); + const keyOwnershipProofHex = `0x${keyOwnershipProof.toHuman().toString().slice(8)}`; + + const tx = polkadotJs.tx.sudo.sudoUncheckedWeight( + polkadotJs.tx.utility.dispatchAs( + { + system: { Signed: alice.address }, + } as any, + polkadotJs.tx.babe.reportEquivocation(doubleVotingProof, keyOwnershipProofHex) + ), + { + refTime: 1n, + proofSize: 1n, + } + ); + + const signedTx = await tx.signAsync(alice); + await context.createBlock(signedTx); + + // Slash item should be there + const DeferPeriod = await polkadotJs.consts.externalValidatorSlashes.slashDeferDuration; + + // Alice is an invulnerable, therefore she should not be slashed + const expectedSlashes = await polkadotJs.query.externalValidatorSlashes.slashes( + DeferPeriod.toNumber() + 1 + ); + expect(expectedSlashes.length).to.be.eq(0); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/slashes/test_slashes_are_removed_after_bonding_period.ts b/test/suites/dev-tanssi-relay/slashes/test_slashes_are_removed_after_bonding_period.ts new file mode 100644 index 000000000..91eb73304 --- /dev/null +++ b/test/suites/dev-tanssi-relay/slashes/test_slashes_are_removed_after_bonding_period.ts @@ -0,0 +1,99 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { KeyringPair } from "@moonwall/util"; +import { Keyring } from "@polkadot/keyring"; +import { u8aToHex } from "@polkadot/util"; +import { jumpToSession } from "../../../util/block"; +import { generateBabeEquivocationProof } from "../../../util/slashes"; + +describeSuite({ + id: "DTR1305", + title: "Babe offences bonding period", + foundationMethods: "dev", + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let aliceBabePair: KeyringPair; + let aliceStash: KeyringPair; + beforeAll(async () => { + const keyringBabe = new Keyring({ type: "sr25519" }); + aliceBabePair = keyringBabe.addFromUri("//Alice"); + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + aliceStash = keyringBabe.addFromUri("//Alice//stash"); + }); + it({ + id: "E01", + title: "Babe offences should be removed after bonding period", + test: async function () { + // we crate one block so that we at least have one seal. + await jumpToSession(context, 1); + + // Remove alice from invulnerables (just for the slash) + const removeAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.removeWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([removeAliceFromInvulnerables]); + + // let's inject the equivocation proof + const doubleVotingProof = await generateBabeEquivocationProof(polkadotJs, aliceBabePair); + + // generate key ownership proof + const keyOwnershipProof = ( + await polkadotJs.call.babeApi.generateKeyOwnershipProof( + doubleVotingProof.slotNumber, + u8aToHex(aliceBabePair.publicKey) + ) + ).unwrap(); + const keyOwnershipProofHex = `0x${keyOwnershipProof.toHuman().toString().slice(8)}`; + + const tx = polkadotJs.tx.sudo.sudoUncheckedWeight( + polkadotJs.tx.utility.dispatchAs( + { + system: { Signed: alice.address }, + } as any, + polkadotJs.tx.babe.reportEquivocation(doubleVotingProof, keyOwnershipProofHex) + ), + { + refTime: 1n, + proofSize: 1n, + } + ); + + const signedTx = await tx.signAsync(alice); + await context.createBlock(signedTx); + + // Slash item should be there + const DeferPeriod = (await polkadotJs.consts.externalValidatorSlashes.slashDeferDuration).toNumber(); + + // scheduled slashes + const expectedSlashes = await polkadotJs.query.externalValidatorSlashes.slashes(DeferPeriod + 1); + expect(expectedSlashes.length).to.be.eq(1); + expect(u8aToHex(expectedSlashes[0].validator)).to.be.eq(u8aToHex(aliceStash.addressRaw)); + + // Put alice back to invulnerables + const addAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.addWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([addAliceFromInvulnerables]); + + const sessionsPerEra = await polkadotJs.consts.externalValidators.sessionsPerEra; + const bondingPeriod = await polkadotJs.consts.externalValidatorSlashes.bondingDuration; + + const currentIndex = await polkadotJs.query.session.currentIndex(); + + const targetSession = + currentIndex.toNumber() + sessionsPerEra * (DeferPeriod + 1) + sessionsPerEra * (bondingPeriod + 1); + // TODO: check this + await jumpToSession(context, targetSession); + + // scheduled slashes + const expectedSlashesAfterDefer = await polkadotJs.query.externalValidatorSlashes.slashes( + DeferPeriod + 1 + ); + expect(expectedSlashesAfterDefer.length).to.be.eq(0); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/slashes/test_slashes_babe.ts b/test/suites/dev-tanssi-relay/slashes/test_slashes_babe.ts new file mode 100644 index 000000000..f1a5d56c4 --- /dev/null +++ b/test/suites/dev-tanssi-relay/slashes/test_slashes_babe.ts @@ -0,0 +1,79 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { KeyringPair } from "@moonwall/util"; +import { Keyring } from "@polkadot/keyring"; +import { u8aToHex } from "@polkadot/util"; +import { jumpToSession } from "../../../util/block"; +import { generateBabeEquivocationProof } from "../../../util/slashes"; + +describeSuite({ + id: "DTR1301", + title: "Babe offences should trigger a slash", + foundationMethods: "dev", + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let aliceBabePair: KeyringPair; + let aliceStash: KeyringPair; + beforeAll(async () => { + const keyringBabe = new Keyring({ type: "sr25519" }); + aliceBabePair = keyringBabe.addFromUri("//Alice"); + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + aliceStash = keyringBabe.addFromUri("//Alice//stash"); + }); + it({ + id: "E01", + title: "Babe offences trigger a slash", + test: async function () { + // we crate one block so that we at least have one seal. + await jumpToSession(context, 1); + + // Remove alice from invulnerables (just for the slash) + const removeAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.removeWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([removeAliceFromInvulnerables]); + + // let's inject the equivocation proof + const doubleVotingProof = await generateBabeEquivocationProof(polkadotJs, aliceBabePair); + + // generate key ownership proof + const keyOwnershipProof = ( + await polkadotJs.call.babeApi.generateKeyOwnershipProof( + doubleVotingProof.slotNumber, + u8aToHex(aliceBabePair.publicKey) + ) + ).unwrap(); + const keyOwnershipProofHex = `0x${keyOwnershipProof.toHuman().toString().slice(8)}`; + + const tx = polkadotJs.tx.sudo.sudoUncheckedWeight( + polkadotJs.tx.utility.dispatchAs( + { + system: { Signed: alice.address }, + } as any, + polkadotJs.tx.babe.reportEquivocation(doubleVotingProof, keyOwnershipProofHex) + ), + { + refTime: 1n, + proofSize: 1n, + } + ); + + const signedTx = await tx.signAsync(alice); + await context.createBlock(signedTx); + + // Slash item should be there + const DeferPeriod = await polkadotJs.consts.externalValidatorSlashes.slashDeferDuration; + + // scheduled slashes + const expectedSlashes = await polkadotJs.query.externalValidatorSlashes.slashes( + DeferPeriod.toNumber() + 1 + ); + expect(expectedSlashes.length).to.be.eq(1); + expect(u8aToHex(expectedSlashes[0].validator)).to.be.eq(u8aToHex(aliceStash.addressRaw)); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/slashes/test_slashes_can_be_cancelled.ts b/test/suites/dev-tanssi-relay/slashes/test_slashes_can_be_cancelled.ts new file mode 100644 index 000000000..8047093e7 --- /dev/null +++ b/test/suites/dev-tanssi-relay/slashes/test_slashes_can_be_cancelled.ts @@ -0,0 +1,89 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { KeyringPair } from "@moonwall/util"; +import { Keyring } from "@polkadot/keyring"; +import { u8aToHex } from "@polkadot/util"; +import { jumpToSession } from "../../../util/block"; +import { generateBabeEquivocationProof } from "../../../util/slashes"; + +describeSuite({ + id: "DTR1303", + title: "Babe offences should be cancellable", + foundationMethods: "dev", + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let aliceBabePair: KeyringPair; + let aliceStash: KeyringPair; + beforeAll(async () => { + const keyringBabe = new Keyring({ type: "sr25519" }); + aliceBabePair = keyringBabe.addFromUri("//Alice"); + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + aliceStash = keyringBabe.addFromUri("//Alice//stash"); + }); + it({ + id: "E01", + title: "Babe offences are cancellable during the defer period", + test: async function () { + // we crate one block so that we at least have one seal. + await jumpToSession(context, 1); + + // Remove alice from invulnerables (just for the slash) + const removeAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.removeWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([removeAliceFromInvulnerables]); + + // let's inject the equivocation proof + const doubleVotingProof = await generateBabeEquivocationProof(polkadotJs, aliceBabePair); + + // generate key ownership proof + const keyOwnershipProof = ( + await polkadotJs.call.babeApi.generateKeyOwnershipProof( + doubleVotingProof.slotNumber, + u8aToHex(aliceBabePair.publicKey) + ) + ).unwrap(); + const keyOwnershipProofHex = `0x${keyOwnershipProof.toHuman().toString().slice(8)}`; + + const tx = polkadotJs.tx.sudo.sudoUncheckedWeight( + polkadotJs.tx.utility.dispatchAs( + { + system: { Signed: alice.address }, + } as any, + polkadotJs.tx.babe.reportEquivocation(doubleVotingProof, keyOwnershipProofHex) + ), + { + refTime: 1n, + proofSize: 1n, + } + ); + + const signedTx = await tx.signAsync(alice); + await context.createBlock(signedTx); + + // Slash item should be there + const DeferPeriod = (await polkadotJs.consts.externalValidatorSlashes.slashDeferDuration).toNumber(); + + // scheduled slashes + const expectedSlashes = await polkadotJs.query.externalValidatorSlashes.slashes(DeferPeriod + 1); + expect(expectedSlashes.length).to.be.eq(1); + expect(u8aToHex(expectedSlashes[0].validator)).to.be.eq(u8aToHex(aliceStash.addressRaw)); + + // Remove alice from invulnerables (just for the slash) + const cancelSlash = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidatorSlashes.cancelDeferredSlash(DeferPeriod + 1, [0])) + .signAsync(alice); + await context.createBlock([cancelSlash]); + + // alashes have dissapeared + const expectedSlashesAfterCancel = await polkadotJs.query.externalValidatorSlashes.slashes( + DeferPeriod + 1 + ); + expect(expectedSlashesAfterCancel.length).to.be.eq(0); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/slashes/test_slashes_grandpa.ts b/test/suites/dev-tanssi-relay/slashes/test_slashes_grandpa.ts new file mode 100644 index 000000000..830ca0a3f --- /dev/null +++ b/test/suites/dev-tanssi-relay/slashes/test_slashes_grandpa.ts @@ -0,0 +1,76 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { KeyringPair } from "@moonwall/util"; +import { Keyring } from "@polkadot/keyring"; +import { u8aToHex } from "@polkadot/util"; +import { jumpToSession } from "../../../util/block"; +import { generateGrandpaEquivocationProof } from "../../../util/slashes"; + +describeSuite({ + id: "DTR1306", + title: "Grandpa offences should trigger a slash", + foundationMethods: "dev", + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let aliceGrandpaPair: KeyringPair; + let aliceStash: KeyringPair; + beforeAll(async () => { + const keyringGrandpa = new Keyring({ type: "ed25519" }); + const keyringSr25519 = new Keyring({ type: "sr25519" }); + aliceGrandpaPair = keyringGrandpa.addFromUri("//Alice"); + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + aliceStash = keyringSr25519.addFromUri("//Alice//stash"); + }); + it({ + id: "E01", + title: "Grandpa offences trigger a slashing event", + test: async function () { + // we crate one block so that we at least have one seal. + await jumpToSession(context, 1); + + // Remove alice from invulnerables (just for the slash) + const removeAliceFromInvulnerables = await polkadotJs.tx.sudo + .sudo(polkadotJs.tx.externalValidators.removeWhitelisted(aliceStash.address)) + .signAsync(alice); + await context.createBlock([removeAliceFromInvulnerables]); + + const doubleVotingProof = await generateGrandpaEquivocationProof(polkadotJs, aliceGrandpaPair); + + const keyOwnershipProof = ( + await polkadotJs.call.grandpaApi.generateKeyOwnershipProof( + doubleVotingProof.setId, + u8aToHex(aliceGrandpaPair.publicKey) + ) + ).unwrap(); + const keyOwnershipProofHex = `0x${keyOwnershipProof.toHuman().toString().slice(8)}`; + + const tx = polkadotJs.tx.sudo.sudoUncheckedWeight( + polkadotJs.tx.utility.dispatchAs( + { + system: { Signed: alice.address }, + } as any, + polkadotJs.tx.grandpa.reportEquivocation(doubleVotingProof, keyOwnershipProofHex) + ), + { + refTime: 1n, + proofSize: 1n, + } + ); + + const signedTx = await tx.signAsync(alice); + await context.createBlock(signedTx); + + // Slash item should be there + const DeferPeriod = (await polkadotJs.consts.externalValidatorSlashes.slashDeferDuration).toNumber(); + + // scheduled slashes + const expectedSlashes = await polkadotJs.query.externalValidatorSlashes.slashes(DeferPeriod + 1); + expect(expectedSlashes.length).to.be.eq(1); + expect(u8aToHex(expectedSlashes[0].validator)).to.be.eq(u8aToHex(aliceStash.addressRaw)); + }, + }); + }, +}); diff --git a/test/util/slashes.ts b/test/util/slashes.ts new file mode 100644 index 000000000..483dbaf3f --- /dev/null +++ b/test/util/slashes.ts @@ -0,0 +1,118 @@ +import { ApiPromise } from "@polkadot/api"; +import { + BabeEquivocationProof, + GrandpaEquivocationProof, + GrandpaEquivocation, + GrandpaEquivocationValue, +} from "@polkadot/types/interfaces"; +import { SpRuntimeHeader, SpRuntimeDigestDigestItem, FinalityGrandpaPrevote } from "@polkadot/types/lookup"; +import { KeyringPair } from "@moonwall/util"; +import { blake2AsHex } from "@polkadot/util-crypto"; +import { u8aToHex, stringToHex, hexToU8a } from "@polkadot/util"; + +export async function generateBabeEquivocationProof( + api: ApiPromise, + pair: KeyringPair +): Promise { + const baseHeader = await api.rpc.chain.getHeader(); + const baseHeader2 = await api.rpc.chain.getHeader(); + + const header1: SpRuntimeHeader = api.createType("SpRuntimeHeader", { + digest: baseHeader.digest, + extrinsicsRoot: baseHeader.extrinsicsRoot, + stateRoot: baseHeader.stateRoot, + parentHash: baseHeader.parentHash, + number: 1, + }); + + // we just change the block number + const header2: SpRuntimeHeader = api.createType("SpRuntimeHeader", { + digest: baseHeader2.digest, + extrinsicsRoot: baseHeader2.extrinsicsRoot, + stateRoot: baseHeader2.stateRoot, + parentHash: baseHeader2.parentHash, + number: 2, + }); + + const sig1 = pair.sign(blake2AsHex(header1.toU8a())); + const sig2 = pair.sign(blake2AsHex(header2.toU8a())); + + const slot = await api.query.babe.currentSlot(); + + const digestItemSeal1: SpRuntimeDigestDigestItem = api.createType("SpRuntimeDigestDigestItem", { + Seal: [stringToHex("BABE"), u8aToHex(sig1)], + }); + + const digestItemSeal2: SpRuntimeDigestDigestItem = api.createType("SpRuntimeDigestDigestItem", { + Seal: [stringToHex("BABE"), u8aToHex(sig2)], + }); + + header1.digest.logs.push(digestItemSeal1); + header2.digest.logs.push(digestItemSeal2); + + const doubleVotingProof: BabeEquivocationProof = api.createType("BabeEquivocationProof", { + offender: pair.publicKey, + slotNumber: slot, + firstHeader: header1, + secondHeader: header2, + }); + return doubleVotingProof; +} + +export async function generateGrandpaEquivocationProof( + api: ApiPromise, + pair: KeyringPair +): Promise { + const prevote1: FinalityGrandpaPrevote = api.createType("FinalityGrandpaPrevote", { + targetHash: "0x0000000000000000000000000000000000000000000000000000000000000000", + targetNumber: 1, + }); + + const prevote2: FinalityGrandpaPrevote = api.createType("FinalityGrandpaPrevote", { + targetHash: "0x0000000000000000000000000000000000000000000000000000000000000000", + targetNumber: 2, + }); + + const roundNumber = api.createType("u64", 1); + const setId = await api.query.grandpa.currentSetId(); + + // I could not find the proper struct that holds all this into a singl message + // ergo I need to construct the signing payload myself + // the first 0 is because of this enum variant + // https://github.com/paritytech/finality-grandpa/blob/8c45a664c05657f0c71057158d3ba555ba7d20de/src/lib.rs#L228 + // then we have the prevote message + // then the round number + // then the set id + const toSign1 = new Uint8Array([ + ...hexToU8a("0x00"), + ...prevote1.toU8a(), + ...roundNumber.toU8a(), + ...setId.toU8a(), + ]); + + const toSign2 = new Uint8Array([ + ...hexToU8a("0x00"), + ...prevote2.toU8a(), + ...roundNumber.toU8a(), + ...setId.toU8a(), + ]); + const sig1 = pair.sign(toSign1); + const sig2 = pair.sign(toSign2); + + const equivocationValue: GrandpaEquivocationValue = api.createType("GrandpaEquivocationValue", { + roundNumber, + identity: pair.address, + first: [prevote1, sig1], + second: [prevote2, sig2], + }); + + const equivocation: GrandpaEquivocation = api.createType("GrandpaEquivocation", { + Prevote: equivocationValue, + }); + + const doubleVotingProof: GrandpaEquivocationProof = api.createType("GrandpaEquivocationProof", { + setId, + equivocation, + }); + return doubleVotingProof; +} diff --git a/typescript-api/src/dancelight/interfaces/augment-api-consts.ts b/typescript-api/src/dancelight/interfaces/augment-api-consts.ts index dc0004bb4..411a2d61d 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-consts.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-consts.ts @@ -155,6 +155,19 @@ declare module "@polkadot/api-base/types/consts" { /** Generic const */ [key: string]: Codec; }; + externalValidatorSlashes: { + /** Number of eras that staked funds must remain bonded for. */ + bondingDuration: u32 & AugmentedConst; + /** + * Number of eras that slashes are deferred by, after computation. + * + * This should be less than the bonding duration. Set to 0 if slashes should be applied immediately, without + * opportunity for intervention. + */ + slashDeferDuration: u32 & AugmentedConst; + /** Generic const */ + [key: string]: Codec; + }; fellowshipReferenda: { /** * Quantization level for the referendum wakeup scheduler. A higher number will result in fewer storage diff --git a/typescript-api/src/dancelight/interfaces/augment-api-errors.ts b/typescript-api/src/dancelight/interfaces/augment-api-errors.ts index e41215365..9727ad457 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-errors.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-errors.ts @@ -243,6 +243,24 @@ declare module "@polkadot/api-base/types/errors" { /** Generic error */ [key: string]: AugmentedError; }; + externalValidatorSlashes: { + /** The slash to be cancelled has already elapsed the DeferPeriod */ + DeferPeriodIsOver: AugmentedError; + /** The era for which the slash wants to be cancelled has no slashes */ + EmptyTargets: AugmentedError; + /** There was an error computing the slash */ + ErrorComputingSlash: AugmentedError; + /** No slash was found to be cancelled at the given index */ + InvalidSlashIndex: AugmentedError; + /** Slash indices to be cancelled are not sorted or unique */ + NotSortedAndUnique: AugmentedError; + /** Provided an era in the future */ + ProvidedFutureEra: AugmentedError; + /** Provided an era that is not slashable */ + ProvidedNonSlashableEra: AugmentedError; + /** Generic error */ + [key: string]: AugmentedError; + }; fellowshipCollective: { /** Account is already a member. */ AlreadyMember: AugmentedError; diff --git a/typescript-api/src/dancelight/interfaces/augment-api-events.ts b/typescript-api/src/dancelight/interfaces/augment-api-events.ts index b96506f9e..bf0aa160b 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-events.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-events.ts @@ -8,7 +8,7 @@ import "@polkadot/api-base/types/events"; import type { ApiTypes, AugmentedEvent } from "@polkadot/api-base/types"; import type { Bytes, Null, Option, Result, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from "@polkadot/types-codec"; import type { ITuple } from "@polkadot/types-codec/types"; -import type { AccountId32, H256 } from "@polkadot/types/interfaces/runtime"; +import type { AccountId32, H256, Perbill } from "@polkadot/types/interfaces/runtime"; import type { DancelightRuntimeProxyType, DancelightRuntimeRuntimeParametersKey, @@ -228,6 +228,16 @@ declare module "@polkadot/api-base/types/events" { /** Generic event */ [key: string]: AugmentedEvent; }; + externalValidatorSlashes: { + /** Removed author data */ + SlashReported: AugmentedEvent< + ApiType, + [validator: AccountId32, fraction: Perbill, slashEra: u32], + { validator: AccountId32; fraction: Perbill; slashEra: u32 } + >; + /** Generic event */ + [key: string]: AugmentedEvent; + }; fellowshipCollective: { /** A member `who` has been added. */ MemberAdded: AugmentedEvent; diff --git a/typescript-api/src/dancelight/interfaces/augment-api-query.ts b/typescript-api/src/dancelight/interfaces/augment-api-query.ts index ad9e5579f..f10abf0a0 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-query.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-query.ts @@ -47,6 +47,7 @@ import type { PalletConfigurationHostConfiguration, PalletConvictionVotingVoteVoting, PalletDataPreserversRegisteredProfile, + PalletExternalValidatorSlashesSlash, PalletExternalValidatorsForcing, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, @@ -711,6 +712,36 @@ declare module "@polkadot/api-base/types/storage" { /** Generic query */ [key: string]: QueryableStorageEntry; }; + externalValidatorSlashes: { + /** + * A mapping from still-bonded eras to the first session index of that era. + * + * Must contains information for eras for the range: `[active_era - bounding_duration; active_era]` + */ + bondedEras: AugmentedQuery Observable>>, []> & + QueryableStorageEntry; + /** A counter on the number of slashes we have performed */ + nextSlashId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** All unapplied slashes that are queued for later. */ + slashes: AugmentedQuery< + ApiType, + (arg: u32 | AnyNumber | Uint8Array) => Observable>, + [u32] + > & + QueryableStorageEntry; + /** All slashing events on validators, mapped by era to the highest slash proportion and slash value of the era. */ + validatorSlashInEra: AugmentedQuery< + ApiType, + ( + arg1: u32 | AnyNumber | Uint8Array, + arg2: AccountId32 | string | Uint8Array + ) => Observable>, + [u32, AccountId32] + > & + QueryableStorageEntry; + /** Generic query */ + [key: string]: QueryableStorageEntry; + }; fellowshipCollective: { /** The index of each ranks's member into the group of members who have at least that rank. */ idToIndex: AugmentedQuery< diff --git a/typescript-api/src/dancelight/interfaces/augment-api-tx.ts b/typescript-api/src/dancelight/interfaces/augment-api-tx.ts index 12d597a23..2bb4f9520 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-tx.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-tx.ts @@ -1320,6 +1320,26 @@ declare module "@polkadot/api-base/types/submittable" { /** Generic tx */ [key: string]: SubmittableExtrinsicFunction; }; + externalValidatorSlashes: { + /** Cancel a slash that was deferred for a later era */ + cancelDeferredSlash: AugmentedSubmittable< + ( + era: u32 | AnyNumber | Uint8Array, + slashIndices: Vec | (u32 | AnyNumber | Uint8Array)[] + ) => SubmittableExtrinsic, + [u32, Vec] + >; + forceInjectSlash: AugmentedSubmittable< + ( + era: u32 | AnyNumber | Uint8Array, + validator: AccountId32 | string | Uint8Array, + percentage: Perbill | AnyNumber | Uint8Array + ) => SubmittableExtrinsic, + [u32, AccountId32, Perbill] + >; + /** Generic tx */ + [key: string]: SubmittableExtrinsicFunction; + }; fellowshipCollective: { /** * Introduce a new member. diff --git a/typescript-api/src/dancelight/interfaces/lookup.ts b/typescript-api/src/dancelight/interfaces/lookup.ts index ad1e3967e..87c8d4016 100644 --- a/typescript-api/src/dancelight/interfaces/lookup.ts +++ b/typescript-api/src/dancelight/interfaces/lookup.ts @@ -453,7 +453,17 @@ export default { PalletExternalValidatorsForcing: { _enum: ["NotForcing", "ForceNew", "ForceNone", "ForceAlways"], }, - /** Lookup56: pallet_session::pallet::Event */ + /** Lookup56: pallet_external_validator_slashes::pallet::Event */ + PalletExternalValidatorSlashesEvent: { + _enum: { + SlashReported: { + validator: "AccountId32", + fraction: "Perbill", + slashEra: "u32", + }, + }, + }, + /** Lookup58: pallet_session::pallet::Event */ PalletSessionEvent: { _enum: { NewSession: { @@ -461,7 +471,7 @@ export default { }, }, }, - /** Lookup57: pallet_grandpa::pallet::Event */ + /** Lookup59: pallet_grandpa::pallet::Event */ PalletGrandpaEvent: { _enum: { NewAuthorities: { @@ -471,9 +481,9 @@ export default { Resumed: "Null", }, }, - /** Lookup60: sp_consensus_grandpa::app::Public */ + /** Lookup62: sp_consensus_grandpa::app::Public */ SpConsensusGrandpaAppPublic: "[u8;32]", - /** Lookup61: pallet_inflation_rewards::pallet::Event */ + /** Lookup63: pallet_inflation_rewards::pallet::Event */ PalletInflationRewardsEvent: { _enum: { RewardedOrchestrator: { @@ -487,7 +497,7 @@ export default { }, }, }, - /** Lookup62: pallet_treasury::pallet::Event */ + /** Lookup64: pallet_treasury::pallet::Event */ PalletTreasuryEvent: { _enum: { Spending: { @@ -540,14 +550,14 @@ export default { }, }, }, - /** Lookup64: pallet_conviction_voting::pallet::Event */ + /** Lookup66: pallet_conviction_voting::pallet::Event */ PalletConvictionVotingEvent: { _enum: { Delegated: "(AccountId32,AccountId32)", Undelegated: "AccountId32", }, }, - /** Lookup65: pallet_referenda::pallet::Event */ + /** Lookup67: pallet_referenda::pallet::Event */ PalletReferendaEvent: { _enum: { Submitted: { @@ -626,7 +636,7 @@ export default { }, }, /** - * Lookup67: frame_support::traits::preimages::Bounded */ FrameSupportPreimagesBounded: { @@ -647,7 +657,7 @@ export default { }, }, }, - /** Lookup69: frame_system::pallet::Call */ + /** Lookup71: frame_system::pallet::Call */ FrameSystemCall: { _enum: { remark: { @@ -690,7 +700,7 @@ export default { }, }, }, - /** Lookup73: pallet_babe::pallet::Call */ + /** Lookup75: pallet_babe::pallet::Call */ PalletBabeCall: { _enum: { report_equivocation: { @@ -707,7 +717,7 @@ export default { }, }, /** - * Lookup74: sp_consensus_slots::EquivocationProof, + * Lookup76: sp_consensus_slots::EquivocationProof, * sp_consensus_babe::app::Public> */ SpConsensusSlotsEquivocationProof: { @@ -716,7 +726,7 @@ export default { firstHeader: "SpRuntimeHeader", secondHeader: "SpRuntimeHeader", }, - /** Lookup75: sp_runtime::generic::header::Header */ + /** Lookup77: sp_runtime::generic::header::Header */ SpRuntimeHeader: { parentHash: "H256", number: "Compact", @@ -724,15 +734,15 @@ export default { extrinsicsRoot: "H256", digest: "SpRuntimeDigest", }, - /** Lookup77: sp_consensus_babe::app::Public */ + /** Lookup79: sp_consensus_babe::app::Public */ SpConsensusBabeAppPublic: "[u8;32]", - /** Lookup78: sp_session::MembershipProof */ + /** Lookup80: sp_session::MembershipProof */ SpSessionMembershipProof: { session: "u32", trieNodes: "Vec", validatorCount: "u32", }, - /** Lookup79: sp_consensus_babe::digests::NextConfigDescriptor */ + /** Lookup81: sp_consensus_babe::digests::NextConfigDescriptor */ SpConsensusBabeDigestsNextConfigDescriptor: { _enum: { __Unused0: "Null", @@ -742,11 +752,11 @@ export default { }, }, }, - /** Lookup81: sp_consensus_babe::AllowedSlots */ + /** Lookup83: sp_consensus_babe::AllowedSlots */ SpConsensusBabeAllowedSlots: { _enum: ["PrimarySlots", "PrimaryAndSecondaryPlainSlots", "PrimaryAndSecondaryVRFSlots"], }, - /** Lookup82: pallet_timestamp::pallet::Call */ + /** Lookup84: pallet_timestamp::pallet::Call */ PalletTimestampCall: { _enum: { set: { @@ -754,7 +764,7 @@ export default { }, }, }, - /** Lookup83: pallet_balances::pallet::Call */ + /** Lookup85: pallet_balances::pallet::Call */ PalletBalancesCall: { _enum: { transfer_allow_death: { @@ -797,11 +807,11 @@ export default { }, }, }, - /** Lookup89: pallet_balances::types::AdjustmentDirection */ + /** Lookup91: pallet_balances::types::AdjustmentDirection */ PalletBalancesAdjustmentDirection: { _enum: ["Increase", "Decrease"], }, - /** Lookup90: pallet_parameters::pallet::Call */ + /** Lookup92: pallet_parameters::pallet::Call */ PalletParametersCall: { _enum: { set_parameter: { @@ -809,20 +819,20 @@ export default { }, }, }, - /** Lookup91: dancelight_runtime::RuntimeParameters */ + /** Lookup93: dancelight_runtime::RuntimeParameters */ DancelightRuntimeRuntimeParameters: { _enum: { Preimage: "DancelightRuntimeDynamicParamsPreimageParameters", }, }, - /** Lookup92: dancelight_runtime::dynamic_params::preimage::Parameters */ + /** Lookup94: dancelight_runtime::dynamic_params::preimage::Parameters */ DancelightRuntimeDynamicParamsPreimageParameters: { _enum: { BaseDeposit: "(DancelightRuntimeDynamicParamsPreimageBaseDeposit,Option)", ByteDeposit: "(DancelightRuntimeDynamicParamsPreimageByteDeposit,Option)", }, }, - /** Lookup93: pallet_registrar::pallet::Call */ + /** Lookup95: pallet_registrar::pallet::Call */ PalletRegistrarCall: { _enum: { register: { @@ -873,7 +883,7 @@ export default { }, }, }, - /** Lookup94: dp_container_chain_genesis_data::ContainerChainGenesisData */ + /** Lookup96: dp_container_chain_genesis_data::ContainerChainGenesisData */ DpContainerChainGenesisDataContainerChainGenesisData: { storage: "Vec", name: "Bytes", @@ -882,36 +892,36 @@ export default { extensions: "Bytes", properties: "DpContainerChainGenesisDataProperties", }, - /** Lookup96: dp_container_chain_genesis_data::ContainerChainGenesisDataItem */ + /** Lookup98: dp_container_chain_genesis_data::ContainerChainGenesisDataItem */ DpContainerChainGenesisDataContainerChainGenesisDataItem: { key: "Bytes", value: "Bytes", }, - /** Lookup98: dp_container_chain_genesis_data::Properties */ + /** Lookup100: dp_container_chain_genesis_data::Properties */ DpContainerChainGenesisDataProperties: { tokenMetadata: "DpContainerChainGenesisDataTokenMetadata", isEthereum: "bool", }, - /** Lookup99: dp_container_chain_genesis_data::TokenMetadata */ + /** Lookup101: dp_container_chain_genesis_data::TokenMetadata */ DpContainerChainGenesisDataTokenMetadata: { tokenSymbol: "Bytes", ss58Format: "u32", tokenDecimals: "u32", }, - /** Lookup103: tp_traits::SlotFrequency */ + /** Lookup105: tp_traits::SlotFrequency */ TpTraitsSlotFrequency: { min: "u32", max: "u32", }, - /** Lookup105: tp_traits::ParathreadParams */ + /** Lookup107: tp_traits::ParathreadParams */ TpTraitsParathreadParams: { slotFrequency: "TpTraitsSlotFrequency", }, - /** Lookup106: sp_trie::storage_proof::StorageProof */ + /** Lookup108: sp_trie::storage_proof::StorageProof */ SpTrieStorageProof: { trieNodes: "BTreeSet", }, - /** Lookup108: sp_runtime::MultiSignature */ + /** Lookup110: sp_runtime::MultiSignature */ SpRuntimeMultiSignature: { _enum: { Ed25519: "[u8;64]", @@ -919,7 +929,7 @@ export default { Ecdsa: "[u8;65]", }, }, - /** Lookup111: pallet_configuration::pallet::Call */ + /** Lookup113: pallet_configuration::pallet::Call */ PalletConfigurationCall: { _enum: { set_max_collators: { @@ -1019,7 +1029,7 @@ export default { }, }, }, - /** Lookup114: pallet_invulnerables::pallet::Call */ + /** Lookup115: pallet_invulnerables::pallet::Call */ PalletInvulnerablesCall: { _enum: { __Unused0: "Null", @@ -1031,11 +1041,11 @@ export default { }, }, }, - /** Lookup115: pallet_collator_assignment::pallet::Call */ + /** Lookup116: pallet_collator_assignment::pallet::Call */ PalletCollatorAssignmentCall: "Null", - /** Lookup116: pallet_authority_assignment::pallet::Call */ + /** Lookup117: pallet_authority_assignment::pallet::Call */ PalletAuthorityAssignmentCall: "Null", - /** Lookup117: pallet_author_noting::pallet::Call */ + /** Lookup118: pallet_author_noting::pallet::Call */ PalletAuthorNotingCall: { _enum: { set_latest_author_data: { @@ -1052,7 +1062,7 @@ export default { }, }, }, - /** Lookup118: pallet_services_payment::pallet::Call */ + /** Lookup119: pallet_services_payment::pallet::Call */ PalletServicesPaymentCall: { _enum: { purchase_credits: { @@ -1085,7 +1095,7 @@ export default { }, }, }, - /** Lookup119: pallet_data_preservers::pallet::Call */ + /** Lookup120: pallet_data_preservers::pallet::Call */ PalletDataPreserversCall: { _enum: { __Unused0: "Null", @@ -1126,14 +1136,14 @@ export default { }, }, }, - /** Lookup120: pallet_data_preservers::types::Profile */ + /** Lookup121: pallet_data_preservers::types::Profile */ PalletDataPreserversProfile: { url: "Bytes", paraIds: "PalletDataPreserversParaIdsFilter", mode: "PalletDataPreserversProfileMode", assignmentRequest: "DancelightRuntimePreserversAssignmentPaymentRequest", }, - /** Lookup122: pallet_data_preservers::types::ParaIdsFilter */ + /** Lookup123: pallet_data_preservers::types::ParaIdsFilter */ PalletDataPreserversParaIdsFilter: { _enum: { AnyParaId: "Null", @@ -1141,7 +1151,7 @@ export default { Blacklist: "BTreeSet", }, }, - /** Lookup126: pallet_data_preservers::types::ProfileMode */ + /** Lookup127: pallet_data_preservers::types::ProfileMode */ PalletDataPreserversProfileMode: { _enum: { Bootnode: "Null", @@ -1150,19 +1160,19 @@ export default { }, }, }, - /** Lookup127: dancelight_runtime::PreserversAssignmentPaymentRequest */ + /** Lookup128: dancelight_runtime::PreserversAssignmentPaymentRequest */ DancelightRuntimePreserversAssignmentPaymentRequest: { _enum: ["Free"], }, - /** Lookup128: dancelight_runtime::PreserversAssignmentPaymentExtra */ + /** Lookup129: dancelight_runtime::PreserversAssignmentPaymentExtra */ DancelightRuntimePreserversAssignmentPaymentExtra: { _enum: ["Free"], }, - /** Lookup129: dancelight_runtime::PreserversAssignmentPaymentWitness */ + /** Lookup130: dancelight_runtime::PreserversAssignmentPaymentWitness */ DancelightRuntimePreserversAssignmentPaymentWitness: { _enum: ["Free"], }, - /** Lookup130: pallet_external_validators::pallet::Call */ + /** Lookup131: pallet_external_validators::pallet::Call */ PalletExternalValidatorsCall: { _enum: { skip_external_validators: { @@ -1179,7 +1189,21 @@ export default { }, }, }, - /** Lookup131: pallet_session::pallet::Call */ + /** Lookup132: pallet_external_validator_slashes::pallet::Call */ + PalletExternalValidatorSlashesCall: { + _enum: { + cancel_deferred_slash: { + era: "u32", + slashIndices: "Vec", + }, + force_inject_slash: { + era: "u32", + validator: "AccountId32", + percentage: "Perbill", + }, + }, + }, + /** Lookup134: pallet_session::pallet::Call */ PalletSessionCall: { _enum: { set_keys: { @@ -1192,7 +1216,7 @@ export default { purge_keys: "Null", }, }, - /** Lookup132: dancelight_runtime::SessionKeys */ + /** Lookup135: dancelight_runtime::SessionKeys */ DancelightRuntimeSessionKeys: { grandpa: "SpConsensusGrandpaAppPublic", babe: "SpConsensusBabeAppPublic", @@ -1202,17 +1226,17 @@ export default { beefy: "SpConsensusBeefyEcdsaCryptoPublic", nimbus: "NimbusPrimitivesNimbusCryptoPublic", }, - /** Lookup133: polkadot_primitives::v7::validator_app::Public */ + /** Lookup136: polkadot_primitives::v7::validator_app::Public */ PolkadotPrimitivesV7ValidatorAppPublic: "[u8;32]", - /** Lookup134: polkadot_primitives::v7::assignment_app::Public */ + /** Lookup137: polkadot_primitives::v7::assignment_app::Public */ PolkadotPrimitivesV7AssignmentAppPublic: "[u8;32]", - /** Lookup135: sp_authority_discovery::app::Public */ + /** Lookup138: sp_authority_discovery::app::Public */ SpAuthorityDiscoveryAppPublic: "[u8;32]", - /** Lookup136: sp_consensus_beefy::ecdsa_crypto::Public */ + /** Lookup139: sp_consensus_beefy::ecdsa_crypto::Public */ SpConsensusBeefyEcdsaCryptoPublic: "[u8;33]", - /** Lookup138: nimbus_primitives::nimbus_crypto::Public */ + /** Lookup141: nimbus_primitives::nimbus_crypto::Public */ NimbusPrimitivesNimbusCryptoPublic: "[u8;32]", - /** Lookup139: pallet_grandpa::pallet::Call */ + /** Lookup142: pallet_grandpa::pallet::Call */ PalletGrandpaCall: { _enum: { report_equivocation: { @@ -1229,12 +1253,12 @@ export default { }, }, }, - /** Lookup140: sp_consensus_grandpa::EquivocationProof */ + /** Lookup143: sp_consensus_grandpa::EquivocationProof */ SpConsensusGrandpaEquivocationProof: { setId: "u64", equivocation: "SpConsensusGrandpaEquivocation", }, - /** Lookup141: sp_consensus_grandpa::Equivocation */ + /** Lookup144: sp_consensus_grandpa::Equivocation */ SpConsensusGrandpaEquivocation: { _enum: { Prevote: "FinalityGrandpaEquivocationPrevote", @@ -1242,7 +1266,7 @@ export default { }, }, /** - * Lookup142: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> */ FinalityGrandpaEquivocationPrevote: { @@ -1251,15 +1275,15 @@ export default { first: "(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)", second: "(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)", }, - /** Lookup143: finality_grandpa::Prevote */ + /** Lookup146: finality_grandpa::Prevote */ FinalityGrandpaPrevote: { targetHash: "H256", targetNumber: "u32", }, - /** Lookup144: sp_consensus_grandpa::app::Signature */ + /** Lookup147: sp_consensus_grandpa::app::Signature */ SpConsensusGrandpaAppSignature: "[u8;64]", /** - * Lookup146: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> */ FinalityGrandpaEquivocationPrecommit: { @@ -1268,12 +1292,12 @@ export default { first: "(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)", second: "(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)", }, - /** Lookup147: finality_grandpa::Precommit */ + /** Lookup150: finality_grandpa::Precommit */ FinalityGrandpaPrecommit: { targetHash: "H256", targetNumber: "u32", }, - /** Lookup149: pallet_treasury::pallet::Call */ + /** Lookup152: pallet_treasury::pallet::Call */ PalletTreasuryCall: { _enum: { __Unused0: "Null", @@ -1303,7 +1327,7 @@ export default { }, }, }, - /** Lookup151: pallet_conviction_voting::pallet::Call */ + /** Lookup154: pallet_conviction_voting::pallet::Call */ PalletConvictionVotingCall: { _enum: { vote: { @@ -1334,7 +1358,7 @@ export default { }, }, }, - /** Lookup152: pallet_conviction_voting::vote::AccountVote */ + /** Lookup155: pallet_conviction_voting::vote::AccountVote */ PalletConvictionVotingVoteAccountVote: { _enum: { Standard: { @@ -1352,11 +1376,11 @@ export default { }, }, }, - /** Lookup154: pallet_conviction_voting::conviction::Conviction */ + /** Lookup157: pallet_conviction_voting::conviction::Conviction */ PalletConvictionVotingConviction: { _enum: ["None", "Locked1x", "Locked2x", "Locked3x", "Locked4x", "Locked5x", "Locked6x"], }, - /** Lookup156: pallet_referenda::pallet::Call */ + /** Lookup159: pallet_referenda::pallet::Call */ PalletReferendaCall: { _enum: { submit: { @@ -1391,7 +1415,7 @@ export default { }, }, }, - /** Lookup157: dancelight_runtime::OriginCaller */ + /** Lookup160: dancelight_runtime::OriginCaller */ DancelightRuntimeOriginCaller: { _enum: { system: "FrameSupportDispatchRawOrigin", @@ -1487,7 +1511,7 @@ export default { XcmPallet: "PalletXcmOrigin", }, }, - /** Lookup158: frame_support::dispatch::RawOrigin */ + /** Lookup161: frame_support::dispatch::RawOrigin */ FrameSupportDispatchRawOrigin: { _enum: { Root: "Null", @@ -1495,7 +1519,7 @@ export default { None: "Null", }, }, - /** Lookup159: dancelight_runtime::governance::origins::pallet_custom_origins::Origin */ + /** Lookup162: dancelight_runtime::governance::origins::pallet_custom_origins::Origin */ DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin: { _enum: [ "StakingAdmin", @@ -1527,39 +1551,39 @@ export default { "Fellowship9Dan", ], }, - /** Lookup160: polkadot_runtime_parachains::origin::pallet::Origin */ + /** Lookup163: polkadot_runtime_parachains::origin::pallet::Origin */ PolkadotRuntimeParachainsOriginPalletOrigin: { _enum: { Parachain: "u32", }, }, - /** Lookup161: pallet_xcm::pallet::Origin */ + /** Lookup164: pallet_xcm::pallet::Origin */ PalletXcmOrigin: { _enum: { Xcm: "StagingXcmV4Location", Response: "StagingXcmV4Location", }, }, - /** Lookup162: staging_xcm::v4::location::Location */ + /** Lookup165: staging_xcm::v4::location::Location */ StagingXcmV4Location: { parents: "u8", interior: "StagingXcmV4Junctions", }, - /** Lookup163: staging_xcm::v4::junctions::Junctions */ + /** Lookup166: staging_xcm::v4::junctions::Junctions */ StagingXcmV4Junctions: { _enum: { Here: "Null", - X1: "[Lookup165;1]", - X2: "[Lookup165;2]", - X3: "[Lookup165;3]", - X4: "[Lookup165;4]", - X5: "[Lookup165;5]", - X6: "[Lookup165;6]", - X7: "[Lookup165;7]", - X8: "[Lookup165;8]", + X1: "[Lookup168;1]", + X2: "[Lookup168;2]", + X3: "[Lookup168;3]", + X4: "[Lookup168;4]", + X5: "[Lookup168;5]", + X6: "[Lookup168;6]", + X7: "[Lookup168;7]", + X8: "[Lookup168;8]", }, }, - /** Lookup165: staging_xcm::v4::junction::Junction */ + /** Lookup168: staging_xcm::v4::junction::Junction */ StagingXcmV4Junction: { _enum: { Parachain: "Compact", @@ -1589,7 +1613,7 @@ export default { GlobalConsensus: "StagingXcmV4JunctionNetworkId", }, }, - /** Lookup167: staging_xcm::v4::junction::NetworkId */ + /** Lookup170: staging_xcm::v4::junction::NetworkId */ StagingXcmV4JunctionNetworkId: { _enum: { ByGenesis: "[u8;32]", @@ -1610,7 +1634,7 @@ export default { PolkadotBulletin: "Null", }, }, - /** Lookup168: xcm::v3::junction::BodyId */ + /** Lookup171: xcm::v3::junction::BodyId */ XcmV3JunctionBodyId: { _enum: { Unit: "Null", @@ -1625,7 +1649,7 @@ export default { Treasury: "Null", }, }, - /** Lookup169: xcm::v3::junction::BodyPart */ + /** Lookup172: xcm::v3::junction::BodyPart */ XcmV3JunctionBodyPart: { _enum: { Voice: "Null", @@ -1646,16 +1670,16 @@ export default { }, }, }, - /** Lookup177: sp_core::Void */ + /** Lookup180: sp_core::Void */ SpCoreVoid: "Null", - /** Lookup178: frame_support::traits::schedule::DispatchTime */ + /** Lookup181: frame_support::traits::schedule::DispatchTime */ FrameSupportScheduleDispatchTime: { _enum: { At: "u32", After: "u32", }, }, - /** Lookup180: pallet_ranked_collective::pallet::Call */ + /** Lookup183: pallet_ranked_collective::pallet::Call */ PalletRankedCollectiveCall: { _enum: { add_member: { @@ -1685,7 +1709,7 @@ export default { }, }, }, - /** Lookup182: pallet_whitelist::pallet::Call */ + /** Lookup185: pallet_whitelist::pallet::Call */ PalletWhitelistCall: { _enum: { whitelist_call: { @@ -1704,7 +1728,7 @@ export default { }, }, }, - /** Lookup183: polkadot_runtime_parachains::configuration::pallet::Call */ + /** Lookup186: polkadot_runtime_parachains::configuration::pallet::Call */ PolkadotRuntimeParachainsConfigurationPalletCall: { _enum: { set_validation_upgrade_cooldown: { @@ -2003,14 +2027,14 @@ export default { }, }, }, - /** Lookup184: polkadot_primitives::v7::async_backing::AsyncBackingParams */ + /** Lookup187: polkadot_primitives::v7::async_backing::AsyncBackingParams */ PolkadotPrimitivesV7AsyncBackingAsyncBackingParams: { maxCandidateDepth: "u32", allowedAncestryLen: "u32", }, - /** Lookup185: polkadot_primitives::v7::executor_params::ExecutorParams */ + /** Lookup188: polkadot_primitives::v7::executor_params::ExecutorParams */ PolkadotPrimitivesV7ExecutorParams: "Vec", - /** Lookup187: polkadot_primitives::v7::executor_params::ExecutorParam */ + /** Lookup190: polkadot_primitives::v7::executor_params::ExecutorParam */ PolkadotPrimitivesV7ExecutorParamsExecutorParam: { _enum: { __Unused0: "Null", @@ -2023,19 +2047,19 @@ export default { WasmExtBulkMemory: "Null", }, }, - /** Lookup188: polkadot_primitives::v7::PvfPrepKind */ + /** Lookup191: polkadot_primitives::v7::PvfPrepKind */ PolkadotPrimitivesV7PvfPrepKind: { _enum: ["Precheck", "Prepare"], }, - /** Lookup189: polkadot_primitives::v7::PvfExecKind */ + /** Lookup192: polkadot_primitives::v7::PvfExecKind */ PolkadotPrimitivesV7PvfExecKind: { _enum: ["Backing", "Approval"], }, - /** Lookup190: polkadot_primitives::v7::ApprovalVotingParams */ + /** Lookup193: polkadot_primitives::v7::ApprovalVotingParams */ PolkadotPrimitivesV7ApprovalVotingParams: { maxApprovalCoalesceCount: "u32", }, - /** Lookup191: polkadot_primitives::vstaging::SchedulerParams */ + /** Lookup194: polkadot_primitives::vstaging::SchedulerParams */ PolkadotPrimitivesVstagingSchedulerParams: { groupRotationFrequency: "u32", parasAvailabilityPeriod: "u32", @@ -2049,11 +2073,11 @@ export default { onDemandBaseFee: "u128", ttl: "u32", }, - /** Lookup192: polkadot_runtime_parachains::shared::pallet::Call */ + /** Lookup195: polkadot_runtime_parachains::shared::pallet::Call */ PolkadotRuntimeParachainsSharedPalletCall: "Null", - /** Lookup193: polkadot_runtime_parachains::inclusion::pallet::Call */ + /** Lookup196: polkadot_runtime_parachains::inclusion::pallet::Call */ PolkadotRuntimeParachainsInclusionPalletCall: "Null", - /** Lookup194: polkadot_runtime_parachains::paras_inherent::pallet::Call */ + /** Lookup197: polkadot_runtime_parachains::paras_inherent::pallet::Call */ PolkadotRuntimeParachainsParasInherentPalletCall: { _enum: { enter: { @@ -2061,7 +2085,7 @@ export default { }, }, }, - /** Lookup195: polkadot_primitives::v7::InherentData> */ + /** Lookup198: polkadot_primitives::v7::InherentData> */ PolkadotPrimitivesV7InherentData: { bitfields: "Vec", backedCandidates: "Vec", @@ -2069,7 +2093,7 @@ export default { parentHeader: "SpRuntimeHeader", }, /** - * Lookup197: polkadot_primitives::v7::signed::UncheckedSigned */ PolkadotPrimitivesV7SignedUncheckedSigned: { @@ -2077,22 +2101,22 @@ export default { validatorIndex: "u32", signature: "PolkadotPrimitivesV7ValidatorAppSignature", }, - /** Lookup200: bitvec::order::Lsb0 */ + /** Lookup203: bitvec::order::Lsb0 */ BitvecOrderLsb0: "Null", - /** Lookup202: polkadot_primitives::v7::validator_app::Signature */ + /** Lookup205: polkadot_primitives::v7::validator_app::Signature */ PolkadotPrimitivesV7ValidatorAppSignature: "[u8;64]", - /** Lookup204: polkadot_primitives::v7::BackedCandidate */ + /** Lookup207: polkadot_primitives::v7::BackedCandidate */ PolkadotPrimitivesV7BackedCandidate: { candidate: "PolkadotPrimitivesV7CommittedCandidateReceipt", validityVotes: "Vec", validatorIndices: "BitVec", }, - /** Lookup205: polkadot_primitives::v7::CommittedCandidateReceipt */ + /** Lookup208: polkadot_primitives::v7::CommittedCandidateReceipt */ PolkadotPrimitivesV7CommittedCandidateReceipt: { descriptor: "PolkadotPrimitivesV7CandidateDescriptor", commitments: "PolkadotPrimitivesV7CandidateCommitments", }, - /** Lookup206: polkadot_primitives::v7::CandidateDescriptor */ + /** Lookup209: polkadot_primitives::v7::CandidateDescriptor */ PolkadotPrimitivesV7CandidateDescriptor: { paraId: "u32", relayParent: "H256", @@ -2104,11 +2128,11 @@ export default { paraHead: "H256", validationCodeHash: "H256", }, - /** Lookup207: polkadot_primitives::v7::collator_app::Public */ + /** Lookup210: polkadot_primitives::v7::collator_app::Public */ PolkadotPrimitivesV7CollatorAppPublic: "[u8;32]", - /** Lookup208: polkadot_primitives::v7::collator_app::Signature */ + /** Lookup211: polkadot_primitives::v7::collator_app::Signature */ PolkadotPrimitivesV7CollatorAppSignature: "[u8;64]", - /** Lookup210: polkadot_primitives::v7::CandidateCommitments */ + /** Lookup213: polkadot_primitives::v7::CandidateCommitments */ PolkadotPrimitivesV7CandidateCommitments: { upwardMessages: "Vec", horizontalMessages: "Vec", @@ -2117,12 +2141,12 @@ export default { processedDownwardMessages: "u32", hrmpWatermark: "u32", }, - /** Lookup213: polkadot_core_primitives::OutboundHrmpMessage */ + /** Lookup216: polkadot_core_primitives::OutboundHrmpMessage */ PolkadotCorePrimitivesOutboundHrmpMessage: { recipient: "u32", data: "Bytes", }, - /** Lookup218: polkadot_primitives::v7::ValidityAttestation */ + /** Lookup221: polkadot_primitives::v7::ValidityAttestation */ PolkadotPrimitivesV7ValidityAttestation: { _enum: { __Unused0: "Null", @@ -2130,20 +2154,20 @@ export default { Explicit: "PolkadotPrimitivesV7ValidatorAppSignature", }, }, - /** Lookup220: polkadot_primitives::v7::DisputeStatementSet */ + /** Lookup223: polkadot_primitives::v7::DisputeStatementSet */ PolkadotPrimitivesV7DisputeStatementSet: { candidateHash: "H256", session: "u32", statements: "Vec<(PolkadotPrimitivesV7DisputeStatement,u32,PolkadotPrimitivesV7ValidatorAppSignature)>", }, - /** Lookup224: polkadot_primitives::v7::DisputeStatement */ + /** Lookup227: polkadot_primitives::v7::DisputeStatement */ PolkadotPrimitivesV7DisputeStatement: { _enum: { Valid: "PolkadotPrimitivesV7ValidDisputeStatementKind", Invalid: "PolkadotPrimitivesV7InvalidDisputeStatementKind", }, }, - /** Lookup225: polkadot_primitives::v7::ValidDisputeStatementKind */ + /** Lookup228: polkadot_primitives::v7::ValidDisputeStatementKind */ PolkadotPrimitivesV7ValidDisputeStatementKind: { _enum: { Explicit: "Null", @@ -2153,11 +2177,11 @@ export default { ApprovalCheckingMultipleCandidates: "Vec", }, }, - /** Lookup227: polkadot_primitives::v7::InvalidDisputeStatementKind */ + /** Lookup230: polkadot_primitives::v7::InvalidDisputeStatementKind */ PolkadotPrimitivesV7InvalidDisputeStatementKind: { _enum: ["Explicit"], }, - /** Lookup228: polkadot_runtime_parachains::paras::pallet::Call */ + /** Lookup231: polkadot_runtime_parachains::paras::pallet::Call */ PolkadotRuntimeParachainsParasPalletCall: { _enum: { force_set_current_code: { @@ -2196,14 +2220,14 @@ export default { }, }, }, - /** Lookup229: polkadot_primitives::v7::PvfCheckStatement */ + /** Lookup232: polkadot_primitives::v7::PvfCheckStatement */ PolkadotPrimitivesV7PvfCheckStatement: { accept: "bool", subject: "H256", sessionIndex: "u32", validatorIndex: "u32", }, - /** Lookup230: polkadot_runtime_parachains::initializer::pallet::Call */ + /** Lookup233: polkadot_runtime_parachains::initializer::pallet::Call */ PolkadotRuntimeParachainsInitializerPalletCall: { _enum: { force_approve: { @@ -2211,7 +2235,7 @@ export default { }, }, }, - /** Lookup231: polkadot_runtime_parachains::hrmp::pallet::Call */ + /** Lookup234: polkadot_runtime_parachains::hrmp::pallet::Call */ PolkadotRuntimeParachainsHrmpPalletCall: { _enum: { hrmp_init_open_channel: { @@ -2259,16 +2283,16 @@ export default { }, }, }, - /** Lookup232: polkadot_parachain_primitives::primitives::HrmpChannelId */ + /** Lookup235: polkadot_parachain_primitives::primitives::HrmpChannelId */ PolkadotParachainPrimitivesPrimitivesHrmpChannelId: { sender: "u32", recipient: "u32", }, - /** Lookup233: polkadot_runtime_parachains::disputes::pallet::Call */ + /** Lookup236: polkadot_runtime_parachains::disputes::pallet::Call */ PolkadotRuntimeParachainsDisputesPalletCall: { _enum: ["force_unfreeze"], }, - /** Lookup234: polkadot_runtime_parachains::disputes::slashing::pallet::Call */ + /** Lookup237: polkadot_runtime_parachains::disputes::slashing::pallet::Call */ PolkadotRuntimeParachainsDisputesSlashingPalletCall: { _enum: { report_dispute_lost_unsigned: { @@ -2277,23 +2301,23 @@ export default { }, }, }, - /** Lookup235: polkadot_primitives::v7::slashing::DisputeProof */ + /** Lookup238: polkadot_primitives::v7::slashing::DisputeProof */ PolkadotPrimitivesV7SlashingDisputeProof: { timeSlot: "PolkadotPrimitivesV7SlashingDisputesTimeSlot", kind: "PolkadotPrimitivesV7SlashingSlashingOffenceKind", validatorIndex: "u32", validatorId: "PolkadotPrimitivesV7ValidatorAppPublic", }, - /** Lookup236: polkadot_primitives::v7::slashing::DisputesTimeSlot */ + /** Lookup239: polkadot_primitives::v7::slashing::DisputesTimeSlot */ PolkadotPrimitivesV7SlashingDisputesTimeSlot: { sessionIndex: "u32", candidateHash: "H256", }, - /** Lookup237: polkadot_primitives::v7::slashing::SlashingOffenceKind */ + /** Lookup240: polkadot_primitives::v7::slashing::SlashingOffenceKind */ PolkadotPrimitivesV7SlashingSlashingOffenceKind: { _enum: ["ForInvalid", "AgainstValid"], }, - /** Lookup238: pallet_message_queue::pallet::Call */ + /** Lookup241: pallet_message_queue::pallet::Call */ PalletMessageQueueCall: { _enum: { reap_page: { @@ -2308,19 +2332,19 @@ export default { }, }, }, - /** Lookup239: polkadot_runtime_parachains::inclusion::AggregateMessageOrigin */ + /** Lookup242: polkadot_runtime_parachains::inclusion::AggregateMessageOrigin */ PolkadotRuntimeParachainsInclusionAggregateMessageOrigin: { _enum: { Ump: "PolkadotRuntimeParachainsInclusionUmpQueueId", }, }, - /** Lookup240: polkadot_runtime_parachains::inclusion::UmpQueueId */ + /** Lookup243: polkadot_runtime_parachains::inclusion::UmpQueueId */ PolkadotRuntimeParachainsInclusionUmpQueueId: { _enum: { Para: "u32", }, }, - /** Lookup241: polkadot_runtime_parachains::assigner_on_demand::pallet::Call */ + /** Lookup244: polkadot_runtime_parachains::assigner_on_demand::pallet::Call */ PolkadotRuntimeParachainsAssignerOnDemandPalletCall: { _enum: { place_order_allow_death: { @@ -2333,7 +2357,7 @@ export default { }, }, }, - /** Lookup242: polkadot_runtime_common::paras_registrar::pallet::Call */ + /** Lookup245: polkadot_runtime_common::paras_registrar::pallet::Call */ PolkadotRuntimeCommonParasRegistrarPalletCall: { _enum: { register: { @@ -2372,7 +2396,7 @@ export default { }, }, }, - /** Lookup243: pallet_utility::pallet::Call */ + /** Lookup246: pallet_utility::pallet::Call */ PalletUtilityCall: { _enum: { batch: { @@ -2398,7 +2422,7 @@ export default { }, }, }, - /** Lookup245: pallet_identity::pallet::Call */ + /** Lookup248: pallet_identity::pallet::Call */ PalletIdentityCall: { _enum: { add_registrar: { @@ -2481,7 +2505,7 @@ export default { }, }, }, - /** Lookup246: pallet_identity::legacy::IdentityInfo */ + /** Lookup249: pallet_identity::legacy::IdentityInfo */ PalletIdentityLegacyIdentityInfo: { additional: "Vec<(Data,Data)>", display: "Data", @@ -2493,7 +2517,7 @@ export default { image: "Data", twitter: "Data", }, - /** Lookup283: pallet_identity::types::Judgement */ + /** Lookup286: pallet_identity::types::Judgement */ PalletIdentityJudgement: { _enum: { Unknown: "Null", @@ -2505,7 +2529,7 @@ export default { Erroneous: "Null", }, }, - /** Lookup286: pallet_scheduler::pallet::Call */ + /** Lookup289: pallet_scheduler::pallet::Call */ PalletSchedulerCall: { _enum: { schedule: { @@ -2559,7 +2583,7 @@ export default { }, }, }, - /** Lookup289: pallet_proxy::pallet::Call */ + /** Lookup292: pallet_proxy::pallet::Call */ PalletProxyCall: { _enum: { proxy: { @@ -2610,7 +2634,7 @@ export default { }, }, }, - /** Lookup291: dancelight_runtime::ProxyType */ + /** Lookup294: dancelight_runtime::ProxyType */ DancelightRuntimeProxyType: { _enum: [ "Any", @@ -2623,7 +2647,7 @@ export default { "SudoRegistrar", ], }, - /** Lookup292: pallet_multisig::pallet::Call */ + /** Lookup295: pallet_multisig::pallet::Call */ PalletMultisigCall: { _enum: { as_multi_threshold_1: { @@ -2652,12 +2676,12 @@ export default { }, }, }, - /** Lookup294: pallet_multisig::Timepoint */ + /** Lookup297: pallet_multisig::Timepoint */ PalletMultisigTimepoint: { height: "u32", index: "u32", }, - /** Lookup295: pallet_preimage::pallet::Call */ + /** Lookup298: pallet_preimage::pallet::Call */ PalletPreimageCall: { _enum: { note_preimage: { @@ -2686,7 +2710,7 @@ export default { }, }, }, - /** Lookup297: pallet_asset_rate::pallet::Call */ + /** Lookup300: pallet_asset_rate::pallet::Call */ PalletAssetRateCall: { _enum: { create: { @@ -2702,7 +2726,7 @@ export default { }, }, }, - /** Lookup299: pallet_xcm::pallet::Call */ + /** Lookup302: pallet_xcm::pallet::Call */ PalletXcmCall: { _enum: { send: { @@ -2777,7 +2801,7 @@ export default { }, }, }, - /** Lookup300: xcm::VersionedLocation */ + /** Lookup303: xcm::VersionedLocation */ XcmVersionedLocation: { _enum: { __Unused0: "Null", @@ -2787,12 +2811,12 @@ export default { V4: "StagingXcmV4Location", }, }, - /** Lookup301: xcm::v2::multilocation::MultiLocation */ + /** Lookup304: xcm::v2::multilocation::MultiLocation */ XcmV2MultiLocation: { parents: "u8", interior: "XcmV2MultilocationJunctions", }, - /** Lookup302: xcm::v2::multilocation::Junctions */ + /** Lookup305: xcm::v2::multilocation::Junctions */ XcmV2MultilocationJunctions: { _enum: { Here: "Null", @@ -2806,7 +2830,7 @@ export default { X8: "(XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction)", }, }, - /** Lookup303: xcm::v2::junction::Junction */ + /** Lookup306: xcm::v2::junction::Junction */ XcmV2Junction: { _enum: { Parachain: "Compact", @@ -2832,7 +2856,7 @@ export default { }, }, }, - /** Lookup304: xcm::v2::NetworkId */ + /** Lookup307: xcm::v2::NetworkId */ XcmV2NetworkId: { _enum: { Any: "Null", @@ -2841,7 +2865,7 @@ export default { Kusama: "Null", }, }, - /** Lookup306: xcm::v2::BodyId */ + /** Lookup309: xcm::v2::BodyId */ XcmV2BodyId: { _enum: { Unit: "Null", @@ -2856,7 +2880,7 @@ export default { Treasury: "Null", }, }, - /** Lookup307: xcm::v2::BodyPart */ + /** Lookup310: xcm::v2::BodyPart */ XcmV2BodyPart: { _enum: { Voice: "Null", @@ -2877,12 +2901,12 @@ export default { }, }, }, - /** Lookup308: staging_xcm::v3::multilocation::MultiLocation */ + /** Lookup311: staging_xcm::v3::multilocation::MultiLocation */ StagingXcmV3MultiLocation: { parents: "u8", interior: "XcmV3Junctions", }, - /** Lookup309: xcm::v3::junctions::Junctions */ + /** Lookup312: xcm::v3::junctions::Junctions */ XcmV3Junctions: { _enum: { Here: "Null", @@ -2896,7 +2920,7 @@ export default { X8: "(XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction)", }, }, - /** Lookup310: xcm::v3::junction::Junction */ + /** Lookup313: xcm::v3::junction::Junction */ XcmV3Junction: { _enum: { Parachain: "Compact", @@ -2926,7 +2950,7 @@ export default { GlobalConsensus: "XcmV3JunctionNetworkId", }, }, - /** Lookup312: xcm::v3::junction::NetworkId */ + /** Lookup315: xcm::v3::junction::NetworkId */ XcmV3JunctionNetworkId: { _enum: { ByGenesis: "[u8;32]", @@ -2947,7 +2971,7 @@ export default { PolkadotBulletin: "Null", }, }, - /** Lookup313: xcm::VersionedXcm */ + /** Lookup316: xcm::VersionedXcm */ XcmVersionedXcm: { _enum: { __Unused0: "Null", @@ -2957,9 +2981,9 @@ export default { V4: "StagingXcmV4Xcm", }, }, - /** Lookup314: xcm::v2::Xcm */ + /** Lookup317: xcm::v2::Xcm */ XcmV2Xcm: "Vec", - /** Lookup316: xcm::v2::Instruction */ + /** Lookup319: xcm::v2::Instruction */ XcmV2Instruction: { _enum: { WithdrawAsset: "XcmV2MultiassetMultiAssets", @@ -3055,28 +3079,28 @@ export default { UnsubscribeVersion: "Null", }, }, - /** Lookup317: xcm::v2::multiasset::MultiAssets */ + /** Lookup320: xcm::v2::multiasset::MultiAssets */ XcmV2MultiassetMultiAssets: "Vec", - /** Lookup319: xcm::v2::multiasset::MultiAsset */ + /** Lookup322: xcm::v2::multiasset::MultiAsset */ XcmV2MultiAsset: { id: "XcmV2MultiassetAssetId", fun: "XcmV2MultiassetFungibility", }, - /** Lookup320: xcm::v2::multiasset::AssetId */ + /** Lookup323: xcm::v2::multiasset::AssetId */ XcmV2MultiassetAssetId: { _enum: { Concrete: "XcmV2MultiLocation", Abstract: "Bytes", }, }, - /** Lookup321: xcm::v2::multiasset::Fungibility */ + /** Lookup324: xcm::v2::multiasset::Fungibility */ XcmV2MultiassetFungibility: { _enum: { Fungible: "Compact", NonFungible: "XcmV2MultiassetAssetInstance", }, }, - /** Lookup322: xcm::v2::multiasset::AssetInstance */ + /** Lookup325: xcm::v2::multiasset::AssetInstance */ XcmV2MultiassetAssetInstance: { _enum: { Undefined: "Null", @@ -3088,7 +3112,7 @@ export default { Blob: "Bytes", }, }, - /** Lookup323: xcm::v2::Response */ + /** Lookup326: xcm::v2::Response */ XcmV2Response: { _enum: { Null: "Null", @@ -3097,7 +3121,7 @@ export default { Version: "u32", }, }, - /** Lookup326: xcm::v2::traits::Error */ + /** Lookup329: xcm::v2::traits::Error */ XcmV2TraitsError: { _enum: { Overflow: "Null", @@ -3128,22 +3152,22 @@ export default { WeightNotComputable: "Null", }, }, - /** Lookup327: xcm::v2::OriginKind */ + /** Lookup330: xcm::v2::OriginKind */ XcmV2OriginKind: { _enum: ["Native", "SovereignAccount", "Superuser", "Xcm"], }, - /** Lookup328: xcm::double_encoded::DoubleEncoded */ + /** Lookup331: xcm::double_encoded::DoubleEncoded */ XcmDoubleEncoded: { encoded: "Bytes", }, - /** Lookup329: xcm::v2::multiasset::MultiAssetFilter */ + /** Lookup332: xcm::v2::multiasset::MultiAssetFilter */ XcmV2MultiassetMultiAssetFilter: { _enum: { Definite: "XcmV2MultiassetMultiAssets", Wild: "XcmV2MultiassetWildMultiAsset", }, }, - /** Lookup330: xcm::v2::multiasset::WildMultiAsset */ + /** Lookup333: xcm::v2::multiasset::WildMultiAsset */ XcmV2MultiassetWildMultiAsset: { _enum: { All: "Null", @@ -3153,20 +3177,20 @@ export default { }, }, }, - /** Lookup331: xcm::v2::multiasset::WildFungibility */ + /** Lookup334: xcm::v2::multiasset::WildFungibility */ XcmV2MultiassetWildFungibility: { _enum: ["Fungible", "NonFungible"], }, - /** Lookup332: xcm::v2::WeightLimit */ + /** Lookup335: xcm::v2::WeightLimit */ XcmV2WeightLimit: { _enum: { Unlimited: "Null", Limited: "Compact", }, }, - /** Lookup333: xcm::v3::Xcm */ + /** Lookup336: xcm::v3::Xcm */ XcmV3Xcm: "Vec", - /** Lookup335: xcm::v3::Instruction */ + /** Lookup338: xcm::v3::Instruction */ XcmV3Instruction: { _enum: { WithdrawAsset: "XcmV3MultiassetMultiAssets", @@ -3306,28 +3330,28 @@ export default { }, }, }, - /** Lookup336: xcm::v3::multiasset::MultiAssets */ + /** Lookup339: xcm::v3::multiasset::MultiAssets */ XcmV3MultiassetMultiAssets: "Vec", - /** Lookup338: xcm::v3::multiasset::MultiAsset */ + /** Lookup341: xcm::v3::multiasset::MultiAsset */ XcmV3MultiAsset: { id: "XcmV3MultiassetAssetId", fun: "XcmV3MultiassetFungibility", }, - /** Lookup339: xcm::v3::multiasset::AssetId */ + /** Lookup342: xcm::v3::multiasset::AssetId */ XcmV3MultiassetAssetId: { _enum: { Concrete: "StagingXcmV3MultiLocation", Abstract: "[u8;32]", }, }, - /** Lookup340: xcm::v3::multiasset::Fungibility */ + /** Lookup343: xcm::v3::multiasset::Fungibility */ XcmV3MultiassetFungibility: { _enum: { Fungible: "Compact", NonFungible: "XcmV3MultiassetAssetInstance", }, }, - /** Lookup341: xcm::v3::multiasset::AssetInstance */ + /** Lookup344: xcm::v3::multiasset::AssetInstance */ XcmV3MultiassetAssetInstance: { _enum: { Undefined: "Null", @@ -3338,7 +3362,7 @@ export default { Array32: "[u8;32]", }, }, - /** Lookup342: xcm::v3::Response */ + /** Lookup345: xcm::v3::Response */ XcmV3Response: { _enum: { Null: "Null", @@ -3349,7 +3373,7 @@ export default { DispatchResult: "XcmV3MaybeErrorCode", }, }, - /** Lookup345: xcm::v3::traits::Error */ + /** Lookup348: xcm::v3::traits::Error */ XcmV3TraitsError: { _enum: { Overflow: "Null", @@ -3394,7 +3418,7 @@ export default { ExceedsStackLimit: "Null", }, }, - /** Lookup347: xcm::v3::PalletInfo */ + /** Lookup350: xcm::v3::PalletInfo */ XcmV3PalletInfo: { index: "Compact", name: "Bytes", @@ -3403,7 +3427,7 @@ export default { minor: "Compact", patch: "Compact", }, - /** Lookup350: xcm::v3::MaybeErrorCode */ + /** Lookup353: xcm::v3::MaybeErrorCode */ XcmV3MaybeErrorCode: { _enum: { Success: "Null", @@ -3411,24 +3435,24 @@ export default { TruncatedError: "Bytes", }, }, - /** Lookup353: xcm::v3::OriginKind */ + /** Lookup356: xcm::v3::OriginKind */ XcmV3OriginKind: { _enum: ["Native", "SovereignAccount", "Superuser", "Xcm"], }, - /** Lookup354: xcm::v3::QueryResponseInfo */ + /** Lookup357: xcm::v3::QueryResponseInfo */ XcmV3QueryResponseInfo: { destination: "StagingXcmV3MultiLocation", queryId: "Compact", maxWeight: "SpWeightsWeightV2Weight", }, - /** Lookup355: xcm::v3::multiasset::MultiAssetFilter */ + /** Lookup358: xcm::v3::multiasset::MultiAssetFilter */ XcmV3MultiassetMultiAssetFilter: { _enum: { Definite: "XcmV3MultiassetMultiAssets", Wild: "XcmV3MultiassetWildMultiAsset", }, }, - /** Lookup356: xcm::v3::multiasset::WildMultiAsset */ + /** Lookup359: xcm::v3::multiasset::WildMultiAsset */ XcmV3MultiassetWildMultiAsset: { _enum: { All: "Null", @@ -3444,20 +3468,20 @@ export default { }, }, }, - /** Lookup357: xcm::v3::multiasset::WildFungibility */ + /** Lookup360: xcm::v3::multiasset::WildFungibility */ XcmV3MultiassetWildFungibility: { _enum: ["Fungible", "NonFungible"], }, - /** Lookup358: xcm::v3::WeightLimit */ + /** Lookup361: xcm::v3::WeightLimit */ XcmV3WeightLimit: { _enum: { Unlimited: "Null", Limited: "SpWeightsWeightV2Weight", }, }, - /** Lookup359: staging_xcm::v4::Xcm */ + /** Lookup362: staging_xcm::v4::Xcm */ StagingXcmV4Xcm: "Vec", - /** Lookup361: staging_xcm::v4::Instruction */ + /** Lookup364: staging_xcm::v4::Instruction */ StagingXcmV4Instruction: { _enum: { WithdrawAsset: "StagingXcmV4AssetAssets", @@ -3597,23 +3621,23 @@ export default { }, }, }, - /** Lookup362: staging_xcm::v4::asset::Assets */ + /** Lookup365: staging_xcm::v4::asset::Assets */ StagingXcmV4AssetAssets: "Vec", - /** Lookup364: staging_xcm::v4::asset::Asset */ + /** Lookup367: staging_xcm::v4::asset::Asset */ StagingXcmV4Asset: { id: "StagingXcmV4AssetAssetId", fun: "StagingXcmV4AssetFungibility", }, - /** Lookup365: staging_xcm::v4::asset::AssetId */ + /** Lookup368: staging_xcm::v4::asset::AssetId */ StagingXcmV4AssetAssetId: "StagingXcmV4Location", - /** Lookup366: staging_xcm::v4::asset::Fungibility */ + /** Lookup369: staging_xcm::v4::asset::Fungibility */ StagingXcmV4AssetFungibility: { _enum: { Fungible: "Compact", NonFungible: "StagingXcmV4AssetAssetInstance", }, }, - /** Lookup367: staging_xcm::v4::asset::AssetInstance */ + /** Lookup370: staging_xcm::v4::asset::AssetInstance */ StagingXcmV4AssetAssetInstance: { _enum: { Undefined: "Null", @@ -3624,7 +3648,7 @@ export default { Array32: "[u8;32]", }, }, - /** Lookup368: staging_xcm::v4::Response */ + /** Lookup371: staging_xcm::v4::Response */ StagingXcmV4Response: { _enum: { Null: "Null", @@ -3635,7 +3659,7 @@ export default { DispatchResult: "XcmV3MaybeErrorCode", }, }, - /** Lookup370: staging_xcm::v4::PalletInfo */ + /** Lookup373: staging_xcm::v4::PalletInfo */ StagingXcmV4PalletInfo: { index: "Compact", name: "Bytes", @@ -3644,20 +3668,20 @@ export default { minor: "Compact", patch: "Compact", }, - /** Lookup374: staging_xcm::v4::QueryResponseInfo */ + /** Lookup377: staging_xcm::v4::QueryResponseInfo */ StagingXcmV4QueryResponseInfo: { destination: "StagingXcmV4Location", queryId: "Compact", maxWeight: "SpWeightsWeightV2Weight", }, - /** Lookup375: staging_xcm::v4::asset::AssetFilter */ + /** Lookup378: staging_xcm::v4::asset::AssetFilter */ StagingXcmV4AssetAssetFilter: { _enum: { Definite: "StagingXcmV4AssetAssets", Wild: "StagingXcmV4AssetWildAsset", }, }, - /** Lookup376: staging_xcm::v4::asset::WildAsset */ + /** Lookup379: staging_xcm::v4::asset::WildAsset */ StagingXcmV4AssetWildAsset: { _enum: { All: "Null", @@ -3673,11 +3697,11 @@ export default { }, }, }, - /** Lookup377: staging_xcm::v4::asset::WildFungibility */ + /** Lookup380: staging_xcm::v4::asset::WildFungibility */ StagingXcmV4AssetWildFungibility: { _enum: ["Fungible", "NonFungible"], }, - /** Lookup378: xcm::VersionedAssets */ + /** Lookup381: xcm::VersionedAssets */ XcmVersionedAssets: { _enum: { __Unused0: "Null", @@ -3687,7 +3711,7 @@ export default { V4: "StagingXcmV4AssetAssets", }, }, - /** Lookup390: staging_xcm_executor::traits::asset_transfer::TransferType */ + /** Lookup393: staging_xcm_executor::traits::asset_transfer::TransferType */ StagingXcmExecutorAssetTransferTransferType: { _enum: { Teleport: "Null", @@ -3696,7 +3720,7 @@ export default { RemoteReserve: "XcmVersionedLocation", }, }, - /** Lookup391: xcm::VersionedAssetId */ + /** Lookup394: xcm::VersionedAssetId */ XcmVersionedAssetId: { _enum: { __Unused0: "Null", @@ -3706,7 +3730,7 @@ export default { V4: "StagingXcmV4AssetAssetId", }, }, - /** Lookup392: pallet_migrations::pallet::Call */ + /** Lookup395: pallet_migrations::pallet::Call */ PalletMigrationsCall: { _enum: { force_set_cursor: { @@ -3723,20 +3747,20 @@ export default { }, }, }, - /** Lookup394: pallet_migrations::MigrationCursor, BlockNumber> */ + /** Lookup397: pallet_migrations::MigrationCursor, BlockNumber> */ PalletMigrationsMigrationCursor: { _enum: { Active: "PalletMigrationsActiveCursor", Stuck: "Null", }, }, - /** Lookup396: pallet_migrations::ActiveCursor, BlockNumber> */ + /** Lookup399: pallet_migrations::ActiveCursor, BlockNumber> */ PalletMigrationsActiveCursor: { index: "u32", innerCursor: "Option", startedAt: "u32", }, - /** Lookup398: pallet_migrations::HistoricCleanupSelector> */ + /** Lookup401: pallet_migrations::HistoricCleanupSelector> */ PalletMigrationsHistoricCleanupSelector: { _enum: { Specific: "Vec", @@ -3746,7 +3770,7 @@ export default { }, }, }, - /** Lookup401: pallet_beefy::pallet::Call */ + /** Lookup404: pallet_beefy::pallet::Call */ PalletBeefyCall: { _enum: { report_double_voting: { @@ -3779,17 +3803,17 @@ export default { }, }, /** - * Lookup402: sp_consensus_beefy::DoubleVotingProof */ SpConsensusBeefyDoubleVotingProof: { first: "SpConsensusBeefyVoteMessage", second: "SpConsensusBeefyVoteMessage", }, - /** Lookup403: sp_consensus_beefy::ecdsa_crypto::Signature */ + /** Lookup406: sp_consensus_beefy::ecdsa_crypto::Signature */ SpConsensusBeefyEcdsaCryptoSignature: "[u8;65]", /** - * Lookup404: sp_consensus_beefy::VoteMessage */ SpConsensusBeefyVoteMessage: { @@ -3797,16 +3821,16 @@ export default { id: "SpConsensusBeefyEcdsaCryptoPublic", signature: "SpConsensusBeefyEcdsaCryptoSignature", }, - /** Lookup405: sp_consensus_beefy::commitment::Commitment */ + /** Lookup408: sp_consensus_beefy::commitment::Commitment */ SpConsensusBeefyCommitment: { payload: "SpConsensusBeefyPayload", blockNumber: "u32", validatorSetId: "u64", }, - /** Lookup406: sp_consensus_beefy::payload::Payload */ + /** Lookup409: sp_consensus_beefy::payload::Payload */ SpConsensusBeefyPayload: "Vec<([u8;2],Bytes)>", /** - * Lookup409: sp_consensus_beefy::ForkVotingProof, + * Lookup412: sp_consensus_beefy::ForkVotingProof, * sp_consensus_beefy::ecdsa_crypto::Public, sp_mmr_primitives::AncestryProof> */ SpConsensusBeefyForkVotingProof: { @@ -3814,18 +3838,18 @@ export default { ancestryProof: "SpMmrPrimitivesAncestryProof", header: "SpRuntimeHeader", }, - /** Lookup410: sp_mmr_primitives::AncestryProof */ + /** Lookup413: sp_mmr_primitives::AncestryProof */ SpMmrPrimitivesAncestryProof: { prevPeaks: "Vec", prevLeafCount: "u64", leafCount: "u64", items: "Vec<(u64,H256)>", }, - /** Lookup413: sp_consensus_beefy::FutureBlockVotingProof */ + /** Lookup416: sp_consensus_beefy::FutureBlockVotingProof */ SpConsensusBeefyFutureBlockVotingProof: { vote: "SpConsensusBeefyVoteMessage", }, - /** Lookup414: snowbridge_pallet_ethereum_client::pallet::Call */ + /** Lookup417: snowbridge_pallet_ethereum_client::pallet::Call */ SnowbridgePalletEthereumClientCall: { _enum: { force_checkpoint: { @@ -3840,7 +3864,7 @@ export default { }, }, }, - /** Lookup415: snowbridge_beacon_primitives::updates::CheckpointUpdate */ + /** Lookup418: snowbridge_beacon_primitives::updates::CheckpointUpdate */ SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate: { header: "SnowbridgeBeaconPrimitivesBeaconHeader", currentSyncCommittee: "SnowbridgeBeaconPrimitivesSyncCommittee", @@ -3849,7 +3873,7 @@ export default { blockRootsRoot: "H256", blockRootsBranch: "Vec", }, - /** Lookup416: snowbridge_beacon_primitives::types::BeaconHeader */ + /** Lookup419: snowbridge_beacon_primitives::types::BeaconHeader */ SnowbridgeBeaconPrimitivesBeaconHeader: { slot: "u64", proposerIndex: "u64", @@ -3857,14 +3881,14 @@ export default { stateRoot: "H256", bodyRoot: "H256", }, - /** Lookup417: snowbridge_beacon_primitives::types::SyncCommittee */ + /** Lookup420: snowbridge_beacon_primitives::types::SyncCommittee */ SnowbridgeBeaconPrimitivesSyncCommittee: { pubkeys: "[[u8;48];512]", aggregatePubkey: "SnowbridgeBeaconPrimitivesPublicKey", }, - /** Lookup419: snowbridge_beacon_primitives::types::PublicKey */ + /** Lookup422: snowbridge_beacon_primitives::types::PublicKey */ SnowbridgeBeaconPrimitivesPublicKey: "[u8;48]", - /** Lookup421: snowbridge_beacon_primitives::updates::Update */ + /** Lookup424: snowbridge_beacon_primitives::updates::Update */ SnowbridgeBeaconPrimitivesUpdatesUpdate: { attestedHeader: "SnowbridgeBeaconPrimitivesBeaconHeader", syncAggregate: "SnowbridgeBeaconPrimitivesSyncAggregate", @@ -3875,23 +3899,23 @@ export default { blockRootsRoot: "H256", blockRootsBranch: "Vec", }, - /** Lookup422: snowbridge_beacon_primitives::types::SyncAggregate */ + /** Lookup425: snowbridge_beacon_primitives::types::SyncAggregate */ SnowbridgeBeaconPrimitivesSyncAggregate: { syncCommitteeBits: "[u8;64]", syncCommitteeSignature: "SnowbridgeBeaconPrimitivesSignature", }, - /** Lookup423: snowbridge_beacon_primitives::types::Signature */ + /** Lookup426: snowbridge_beacon_primitives::types::Signature */ SnowbridgeBeaconPrimitivesSignature: "[u8;96]", - /** Lookup426: snowbridge_beacon_primitives::updates::NextSyncCommitteeUpdate */ + /** Lookup429: snowbridge_beacon_primitives::updates::NextSyncCommitteeUpdate */ SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate: { nextSyncCommittee: "SnowbridgeBeaconPrimitivesSyncCommittee", nextSyncCommitteeBranch: "Vec", }, - /** Lookup427: snowbridge_core::operating_mode::BasicOperatingMode */ + /** Lookup430: snowbridge_core::operating_mode::BasicOperatingMode */ SnowbridgeCoreOperatingModeBasicOperatingMode: { _enum: ["Normal", "Halted"], }, - /** Lookup428: polkadot_runtime_common::paras_sudo_wrapper::pallet::Call */ + /** Lookup431: polkadot_runtime_common::paras_sudo_wrapper::pallet::Call */ PolkadotRuntimeCommonParasSudoWrapperPalletCall: { _enum: { sudo_schedule_para_initialize: { @@ -3919,13 +3943,13 @@ export default { }, }, }, - /** Lookup429: polkadot_runtime_parachains::paras::ParaGenesisArgs */ + /** Lookup432: polkadot_runtime_parachains::paras::ParaGenesisArgs */ PolkadotRuntimeParachainsParasParaGenesisArgs: { genesisHead: "Bytes", validationCode: "Bytes", paraKind: "bool", }, - /** Lookup430: pallet_root_testing::pallet::Call */ + /** Lookup433: pallet_root_testing::pallet::Call */ PalletRootTestingCall: { _enum: { fill_block: { @@ -3934,7 +3958,7 @@ export default { trigger_defensive: "Null", }, }, - /** Lookup431: pallet_sudo::pallet::Call */ + /** Lookup434: pallet_sudo::pallet::Call */ PalletSudoCall: { _enum: { sudo: { @@ -3957,15 +3981,15 @@ export default { remove_key: "Null", }, }, - /** Lookup432: sp_runtime::traits::BlakeTwo256 */ + /** Lookup435: sp_runtime::traits::BlakeTwo256 */ SpRuntimeBlakeTwo256: "Null", - /** Lookup434: pallet_conviction_voting::types::Tally */ + /** Lookup437: pallet_conviction_voting::types::Tally */ PalletConvictionVotingTally: { ayes: "u128", nays: "u128", support: "u128", }, - /** Lookup435: pallet_ranked_collective::pallet::Event */ + /** Lookup438: pallet_ranked_collective::pallet::Event */ PalletRankedCollectiveEvent: { _enum: { MemberAdded: { @@ -3991,20 +4015,20 @@ export default { }, }, }, - /** Lookup436: pallet_ranked_collective::VoteRecord */ + /** Lookup439: pallet_ranked_collective::VoteRecord */ PalletRankedCollectiveVoteRecord: { _enum: { Aye: "u32", Nay: "u32", }, }, - /** Lookup437: pallet_ranked_collective::Tally */ + /** Lookup440: pallet_ranked_collective::Tally */ PalletRankedCollectiveTally: { bareAyes: "u32", ayes: "u32", nays: "u32", }, - /** Lookup439: pallet_whitelist::pallet::Event */ + /** Lookup442: pallet_whitelist::pallet::Event */ PalletWhitelistEvent: { _enum: { CallWhitelisted: { @@ -4019,17 +4043,17 @@ export default { }, }, }, - /** Lookup441: frame_support::dispatch::PostDispatchInfo */ + /** Lookup444: frame_support::dispatch::PostDispatchInfo */ FrameSupportDispatchPostDispatchInfo: { actualWeight: "Option", paysFee: "FrameSupportDispatchPays", }, - /** Lookup443: sp_runtime::DispatchErrorWithPostInfo */ + /** Lookup446: sp_runtime::DispatchErrorWithPostInfo */ SpRuntimeDispatchErrorWithPostInfo: { postInfo: "FrameSupportDispatchPostDispatchInfo", error: "SpRuntimeDispatchError", }, - /** Lookup444: polkadot_runtime_parachains::inclusion::pallet::Event */ + /** Lookup447: polkadot_runtime_parachains::inclusion::pallet::Event */ PolkadotRuntimeParachainsInclusionPalletEvent: { _enum: { CandidateBacked: "(PolkadotPrimitivesV7CandidateReceipt,Bytes,u32,u32)", @@ -4041,12 +4065,12 @@ export default { }, }, }, - /** Lookup445: polkadot_primitives::v7::CandidateReceipt */ + /** Lookup448: polkadot_primitives::v7::CandidateReceipt */ PolkadotPrimitivesV7CandidateReceipt: { descriptor: "PolkadotPrimitivesV7CandidateDescriptor", commitmentsHash: "H256", }, - /** Lookup448: polkadot_runtime_parachains::paras::pallet::Event */ + /** Lookup451: polkadot_runtime_parachains::paras::pallet::Event */ PolkadotRuntimeParachainsParasPalletEvent: { _enum: { CurrentCodeUpdated: "u32", @@ -4059,7 +4083,7 @@ export default { PvfCheckRejected: "(H256,u32)", }, }, - /** Lookup449: polkadot_runtime_parachains::hrmp::pallet::Event */ + /** Lookup452: polkadot_runtime_parachains::hrmp::pallet::Event */ PolkadotRuntimeParachainsHrmpPalletEvent: { _enum: { OpenChannelRequested: { @@ -4098,7 +4122,7 @@ export default { }, }, }, - /** Lookup450: polkadot_runtime_parachains::disputes::pallet::Event */ + /** Lookup453: polkadot_runtime_parachains::disputes::pallet::Event */ PolkadotRuntimeParachainsDisputesPalletEvent: { _enum: { DisputeInitiated: "(H256,PolkadotRuntimeParachainsDisputesDisputeLocation)", @@ -4106,15 +4130,15 @@ export default { Revert: "u32", }, }, - /** Lookup451: polkadot_runtime_parachains::disputes::DisputeLocation */ + /** Lookup454: polkadot_runtime_parachains::disputes::DisputeLocation */ PolkadotRuntimeParachainsDisputesDisputeLocation: { _enum: ["Local", "Remote"], }, - /** Lookup452: polkadot_runtime_parachains::disputes::DisputeResult */ + /** Lookup455: polkadot_runtime_parachains::disputes::DisputeResult */ PolkadotRuntimeParachainsDisputesDisputeResult: { _enum: ["Valid", "Invalid"], }, - /** Lookup453: pallet_message_queue::pallet::Event */ + /** Lookup456: pallet_message_queue::pallet::Event */ PalletMessageQueueEvent: { _enum: { ProcessingFailed: { @@ -4140,7 +4164,7 @@ export default { }, }, }, - /** Lookup454: frame_support::traits::messages::ProcessMessageError */ + /** Lookup457: frame_support::traits::messages::ProcessMessageError */ FrameSupportMessagesProcessMessageError: { _enum: { BadFormat: "Null", @@ -4151,7 +4175,7 @@ export default { StackLimitReached: "Null", }, }, - /** Lookup455: polkadot_runtime_parachains::assigner_on_demand::pallet::Event */ + /** Lookup458: polkadot_runtime_parachains::assigner_on_demand::pallet::Event */ PolkadotRuntimeParachainsAssignerOnDemandPalletEvent: { _enum: { OnDemandOrderPlaced: { @@ -4164,7 +4188,7 @@ export default { }, }, }, - /** Lookup456: polkadot_runtime_common::paras_registrar::pallet::Event */ + /** Lookup459: polkadot_runtime_common::paras_registrar::pallet::Event */ PolkadotRuntimeCommonParasRegistrarPalletEvent: { _enum: { Registered: { @@ -4184,7 +4208,7 @@ export default { }, }, }, - /** Lookup457: pallet_utility::pallet::Event */ + /** Lookup460: pallet_utility::pallet::Event */ PalletUtilityEvent: { _enum: { BatchInterrupted: { @@ -4202,7 +4226,7 @@ export default { }, }, }, - /** Lookup459: pallet_identity::pallet::Event */ + /** Lookup462: pallet_identity::pallet::Event */ PalletIdentityEvent: { _enum: { IdentitySet: { @@ -4274,7 +4298,7 @@ export default { }, }, }, - /** Lookup460: pallet_scheduler::pallet::Event */ + /** Lookup463: pallet_scheduler::pallet::Event */ PalletSchedulerEvent: { _enum: { Scheduled: { @@ -4318,7 +4342,7 @@ export default { }, }, }, - /** Lookup462: pallet_proxy::pallet::Event */ + /** Lookup465: pallet_proxy::pallet::Event */ PalletProxyEvent: { _enum: { ProxyExecuted: { @@ -4349,7 +4373,7 @@ export default { }, }, }, - /** Lookup463: pallet_multisig::pallet::Event */ + /** Lookup466: pallet_multisig::pallet::Event */ PalletMultisigEvent: { _enum: { NewMultisig: { @@ -4378,7 +4402,7 @@ export default { }, }, }, - /** Lookup464: pallet_preimage::pallet::Event */ + /** Lookup467: pallet_preimage::pallet::Event */ PalletPreimageEvent: { _enum: { Noted: { @@ -4401,7 +4425,7 @@ export default { }, }, }, - /** Lookup465: pallet_asset_rate::pallet::Event */ + /** Lookup468: pallet_asset_rate::pallet::Event */ PalletAssetRateEvent: { _enum: { AssetRateCreated: { @@ -4421,7 +4445,7 @@ export default { }, }, }, - /** Lookup466: pallet_xcm::pallet::Event */ + /** Lookup469: pallet_xcm::pallet::Event */ PalletXcmEvent: { _enum: { Attempted: { @@ -4544,7 +4568,7 @@ export default { }, }, }, - /** Lookup467: staging_xcm::v4::traits::Outcome */ + /** Lookup470: staging_xcm::v4::traits::Outcome */ StagingXcmV4TraitsOutcome: { _enum: { Complete: { @@ -4559,7 +4583,7 @@ export default { }, }, }, - /** Lookup468: pallet_migrations::pallet::Event */ + /** Lookup471: pallet_migrations::pallet::Event */ PalletMigrationsEvent: { _enum: { RuntimeUpgradeStarted: "Null", @@ -4581,7 +4605,7 @@ export default { }, }, }, - /** Lookup470: snowbridge_pallet_ethereum_client::pallet::Event */ + /** Lookup473: snowbridge_pallet_ethereum_client::pallet::Event */ SnowbridgePalletEthereumClientEvent: { _enum: { BeaconHeaderImported: { @@ -4596,11 +4620,11 @@ export default { }, }, }, - /** Lookup471: pallet_root_testing::pallet::Event */ + /** Lookup474: pallet_root_testing::pallet::Event */ PalletRootTestingEvent: { _enum: ["DefensiveTestCall"], }, - /** Lookup472: pallet_sudo::pallet::Event */ + /** Lookup475: pallet_sudo::pallet::Event */ PalletSudoEvent: { _enum: { Sudid: { @@ -4619,7 +4643,7 @@ export default { }, }, }, - /** Lookup473: frame_system::Phase */ + /** Lookup476: frame_system::Phase */ FrameSystemPhase: { _enum: { ApplyExtrinsic: "u32", @@ -4627,51 +4651,51 @@ export default { Initialization: "Null", }, }, - /** Lookup475: frame_system::LastRuntimeUpgradeInfo */ + /** Lookup478: frame_system::LastRuntimeUpgradeInfo */ FrameSystemLastRuntimeUpgradeInfo: { specVersion: "Compact", specName: "Text", }, - /** Lookup477: frame_system::CodeUpgradeAuthorization */ + /** Lookup480: frame_system::CodeUpgradeAuthorization */ FrameSystemCodeUpgradeAuthorization: { codeHash: "H256", checkVersion: "bool", }, - /** Lookup478: frame_system::limits::BlockWeights */ + /** Lookup481: frame_system::limits::BlockWeights */ FrameSystemLimitsBlockWeights: { baseBlock: "SpWeightsWeightV2Weight", maxBlock: "SpWeightsWeightV2Weight", perClass: "FrameSupportDispatchPerDispatchClassWeightsPerClass", }, - /** Lookup479: frame_support::dispatch::PerDispatchClass */ + /** Lookup482: frame_support::dispatch::PerDispatchClass */ FrameSupportDispatchPerDispatchClassWeightsPerClass: { normal: "FrameSystemLimitsWeightsPerClass", operational: "FrameSystemLimitsWeightsPerClass", mandatory: "FrameSystemLimitsWeightsPerClass", }, - /** Lookup480: frame_system::limits::WeightsPerClass */ + /** Lookup483: frame_system::limits::WeightsPerClass */ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: "SpWeightsWeightV2Weight", maxExtrinsic: "Option", maxTotal: "Option", reserved: "Option", }, - /** Lookup481: frame_system::limits::BlockLength */ + /** Lookup484: frame_system::limits::BlockLength */ FrameSystemLimitsBlockLength: { max: "FrameSupportDispatchPerDispatchClassU32", }, - /** Lookup482: frame_support::dispatch::PerDispatchClass */ + /** Lookup485: frame_support::dispatch::PerDispatchClass */ FrameSupportDispatchPerDispatchClassU32: { normal: "u32", operational: "u32", mandatory: "u32", }, - /** Lookup483: sp_weights::RuntimeDbWeight */ + /** Lookup486: sp_weights::RuntimeDbWeight */ SpWeightsRuntimeDbWeight: { read: "u64", write: "u64", }, - /** Lookup484: sp_version::RuntimeVersion */ + /** Lookup487: sp_version::RuntimeVersion */ SpVersionRuntimeVersion: { specName: "Text", implName: "Text", @@ -4682,7 +4706,7 @@ export default { transactionVersion: "u32", stateVersion: "u8", }, - /** Lookup488: frame_system::pallet::Error */ + /** Lookup491: frame_system::pallet::Error */ FrameSystemError: { _enum: [ "InvalidSpecName", @@ -4696,7 +4720,7 @@ export default { "Unauthorized", ], }, - /** Lookup495: sp_consensus_babe::digests::PreDigest */ + /** Lookup498: sp_consensus_babe::digests::PreDigest */ SpConsensusBabeDigestsPreDigest: { _enum: { __Unused0: "Null", @@ -4705,34 +4729,34 @@ export default { SecondaryVRF: "SpConsensusBabeDigestsSecondaryVRFPreDigest", }, }, - /** Lookup496: sp_consensus_babe::digests::PrimaryPreDigest */ + /** Lookup499: sp_consensus_babe::digests::PrimaryPreDigest */ SpConsensusBabeDigestsPrimaryPreDigest: { authorityIndex: "u32", slot: "u64", vrfSignature: "SpCoreSr25519VrfVrfSignature", }, - /** Lookup497: sp_core::sr25519::vrf::VrfSignature */ + /** Lookup500: sp_core::sr25519::vrf::VrfSignature */ SpCoreSr25519VrfVrfSignature: { preOutput: "[u8;32]", proof: "[u8;64]", }, - /** Lookup498: sp_consensus_babe::digests::SecondaryPlainPreDigest */ + /** Lookup501: sp_consensus_babe::digests::SecondaryPlainPreDigest */ SpConsensusBabeDigestsSecondaryPlainPreDigest: { authorityIndex: "u32", slot: "u64", }, - /** Lookup499: sp_consensus_babe::digests::SecondaryVRFPreDigest */ + /** Lookup502: sp_consensus_babe::digests::SecondaryVRFPreDigest */ SpConsensusBabeDigestsSecondaryVRFPreDigest: { authorityIndex: "u32", slot: "u64", vrfSignature: "SpCoreSr25519VrfVrfSignature", }, - /** Lookup500: sp_consensus_babe::BabeEpochConfiguration */ + /** Lookup503: sp_consensus_babe::BabeEpochConfiguration */ SpConsensusBabeBabeEpochConfiguration: { c: "(u64,u64)", allowedSlots: "SpConsensusBabeAllowedSlots", }, - /** Lookup504: pallet_babe::pallet::Error */ + /** Lookup507: pallet_babe::pallet::Error */ PalletBabeError: { _enum: [ "InvalidEquivocationProof", @@ -4741,22 +4765,22 @@ export default { "InvalidConfiguration", ], }, - /** Lookup506: pallet_balances::types::BalanceLock */ + /** Lookup509: pallet_balances::types::BalanceLock */ PalletBalancesBalanceLock: { id: "[u8;8]", amount: "u128", reasons: "PalletBalancesReasons", }, - /** Lookup507: pallet_balances::types::Reasons */ + /** Lookup510: pallet_balances::types::Reasons */ PalletBalancesReasons: { _enum: ["Fee", "Misc", "All"], }, - /** Lookup510: pallet_balances::types::ReserveData */ + /** Lookup513: pallet_balances::types::ReserveData */ PalletBalancesReserveData: { id: "[u8;8]", amount: "u128", }, - /** Lookup514: dancelight_runtime::RuntimeHoldReason */ + /** Lookup517: dancelight_runtime::RuntimeHoldReason */ DancelightRuntimeRuntimeHoldReason: { _enum: { __Unused0: "Null", @@ -4847,24 +4871,24 @@ export default { Preimage: "PalletPreimageHoldReason", }, }, - /** Lookup515: pallet_registrar::pallet::HoldReason */ + /** Lookup518: pallet_registrar::pallet::HoldReason */ PalletRegistrarHoldReason: { _enum: ["RegistrarDeposit"], }, - /** Lookup516: pallet_data_preservers::pallet::HoldReason */ + /** Lookup519: pallet_data_preservers::pallet::HoldReason */ PalletDataPreserversHoldReason: { _enum: ["ProfileDeposit"], }, - /** Lookup517: pallet_preimage::pallet::HoldReason */ + /** Lookup520: pallet_preimage::pallet::HoldReason */ PalletPreimageHoldReason: { _enum: ["Preimage"], }, - /** Lookup520: frame_support::traits::tokens::misc::IdAmount */ + /** Lookup523: frame_support::traits::tokens::misc::IdAmount */ FrameSupportTokensMiscIdAmount: { id: "Null", amount: "u128", }, - /** Lookup522: pallet_balances::pallet::Error */ + /** Lookup525: pallet_balances::pallet::Error */ PalletBalancesError: { _enum: [ "VestingBalance", @@ -4881,21 +4905,21 @@ export default { "DeltaZero", ], }, - /** Lookup523: pallet_transaction_payment::Releases */ + /** Lookup526: pallet_transaction_payment::Releases */ PalletTransactionPaymentReleases: { _enum: ["V1Ancient", "V2"], }, - /** Lookup524: sp_staking::offence::OffenceDetails */ + /** Lookup527: sp_staking::offence::OffenceDetails */ SpStakingOffenceOffenceDetails: { offender: "(AccountId32,Null)", reporters: "Vec", }, - /** Lookup536: pallet_registrar::pallet::DepositInfo */ + /** Lookup539: pallet_registrar::pallet::DepositInfo */ PalletRegistrarDepositInfo: { creator: "AccountId32", deposit: "u128", }, - /** Lookup537: pallet_registrar::pallet::Error */ + /** Lookup540: pallet_registrar::pallet::Error */ PalletRegistrarError: { _enum: [ "ParaIdAlreadyRegistered", @@ -4917,7 +4941,7 @@ export default { "WasmCodeNecessary", ], }, - /** Lookup538: pallet_configuration::HostConfiguration */ + /** Lookup541: pallet_configuration::HostConfiguration */ PalletConfigurationHostConfiguration: { maxCollators: "u32", minOrchestratorCollators: "u32", @@ -4929,11 +4953,11 @@ export default { targetContainerChainFullness: "Perbill", maxParachainCoresPercentage: "Option", }, - /** Lookup541: pallet_configuration::pallet::Error */ + /** Lookup544: pallet_configuration::pallet::Error */ PalletConfigurationError: { _enum: ["InvalidNewValue"], }, - /** Lookup543: pallet_invulnerables::pallet::Error */ + /** Lookup546: pallet_invulnerables::pallet::Error */ PalletInvulnerablesError: { _enum: [ "TooManyInvulnerables", @@ -4943,23 +4967,23 @@ export default { "UnableToDeriveCollatorId", ], }, - /** Lookup544: dp_collator_assignment::AssignedCollators */ + /** Lookup547: dp_collator_assignment::AssignedCollators */ DpCollatorAssignmentAssignedCollatorsAccountId32: { orchestratorChain: "Vec", containerChains: "BTreeMap>", }, - /** Lookup549: dp_collator_assignment::AssignedCollators */ + /** Lookup552: dp_collator_assignment::AssignedCollators */ DpCollatorAssignmentAssignedCollatorsPublic: { orchestratorChain: "Vec", containerChains: "BTreeMap>", }, - /** Lookup557: tp_traits::ContainerChainBlockInfo */ + /** Lookup560: tp_traits::ContainerChainBlockInfo */ TpTraitsContainerChainBlockInfo: { blockNumber: "u32", author: "AccountId32", latestSlotNumber: "u64", }, - /** Lookup558: pallet_author_noting::pallet::Error */ + /** Lookup561: pallet_author_noting::pallet::Error */ PalletAuthorNotingError: { _enum: [ "FailedReading", @@ -4971,18 +4995,18 @@ export default { "NonAuraDigest", ], }, - /** Lookup559: pallet_services_payment::pallet::Error */ + /** Lookup562: pallet_services_payment::pallet::Error */ PalletServicesPaymentError: { _enum: ["InsufficientFundsToPurchaseCredits", "InsufficientCredits", "CreditPriceTooExpensive"], }, - /** Lookup560: pallet_data_preservers::types::RegisteredProfile */ + /** Lookup563: pallet_data_preservers::types::RegisteredProfile */ PalletDataPreserversRegisteredProfile: { account: "AccountId32", deposit: "u128", profile: "PalletDataPreserversProfile", assignment: "Option<(u32,DancelightRuntimePreserversAssignmentPaymentWitness)>", }, - /** Lookup566: pallet_data_preservers::pallet::Error */ + /** Lookup569: pallet_data_preservers::pallet::Error */ PalletDataPreserversError: { _enum: [ "NoBootNodes", @@ -4997,12 +5021,12 @@ export default { "CantDeleteAssignedProfile", ], }, - /** Lookup569: tp_traits::ActiveEraInfo */ + /** Lookup572: tp_traits::ActiveEraInfo */ TpTraitsActiveEraInfo: { index: "u32", start: "Option", }, - /** Lookup571: pallet_external_validators::pallet::Error */ + /** Lookup574: pallet_external_validators::pallet::Error */ PalletExternalValidatorsError: { _enum: [ "TooManyWhitelisted", @@ -5012,13 +5036,33 @@ export default { "UnableToDeriveValidatorId", ], }, - /** Lookup576: sp_core::crypto::KeyTypeId */ + /** Lookup577: pallet_external_validator_slashes::Slash */ + PalletExternalValidatorSlashesSlash: { + validator: "AccountId32", + reporters: "Vec", + slashId: "u32", + percentage: "Perbill", + confirmed: "bool", + }, + /** Lookup578: pallet_external_validator_slashes::pallet::Error */ + PalletExternalValidatorSlashesError: { + _enum: [ + "EmptyTargets", + "InvalidSlashIndex", + "NotSortedAndUnique", + "ProvidedFutureEra", + "ProvidedNonSlashableEra", + "DeferPeriodIsOver", + "ErrorComputingSlash", + ], + }, + /** Lookup582: sp_core::crypto::KeyTypeId */ SpCoreCryptoKeyTypeId: "[u8;4]", - /** Lookup577: pallet_session::pallet::Error */ + /** Lookup583: pallet_session::pallet::Error */ PalletSessionError: { _enum: ["InvalidProof", "NoAssociatedValidatorId", "DuplicatedKey", "NoKeys", "NoAccount"], }, - /** Lookup578: pallet_grandpa::StoredState */ + /** Lookup584: pallet_grandpa::StoredState */ PalletGrandpaStoredState: { _enum: { Live: "Null", @@ -5033,14 +5077,14 @@ export default { }, }, }, - /** Lookup579: pallet_grandpa::StoredPendingChange */ + /** Lookup585: pallet_grandpa::StoredPendingChange */ PalletGrandpaStoredPendingChange: { scheduledAt: "u32", delay: "u32", nextAuthorities: "Vec<(SpConsensusGrandpaAppPublic,u64)>", forced: "Option", }, - /** Lookup581: pallet_grandpa::pallet::Error */ + /** Lookup587: pallet_grandpa::pallet::Error */ PalletGrandpaError: { _enum: [ "PauseFailed", @@ -5052,12 +5096,12 @@ export default { "DuplicateOffenceReport", ], }, - /** Lookup584: pallet_inflation_rewards::pallet::ChainsToRewardValue */ + /** Lookup590: pallet_inflation_rewards::pallet::ChainsToRewardValue */ PalletInflationRewardsChainsToRewardValue: { paraIds: "Vec", rewardsPerChain: "u128", }, - /** Lookup585: pallet_treasury::Proposal */ + /** Lookup591: pallet_treasury::Proposal */ PalletTreasuryProposal: { proposer: "AccountId32", value: "u128", @@ -5065,7 +5109,7 @@ export default { bond: "u128", }, /** - * Lookup587: pallet_treasury::SpendStatus */ PalletTreasurySpendStatus: { @@ -5076,7 +5120,7 @@ export default { expireAt: "u32", status: "PalletTreasuryPaymentState", }, - /** Lookup588: pallet_treasury::PaymentState */ + /** Lookup594: pallet_treasury::PaymentState */ PalletTreasuryPaymentState: { _enum: { Pending: "Null", @@ -5086,9 +5130,9 @@ export default { Failed: "Null", }, }, - /** Lookup590: frame_support::PalletId */ + /** Lookup596: frame_support::PalletId */ FrameSupportPalletId: "[u8;8]", - /** Lookup591: pallet_treasury::pallet::Error */ + /** Lookup597: pallet_treasury::pallet::Error */ PalletTreasuryError: { _enum: [ "InvalidIndex", @@ -5105,7 +5149,7 @@ export default { ], }, /** - * Lookup593: pallet_conviction_voting::vote::Voting */ PalletConvictionVotingVoteVoting: { @@ -5114,20 +5158,20 @@ export default { Delegating: "PalletConvictionVotingVoteDelegating", }, }, - /** Lookup594: pallet_conviction_voting::vote::Casting */ + /** Lookup600: pallet_conviction_voting::vote::Casting */ PalletConvictionVotingVoteCasting: { votes: "Vec<(u32,PalletConvictionVotingVoteAccountVote)>", delegations: "PalletConvictionVotingDelegations", prior: "PalletConvictionVotingVotePriorLock", }, - /** Lookup598: pallet_conviction_voting::types::Delegations */ + /** Lookup604: pallet_conviction_voting::types::Delegations */ PalletConvictionVotingDelegations: { votes: "u128", capital: "u128", }, - /** Lookup599: pallet_conviction_voting::vote::PriorLock */ + /** Lookup605: pallet_conviction_voting::vote::PriorLock */ PalletConvictionVotingVotePriorLock: "(u32,u128)", - /** Lookup600: pallet_conviction_voting::vote::Delegating */ + /** Lookup606: pallet_conviction_voting::vote::Delegating */ PalletConvictionVotingVoteDelegating: { balance: "u128", target: "AccountId32", @@ -5135,7 +5179,7 @@ export default { delegations: "PalletConvictionVotingDelegations", prior: "PalletConvictionVotingVotePriorLock", }, - /** Lookup604: pallet_conviction_voting::pallet::Error */ + /** Lookup610: pallet_conviction_voting::pallet::Error */ PalletConvictionVotingError: { _enum: [ "NotOngoing", @@ -5153,7 +5197,7 @@ export default { ], }, /** - * Lookup605: pallet_referenda::types::ReferendumInfo, * Balance, pallet_conviction_voting::types::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5168,7 +5212,7 @@ export default { }, }, /** - * Lookup606: pallet_referenda::types::ReferendumStatus, * Balance, pallet_conviction_voting::types::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5185,17 +5229,17 @@ export default { inQueue: "bool", alarm: "Option<(u32,(u32,u32))>", }, - /** Lookup607: pallet_referenda::types::Deposit */ + /** Lookup613: pallet_referenda::types::Deposit */ PalletReferendaDeposit: { who: "AccountId32", amount: "u128", }, - /** Lookup610: pallet_referenda::types::DecidingStatus */ + /** Lookup616: pallet_referenda::types::DecidingStatus */ PalletReferendaDecidingStatus: { since: "u32", confirming: "Option", }, - /** Lookup618: pallet_referenda::types::TrackInfo */ + /** Lookup624: pallet_referenda::types::TrackInfo */ PalletReferendaTrackInfo: { name: "Text", maxDeciding: "u32", @@ -5207,7 +5251,7 @@ export default { minApproval: "PalletReferendaCurve", minSupport: "PalletReferendaCurve", }, - /** Lookup619: pallet_referenda::types::Curve */ + /** Lookup625: pallet_referenda::types::Curve */ PalletReferendaCurve: { _enum: { LinearDecreasing: { @@ -5228,7 +5272,7 @@ export default { }, }, }, - /** Lookup622: pallet_referenda::pallet::Error */ + /** Lookup628: pallet_referenda::pallet::Error */ PalletReferendaError: { _enum: [ "NotOngoing", @@ -5247,11 +5291,11 @@ export default { "PreimageStoredWithDifferentLength", ], }, - /** Lookup623: pallet_ranked_collective::MemberRecord */ + /** Lookup629: pallet_ranked_collective::MemberRecord */ PalletRankedCollectiveMemberRecord: { rank: "u16", }, - /** Lookup628: pallet_ranked_collective::pallet::Error */ + /** Lookup633: pallet_ranked_collective::pallet::Error */ PalletRankedCollectiveError: { _enum: [ "AlreadyMember", @@ -5268,7 +5312,7 @@ export default { ], }, /** - * Lookup629: pallet_referenda::types::ReferendumInfo, * Balance, pallet_ranked_collective::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5283,7 +5327,7 @@ export default { }, }, /** - * Lookup630: pallet_referenda::types::ReferendumStatus, * Balance, pallet_ranked_collective::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5300,7 +5344,7 @@ export default { inQueue: "bool", alarm: "Option<(u32,(u32,u32))>", }, - /** Lookup633: pallet_whitelist::pallet::Error */ + /** Lookup638: pallet_whitelist::pallet::Error */ PalletWhitelistError: { _enum: [ "UnavailablePreImage", @@ -5310,7 +5354,7 @@ export default { "CallAlreadyWhitelisted", ], }, - /** Lookup634: polkadot_runtime_parachains::configuration::HostConfiguration */ + /** Lookup639: polkadot_runtime_parachains::configuration::HostConfiguration */ PolkadotRuntimeParachainsConfigurationHostConfiguration: { maxCodeSize: "u32", maxHeadDataSize: "u32", @@ -5348,16 +5392,16 @@ export default { approvalVotingParams: "PolkadotPrimitivesV7ApprovalVotingParams", schedulerParams: "PolkadotPrimitivesVstagingSchedulerParams", }, - /** Lookup637: polkadot_runtime_parachains::configuration::pallet::Error */ + /** Lookup642: polkadot_runtime_parachains::configuration::pallet::Error */ PolkadotRuntimeParachainsConfigurationPalletError: { _enum: ["InvalidNewValue"], }, - /** Lookup640: polkadot_runtime_parachains::shared::AllowedRelayParentsTracker */ + /** Lookup645: polkadot_runtime_parachains::shared::AllowedRelayParentsTracker */ PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker: { buffer: "Vec<(H256,H256)>", latestNumber: "u32", }, - /** Lookup644: polkadot_runtime_parachains::inclusion::CandidatePendingAvailability */ + /** Lookup649: polkadot_runtime_parachains::inclusion::CandidatePendingAvailability */ PolkadotRuntimeParachainsInclusionCandidatePendingAvailability: { _alias: { hash_: "hash", @@ -5372,7 +5416,7 @@ export default { backedInNumber: "u32", backingGroup: "u32", }, - /** Lookup645: polkadot_runtime_parachains::inclusion::pallet::Error */ + /** Lookup650: polkadot_runtime_parachains::inclusion::pallet::Error */ PolkadotRuntimeParachainsInclusionPalletError: { _enum: [ "ValidatorIndexOutOfBounds", @@ -5395,14 +5439,14 @@ export default { "ParaHeadMismatch", ], }, - /** Lookup646: polkadot_primitives::v7::ScrapedOnChainVotes */ + /** Lookup651: polkadot_primitives::v7::ScrapedOnChainVotes */ PolkadotPrimitivesV7ScrapedOnChainVotes: { session: "u32", backingValidatorsPerCandidate: "Vec<(PolkadotPrimitivesV7CandidateReceipt,Vec<(u32,PolkadotPrimitivesV7ValidityAttestation)>)>", disputes: "Vec", }, - /** Lookup651: polkadot_runtime_parachains::paras_inherent::pallet::Error */ + /** Lookup656: polkadot_runtime_parachains::paras_inherent::pallet::Error */ PolkadotRuntimeParachainsParasInherentPalletError: { _enum: [ "TooManyInclusionInherents", @@ -5412,20 +5456,20 @@ export default { "UnscheduledCandidate", ], }, - /** Lookup654: polkadot_runtime_parachains::scheduler::pallet::CoreOccupied */ + /** Lookup659: polkadot_runtime_parachains::scheduler::pallet::CoreOccupied */ PolkadotRuntimeParachainsSchedulerPalletCoreOccupied: { _enum: { Free: "Null", Paras: "PolkadotRuntimeParachainsSchedulerPalletParasEntry", }, }, - /** Lookup655: polkadot_runtime_parachains::scheduler::pallet::ParasEntry */ + /** Lookup660: polkadot_runtime_parachains::scheduler::pallet::ParasEntry */ PolkadotRuntimeParachainsSchedulerPalletParasEntry: { assignment: "PolkadotRuntimeParachainsSchedulerCommonAssignment", availabilityTimeouts: "u32", ttl: "u32", }, - /** Lookup656: polkadot_runtime_parachains::scheduler::common::Assignment */ + /** Lookup661: polkadot_runtime_parachains::scheduler::common::Assignment */ PolkadotRuntimeParachainsSchedulerCommonAssignment: { _enum: { Pool: { @@ -5435,7 +5479,7 @@ export default { Bulk: "u32", }, }, - /** Lookup661: polkadot_runtime_parachains::paras::PvfCheckActiveVoteState */ + /** Lookup666: polkadot_runtime_parachains::paras::PvfCheckActiveVoteState */ PolkadotRuntimeParachainsParasPvfCheckActiveVoteState: { votesAccept: "BitVec", votesReject: "BitVec", @@ -5443,7 +5487,7 @@ export default { createdAt: "u32", causes: "Vec", }, - /** Lookup663: polkadot_runtime_parachains::paras::PvfCheckCause */ + /** Lookup668: polkadot_runtime_parachains::paras::PvfCheckCause */ PolkadotRuntimeParachainsParasPvfCheckCause: { _enum: { Onboarding: "u32", @@ -5454,11 +5498,11 @@ export default { }, }, }, - /** Lookup664: polkadot_runtime_parachains::paras::UpgradeStrategy */ + /** Lookup669: polkadot_runtime_parachains::paras::UpgradeStrategy */ PolkadotRuntimeParachainsParasUpgradeStrategy: { _enum: ["SetGoAheadSignal", "ApplyAtExpectedBlock"], }, - /** Lookup666: polkadot_runtime_parachains::paras::ParaLifecycle */ + /** Lookup671: polkadot_runtime_parachains::paras::ParaLifecycle */ PolkadotRuntimeParachainsParasParaLifecycle: { _enum: [ "Onboarding", @@ -5470,25 +5514,25 @@ export default { "OffboardingParachain", ], }, - /** Lookup668: polkadot_runtime_parachains::paras::ParaPastCodeMeta */ + /** Lookup673: polkadot_runtime_parachains::paras::ParaPastCodeMeta */ PolkadotRuntimeParachainsParasParaPastCodeMeta: { upgradeTimes: "Vec", lastPruned: "Option", }, - /** Lookup670: polkadot_runtime_parachains::paras::ReplacementTimes */ + /** Lookup675: polkadot_runtime_parachains::paras::ReplacementTimes */ PolkadotRuntimeParachainsParasReplacementTimes: { expectedAt: "u32", activatedAt: "u32", }, - /** Lookup672: polkadot_primitives::v7::UpgradeGoAhead */ + /** Lookup677: polkadot_primitives::v7::UpgradeGoAhead */ PolkadotPrimitivesV7UpgradeGoAhead: { _enum: ["Abort", "GoAhead"], }, - /** Lookup673: polkadot_primitives::v7::UpgradeRestriction */ + /** Lookup678: polkadot_primitives::v7::UpgradeRestriction */ PolkadotPrimitivesV7UpgradeRestriction: { _enum: ["Present"], }, - /** Lookup674: polkadot_runtime_parachains::paras::pallet::Error */ + /** Lookup679: polkadot_runtime_parachains::paras::pallet::Error */ PolkadotRuntimeParachainsParasPalletError: { _enum: [ "NotRegistered", @@ -5506,18 +5550,18 @@ export default { "InvalidCode", ], }, - /** Lookup676: polkadot_runtime_parachains::initializer::BufferedSessionChange */ + /** Lookup681: polkadot_runtime_parachains::initializer::BufferedSessionChange */ PolkadotRuntimeParachainsInitializerBufferedSessionChange: { validators: "Vec", queued: "Vec", sessionIndex: "u32", }, - /** Lookup678: polkadot_core_primitives::InboundDownwardMessage */ + /** Lookup683: polkadot_core_primitives::InboundDownwardMessage */ PolkadotCorePrimitivesInboundDownwardMessage: { sentAt: "u32", msg: "Bytes", }, - /** Lookup679: polkadot_runtime_parachains::hrmp::HrmpOpenChannelRequest */ + /** Lookup684: polkadot_runtime_parachains::hrmp::HrmpOpenChannelRequest */ PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest: { confirmed: "bool", age: "u32", @@ -5526,7 +5570,7 @@ export default { maxCapacity: "u32", maxTotalSize: "u32", }, - /** Lookup681: polkadot_runtime_parachains::hrmp::HrmpChannel */ + /** Lookup686: polkadot_runtime_parachains::hrmp::HrmpChannel */ PolkadotRuntimeParachainsHrmpHrmpChannel: { maxCapacity: "u32", maxTotalSize: "u32", @@ -5537,12 +5581,12 @@ export default { senderDeposit: "u128", recipientDeposit: "u128", }, - /** Lookup683: polkadot_core_primitives::InboundHrmpMessage */ + /** Lookup688: polkadot_core_primitives::InboundHrmpMessage */ PolkadotCorePrimitivesInboundHrmpMessage: { sentAt: "u32", data: "Bytes", }, - /** Lookup686: polkadot_runtime_parachains::hrmp::pallet::Error */ + /** Lookup691: polkadot_runtime_parachains::hrmp::pallet::Error */ PolkadotRuntimeParachainsHrmpPalletError: { _enum: [ "OpenHrmpChannelToSelf", @@ -5567,7 +5611,7 @@ export default { "ChannelCreationNotAuthorized", ], }, - /** Lookup688: polkadot_primitives::v7::SessionInfo */ + /** Lookup693: polkadot_primitives::v7::SessionInfo */ PolkadotPrimitivesV7SessionInfo: { activeValidatorIndices: "Vec", randomSeed: "[u8;32]", @@ -5584,20 +5628,20 @@ export default { neededApprovals: "u32", }, /** - * Lookup689: polkadot_primitives::v7::IndexedVec */ PolkadotPrimitivesV7IndexedVecValidatorIndex: "Vec", - /** Lookup690: polkadot_primitives::v7::IndexedVec */ + /** Lookup695: polkadot_primitives::v7::IndexedVec */ PolkadotPrimitivesV7IndexedVecGroupIndex: "Vec>", - /** Lookup692: polkadot_primitives::v7::DisputeState */ + /** Lookup697: polkadot_primitives::v7::DisputeState */ PolkadotPrimitivesV7DisputeState: { validatorsFor: "BitVec", validatorsAgainst: "BitVec", start: "u32", concludedAt: "Option", }, - /** Lookup694: polkadot_runtime_parachains::disputes::pallet::Error */ + /** Lookup699: polkadot_runtime_parachains::disputes::pallet::Error */ PolkadotRuntimeParachainsDisputesPalletError: { _enum: [ "DuplicateDisputeStatementSets", @@ -5611,7 +5655,7 @@ export default { "UnconfirmedDispute", ], }, - /** Lookup695: polkadot_primitives::v7::slashing::PendingSlashes */ + /** Lookup700: polkadot_primitives::v7::slashing::PendingSlashes */ PolkadotPrimitivesV7SlashingPendingSlashes: { _alias: { keys_: "keys", @@ -5619,7 +5663,7 @@ export default { keys_: "BTreeMap", kind: "PolkadotPrimitivesV7SlashingSlashingOffenceKind", }, - /** Lookup699: polkadot_runtime_parachains::disputes::slashing::pallet::Error */ + /** Lookup704: polkadot_runtime_parachains::disputes::slashing::pallet::Error */ PolkadotRuntimeParachainsDisputesSlashingPalletError: { _enum: [ "InvalidKeyOwnershipProof", @@ -5630,7 +5674,7 @@ export default { "DuplicateSlashingReport", ], }, - /** Lookup700: pallet_message_queue::BookState */ + /** Lookup705: pallet_message_queue::BookState */ PalletMessageQueueBookState: { _alias: { size_: "size", @@ -5642,12 +5686,12 @@ export default { messageCount: "u64", size_: "u64", }, - /** Lookup702: pallet_message_queue::Neighbours */ + /** Lookup707: pallet_message_queue::Neighbours */ PalletMessageQueueNeighbours: { prev: "PolkadotRuntimeParachainsInclusionAggregateMessageOrigin", next: "PolkadotRuntimeParachainsInclusionAggregateMessageOrigin", }, - /** Lookup704: pallet_message_queue::Page */ + /** Lookup709: pallet_message_queue::Page */ PalletMessageQueuePage: { remaining: "u32", remainingSize: "u32", @@ -5656,7 +5700,7 @@ export default { last: "u32", heap: "Bytes", }, - /** Lookup706: pallet_message_queue::pallet::Error */ + /** Lookup711: pallet_message_queue::pallet::Error */ PalletMessageQueueError: { _enum: [ "NotReapable", @@ -5670,38 +5714,38 @@ export default { "RecursiveDisallowed", ], }, - /** Lookup707: polkadot_runtime_parachains::assigner_on_demand::types::CoreAffinityCount */ + /** Lookup712: polkadot_runtime_parachains::assigner_on_demand::types::CoreAffinityCount */ PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount: { coreIndex: "u32", count: "u32", }, - /** Lookup708: polkadot_runtime_parachains::assigner_on_demand::types::QueueStatusType */ + /** Lookup713: polkadot_runtime_parachains::assigner_on_demand::types::QueueStatusType */ PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType: { traffic: "u128", nextIndex: "u32", smallestIndex: "u32", freedIndices: "BinaryHeapReverseQueueIndex", }, - /** Lookup710: BinaryHeap */ + /** Lookup715: BinaryHeap */ BinaryHeapReverseQueueIndex: "Vec", - /** Lookup713: BinaryHeap */ + /** Lookup718: BinaryHeap */ BinaryHeapEnqueuedOrder: "Vec", - /** Lookup714: polkadot_runtime_parachains::assigner_on_demand::types::EnqueuedOrder */ + /** Lookup719: polkadot_runtime_parachains::assigner_on_demand::types::EnqueuedOrder */ PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder: { paraId: "u32", idx: "u32", }, - /** Lookup718: polkadot_runtime_parachains::assigner_on_demand::pallet::Error */ + /** Lookup723: polkadot_runtime_parachains::assigner_on_demand::pallet::Error */ PolkadotRuntimeParachainsAssignerOnDemandPalletError: { _enum: ["QueueFull", "SpotPriceHigherThanMaxAmount"], }, - /** Lookup719: polkadot_runtime_common::paras_registrar::ParaInfo */ + /** Lookup724: polkadot_runtime_common::paras_registrar::ParaInfo */ PolkadotRuntimeCommonParasRegistrarParaInfo: { manager: "AccountId32", deposit: "u128", locked: "Option", }, - /** Lookup721: polkadot_runtime_common::paras_registrar::pallet::Error */ + /** Lookup726: polkadot_runtime_common::paras_registrar::pallet::Error */ PolkadotRuntimeCommonParasRegistrarPalletError: { _enum: [ "NotRegistered", @@ -5720,12 +5764,12 @@ export default { "CannotSwap", ], }, - /** Lookup722: pallet_utility::pallet::Error */ + /** Lookup727: pallet_utility::pallet::Error */ PalletUtilityError: { _enum: ["TooManyCalls"], }, /** - * Lookup724: pallet_identity::types::Registration> */ PalletIdentityRegistration: { @@ -5733,18 +5777,18 @@ export default { deposit: "u128", info: "PalletIdentityLegacyIdentityInfo", }, - /** Lookup733: pallet_identity::types::RegistrarInfo */ + /** Lookup738: pallet_identity::types::RegistrarInfo */ PalletIdentityRegistrarInfo: { account: "AccountId32", fee: "u128", fields: "u64", }, - /** Lookup735: pallet_identity::types::AuthorityProperties> */ + /** Lookup740: pallet_identity::types::AuthorityProperties> */ PalletIdentityAuthorityProperties: { suffix: "Bytes", allocation: "u32", }, - /** Lookup738: pallet_identity::pallet::Error */ + /** Lookup743: pallet_identity::pallet::Error */ PalletIdentityError: { _enum: [ "TooManySubAccounts", @@ -5776,7 +5820,7 @@ export default { ], }, /** - * Lookup741: pallet_scheduler::Scheduled, * BlockNumber, dancelight_runtime::OriginCaller, sp_core::crypto::AccountId32> */ @@ -5787,29 +5831,29 @@ export default { maybePeriodic: "Option<(u32,u32)>", origin: "DancelightRuntimeOriginCaller", }, - /** Lookup743: pallet_scheduler::RetryConfig */ + /** Lookup748: pallet_scheduler::RetryConfig */ PalletSchedulerRetryConfig: { totalRetries: "u8", remaining: "u8", period: "u32", }, - /** Lookup744: pallet_scheduler::pallet::Error */ + /** Lookup749: pallet_scheduler::pallet::Error */ PalletSchedulerError: { _enum: ["FailedToSchedule", "NotFound", "TargetBlockNumberInPast", "RescheduleNoChange", "Named"], }, - /** Lookup747: pallet_proxy::ProxyDefinition */ + /** Lookup752: pallet_proxy::ProxyDefinition */ PalletProxyProxyDefinition: { delegate: "AccountId32", proxyType: "DancelightRuntimeProxyType", delay: "u32", }, - /** Lookup751: pallet_proxy::Announcement */ + /** Lookup756: pallet_proxy::Announcement */ PalletProxyAnnouncement: { real: "AccountId32", callHash: "H256", height: "u32", }, - /** Lookup753: pallet_proxy::pallet::Error */ + /** Lookup758: pallet_proxy::pallet::Error */ PalletProxyError: { _enum: [ "TooMany", @@ -5822,14 +5866,14 @@ export default { "NoSelfProxy", ], }, - /** Lookup755: pallet_multisig::Multisig */ + /** Lookup760: pallet_multisig::Multisig */ PalletMultisigMultisig: { when: "PalletMultisigTimepoint", deposit: "u128", depositor: "AccountId32", approvals: "Vec", }, - /** Lookup757: pallet_multisig::pallet::Error */ + /** Lookup762: pallet_multisig::pallet::Error */ PalletMultisigError: { _enum: [ "MinimumThreshold", @@ -5848,7 +5892,7 @@ export default { "AlreadyStored", ], }, - /** Lookup758: pallet_preimage::OldRequestStatus */ + /** Lookup763: pallet_preimage::OldRequestStatus */ PalletPreimageOldRequestStatus: { _enum: { Unrequested: { @@ -5863,7 +5907,7 @@ export default { }, }, /** - * Lookup761: pallet_preimage::RequestStatus> */ PalletPreimageRequestStatus: { @@ -5879,7 +5923,7 @@ export default { }, }, }, - /** Lookup766: pallet_preimage::pallet::Error */ + /** Lookup771: pallet_preimage::pallet::Error */ PalletPreimageError: { _enum: [ "TooBig", @@ -5893,11 +5937,11 @@ export default { "NoCost", ], }, - /** Lookup767: pallet_asset_rate::pallet::Error */ + /** Lookup772: pallet_asset_rate::pallet::Error */ PalletAssetRateError: { _enum: ["UnknownAssetKind", "AlreadyExists", "Overflow"], }, - /** Lookup768: pallet_xcm::pallet::QueryStatus */ + /** Lookup773: pallet_xcm::pallet::QueryStatus */ PalletXcmQueryStatus: { _enum: { Pending: { @@ -5916,7 +5960,7 @@ export default { }, }, }, - /** Lookup772: xcm::VersionedResponse */ + /** Lookup777: xcm::VersionedResponse */ XcmVersionedResponse: { _enum: { __Unused0: "Null", @@ -5926,7 +5970,7 @@ export default { V4: "StagingXcmV4Response", }, }, - /** Lookup778: pallet_xcm::pallet::VersionMigrationStage */ + /** Lookup783: pallet_xcm::pallet::VersionMigrationStage */ PalletXcmVersionMigrationStage: { _enum: { MigrateSupportedVersion: "Null", @@ -5935,14 +5979,14 @@ export default { MigrateAndNotifyOldTargets: "Null", }, }, - /** Lookup780: pallet_xcm::pallet::RemoteLockedFungibleRecord */ + /** Lookup785: pallet_xcm::pallet::RemoteLockedFungibleRecord */ PalletXcmRemoteLockedFungibleRecord: { amount: "u128", owner: "XcmVersionedLocation", locker: "XcmVersionedLocation", consumers: "Vec<(Null,u128)>", }, - /** Lookup787: pallet_xcm::pallet::Error */ + /** Lookup792: pallet_xcm::pallet::Error */ PalletXcmError: { _enum: [ "Unreachable", @@ -5972,11 +6016,11 @@ export default { "LocalExecutionIncomplete", ], }, - /** Lookup788: pallet_migrations::pallet::Error */ + /** Lookup793: pallet_migrations::pallet::Error */ PalletMigrationsError: { _enum: ["PreimageMissing", "WrongUpperBound", "PreimageIsTooBig", "PreimageAlreadyExists"], }, - /** Lookup792: pallet_beefy::pallet::Error */ + /** Lookup797: pallet_beefy::pallet::Error */ PalletBeefyError: { _enum: [ "InvalidKeyOwnershipProof", @@ -5988,43 +6032,43 @@ export default { "InvalidConfiguration", ], }, - /** Lookup793: sp_consensus_beefy::mmr::BeefyAuthoritySet */ + /** Lookup798: sp_consensus_beefy::mmr::BeefyAuthoritySet */ SpConsensusBeefyMmrBeefyAuthoritySet: { id: "u64", len: "u32", keysetCommitment: "H256", }, - /** Lookup794: snowbridge_beacon_primitives::types::CompactBeaconState */ + /** Lookup799: snowbridge_beacon_primitives::types::CompactBeaconState */ SnowbridgeBeaconPrimitivesCompactBeaconState: { slot: "Compact", blockRootsRoot: "H256", }, - /** Lookup795: snowbridge_beacon_primitives::types::SyncCommitteePrepared */ + /** Lookup800: snowbridge_beacon_primitives::types::SyncCommitteePrepared */ SnowbridgeBeaconPrimitivesSyncCommitteePrepared: { root: "H256", - pubkeys: "[Lookup797;512]", + pubkeys: "[Lookup802;512]", aggregatePubkey: "SnowbridgeMilagroBlsKeysPublicKey", }, - /** Lookup797: snowbridge_milagro_bls::keys::PublicKey */ + /** Lookup802: snowbridge_milagro_bls::keys::PublicKey */ SnowbridgeMilagroBlsKeysPublicKey: { point: "SnowbridgeAmclBls381Ecp", }, - /** Lookup798: snowbridge_amcl::bls381::ecp::ECP */ + /** Lookup803: snowbridge_amcl::bls381::ecp::ECP */ SnowbridgeAmclBls381Ecp: { x: "SnowbridgeAmclBls381Fp", y: "SnowbridgeAmclBls381Fp", z: "SnowbridgeAmclBls381Fp", }, - /** Lookup799: snowbridge_amcl::bls381::fp::FP */ + /** Lookup804: snowbridge_amcl::bls381::fp::FP */ SnowbridgeAmclBls381Fp: { x: "SnowbridgeAmclBls381Big", xes: "i32", }, - /** Lookup800: snowbridge_amcl::bls381::big::Big */ + /** Lookup805: snowbridge_amcl::bls381::big::Big */ SnowbridgeAmclBls381Big: { w: "[i32;14]", }, - /** Lookup803: snowbridge_beacon_primitives::types::ForkVersions */ + /** Lookup808: snowbridge_beacon_primitives::types::ForkVersions */ SnowbridgeBeaconPrimitivesForkVersions: { genesis: "SnowbridgeBeaconPrimitivesFork", altair: "SnowbridgeBeaconPrimitivesFork", @@ -6032,12 +6076,12 @@ export default { capella: "SnowbridgeBeaconPrimitivesFork", deneb: "SnowbridgeBeaconPrimitivesFork", }, - /** Lookup804: snowbridge_beacon_primitives::types::Fork */ + /** Lookup809: snowbridge_beacon_primitives::types::Fork */ SnowbridgeBeaconPrimitivesFork: { version: "[u8;4]", epoch: "u64", }, - /** Lookup805: snowbridge_pallet_ethereum_client::pallet::Error */ + /** Lookup810: snowbridge_pallet_ethereum_client::pallet::Error */ SnowbridgePalletEthereumClientError: { _enum: { SkippedSyncCommitteePeriod: "Null", @@ -6067,11 +6111,11 @@ export default { Halted: "Null", }, }, - /** Lookup806: snowbridge_beacon_primitives::bls::BlsError */ + /** Lookup811: snowbridge_beacon_primitives::bls::BlsError */ SnowbridgeBeaconPrimitivesBlsBlsError: { _enum: ["InvalidSignature", "InvalidPublicKey", "InvalidAggregatePublicKeys", "SignatureVerificationFailed"], }, - /** Lookup807: polkadot_runtime_common::paras_sudo_wrapper::pallet::Error */ + /** Lookup812: polkadot_runtime_common::paras_sudo_wrapper::pallet::Error */ PolkadotRuntimeCommonParasSudoWrapperPalletError: { _enum: [ "ParaDoesntExist", @@ -6085,32 +6129,32 @@ export default { "TooManyCores", ], }, - /** Lookup808: pallet_sudo::pallet::Error */ + /** Lookup813: pallet_sudo::pallet::Error */ PalletSudoError: { _enum: ["RequireSudo"], }, - /** Lookup811: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender */ + /** Lookup816: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender */ FrameSystemExtensionsCheckNonZeroSender: "Null", - /** Lookup812: frame_system::extensions::check_spec_version::CheckSpecVersion */ + /** Lookup817: frame_system::extensions::check_spec_version::CheckSpecVersion */ FrameSystemExtensionsCheckSpecVersion: "Null", - /** Lookup813: frame_system::extensions::check_tx_version::CheckTxVersion */ + /** Lookup818: frame_system::extensions::check_tx_version::CheckTxVersion */ FrameSystemExtensionsCheckTxVersion: "Null", - /** Lookup814: frame_system::extensions::check_genesis::CheckGenesis */ + /** Lookup819: frame_system::extensions::check_genesis::CheckGenesis */ FrameSystemExtensionsCheckGenesis: "Null", - /** Lookup817: frame_system::extensions::check_nonce::CheckNonce */ + /** Lookup822: frame_system::extensions::check_nonce::CheckNonce */ FrameSystemExtensionsCheckNonce: "Compact", - /** Lookup818: frame_system::extensions::check_weight::CheckWeight */ + /** Lookup823: frame_system::extensions::check_weight::CheckWeight */ FrameSystemExtensionsCheckWeight: "Null", - /** Lookup819: pallet_transaction_payment::ChargeTransactionPayment */ + /** Lookup824: pallet_transaction_payment::ChargeTransactionPayment */ PalletTransactionPaymentChargeTransactionPayment: "Compact", - /** Lookup820: frame_metadata_hash_extension::CheckMetadataHash */ + /** Lookup825: frame_metadata_hash_extension::CheckMetadataHash */ FrameMetadataHashExtensionCheckMetadataHash: { mode: "FrameMetadataHashExtensionMode", }, - /** Lookup821: frame_metadata_hash_extension::Mode */ + /** Lookup826: frame_metadata_hash_extension::Mode */ FrameMetadataHashExtensionMode: { _enum: ["Disabled", "Enabled"], }, - /** Lookup822: dancelight_runtime::Runtime */ + /** Lookup827: dancelight_runtime::Runtime */ DancelightRuntimeRuntime: "Null", }; diff --git a/typescript-api/src/dancelight/interfaces/registry.ts b/typescript-api/src/dancelight/interfaces/registry.ts index 69cf32fa3..d0e80fce6 100644 --- a/typescript-api/src/dancelight/interfaces/registry.ts +++ b/typescript-api/src/dancelight/interfaces/registry.ts @@ -113,6 +113,10 @@ import type { PalletDataPreserversProfile, PalletDataPreserversProfileMode, PalletDataPreserversRegisteredProfile, + PalletExternalValidatorSlashesCall, + PalletExternalValidatorSlashesError, + PalletExternalValidatorSlashesEvent, + PalletExternalValidatorSlashesSlash, PalletExternalValidatorsCall, PalletExternalValidatorsError, PalletExternalValidatorsEvent, @@ -568,6 +572,10 @@ declare module "@polkadot/types/types/registry" { PalletDataPreserversProfile: PalletDataPreserversProfile; PalletDataPreserversProfileMode: PalletDataPreserversProfileMode; PalletDataPreserversRegisteredProfile: PalletDataPreserversRegisteredProfile; + PalletExternalValidatorSlashesCall: PalletExternalValidatorSlashesCall; + PalletExternalValidatorSlashesError: PalletExternalValidatorSlashesError; + PalletExternalValidatorSlashesEvent: PalletExternalValidatorSlashesEvent; + PalletExternalValidatorSlashesSlash: PalletExternalValidatorSlashesSlash; PalletExternalValidatorsCall: PalletExternalValidatorsCall; PalletExternalValidatorsError: PalletExternalValidatorsError; PalletExternalValidatorsEvent: PalletExternalValidatorsEvent; diff --git a/typescript-api/src/dancelight/interfaces/types-lookup.ts b/typescript-api/src/dancelight/interfaces/types-lookup.ts index ff5f90d32..8df791dea 100644 --- a/typescript-api/src/dancelight/interfaces/types-lookup.ts +++ b/typescript-api/src/dancelight/interfaces/types-lookup.ts @@ -656,7 +656,18 @@ declare module "@polkadot/types/lookup" { readonly type: "NotForcing" | "ForceNew" | "ForceNone" | "ForceAlways"; } - /** @name PalletSessionEvent (56) */ + /** @name PalletExternalValidatorSlashesEvent (56) */ + interface PalletExternalValidatorSlashesEvent extends Enum { + readonly isSlashReported: boolean; + readonly asSlashReported: { + readonly validator: AccountId32; + readonly fraction: Perbill; + readonly slashEra: u32; + } & Struct; + readonly type: "SlashReported"; + } + + /** @name PalletSessionEvent (58) */ interface PalletSessionEvent extends Enum { readonly isNewSession: boolean; readonly asNewSession: { @@ -665,7 +676,7 @@ declare module "@polkadot/types/lookup" { readonly type: "NewSession"; } - /** @name PalletGrandpaEvent (57) */ + /** @name PalletGrandpaEvent (59) */ interface PalletGrandpaEvent extends Enum { readonly isNewAuthorities: boolean; readonly asNewAuthorities: { @@ -676,10 +687,10 @@ declare module "@polkadot/types/lookup" { readonly type: "NewAuthorities" | "Paused" | "Resumed"; } - /** @name SpConsensusGrandpaAppPublic (60) */ + /** @name SpConsensusGrandpaAppPublic (62) */ interface SpConsensusGrandpaAppPublic extends U8aFixed {} - /** @name PalletInflationRewardsEvent (61) */ + /** @name PalletInflationRewardsEvent (63) */ interface PalletInflationRewardsEvent extends Enum { readonly isRewardedOrchestrator: boolean; readonly asRewardedOrchestrator: { @@ -695,7 +706,7 @@ declare module "@polkadot/types/lookup" { readonly type: "RewardedOrchestrator" | "RewardedContainer"; } - /** @name PalletTreasuryEvent (62) */ + /** @name PalletTreasuryEvent (64) */ interface PalletTreasuryEvent extends Enum { readonly isSpending: boolean; readonly asSpending: { @@ -772,7 +783,7 @@ declare module "@polkadot/types/lookup" { | "SpendProcessed"; } - /** @name PalletConvictionVotingEvent (64) */ + /** @name PalletConvictionVotingEvent (66) */ interface PalletConvictionVotingEvent extends Enum { readonly isDelegated: boolean; readonly asDelegated: ITuple<[AccountId32, AccountId32]>; @@ -781,7 +792,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Delegated" | "Undelegated"; } - /** @name PalletReferendaEvent (65) */ + /** @name PalletReferendaEvent (67) */ interface PalletReferendaEvent extends Enum { readonly isSubmitted: boolean; readonly asSubmitted: { @@ -885,7 +896,7 @@ declare module "@polkadot/types/lookup" { | "MetadataCleared"; } - /** @name FrameSupportPreimagesBounded (67) */ + /** @name FrameSupportPreimagesBounded (69) */ interface FrameSupportPreimagesBounded extends Enum { readonly isLegacy: boolean; readonly asLegacy: { @@ -901,7 +912,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Legacy" | "Inline" | "Lookup"; } - /** @name FrameSystemCall (69) */ + /** @name FrameSystemCall (71) */ interface FrameSystemCall extends Enum { readonly isRemark: boolean; readonly asRemark: { @@ -962,7 +973,7 @@ declare module "@polkadot/types/lookup" { | "ApplyAuthorizedUpgrade"; } - /** @name PalletBabeCall (73) */ + /** @name PalletBabeCall (75) */ interface PalletBabeCall extends Enum { readonly isReportEquivocation: boolean; readonly asReportEquivocation: { @@ -981,7 +992,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ReportEquivocation" | "ReportEquivocationUnsigned" | "PlanConfigChange"; } - /** @name SpConsensusSlotsEquivocationProof (74) */ + /** @name SpConsensusSlotsEquivocationProof (76) */ interface SpConsensusSlotsEquivocationProof extends Struct { readonly offender: SpConsensusBabeAppPublic; readonly slot: u64; @@ -989,7 +1000,7 @@ declare module "@polkadot/types/lookup" { readonly secondHeader: SpRuntimeHeader; } - /** @name SpRuntimeHeader (75) */ + /** @name SpRuntimeHeader (77) */ interface SpRuntimeHeader extends Struct { readonly parentHash: H256; readonly number: Compact; @@ -998,17 +1009,17 @@ declare module "@polkadot/types/lookup" { readonly digest: SpRuntimeDigest; } - /** @name SpConsensusBabeAppPublic (77) */ + /** @name SpConsensusBabeAppPublic (79) */ interface SpConsensusBabeAppPublic extends U8aFixed {} - /** @name SpSessionMembershipProof (78) */ + /** @name SpSessionMembershipProof (80) */ interface SpSessionMembershipProof extends Struct { readonly session: u32; readonly trieNodes: Vec; readonly validatorCount: u32; } - /** @name SpConsensusBabeDigestsNextConfigDescriptor (79) */ + /** @name SpConsensusBabeDigestsNextConfigDescriptor (81) */ interface SpConsensusBabeDigestsNextConfigDescriptor extends Enum { readonly isV1: boolean; readonly asV1: { @@ -1018,7 +1029,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V1"; } - /** @name SpConsensusBabeAllowedSlots (81) */ + /** @name SpConsensusBabeAllowedSlots (83) */ interface SpConsensusBabeAllowedSlots extends Enum { readonly isPrimarySlots: boolean; readonly isPrimaryAndSecondaryPlainSlots: boolean; @@ -1026,7 +1037,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PrimarySlots" | "PrimaryAndSecondaryPlainSlots" | "PrimaryAndSecondaryVRFSlots"; } - /** @name PalletTimestampCall (82) */ + /** @name PalletTimestampCall (84) */ interface PalletTimestampCall extends Enum { readonly isSet: boolean; readonly asSet: { @@ -1035,7 +1046,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Set"; } - /** @name PalletBalancesCall (83) */ + /** @name PalletBalancesCall (85) */ interface PalletBalancesCall extends Enum { readonly isTransferAllowDeath: boolean; readonly asTransferAllowDeath: { @@ -1094,14 +1105,14 @@ declare module "@polkadot/types/lookup" { | "Burn"; } - /** @name PalletBalancesAdjustmentDirection (89) */ + /** @name PalletBalancesAdjustmentDirection (91) */ interface PalletBalancesAdjustmentDirection extends Enum { readonly isIncrease: boolean; readonly isDecrease: boolean; readonly type: "Increase" | "Decrease"; } - /** @name PalletParametersCall (90) */ + /** @name PalletParametersCall (92) */ interface PalletParametersCall extends Enum { readonly isSetParameter: boolean; readonly asSetParameter: { @@ -1110,14 +1121,14 @@ declare module "@polkadot/types/lookup" { readonly type: "SetParameter"; } - /** @name DancelightRuntimeRuntimeParameters (91) */ + /** @name DancelightRuntimeRuntimeParameters (93) */ interface DancelightRuntimeRuntimeParameters extends Enum { readonly isPreimage: boolean; readonly asPreimage: DancelightRuntimeDynamicParamsPreimageParameters; readonly type: "Preimage"; } - /** @name DancelightRuntimeDynamicParamsPreimageParameters (92) */ + /** @name DancelightRuntimeDynamicParamsPreimageParameters (94) */ interface DancelightRuntimeDynamicParamsPreimageParameters extends Enum { readonly isBaseDeposit: boolean; readonly asBaseDeposit: ITuple<[DancelightRuntimeDynamicParamsPreimageBaseDeposit, Option]>; @@ -1126,7 +1137,7 @@ declare module "@polkadot/types/lookup" { readonly type: "BaseDeposit" | "ByteDeposit"; } - /** @name PalletRegistrarCall (93) */ + /** @name PalletRegistrarCall (95) */ interface PalletRegistrarCall extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -1196,7 +1207,7 @@ declare module "@polkadot/types/lookup" { | "DeregisterWithRelayProof"; } - /** @name DpContainerChainGenesisDataContainerChainGenesisData (94) */ + /** @name DpContainerChainGenesisDataContainerChainGenesisData (96) */ interface DpContainerChainGenesisDataContainerChainGenesisData extends Struct { readonly storage: Vec; readonly name: Bytes; @@ -1206,42 +1217,42 @@ declare module "@polkadot/types/lookup" { readonly properties: DpContainerChainGenesisDataProperties; } - /** @name DpContainerChainGenesisDataContainerChainGenesisDataItem (96) */ + /** @name DpContainerChainGenesisDataContainerChainGenesisDataItem (98) */ interface DpContainerChainGenesisDataContainerChainGenesisDataItem extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name DpContainerChainGenesisDataProperties (98) */ + /** @name DpContainerChainGenesisDataProperties (100) */ interface DpContainerChainGenesisDataProperties extends Struct { readonly tokenMetadata: DpContainerChainGenesisDataTokenMetadata; readonly isEthereum: bool; } - /** @name DpContainerChainGenesisDataTokenMetadata (99) */ + /** @name DpContainerChainGenesisDataTokenMetadata (101) */ interface DpContainerChainGenesisDataTokenMetadata extends Struct { readonly tokenSymbol: Bytes; readonly ss58Format: u32; readonly tokenDecimals: u32; } - /** @name TpTraitsSlotFrequency (103) */ + /** @name TpTraitsSlotFrequency (105) */ interface TpTraitsSlotFrequency extends Struct { readonly min: u32; readonly max: u32; } - /** @name TpTraitsParathreadParams (105) */ + /** @name TpTraitsParathreadParams (107) */ interface TpTraitsParathreadParams extends Struct { readonly slotFrequency: TpTraitsSlotFrequency; } - /** @name SpTrieStorageProof (106) */ + /** @name SpTrieStorageProof (108) */ interface SpTrieStorageProof extends Struct { readonly trieNodes: BTreeSet; } - /** @name SpRuntimeMultiSignature (108) */ + /** @name SpRuntimeMultiSignature (110) */ interface SpRuntimeMultiSignature extends Enum { readonly isEd25519: boolean; readonly asEd25519: U8aFixed; @@ -1252,7 +1263,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ed25519" | "Sr25519" | "Ecdsa"; } - /** @name PalletConfigurationCall (111) */ + /** @name PalletConfigurationCall (113) */ interface PalletConfigurationCall extends Enum { readonly isSetMaxCollators: boolean; readonly asSetMaxCollators: { @@ -1307,7 +1318,7 @@ declare module "@polkadot/types/lookup" { | "SetBypassConsistencyCheck"; } - /** @name PalletInvulnerablesCall (114) */ + /** @name PalletInvulnerablesCall (115) */ interface PalletInvulnerablesCall extends Enum { readonly isAddInvulnerable: boolean; readonly asAddInvulnerable: { @@ -1320,13 +1331,13 @@ declare module "@polkadot/types/lookup" { readonly type: "AddInvulnerable" | "RemoveInvulnerable"; } - /** @name PalletCollatorAssignmentCall (115) */ + /** @name PalletCollatorAssignmentCall (116) */ type PalletCollatorAssignmentCall = Null; - /** @name PalletAuthorityAssignmentCall (116) */ + /** @name PalletAuthorityAssignmentCall (117) */ type PalletAuthorityAssignmentCall = Null; - /** @name PalletAuthorNotingCall (117) */ + /** @name PalletAuthorNotingCall (118) */ interface PalletAuthorNotingCall extends Enum { readonly isSetLatestAuthorData: boolean; readonly asSetLatestAuthorData: { @@ -1346,7 +1357,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SetLatestAuthorData" | "SetAuthor" | "KillAuthorData"; } - /** @name PalletServicesPaymentCall (118) */ + /** @name PalletServicesPaymentCall (119) */ interface PalletServicesPaymentCall extends Enum { readonly isPurchaseCredits: boolean; readonly asPurchaseCredits: { @@ -1393,7 +1404,7 @@ declare module "@polkadot/types/lookup" { | "SetMaxTip"; } - /** @name PalletDataPreserversCall (119) */ + /** @name PalletDataPreserversCall (120) */ interface PalletDataPreserversCall extends Enum { readonly isCreateProfile: boolean; readonly asCreateProfile: { @@ -1451,7 +1462,7 @@ declare module "@polkadot/types/lookup" { | "ForceStartAssignment"; } - /** @name PalletDataPreserversProfile (120) */ + /** @name PalletDataPreserversProfile (121) */ interface PalletDataPreserversProfile extends Struct { readonly url: Bytes; readonly paraIds: PalletDataPreserversParaIdsFilter; @@ -1459,7 +1470,7 @@ declare module "@polkadot/types/lookup" { readonly assignmentRequest: DancelightRuntimePreserversAssignmentPaymentRequest; } - /** @name PalletDataPreserversParaIdsFilter (122) */ + /** @name PalletDataPreserversParaIdsFilter (123) */ interface PalletDataPreserversParaIdsFilter extends Enum { readonly isAnyParaId: boolean; readonly isWhitelist: boolean; @@ -1469,7 +1480,7 @@ declare module "@polkadot/types/lookup" { readonly type: "AnyParaId" | "Whitelist" | "Blacklist"; } - /** @name PalletDataPreserversProfileMode (126) */ + /** @name PalletDataPreserversProfileMode (127) */ interface PalletDataPreserversProfileMode extends Enum { readonly isBootnode: boolean; readonly isRpc: boolean; @@ -1479,25 +1490,25 @@ declare module "@polkadot/types/lookup" { readonly type: "Bootnode" | "Rpc"; } - /** @name DancelightRuntimePreserversAssignmentPaymentRequest (127) */ + /** @name DancelightRuntimePreserversAssignmentPaymentRequest (128) */ interface DancelightRuntimePreserversAssignmentPaymentRequest extends Enum { readonly isFree: boolean; readonly type: "Free"; } - /** @name DancelightRuntimePreserversAssignmentPaymentExtra (128) */ + /** @name DancelightRuntimePreserversAssignmentPaymentExtra (129) */ interface DancelightRuntimePreserversAssignmentPaymentExtra extends Enum { readonly isFree: boolean; readonly type: "Free"; } - /** @name DancelightRuntimePreserversAssignmentPaymentWitness (129) */ + /** @name DancelightRuntimePreserversAssignmentPaymentWitness (130) */ interface DancelightRuntimePreserversAssignmentPaymentWitness extends Enum { readonly isFree: boolean; readonly type: "Free"; } - /** @name PalletExternalValidatorsCall (130) */ + /** @name PalletExternalValidatorsCall (131) */ interface PalletExternalValidatorsCall extends Enum { readonly isSkipExternalValidators: boolean; readonly asSkipExternalValidators: { @@ -1518,7 +1529,23 @@ declare module "@polkadot/types/lookup" { readonly type: "SkipExternalValidators" | "AddWhitelisted" | "RemoveWhitelisted" | "ForceEra"; } - /** @name PalletSessionCall (131) */ + /** @name PalletExternalValidatorSlashesCall (132) */ + interface PalletExternalValidatorSlashesCall extends Enum { + readonly isCancelDeferredSlash: boolean; + readonly asCancelDeferredSlash: { + readonly era: u32; + readonly slashIndices: Vec; + } & Struct; + readonly isForceInjectSlash: boolean; + readonly asForceInjectSlash: { + readonly era: u32; + readonly validator: AccountId32; + readonly percentage: Perbill; + } & Struct; + readonly type: "CancelDeferredSlash" | "ForceInjectSlash"; + } + + /** @name PalletSessionCall (134) */ interface PalletSessionCall extends Enum { readonly isSetKeys: boolean; readonly asSetKeys: { @@ -1529,7 +1556,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SetKeys" | "PurgeKeys"; } - /** @name DancelightRuntimeSessionKeys (132) */ + /** @name DancelightRuntimeSessionKeys (135) */ interface DancelightRuntimeSessionKeys extends Struct { readonly grandpa: SpConsensusGrandpaAppPublic; readonly babe: SpConsensusBabeAppPublic; @@ -1540,22 +1567,22 @@ declare module "@polkadot/types/lookup" { readonly nimbus: NimbusPrimitivesNimbusCryptoPublic; } - /** @name PolkadotPrimitivesV7ValidatorAppPublic (133) */ + /** @name PolkadotPrimitivesV7ValidatorAppPublic (136) */ interface PolkadotPrimitivesV7ValidatorAppPublic extends U8aFixed {} - /** @name PolkadotPrimitivesV7AssignmentAppPublic (134) */ + /** @name PolkadotPrimitivesV7AssignmentAppPublic (137) */ interface PolkadotPrimitivesV7AssignmentAppPublic extends U8aFixed {} - /** @name SpAuthorityDiscoveryAppPublic (135) */ + /** @name SpAuthorityDiscoveryAppPublic (138) */ interface SpAuthorityDiscoveryAppPublic extends U8aFixed {} - /** @name SpConsensusBeefyEcdsaCryptoPublic (136) */ + /** @name SpConsensusBeefyEcdsaCryptoPublic (139) */ interface SpConsensusBeefyEcdsaCryptoPublic extends U8aFixed {} - /** @name NimbusPrimitivesNimbusCryptoPublic (138) */ + /** @name NimbusPrimitivesNimbusCryptoPublic (141) */ interface NimbusPrimitivesNimbusCryptoPublic extends U8aFixed {} - /** @name PalletGrandpaCall (139) */ + /** @name PalletGrandpaCall (142) */ interface PalletGrandpaCall extends Enum { readonly isReportEquivocation: boolean; readonly asReportEquivocation: { @@ -1575,13 +1602,13 @@ declare module "@polkadot/types/lookup" { readonly type: "ReportEquivocation" | "ReportEquivocationUnsigned" | "NoteStalled"; } - /** @name SpConsensusGrandpaEquivocationProof (140) */ + /** @name SpConsensusGrandpaEquivocationProof (143) */ interface SpConsensusGrandpaEquivocationProof extends Struct { readonly setId: u64; readonly equivocation: SpConsensusGrandpaEquivocation; } - /** @name SpConsensusGrandpaEquivocation (141) */ + /** @name SpConsensusGrandpaEquivocation (144) */ interface SpConsensusGrandpaEquivocation extends Enum { readonly isPrevote: boolean; readonly asPrevote: FinalityGrandpaEquivocationPrevote; @@ -1590,7 +1617,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Prevote" | "Precommit"; } - /** @name FinalityGrandpaEquivocationPrevote (142) */ + /** @name FinalityGrandpaEquivocationPrevote (145) */ interface FinalityGrandpaEquivocationPrevote extends Struct { readonly roundNumber: u64; readonly identity: SpConsensusGrandpaAppPublic; @@ -1598,16 +1625,16 @@ declare module "@polkadot/types/lookup" { readonly second: ITuple<[FinalityGrandpaPrevote, SpConsensusGrandpaAppSignature]>; } - /** @name FinalityGrandpaPrevote (143) */ + /** @name FinalityGrandpaPrevote (146) */ interface FinalityGrandpaPrevote extends Struct { readonly targetHash: H256; readonly targetNumber: u32; } - /** @name SpConsensusGrandpaAppSignature (144) */ + /** @name SpConsensusGrandpaAppSignature (147) */ interface SpConsensusGrandpaAppSignature extends U8aFixed {} - /** @name FinalityGrandpaEquivocationPrecommit (146) */ + /** @name FinalityGrandpaEquivocationPrecommit (149) */ interface FinalityGrandpaEquivocationPrecommit extends Struct { readonly roundNumber: u64; readonly identity: SpConsensusGrandpaAppPublic; @@ -1615,13 +1642,13 @@ declare module "@polkadot/types/lookup" { readonly second: ITuple<[FinalityGrandpaPrecommit, SpConsensusGrandpaAppSignature]>; } - /** @name FinalityGrandpaPrecommit (147) */ + /** @name FinalityGrandpaPrecommit (150) */ interface FinalityGrandpaPrecommit extends Struct { readonly targetHash: H256; readonly targetNumber: u32; } - /** @name PalletTreasuryCall (149) */ + /** @name PalletTreasuryCall (152) */ interface PalletTreasuryCall extends Enum { readonly isSpendLocal: boolean; readonly asSpendLocal: { @@ -1654,7 +1681,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SpendLocal" | "RemoveApproval" | "Spend" | "Payout" | "CheckStatus" | "VoidSpend"; } - /** @name PalletConvictionVotingCall (151) */ + /** @name PalletConvictionVotingCall (154) */ interface PalletConvictionVotingCall extends Enum { readonly isVote: boolean; readonly asVote: { @@ -1691,7 +1718,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Vote" | "Delegate" | "Undelegate" | "Unlock" | "RemoveVote" | "RemoveOtherVote"; } - /** @name PalletConvictionVotingVoteAccountVote (152) */ + /** @name PalletConvictionVotingVoteAccountVote (155) */ interface PalletConvictionVotingVoteAccountVote extends Enum { readonly isStandard: boolean; readonly asStandard: { @@ -1712,7 +1739,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Standard" | "Split" | "SplitAbstain"; } - /** @name PalletConvictionVotingConviction (154) */ + /** @name PalletConvictionVotingConviction (157) */ interface PalletConvictionVotingConviction extends Enum { readonly isNone: boolean; readonly isLocked1x: boolean; @@ -1724,7 +1751,7 @@ declare module "@polkadot/types/lookup" { readonly type: "None" | "Locked1x" | "Locked2x" | "Locked3x" | "Locked4x" | "Locked5x" | "Locked6x"; } - /** @name PalletReferendaCall (156) */ + /** @name PalletReferendaCall (159) */ interface PalletReferendaCall extends Enum { readonly isSubmit: boolean; readonly asSubmit: { @@ -1777,7 +1804,7 @@ declare module "@polkadot/types/lookup" { | "SetMetadata"; } - /** @name DancelightRuntimeOriginCaller (157) */ + /** @name DancelightRuntimeOriginCaller (160) */ interface DancelightRuntimeOriginCaller extends Enum { readonly isSystem: boolean; readonly asSystem: FrameSupportDispatchRawOrigin; @@ -1791,7 +1818,7 @@ declare module "@polkadot/types/lookup" { readonly type: "System" | "Void" | "Origins" | "ParachainsOrigin" | "XcmPallet"; } - /** @name FrameSupportDispatchRawOrigin (158) */ + /** @name FrameSupportDispatchRawOrigin (161) */ interface FrameSupportDispatchRawOrigin extends Enum { readonly isRoot: boolean; readonly isSigned: boolean; @@ -1800,7 +1827,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Root" | "Signed" | "None"; } - /** @name DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin (159) */ + /** @name DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin (162) */ interface DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin extends Enum { readonly isStakingAdmin: boolean; readonly isTreasurer: boolean; @@ -1859,14 +1886,14 @@ declare module "@polkadot/types/lookup" { | "Fellowship9Dan"; } - /** @name PolkadotRuntimeParachainsOriginPalletOrigin (160) */ + /** @name PolkadotRuntimeParachainsOriginPalletOrigin (163) */ interface PolkadotRuntimeParachainsOriginPalletOrigin extends Enum { readonly isParachain: boolean; readonly asParachain: u32; readonly type: "Parachain"; } - /** @name PalletXcmOrigin (161) */ + /** @name PalletXcmOrigin (164) */ interface PalletXcmOrigin extends Enum { readonly isXcm: boolean; readonly asXcm: StagingXcmV4Location; @@ -1875,13 +1902,13 @@ declare module "@polkadot/types/lookup" { readonly type: "Xcm" | "Response"; } - /** @name StagingXcmV4Location (162) */ + /** @name StagingXcmV4Location (165) */ interface StagingXcmV4Location extends Struct { readonly parents: u8; readonly interior: StagingXcmV4Junctions; } - /** @name StagingXcmV4Junctions (163) */ + /** @name StagingXcmV4Junctions (166) */ interface StagingXcmV4Junctions extends Enum { readonly isHere: boolean; readonly isX1: boolean; @@ -1903,7 +1930,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Here" | "X1" | "X2" | "X3" | "X4" | "X5" | "X6" | "X7" | "X8"; } - /** @name StagingXcmV4Junction (165) */ + /** @name StagingXcmV4Junction (168) */ interface StagingXcmV4Junction extends Enum { readonly isParachain: boolean; readonly asParachain: Compact; @@ -1952,7 +1979,7 @@ declare module "@polkadot/types/lookup" { | "GlobalConsensus"; } - /** @name StagingXcmV4JunctionNetworkId (167) */ + /** @name StagingXcmV4JunctionNetworkId (170) */ interface StagingXcmV4JunctionNetworkId extends Enum { readonly isByGenesis: boolean; readonly asByGenesis: U8aFixed; @@ -1987,7 +2014,7 @@ declare module "@polkadot/types/lookup" { | "PolkadotBulletin"; } - /** @name XcmV3JunctionBodyId (168) */ + /** @name XcmV3JunctionBodyId (171) */ interface XcmV3JunctionBodyId extends Enum { readonly isUnit: boolean; readonly isMoniker: boolean; @@ -2014,7 +2041,7 @@ declare module "@polkadot/types/lookup" { | "Treasury"; } - /** @name XcmV3JunctionBodyPart (169) */ + /** @name XcmV3JunctionBodyPart (172) */ interface XcmV3JunctionBodyPart extends Enum { readonly isVoice: boolean; readonly isMembers: boolean; @@ -2039,10 +2066,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Voice" | "Members" | "Fraction" | "AtLeastProportion" | "MoreThanProportion"; } - /** @name SpCoreVoid (177) */ + /** @name SpCoreVoid (180) */ type SpCoreVoid = Null; - /** @name FrameSupportScheduleDispatchTime (178) */ + /** @name FrameSupportScheduleDispatchTime (181) */ interface FrameSupportScheduleDispatchTime extends Enum { readonly isAt: boolean; readonly asAt: u32; @@ -2051,7 +2078,7 @@ declare module "@polkadot/types/lookup" { readonly type: "At" | "After"; } - /** @name PalletRankedCollectiveCall (180) */ + /** @name PalletRankedCollectiveCall (183) */ interface PalletRankedCollectiveCall extends Enum { readonly isAddMember: boolean; readonly asAddMember: { @@ -2095,7 +2122,7 @@ declare module "@polkadot/types/lookup" { | "ExchangeMember"; } - /** @name PalletWhitelistCall (182) */ + /** @name PalletWhitelistCall (185) */ interface PalletWhitelistCall extends Enum { readonly isWhitelistCall: boolean; readonly asWhitelistCall: { @@ -2122,7 +2149,7 @@ declare module "@polkadot/types/lookup" { | "DispatchWhitelistedCallWithPreimage"; } - /** @name PolkadotRuntimeParachainsConfigurationPalletCall (183) */ + /** @name PolkadotRuntimeParachainsConfigurationPalletCall (186) */ interface PolkadotRuntimeParachainsConfigurationPalletCall extends Enum { readonly isSetValidationUpgradeCooldown: boolean; readonly asSetValidationUpgradeCooldown: { @@ -2368,16 +2395,16 @@ declare module "@polkadot/types/lookup" { | "SetSchedulerParams"; } - /** @name PolkadotPrimitivesV7AsyncBackingAsyncBackingParams (184) */ + /** @name PolkadotPrimitivesV7AsyncBackingAsyncBackingParams (187) */ interface PolkadotPrimitivesV7AsyncBackingAsyncBackingParams extends Struct { readonly maxCandidateDepth: u32; readonly allowedAncestryLen: u32; } - /** @name PolkadotPrimitivesV7ExecutorParams (185) */ + /** @name PolkadotPrimitivesV7ExecutorParams (188) */ interface PolkadotPrimitivesV7ExecutorParams extends Vec {} - /** @name PolkadotPrimitivesV7ExecutorParamsExecutorParam (187) */ + /** @name PolkadotPrimitivesV7ExecutorParamsExecutorParam (190) */ interface PolkadotPrimitivesV7ExecutorParamsExecutorParam extends Enum { readonly isMaxMemoryPages: boolean; readonly asMaxMemoryPages: u32; @@ -2402,26 +2429,26 @@ declare module "@polkadot/types/lookup" { | "WasmExtBulkMemory"; } - /** @name PolkadotPrimitivesV7PvfPrepKind (188) */ + /** @name PolkadotPrimitivesV7PvfPrepKind (191) */ interface PolkadotPrimitivesV7PvfPrepKind extends Enum { readonly isPrecheck: boolean; readonly isPrepare: boolean; readonly type: "Precheck" | "Prepare"; } - /** @name PolkadotPrimitivesV7PvfExecKind (189) */ + /** @name PolkadotPrimitivesV7PvfExecKind (192) */ interface PolkadotPrimitivesV7PvfExecKind extends Enum { readonly isBacking: boolean; readonly isApproval: boolean; readonly type: "Backing" | "Approval"; } - /** @name PolkadotPrimitivesV7ApprovalVotingParams (190) */ + /** @name PolkadotPrimitivesV7ApprovalVotingParams (193) */ interface PolkadotPrimitivesV7ApprovalVotingParams extends Struct { readonly maxApprovalCoalesceCount: u32; } - /** @name PolkadotPrimitivesVstagingSchedulerParams (191) */ + /** @name PolkadotPrimitivesVstagingSchedulerParams (194) */ interface PolkadotPrimitivesVstagingSchedulerParams extends Struct { readonly groupRotationFrequency: u32; readonly parasAvailabilityPeriod: u32; @@ -2436,13 +2463,13 @@ declare module "@polkadot/types/lookup" { readonly ttl: u32; } - /** @name PolkadotRuntimeParachainsSharedPalletCall (192) */ + /** @name PolkadotRuntimeParachainsSharedPalletCall (195) */ type PolkadotRuntimeParachainsSharedPalletCall = Null; - /** @name PolkadotRuntimeParachainsInclusionPalletCall (193) */ + /** @name PolkadotRuntimeParachainsInclusionPalletCall (196) */ type PolkadotRuntimeParachainsInclusionPalletCall = Null; - /** @name PolkadotRuntimeParachainsParasInherentPalletCall (194) */ + /** @name PolkadotRuntimeParachainsParasInherentPalletCall (197) */ interface PolkadotRuntimeParachainsParasInherentPalletCall extends Enum { readonly isEnter: boolean; readonly asEnter: { @@ -2451,7 +2478,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Enter"; } - /** @name PolkadotPrimitivesV7InherentData (195) */ + /** @name PolkadotPrimitivesV7InherentData (198) */ interface PolkadotPrimitivesV7InherentData extends Struct { readonly bitfields: Vec; readonly backedCandidates: Vec; @@ -2459,33 +2486,33 @@ declare module "@polkadot/types/lookup" { readonly parentHeader: SpRuntimeHeader; } - /** @name PolkadotPrimitivesV7SignedUncheckedSigned (197) */ + /** @name PolkadotPrimitivesV7SignedUncheckedSigned (200) */ interface PolkadotPrimitivesV7SignedUncheckedSigned extends Struct { readonly payload: BitVec; readonly validatorIndex: u32; readonly signature: PolkadotPrimitivesV7ValidatorAppSignature; } - /** @name BitvecOrderLsb0 (200) */ + /** @name BitvecOrderLsb0 (203) */ type BitvecOrderLsb0 = Null; - /** @name PolkadotPrimitivesV7ValidatorAppSignature (202) */ + /** @name PolkadotPrimitivesV7ValidatorAppSignature (205) */ interface PolkadotPrimitivesV7ValidatorAppSignature extends U8aFixed {} - /** @name PolkadotPrimitivesV7BackedCandidate (204) */ + /** @name PolkadotPrimitivesV7BackedCandidate (207) */ interface PolkadotPrimitivesV7BackedCandidate extends Struct { readonly candidate: PolkadotPrimitivesV7CommittedCandidateReceipt; readonly validityVotes: Vec; readonly validatorIndices: BitVec; } - /** @name PolkadotPrimitivesV7CommittedCandidateReceipt (205) */ + /** @name PolkadotPrimitivesV7CommittedCandidateReceipt (208) */ interface PolkadotPrimitivesV7CommittedCandidateReceipt extends Struct { readonly descriptor: PolkadotPrimitivesV7CandidateDescriptor; readonly commitments: PolkadotPrimitivesV7CandidateCommitments; } - /** @name PolkadotPrimitivesV7CandidateDescriptor (206) */ + /** @name PolkadotPrimitivesV7CandidateDescriptor (209) */ interface PolkadotPrimitivesV7CandidateDescriptor extends Struct { readonly paraId: u32; readonly relayParent: H256; @@ -2498,13 +2525,13 @@ declare module "@polkadot/types/lookup" { readonly validationCodeHash: H256; } - /** @name PolkadotPrimitivesV7CollatorAppPublic (207) */ + /** @name PolkadotPrimitivesV7CollatorAppPublic (210) */ interface PolkadotPrimitivesV7CollatorAppPublic extends U8aFixed {} - /** @name PolkadotPrimitivesV7CollatorAppSignature (208) */ + /** @name PolkadotPrimitivesV7CollatorAppSignature (211) */ interface PolkadotPrimitivesV7CollatorAppSignature extends U8aFixed {} - /** @name PolkadotPrimitivesV7CandidateCommitments (210) */ + /** @name PolkadotPrimitivesV7CandidateCommitments (213) */ interface PolkadotPrimitivesV7CandidateCommitments extends Struct { readonly upwardMessages: Vec; readonly horizontalMessages: Vec; @@ -2514,13 +2541,13 @@ declare module "@polkadot/types/lookup" { readonly hrmpWatermark: u32; } - /** @name PolkadotCorePrimitivesOutboundHrmpMessage (213) */ + /** @name PolkadotCorePrimitivesOutboundHrmpMessage (216) */ interface PolkadotCorePrimitivesOutboundHrmpMessage extends Struct { readonly recipient: u32; readonly data: Bytes; } - /** @name PolkadotPrimitivesV7ValidityAttestation (218) */ + /** @name PolkadotPrimitivesV7ValidityAttestation (221) */ interface PolkadotPrimitivesV7ValidityAttestation extends Enum { readonly isImplicit: boolean; readonly asImplicit: PolkadotPrimitivesV7ValidatorAppSignature; @@ -2529,7 +2556,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Implicit" | "Explicit"; } - /** @name PolkadotPrimitivesV7DisputeStatementSet (220) */ + /** @name PolkadotPrimitivesV7DisputeStatementSet (223) */ interface PolkadotPrimitivesV7DisputeStatementSet extends Struct { readonly candidateHash: H256; readonly session: u32; @@ -2538,7 +2565,7 @@ declare module "@polkadot/types/lookup" { >; } - /** @name PolkadotPrimitivesV7DisputeStatement (224) */ + /** @name PolkadotPrimitivesV7DisputeStatement (227) */ interface PolkadotPrimitivesV7DisputeStatement extends Enum { readonly isValid: boolean; readonly asValid: PolkadotPrimitivesV7ValidDisputeStatementKind; @@ -2547,7 +2574,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Valid" | "Invalid"; } - /** @name PolkadotPrimitivesV7ValidDisputeStatementKind (225) */ + /** @name PolkadotPrimitivesV7ValidDisputeStatementKind (228) */ interface PolkadotPrimitivesV7ValidDisputeStatementKind extends Enum { readonly isExplicit: boolean; readonly isBackingSeconded: boolean; @@ -2565,13 +2592,13 @@ declare module "@polkadot/types/lookup" { | "ApprovalCheckingMultipleCandidates"; } - /** @name PolkadotPrimitivesV7InvalidDisputeStatementKind (227) */ + /** @name PolkadotPrimitivesV7InvalidDisputeStatementKind (230) */ interface PolkadotPrimitivesV7InvalidDisputeStatementKind extends Enum { readonly isExplicit: boolean; readonly type: "Explicit"; } - /** @name PolkadotRuntimeParachainsParasPalletCall (228) */ + /** @name PolkadotRuntimeParachainsParasPalletCall (231) */ interface PolkadotRuntimeParachainsParasPalletCall extends Enum { readonly isForceSetCurrentCode: boolean; readonly asForceSetCurrentCode: { @@ -2628,7 +2655,7 @@ declare module "@polkadot/types/lookup" { | "ForceSetMostRecentContext"; } - /** @name PolkadotPrimitivesV7PvfCheckStatement (229) */ + /** @name PolkadotPrimitivesV7PvfCheckStatement (232) */ interface PolkadotPrimitivesV7PvfCheckStatement extends Struct { readonly accept: bool; readonly subject: H256; @@ -2636,7 +2663,7 @@ declare module "@polkadot/types/lookup" { readonly validatorIndex: u32; } - /** @name PolkadotRuntimeParachainsInitializerPalletCall (230) */ + /** @name PolkadotRuntimeParachainsInitializerPalletCall (233) */ interface PolkadotRuntimeParachainsInitializerPalletCall extends Enum { readonly isForceApprove: boolean; readonly asForceApprove: { @@ -2645,7 +2672,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ForceApprove"; } - /** @name PolkadotRuntimeParachainsHrmpPalletCall (231) */ + /** @name PolkadotRuntimeParachainsHrmpPalletCall (234) */ interface PolkadotRuntimeParachainsHrmpPalletCall extends Enum { readonly isHrmpInitOpenChannel: boolean; readonly asHrmpInitOpenChannel: { @@ -2715,19 +2742,19 @@ declare module "@polkadot/types/lookup" { | "EstablishChannelWithSystem"; } - /** @name PolkadotParachainPrimitivesPrimitivesHrmpChannelId (232) */ + /** @name PolkadotParachainPrimitivesPrimitivesHrmpChannelId (235) */ interface PolkadotParachainPrimitivesPrimitivesHrmpChannelId extends Struct { readonly sender: u32; readonly recipient: u32; } - /** @name PolkadotRuntimeParachainsDisputesPalletCall (233) */ + /** @name PolkadotRuntimeParachainsDisputesPalletCall (236) */ interface PolkadotRuntimeParachainsDisputesPalletCall extends Enum { readonly isForceUnfreeze: boolean; readonly type: "ForceUnfreeze"; } - /** @name PolkadotRuntimeParachainsDisputesSlashingPalletCall (234) */ + /** @name PolkadotRuntimeParachainsDisputesSlashingPalletCall (237) */ interface PolkadotRuntimeParachainsDisputesSlashingPalletCall extends Enum { readonly isReportDisputeLostUnsigned: boolean; readonly asReportDisputeLostUnsigned: { @@ -2737,7 +2764,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ReportDisputeLostUnsigned"; } - /** @name PolkadotPrimitivesV7SlashingDisputeProof (235) */ + /** @name PolkadotPrimitivesV7SlashingDisputeProof (238) */ interface PolkadotPrimitivesV7SlashingDisputeProof extends Struct { readonly timeSlot: PolkadotPrimitivesV7SlashingDisputesTimeSlot; readonly kind: PolkadotPrimitivesV7SlashingSlashingOffenceKind; @@ -2745,20 +2772,20 @@ declare module "@polkadot/types/lookup" { readonly validatorId: PolkadotPrimitivesV7ValidatorAppPublic; } - /** @name PolkadotPrimitivesV7SlashingDisputesTimeSlot (236) */ + /** @name PolkadotPrimitivesV7SlashingDisputesTimeSlot (239) */ interface PolkadotPrimitivesV7SlashingDisputesTimeSlot extends Struct { readonly sessionIndex: u32; readonly candidateHash: H256; } - /** @name PolkadotPrimitivesV7SlashingSlashingOffenceKind (237) */ + /** @name PolkadotPrimitivesV7SlashingSlashingOffenceKind (240) */ interface PolkadotPrimitivesV7SlashingSlashingOffenceKind extends Enum { readonly isForInvalid: boolean; readonly isAgainstValid: boolean; readonly type: "ForInvalid" | "AgainstValid"; } - /** @name PalletMessageQueueCall (238) */ + /** @name PalletMessageQueueCall (241) */ interface PalletMessageQueueCall extends Enum { readonly isReapPage: boolean; readonly asReapPage: { @@ -2775,21 +2802,21 @@ declare module "@polkadot/types/lookup" { readonly type: "ReapPage" | "ExecuteOverweight"; } - /** @name PolkadotRuntimeParachainsInclusionAggregateMessageOrigin (239) */ + /** @name PolkadotRuntimeParachainsInclusionAggregateMessageOrigin (242) */ interface PolkadotRuntimeParachainsInclusionAggregateMessageOrigin extends Enum { readonly isUmp: boolean; readonly asUmp: PolkadotRuntimeParachainsInclusionUmpQueueId; readonly type: "Ump"; } - /** @name PolkadotRuntimeParachainsInclusionUmpQueueId (240) */ + /** @name PolkadotRuntimeParachainsInclusionUmpQueueId (243) */ interface PolkadotRuntimeParachainsInclusionUmpQueueId extends Enum { readonly isPara: boolean; readonly asPara: u32; readonly type: "Para"; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletCall (241) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletCall (244) */ interface PolkadotRuntimeParachainsAssignerOnDemandPalletCall extends Enum { readonly isPlaceOrderAllowDeath: boolean; readonly asPlaceOrderAllowDeath: { @@ -2804,7 +2831,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PlaceOrderAllowDeath" | "PlaceOrderKeepAlive"; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletCall (242) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletCall (245) */ interface PolkadotRuntimeCommonParasRegistrarPalletCall extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -2860,7 +2887,7 @@ declare module "@polkadot/types/lookup" { | "SetCurrentHead"; } - /** @name PalletUtilityCall (243) */ + /** @name PalletUtilityCall (246) */ interface PalletUtilityCall extends Enum { readonly isBatch: boolean; readonly asBatch: { @@ -2892,7 +2919,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Batch" | "AsDerivative" | "BatchAll" | "DispatchAs" | "ForceBatch" | "WithWeight"; } - /** @name PalletIdentityCall (245) */ + /** @name PalletIdentityCall (248) */ interface PalletIdentityCall extends Enum { readonly isAddRegistrar: boolean; readonly asAddRegistrar: { @@ -3014,7 +3041,7 @@ declare module "@polkadot/types/lookup" { | "RemoveDanglingUsername"; } - /** @name PalletIdentityLegacyIdentityInfo (246) */ + /** @name PalletIdentityLegacyIdentityInfo (249) */ interface PalletIdentityLegacyIdentityInfo extends Struct { readonly additional: Vec>; readonly display: Data; @@ -3027,7 +3054,7 @@ declare module "@polkadot/types/lookup" { readonly twitter: Data; } - /** @name PalletIdentityJudgement (283) */ + /** @name PalletIdentityJudgement (286) */ interface PalletIdentityJudgement extends Enum { readonly isUnknown: boolean; readonly isFeePaid: boolean; @@ -3040,7 +3067,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unknown" | "FeePaid" | "Reasonable" | "KnownGood" | "OutOfDate" | "LowQuality" | "Erroneous"; } - /** @name PalletSchedulerCall (286) */ + /** @name PalletSchedulerCall (289) */ interface PalletSchedulerCall extends Enum { readonly isSchedule: boolean; readonly asSchedule: { @@ -3114,7 +3141,7 @@ declare module "@polkadot/types/lookup" { | "CancelRetryNamed"; } - /** @name PalletProxyCall (289) */ + /** @name PalletProxyCall (292) */ interface PalletProxyCall extends Enum { readonly isProxy: boolean; readonly asProxy: { @@ -3184,7 +3211,7 @@ declare module "@polkadot/types/lookup" { | "ProxyAnnounced"; } - /** @name DancelightRuntimeProxyType (291) */ + /** @name DancelightRuntimeProxyType (294) */ interface DancelightRuntimeProxyType extends Enum { readonly isAny: boolean; readonly isNonTransfer: boolean; @@ -3205,7 +3232,7 @@ declare module "@polkadot/types/lookup" { | "SudoRegistrar"; } - /** @name PalletMultisigCall (292) */ + /** @name PalletMultisigCall (295) */ interface PalletMultisigCall extends Enum { readonly isAsMultiThreshold1: boolean; readonly asAsMultiThreshold1: { @@ -3238,13 +3265,13 @@ declare module "@polkadot/types/lookup" { readonly type: "AsMultiThreshold1" | "AsMulti" | "ApproveAsMulti" | "CancelAsMulti"; } - /** @name PalletMultisigTimepoint (294) */ + /** @name PalletMultisigTimepoint (297) */ interface PalletMultisigTimepoint extends Struct { readonly height: u32; readonly index: u32; } - /** @name PalletPreimageCall (295) */ + /** @name PalletPreimageCall (298) */ interface PalletPreimageCall extends Enum { readonly isNotePreimage: boolean; readonly asNotePreimage: { @@ -3269,7 +3296,7 @@ declare module "@polkadot/types/lookup" { readonly type: "NotePreimage" | "UnnotePreimage" | "RequestPreimage" | "UnrequestPreimage" | "EnsureUpdated"; } - /** @name PalletAssetRateCall (297) */ + /** @name PalletAssetRateCall (300) */ interface PalletAssetRateCall extends Enum { readonly isCreate: boolean; readonly asCreate: { @@ -3288,7 +3315,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Create" | "Update" | "Remove"; } - /** @name PalletXcmCall (299) */ + /** @name PalletXcmCall (302) */ interface PalletXcmCall extends Enum { readonly isSend: boolean; readonly asSend: { @@ -3391,7 +3418,7 @@ declare module "@polkadot/types/lookup" { | "TransferAssetsUsingTypeAndThen"; } - /** @name XcmVersionedLocation (300) */ + /** @name XcmVersionedLocation (303) */ interface XcmVersionedLocation extends Enum { readonly isV2: boolean; readonly asV2: XcmV2MultiLocation; @@ -3402,13 +3429,13 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name XcmV2MultiLocation (301) */ + /** @name XcmV2MultiLocation (304) */ interface XcmV2MultiLocation extends Struct { readonly parents: u8; readonly interior: XcmV2MultilocationJunctions; } - /** @name XcmV2MultilocationJunctions (302) */ + /** @name XcmV2MultilocationJunctions (305) */ interface XcmV2MultilocationJunctions extends Enum { readonly isHere: boolean; readonly isX1: boolean; @@ -3445,7 +3472,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Here" | "X1" | "X2" | "X3" | "X4" | "X5" | "X6" | "X7" | "X8"; } - /** @name XcmV2Junction (303) */ + /** @name XcmV2Junction (306) */ interface XcmV2Junction extends Enum { readonly isParachain: boolean; readonly asParachain: Compact; @@ -3488,7 +3515,7 @@ declare module "@polkadot/types/lookup" { | "Plurality"; } - /** @name XcmV2NetworkId (304) */ + /** @name XcmV2NetworkId (307) */ interface XcmV2NetworkId extends Enum { readonly isAny: boolean; readonly isNamed: boolean; @@ -3498,7 +3525,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Any" | "Named" | "Polkadot" | "Kusama"; } - /** @name XcmV2BodyId (306) */ + /** @name XcmV2BodyId (309) */ interface XcmV2BodyId extends Enum { readonly isUnit: boolean; readonly isNamed: boolean; @@ -3525,7 +3552,7 @@ declare module "@polkadot/types/lookup" { | "Treasury"; } - /** @name XcmV2BodyPart (307) */ + /** @name XcmV2BodyPart (310) */ interface XcmV2BodyPart extends Enum { readonly isVoice: boolean; readonly isMembers: boolean; @@ -3550,13 +3577,13 @@ declare module "@polkadot/types/lookup" { readonly type: "Voice" | "Members" | "Fraction" | "AtLeastProportion" | "MoreThanProportion"; } - /** @name StagingXcmV3MultiLocation (308) */ + /** @name StagingXcmV3MultiLocation (311) */ interface StagingXcmV3MultiLocation extends Struct { readonly parents: u8; readonly interior: XcmV3Junctions; } - /** @name XcmV3Junctions (309) */ + /** @name XcmV3Junctions (312) */ interface XcmV3Junctions extends Enum { readonly isHere: boolean; readonly isX1: boolean; @@ -3593,7 +3620,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Here" | "X1" | "X2" | "X3" | "X4" | "X5" | "X6" | "X7" | "X8"; } - /** @name XcmV3Junction (310) */ + /** @name XcmV3Junction (313) */ interface XcmV3Junction extends Enum { readonly isParachain: boolean; readonly asParachain: Compact; @@ -3642,7 +3669,7 @@ declare module "@polkadot/types/lookup" { | "GlobalConsensus"; } - /** @name XcmV3JunctionNetworkId (312) */ + /** @name XcmV3JunctionNetworkId (315) */ interface XcmV3JunctionNetworkId extends Enum { readonly isByGenesis: boolean; readonly asByGenesis: U8aFixed; @@ -3677,7 +3704,7 @@ declare module "@polkadot/types/lookup" { | "PolkadotBulletin"; } - /** @name XcmVersionedXcm (313) */ + /** @name XcmVersionedXcm (316) */ interface XcmVersionedXcm extends Enum { readonly isV2: boolean; readonly asV2: XcmV2Xcm; @@ -3688,10 +3715,10 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name XcmV2Xcm (314) */ + /** @name XcmV2Xcm (317) */ interface XcmV2Xcm extends Vec {} - /** @name XcmV2Instruction (316) */ + /** @name XcmV2Instruction (319) */ interface XcmV2Instruction extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: XcmV2MultiassetMultiAssets; @@ -3839,16 +3866,16 @@ declare module "@polkadot/types/lookup" { | "UnsubscribeVersion"; } - /** @name XcmV2MultiassetMultiAssets (317) */ + /** @name XcmV2MultiassetMultiAssets (320) */ interface XcmV2MultiassetMultiAssets extends Vec {} - /** @name XcmV2MultiAsset (319) */ + /** @name XcmV2MultiAsset (322) */ interface XcmV2MultiAsset extends Struct { readonly id: XcmV2MultiassetAssetId; readonly fun: XcmV2MultiassetFungibility; } - /** @name XcmV2MultiassetAssetId (320) */ + /** @name XcmV2MultiassetAssetId (323) */ interface XcmV2MultiassetAssetId extends Enum { readonly isConcrete: boolean; readonly asConcrete: XcmV2MultiLocation; @@ -3857,7 +3884,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Concrete" | "Abstract"; } - /** @name XcmV2MultiassetFungibility (321) */ + /** @name XcmV2MultiassetFungibility (324) */ interface XcmV2MultiassetFungibility extends Enum { readonly isFungible: boolean; readonly asFungible: Compact; @@ -3866,7 +3893,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV2MultiassetAssetInstance (322) */ + /** @name XcmV2MultiassetAssetInstance (325) */ interface XcmV2MultiassetAssetInstance extends Enum { readonly isUndefined: boolean; readonly isIndex: boolean; @@ -3884,7 +3911,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Undefined" | "Index" | "Array4" | "Array8" | "Array16" | "Array32" | "Blob"; } - /** @name XcmV2Response (323) */ + /** @name XcmV2Response (326) */ interface XcmV2Response extends Enum { readonly isNull: boolean; readonly isAssets: boolean; @@ -3896,7 +3923,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Null" | "Assets" | "ExecutionResult" | "Version"; } - /** @name XcmV2TraitsError (326) */ + /** @name XcmV2TraitsError (329) */ interface XcmV2TraitsError extends Enum { readonly isOverflow: boolean; readonly isUnimplemented: boolean; @@ -3955,7 +3982,7 @@ declare module "@polkadot/types/lookup" { | "WeightNotComputable"; } - /** @name XcmV2OriginKind (327) */ + /** @name XcmV2OriginKind (330) */ interface XcmV2OriginKind extends Enum { readonly isNative: boolean; readonly isSovereignAccount: boolean; @@ -3964,12 +3991,12 @@ declare module "@polkadot/types/lookup" { readonly type: "Native" | "SovereignAccount" | "Superuser" | "Xcm"; } - /** @name XcmDoubleEncoded (328) */ + /** @name XcmDoubleEncoded (331) */ interface XcmDoubleEncoded extends Struct { readonly encoded: Bytes; } - /** @name XcmV2MultiassetMultiAssetFilter (329) */ + /** @name XcmV2MultiassetMultiAssetFilter (332) */ interface XcmV2MultiassetMultiAssetFilter extends Enum { readonly isDefinite: boolean; readonly asDefinite: XcmV2MultiassetMultiAssets; @@ -3978,7 +4005,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Definite" | "Wild"; } - /** @name XcmV2MultiassetWildMultiAsset (330) */ + /** @name XcmV2MultiassetWildMultiAsset (333) */ interface XcmV2MultiassetWildMultiAsset extends Enum { readonly isAll: boolean; readonly isAllOf: boolean; @@ -3989,14 +4016,14 @@ declare module "@polkadot/types/lookup" { readonly type: "All" | "AllOf"; } - /** @name XcmV2MultiassetWildFungibility (331) */ + /** @name XcmV2MultiassetWildFungibility (334) */ interface XcmV2MultiassetWildFungibility extends Enum { readonly isFungible: boolean; readonly isNonFungible: boolean; readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV2WeightLimit (332) */ + /** @name XcmV2WeightLimit (335) */ interface XcmV2WeightLimit extends Enum { readonly isUnlimited: boolean; readonly isLimited: boolean; @@ -4004,10 +4031,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Unlimited" | "Limited"; } - /** @name XcmV3Xcm (333) */ + /** @name XcmV3Xcm (336) */ interface XcmV3Xcm extends Vec {} - /** @name XcmV3Instruction (335) */ + /** @name XcmV3Instruction (338) */ interface XcmV3Instruction extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: XcmV3MultiassetMultiAssets; @@ -4237,16 +4264,16 @@ declare module "@polkadot/types/lookup" { | "UnpaidExecution"; } - /** @name XcmV3MultiassetMultiAssets (336) */ + /** @name XcmV3MultiassetMultiAssets (339) */ interface XcmV3MultiassetMultiAssets extends Vec {} - /** @name XcmV3MultiAsset (338) */ + /** @name XcmV3MultiAsset (341) */ interface XcmV3MultiAsset extends Struct { readonly id: XcmV3MultiassetAssetId; readonly fun: XcmV3MultiassetFungibility; } - /** @name XcmV3MultiassetAssetId (339) */ + /** @name XcmV3MultiassetAssetId (342) */ interface XcmV3MultiassetAssetId extends Enum { readonly isConcrete: boolean; readonly asConcrete: StagingXcmV3MultiLocation; @@ -4255,7 +4282,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Concrete" | "Abstract"; } - /** @name XcmV3MultiassetFungibility (340) */ + /** @name XcmV3MultiassetFungibility (343) */ interface XcmV3MultiassetFungibility extends Enum { readonly isFungible: boolean; readonly asFungible: Compact; @@ -4264,7 +4291,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV3MultiassetAssetInstance (341) */ + /** @name XcmV3MultiassetAssetInstance (344) */ interface XcmV3MultiassetAssetInstance extends Enum { readonly isUndefined: boolean; readonly isIndex: boolean; @@ -4280,7 +4307,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Undefined" | "Index" | "Array4" | "Array8" | "Array16" | "Array32"; } - /** @name XcmV3Response (342) */ + /** @name XcmV3Response (345) */ interface XcmV3Response extends Enum { readonly isNull: boolean; readonly isAssets: boolean; @@ -4296,7 +4323,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Null" | "Assets" | "ExecutionResult" | "Version" | "PalletsInfo" | "DispatchResult"; } - /** @name XcmV3TraitsError (345) */ + /** @name XcmV3TraitsError (348) */ interface XcmV3TraitsError extends Enum { readonly isOverflow: boolean; readonly isUnimplemented: boolean; @@ -4383,7 +4410,7 @@ declare module "@polkadot/types/lookup" { | "ExceedsStackLimit"; } - /** @name XcmV3PalletInfo (347) */ + /** @name XcmV3PalletInfo (350) */ interface XcmV3PalletInfo extends Struct { readonly index: Compact; readonly name: Bytes; @@ -4393,7 +4420,7 @@ declare module "@polkadot/types/lookup" { readonly patch: Compact; } - /** @name XcmV3MaybeErrorCode (350) */ + /** @name XcmV3MaybeErrorCode (353) */ interface XcmV3MaybeErrorCode extends Enum { readonly isSuccess: boolean; readonly isError: boolean; @@ -4403,7 +4430,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Success" | "Error" | "TruncatedError"; } - /** @name XcmV3OriginKind (353) */ + /** @name XcmV3OriginKind (356) */ interface XcmV3OriginKind extends Enum { readonly isNative: boolean; readonly isSovereignAccount: boolean; @@ -4412,14 +4439,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Native" | "SovereignAccount" | "Superuser" | "Xcm"; } - /** @name XcmV3QueryResponseInfo (354) */ + /** @name XcmV3QueryResponseInfo (357) */ interface XcmV3QueryResponseInfo extends Struct { readonly destination: StagingXcmV3MultiLocation; readonly queryId: Compact; readonly maxWeight: SpWeightsWeightV2Weight; } - /** @name XcmV3MultiassetMultiAssetFilter (355) */ + /** @name XcmV3MultiassetMultiAssetFilter (358) */ interface XcmV3MultiassetMultiAssetFilter extends Enum { readonly isDefinite: boolean; readonly asDefinite: XcmV3MultiassetMultiAssets; @@ -4428,7 +4455,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Definite" | "Wild"; } - /** @name XcmV3MultiassetWildMultiAsset (356) */ + /** @name XcmV3MultiassetWildMultiAsset (359) */ interface XcmV3MultiassetWildMultiAsset extends Enum { readonly isAll: boolean; readonly isAllOf: boolean; @@ -4447,14 +4474,14 @@ declare module "@polkadot/types/lookup" { readonly type: "All" | "AllOf" | "AllCounted" | "AllOfCounted"; } - /** @name XcmV3MultiassetWildFungibility (357) */ + /** @name XcmV3MultiassetWildFungibility (360) */ interface XcmV3MultiassetWildFungibility extends Enum { readonly isFungible: boolean; readonly isNonFungible: boolean; readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV3WeightLimit (358) */ + /** @name XcmV3WeightLimit (361) */ interface XcmV3WeightLimit extends Enum { readonly isUnlimited: boolean; readonly isLimited: boolean; @@ -4462,10 +4489,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Unlimited" | "Limited"; } - /** @name StagingXcmV4Xcm (359) */ + /** @name StagingXcmV4Xcm (362) */ interface StagingXcmV4Xcm extends Vec {} - /** @name StagingXcmV4Instruction (361) */ + /** @name StagingXcmV4Instruction (364) */ interface StagingXcmV4Instruction extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: StagingXcmV4AssetAssets; @@ -4695,19 +4722,19 @@ declare module "@polkadot/types/lookup" { | "UnpaidExecution"; } - /** @name StagingXcmV4AssetAssets (362) */ + /** @name StagingXcmV4AssetAssets (365) */ interface StagingXcmV4AssetAssets extends Vec {} - /** @name StagingXcmV4Asset (364) */ + /** @name StagingXcmV4Asset (367) */ interface StagingXcmV4Asset extends Struct { readonly id: StagingXcmV4AssetAssetId; readonly fun: StagingXcmV4AssetFungibility; } - /** @name StagingXcmV4AssetAssetId (365) */ + /** @name StagingXcmV4AssetAssetId (368) */ interface StagingXcmV4AssetAssetId extends StagingXcmV4Location {} - /** @name StagingXcmV4AssetFungibility (366) */ + /** @name StagingXcmV4AssetFungibility (369) */ interface StagingXcmV4AssetFungibility extends Enum { readonly isFungible: boolean; readonly asFungible: Compact; @@ -4716,7 +4743,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Fungible" | "NonFungible"; } - /** @name StagingXcmV4AssetAssetInstance (367) */ + /** @name StagingXcmV4AssetAssetInstance (370) */ interface StagingXcmV4AssetAssetInstance extends Enum { readonly isUndefined: boolean; readonly isIndex: boolean; @@ -4732,7 +4759,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Undefined" | "Index" | "Array4" | "Array8" | "Array16" | "Array32"; } - /** @name StagingXcmV4Response (368) */ + /** @name StagingXcmV4Response (371) */ interface StagingXcmV4Response extends Enum { readonly isNull: boolean; readonly isAssets: boolean; @@ -4748,7 +4775,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Null" | "Assets" | "ExecutionResult" | "Version" | "PalletsInfo" | "DispatchResult"; } - /** @name StagingXcmV4PalletInfo (370) */ + /** @name StagingXcmV4PalletInfo (373) */ interface StagingXcmV4PalletInfo extends Struct { readonly index: Compact; readonly name: Bytes; @@ -4758,14 +4785,14 @@ declare module "@polkadot/types/lookup" { readonly patch: Compact; } - /** @name StagingXcmV4QueryResponseInfo (374) */ + /** @name StagingXcmV4QueryResponseInfo (377) */ interface StagingXcmV4QueryResponseInfo extends Struct { readonly destination: StagingXcmV4Location; readonly queryId: Compact; readonly maxWeight: SpWeightsWeightV2Weight; } - /** @name StagingXcmV4AssetAssetFilter (375) */ + /** @name StagingXcmV4AssetAssetFilter (378) */ interface StagingXcmV4AssetAssetFilter extends Enum { readonly isDefinite: boolean; readonly asDefinite: StagingXcmV4AssetAssets; @@ -4774,7 +4801,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Definite" | "Wild"; } - /** @name StagingXcmV4AssetWildAsset (376) */ + /** @name StagingXcmV4AssetWildAsset (379) */ interface StagingXcmV4AssetWildAsset extends Enum { readonly isAll: boolean; readonly isAllOf: boolean; @@ -4793,14 +4820,14 @@ declare module "@polkadot/types/lookup" { readonly type: "All" | "AllOf" | "AllCounted" | "AllOfCounted"; } - /** @name StagingXcmV4AssetWildFungibility (377) */ + /** @name StagingXcmV4AssetWildFungibility (380) */ interface StagingXcmV4AssetWildFungibility extends Enum { readonly isFungible: boolean; readonly isNonFungible: boolean; readonly type: "Fungible" | "NonFungible"; } - /** @name XcmVersionedAssets (378) */ + /** @name XcmVersionedAssets (381) */ interface XcmVersionedAssets extends Enum { readonly isV2: boolean; readonly asV2: XcmV2MultiassetMultiAssets; @@ -4811,7 +4838,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name StagingXcmExecutorAssetTransferTransferType (390) */ + /** @name StagingXcmExecutorAssetTransferTransferType (393) */ interface StagingXcmExecutorAssetTransferTransferType extends Enum { readonly isTeleport: boolean; readonly isLocalReserve: boolean; @@ -4821,7 +4848,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Teleport" | "LocalReserve" | "DestinationReserve" | "RemoteReserve"; } - /** @name XcmVersionedAssetId (391) */ + /** @name XcmVersionedAssetId (394) */ interface XcmVersionedAssetId extends Enum { readonly isV3: boolean; readonly asV3: XcmV3MultiassetAssetId; @@ -4830,7 +4857,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V3" | "V4"; } - /** @name PalletMigrationsCall (392) */ + /** @name PalletMigrationsCall (395) */ interface PalletMigrationsCall extends Enum { readonly isForceSetCursor: boolean; readonly asForceSetCursor: { @@ -4850,7 +4877,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ForceSetCursor" | "ForceSetActiveCursor" | "ForceOnboardMbms" | "ClearHistoric"; } - /** @name PalletMigrationsMigrationCursor (394) */ + /** @name PalletMigrationsMigrationCursor (397) */ interface PalletMigrationsMigrationCursor extends Enum { readonly isActive: boolean; readonly asActive: PalletMigrationsActiveCursor; @@ -4858,14 +4885,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Active" | "Stuck"; } - /** @name PalletMigrationsActiveCursor (396) */ + /** @name PalletMigrationsActiveCursor (399) */ interface PalletMigrationsActiveCursor extends Struct { readonly index: u32; readonly innerCursor: Option; readonly startedAt: u32; } - /** @name PalletMigrationsHistoricCleanupSelector (398) */ + /** @name PalletMigrationsHistoricCleanupSelector (401) */ interface PalletMigrationsHistoricCleanupSelector extends Enum { readonly isSpecific: boolean; readonly asSpecific: Vec; @@ -4877,7 +4904,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Specific" | "Wildcard"; } - /** @name PalletBeefyCall (401) */ + /** @name PalletBeefyCall (404) */ interface PalletBeefyCall extends Enum { readonly isReportDoubleVoting: boolean; readonly asReportDoubleVoting: { @@ -4923,40 +4950,40 @@ declare module "@polkadot/types/lookup" { | "ReportFutureBlockVotingUnsigned"; } - /** @name SpConsensusBeefyDoubleVotingProof (402) */ + /** @name SpConsensusBeefyDoubleVotingProof (405) */ interface SpConsensusBeefyDoubleVotingProof extends Struct { readonly first: SpConsensusBeefyVoteMessage; readonly second: SpConsensusBeefyVoteMessage; } - /** @name SpConsensusBeefyEcdsaCryptoSignature (403) */ + /** @name SpConsensusBeefyEcdsaCryptoSignature (406) */ interface SpConsensusBeefyEcdsaCryptoSignature extends U8aFixed {} - /** @name SpConsensusBeefyVoteMessage (404) */ + /** @name SpConsensusBeefyVoteMessage (407) */ interface SpConsensusBeefyVoteMessage extends Struct { readonly commitment: SpConsensusBeefyCommitment; readonly id: SpConsensusBeefyEcdsaCryptoPublic; readonly signature: SpConsensusBeefyEcdsaCryptoSignature; } - /** @name SpConsensusBeefyCommitment (405) */ + /** @name SpConsensusBeefyCommitment (408) */ interface SpConsensusBeefyCommitment extends Struct { readonly payload: SpConsensusBeefyPayload; readonly blockNumber: u32; readonly validatorSetId: u64; } - /** @name SpConsensusBeefyPayload (406) */ + /** @name SpConsensusBeefyPayload (409) */ interface SpConsensusBeefyPayload extends Vec> {} - /** @name SpConsensusBeefyForkVotingProof (409) */ + /** @name SpConsensusBeefyForkVotingProof (412) */ interface SpConsensusBeefyForkVotingProof extends Struct { readonly vote: SpConsensusBeefyVoteMessage; readonly ancestryProof: SpMmrPrimitivesAncestryProof; readonly header: SpRuntimeHeader; } - /** @name SpMmrPrimitivesAncestryProof (410) */ + /** @name SpMmrPrimitivesAncestryProof (413) */ interface SpMmrPrimitivesAncestryProof extends Struct { readonly prevPeaks: Vec; readonly prevLeafCount: u64; @@ -4964,12 +4991,12 @@ declare module "@polkadot/types/lookup" { readonly items: Vec>; } - /** @name SpConsensusBeefyFutureBlockVotingProof (413) */ + /** @name SpConsensusBeefyFutureBlockVotingProof (416) */ interface SpConsensusBeefyFutureBlockVotingProof extends Struct { readonly vote: SpConsensusBeefyVoteMessage; } - /** @name SnowbridgePalletEthereumClientCall (414) */ + /** @name SnowbridgePalletEthereumClientCall (417) */ interface SnowbridgePalletEthereumClientCall extends Enum { readonly isForceCheckpoint: boolean; readonly asForceCheckpoint: { @@ -4986,7 +5013,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ForceCheckpoint" | "Submit" | "SetOperatingMode"; } - /** @name SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate (415) */ + /** @name SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate (418) */ interface SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate extends Struct { readonly header: SnowbridgeBeaconPrimitivesBeaconHeader; readonly currentSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; @@ -4996,7 +5023,7 @@ declare module "@polkadot/types/lookup" { readonly blockRootsBranch: Vec; } - /** @name SnowbridgeBeaconPrimitivesBeaconHeader (416) */ + /** @name SnowbridgeBeaconPrimitivesBeaconHeader (419) */ interface SnowbridgeBeaconPrimitivesBeaconHeader extends Struct { readonly slot: u64; readonly proposerIndex: u64; @@ -5005,16 +5032,16 @@ declare module "@polkadot/types/lookup" { readonly bodyRoot: H256; } - /** @name SnowbridgeBeaconPrimitivesSyncCommittee (417) */ + /** @name SnowbridgeBeaconPrimitivesSyncCommittee (420) */ interface SnowbridgeBeaconPrimitivesSyncCommittee extends Struct { readonly pubkeys: Vec; readonly aggregatePubkey: SnowbridgeBeaconPrimitivesPublicKey; } - /** @name SnowbridgeBeaconPrimitivesPublicKey (419) */ + /** @name SnowbridgeBeaconPrimitivesPublicKey (422) */ interface SnowbridgeBeaconPrimitivesPublicKey extends U8aFixed {} - /** @name SnowbridgeBeaconPrimitivesUpdatesUpdate (421) */ + /** @name SnowbridgeBeaconPrimitivesUpdatesUpdate (424) */ interface SnowbridgeBeaconPrimitivesUpdatesUpdate extends Struct { readonly attestedHeader: SnowbridgeBeaconPrimitivesBeaconHeader; readonly syncAggregate: SnowbridgeBeaconPrimitivesSyncAggregate; @@ -5026,29 +5053,29 @@ declare module "@polkadot/types/lookup" { readonly blockRootsBranch: Vec; } - /** @name SnowbridgeBeaconPrimitivesSyncAggregate (422) */ + /** @name SnowbridgeBeaconPrimitivesSyncAggregate (425) */ interface SnowbridgeBeaconPrimitivesSyncAggregate extends Struct { readonly syncCommitteeBits: U8aFixed; readonly syncCommitteeSignature: SnowbridgeBeaconPrimitivesSignature; } - /** @name SnowbridgeBeaconPrimitivesSignature (423) */ + /** @name SnowbridgeBeaconPrimitivesSignature (426) */ interface SnowbridgeBeaconPrimitivesSignature extends U8aFixed {} - /** @name SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate (426) */ + /** @name SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate (429) */ interface SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate extends Struct { readonly nextSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; readonly nextSyncCommitteeBranch: Vec; } - /** @name SnowbridgeCoreOperatingModeBasicOperatingMode (427) */ + /** @name SnowbridgeCoreOperatingModeBasicOperatingMode (430) */ interface SnowbridgeCoreOperatingModeBasicOperatingMode extends Enum { readonly isNormal: boolean; readonly isHalted: boolean; readonly type: "Normal" | "Halted"; } - /** @name PolkadotRuntimeCommonParasSudoWrapperPalletCall (428) */ + /** @name PolkadotRuntimeCommonParasSudoWrapperPalletCall (431) */ interface PolkadotRuntimeCommonParasSudoWrapperPalletCall extends Enum { readonly isSudoScheduleParaInitialize: boolean; readonly asSudoScheduleParaInitialize: { @@ -5088,14 +5115,14 @@ declare module "@polkadot/types/lookup" { | "SudoEstablishHrmpChannel"; } - /** @name PolkadotRuntimeParachainsParasParaGenesisArgs (429) */ + /** @name PolkadotRuntimeParachainsParasParaGenesisArgs (432) */ interface PolkadotRuntimeParachainsParasParaGenesisArgs extends Struct { readonly genesisHead: Bytes; readonly validationCode: Bytes; readonly paraKind: bool; } - /** @name PalletRootTestingCall (430) */ + /** @name PalletRootTestingCall (433) */ interface PalletRootTestingCall extends Enum { readonly isFillBlock: boolean; readonly asFillBlock: { @@ -5105,7 +5132,7 @@ declare module "@polkadot/types/lookup" { readonly type: "FillBlock" | "TriggerDefensive"; } - /** @name PalletSudoCall (431) */ + /** @name PalletSudoCall (434) */ interface PalletSudoCall extends Enum { readonly isSudo: boolean; readonly asSudo: { @@ -5129,17 +5156,17 @@ declare module "@polkadot/types/lookup" { readonly type: "Sudo" | "SudoUncheckedWeight" | "SetKey" | "SudoAs" | "RemoveKey"; } - /** @name SpRuntimeBlakeTwo256 (432) */ + /** @name SpRuntimeBlakeTwo256 (435) */ type SpRuntimeBlakeTwo256 = Null; - /** @name PalletConvictionVotingTally (434) */ + /** @name PalletConvictionVotingTally (437) */ interface PalletConvictionVotingTally extends Struct { readonly ayes: u128; readonly nays: u128; readonly support: u128; } - /** @name PalletRankedCollectiveEvent (435) */ + /** @name PalletRankedCollectiveEvent (438) */ interface PalletRankedCollectiveEvent extends Enum { readonly isMemberAdded: boolean; readonly asMemberAdded: { @@ -5170,7 +5197,7 @@ declare module "@polkadot/types/lookup" { readonly type: "MemberAdded" | "RankChanged" | "MemberRemoved" | "Voted" | "MemberExchanged"; } - /** @name PalletRankedCollectiveVoteRecord (436) */ + /** @name PalletRankedCollectiveVoteRecord (439) */ interface PalletRankedCollectiveVoteRecord extends Enum { readonly isAye: boolean; readonly asAye: u32; @@ -5179,14 +5206,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Aye" | "Nay"; } - /** @name PalletRankedCollectiveTally (437) */ + /** @name PalletRankedCollectiveTally (440) */ interface PalletRankedCollectiveTally extends Struct { readonly bareAyes: u32; readonly ayes: u32; readonly nays: u32; } - /** @name PalletWhitelistEvent (439) */ + /** @name PalletWhitelistEvent (442) */ interface PalletWhitelistEvent extends Enum { readonly isCallWhitelisted: boolean; readonly asCallWhitelisted: { @@ -5204,19 +5231,19 @@ declare module "@polkadot/types/lookup" { readonly type: "CallWhitelisted" | "WhitelistedCallRemoved" | "WhitelistedCallDispatched"; } - /** @name FrameSupportDispatchPostDispatchInfo (441) */ + /** @name FrameSupportDispatchPostDispatchInfo (444) */ interface FrameSupportDispatchPostDispatchInfo extends Struct { readonly actualWeight: Option; readonly paysFee: FrameSupportDispatchPays; } - /** @name SpRuntimeDispatchErrorWithPostInfo (443) */ + /** @name SpRuntimeDispatchErrorWithPostInfo (446) */ interface SpRuntimeDispatchErrorWithPostInfo extends Struct { readonly postInfo: FrameSupportDispatchPostDispatchInfo; readonly error: SpRuntimeDispatchError; } - /** @name PolkadotRuntimeParachainsInclusionPalletEvent (444) */ + /** @name PolkadotRuntimeParachainsInclusionPalletEvent (447) */ interface PolkadotRuntimeParachainsInclusionPalletEvent extends Enum { readonly isCandidateBacked: boolean; readonly asCandidateBacked: ITuple<[PolkadotPrimitivesV7CandidateReceipt, Bytes, u32, u32]>; @@ -5232,13 +5259,13 @@ declare module "@polkadot/types/lookup" { readonly type: "CandidateBacked" | "CandidateIncluded" | "CandidateTimedOut" | "UpwardMessagesReceived"; } - /** @name PolkadotPrimitivesV7CandidateReceipt (445) */ + /** @name PolkadotPrimitivesV7CandidateReceipt (448) */ interface PolkadotPrimitivesV7CandidateReceipt extends Struct { readonly descriptor: PolkadotPrimitivesV7CandidateDescriptor; readonly commitmentsHash: H256; } - /** @name PolkadotRuntimeParachainsParasPalletEvent (448) */ + /** @name PolkadotRuntimeParachainsParasPalletEvent (451) */ interface PolkadotRuntimeParachainsParasPalletEvent extends Enum { readonly isCurrentCodeUpdated: boolean; readonly asCurrentCodeUpdated: u32; @@ -5267,7 +5294,7 @@ declare module "@polkadot/types/lookup" { | "PvfCheckRejected"; } - /** @name PolkadotRuntimeParachainsHrmpPalletEvent (449) */ + /** @name PolkadotRuntimeParachainsHrmpPalletEvent (452) */ interface PolkadotRuntimeParachainsHrmpPalletEvent extends Enum { readonly isOpenChannelRequested: boolean; readonly asOpenChannelRequested: { @@ -5320,7 +5347,7 @@ declare module "@polkadot/types/lookup" { | "OpenChannelDepositsUpdated"; } - /** @name PolkadotRuntimeParachainsDisputesPalletEvent (450) */ + /** @name PolkadotRuntimeParachainsDisputesPalletEvent (453) */ interface PolkadotRuntimeParachainsDisputesPalletEvent extends Enum { readonly isDisputeInitiated: boolean; readonly asDisputeInitiated: ITuple<[H256, PolkadotRuntimeParachainsDisputesDisputeLocation]>; @@ -5331,21 +5358,21 @@ declare module "@polkadot/types/lookup" { readonly type: "DisputeInitiated" | "DisputeConcluded" | "Revert"; } - /** @name PolkadotRuntimeParachainsDisputesDisputeLocation (451) */ + /** @name PolkadotRuntimeParachainsDisputesDisputeLocation (454) */ interface PolkadotRuntimeParachainsDisputesDisputeLocation extends Enum { readonly isLocal: boolean; readonly isRemote: boolean; readonly type: "Local" | "Remote"; } - /** @name PolkadotRuntimeParachainsDisputesDisputeResult (452) */ + /** @name PolkadotRuntimeParachainsDisputesDisputeResult (455) */ interface PolkadotRuntimeParachainsDisputesDisputeResult extends Enum { readonly isValid: boolean; readonly isInvalid: boolean; readonly type: "Valid" | "Invalid"; } - /** @name PalletMessageQueueEvent (453) */ + /** @name PalletMessageQueueEvent (456) */ interface PalletMessageQueueEvent extends Enum { readonly isProcessingFailed: boolean; readonly asProcessingFailed: { @@ -5375,7 +5402,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ProcessingFailed" | "Processed" | "OverweightEnqueued" | "PageReaped"; } - /** @name FrameSupportMessagesProcessMessageError (454) */ + /** @name FrameSupportMessagesProcessMessageError (457) */ interface FrameSupportMessagesProcessMessageError extends Enum { readonly isBadFormat: boolean; readonly isCorrupt: boolean; @@ -5387,7 +5414,7 @@ declare module "@polkadot/types/lookup" { readonly type: "BadFormat" | "Corrupt" | "Unsupported" | "Overweight" | "Yield" | "StackLimitReached"; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletEvent (455) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletEvent (458) */ interface PolkadotRuntimeParachainsAssignerOnDemandPalletEvent extends Enum { readonly isOnDemandOrderPlaced: boolean; readonly asOnDemandOrderPlaced: { @@ -5402,7 +5429,7 @@ declare module "@polkadot/types/lookup" { readonly type: "OnDemandOrderPlaced" | "SpotPriceSet"; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletEvent (456) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletEvent (459) */ interface PolkadotRuntimeCommonParasRegistrarPalletEvent extends Enum { readonly isRegistered: boolean; readonly asRegistered: { @@ -5426,7 +5453,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Registered" | "Deregistered" | "Reserved" | "Swapped"; } - /** @name PalletUtilityEvent (457) */ + /** @name PalletUtilityEvent (460) */ interface PalletUtilityEvent extends Enum { readonly isBatchInterrupted: boolean; readonly asBatchInterrupted: { @@ -5453,7 +5480,7 @@ declare module "@polkadot/types/lookup" { | "DispatchedAs"; } - /** @name PalletIdentityEvent (459) */ + /** @name PalletIdentityEvent (462) */ interface PalletIdentityEvent extends Enum { readonly isIdentitySet: boolean; readonly asIdentitySet: { @@ -5559,7 +5586,7 @@ declare module "@polkadot/types/lookup" { | "DanglingUsernameRemoved"; } - /** @name PalletSchedulerEvent (460) */ + /** @name PalletSchedulerEvent (463) */ interface PalletSchedulerEvent extends Enum { readonly isScheduled: boolean; readonly asScheduled: { @@ -5621,7 +5648,7 @@ declare module "@polkadot/types/lookup" { | "PermanentlyOverweight"; } - /** @name PalletProxyEvent (462) */ + /** @name PalletProxyEvent (465) */ interface PalletProxyEvent extends Enum { readonly isProxyExecuted: boolean; readonly asProxyExecuted: { @@ -5657,7 +5684,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ProxyExecuted" | "PureCreated" | "Announced" | "ProxyAdded" | "ProxyRemoved"; } - /** @name PalletMultisigEvent (463) */ + /** @name PalletMultisigEvent (466) */ interface PalletMultisigEvent extends Enum { readonly isNewMultisig: boolean; readonly asNewMultisig: { @@ -5690,7 +5717,7 @@ declare module "@polkadot/types/lookup" { readonly type: "NewMultisig" | "MultisigApproval" | "MultisigExecuted" | "MultisigCancelled"; } - /** @name PalletPreimageEvent (464) */ + /** @name PalletPreimageEvent (467) */ interface PalletPreimageEvent extends Enum { readonly isNoted: boolean; readonly asNoted: { @@ -5707,7 +5734,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Noted" | "Requested" | "Cleared"; } - /** @name PalletAssetRateEvent (465) */ + /** @name PalletAssetRateEvent (468) */ interface PalletAssetRateEvent extends Enum { readonly isAssetRateCreated: boolean; readonly asAssetRateCreated: { @@ -5727,7 +5754,7 @@ declare module "@polkadot/types/lookup" { readonly type: "AssetRateCreated" | "AssetRateRemoved" | "AssetRateUpdated"; } - /** @name PalletXcmEvent (466) */ + /** @name PalletXcmEvent (469) */ interface PalletXcmEvent extends Enum { readonly isAttempted: boolean; readonly asAttempted: { @@ -5892,7 +5919,7 @@ declare module "@polkadot/types/lookup" { | "VersionMigrationFinished"; } - /** @name StagingXcmV4TraitsOutcome (467) */ + /** @name StagingXcmV4TraitsOutcome (470) */ interface StagingXcmV4TraitsOutcome extends Enum { readonly isComplete: boolean; readonly asComplete: { @@ -5910,7 +5937,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Complete" | "Incomplete" | "Error"; } - /** @name PalletMigrationsEvent (468) */ + /** @name PalletMigrationsEvent (471) */ interface PalletMigrationsEvent extends Enum { readonly isRuntimeUpgradeStarted: boolean; readonly isRuntimeUpgradeCompleted: boolean; @@ -5943,7 +5970,7 @@ declare module "@polkadot/types/lookup" { | "FailedToResumeIdleXcmExecution"; } - /** @name SnowbridgePalletEthereumClientEvent (470) */ + /** @name SnowbridgePalletEthereumClientEvent (473) */ interface SnowbridgePalletEthereumClientEvent extends Enum { readonly isBeaconHeaderImported: boolean; readonly asBeaconHeaderImported: { @@ -5961,13 +5988,13 @@ declare module "@polkadot/types/lookup" { readonly type: "BeaconHeaderImported" | "SyncCommitteeUpdated" | "OperatingModeChanged"; } - /** @name PalletRootTestingEvent (471) */ + /** @name PalletRootTestingEvent (474) */ interface PalletRootTestingEvent extends Enum { readonly isDefensiveTestCall: boolean; readonly type: "DefensiveTestCall"; } - /** @name PalletSudoEvent (472) */ + /** @name PalletSudoEvent (475) */ interface PalletSudoEvent extends Enum { readonly isSudid: boolean; readonly asSudid: { @@ -5986,7 +6013,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Sudid" | "KeyChanged" | "KeyRemoved" | "SudoAsDone"; } - /** @name FrameSystemPhase (473) */ + /** @name FrameSystemPhase (476) */ interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -5995,33 +6022,33 @@ declare module "@polkadot/types/lookup" { readonly type: "ApplyExtrinsic" | "Finalization" | "Initialization"; } - /** @name FrameSystemLastRuntimeUpgradeInfo (475) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (478) */ interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemCodeUpgradeAuthorization (477) */ + /** @name FrameSystemCodeUpgradeAuthorization (480) */ interface FrameSystemCodeUpgradeAuthorization extends Struct { readonly codeHash: H256; readonly checkVersion: bool; } - /** @name FrameSystemLimitsBlockWeights (478) */ + /** @name FrameSystemLimitsBlockWeights (481) */ interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: SpWeightsWeightV2Weight; readonly maxBlock: SpWeightsWeightV2Weight; readonly perClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; } - /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (479) */ + /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (482) */ interface FrameSupportDispatchPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (480) */ + /** @name FrameSystemLimitsWeightsPerClass (483) */ interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: SpWeightsWeightV2Weight; readonly maxExtrinsic: Option; @@ -6029,25 +6056,25 @@ declare module "@polkadot/types/lookup" { readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (481) */ + /** @name FrameSystemLimitsBlockLength (484) */ interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportDispatchPerDispatchClassU32; } - /** @name FrameSupportDispatchPerDispatchClassU32 (482) */ + /** @name FrameSupportDispatchPerDispatchClassU32 (485) */ interface FrameSupportDispatchPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name SpWeightsRuntimeDbWeight (483) */ + /** @name SpWeightsRuntimeDbWeight (486) */ interface SpWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (484) */ + /** @name SpVersionRuntimeVersion (487) */ interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -6059,7 +6086,7 @@ declare module "@polkadot/types/lookup" { readonly stateVersion: u8; } - /** @name FrameSystemError (488) */ + /** @name FrameSystemError (491) */ interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -6082,7 +6109,7 @@ declare module "@polkadot/types/lookup" { | "Unauthorized"; } - /** @name SpConsensusBabeDigestsPreDigest (495) */ + /** @name SpConsensusBabeDigestsPreDigest (498) */ interface SpConsensusBabeDigestsPreDigest extends Enum { readonly isPrimary: boolean; readonly asPrimary: SpConsensusBabeDigestsPrimaryPreDigest; @@ -6093,39 +6120,39 @@ declare module "@polkadot/types/lookup" { readonly type: "Primary" | "SecondaryPlain" | "SecondaryVRF"; } - /** @name SpConsensusBabeDigestsPrimaryPreDigest (496) */ + /** @name SpConsensusBabeDigestsPrimaryPreDigest (499) */ interface SpConsensusBabeDigestsPrimaryPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; readonly vrfSignature: SpCoreSr25519VrfVrfSignature; } - /** @name SpCoreSr25519VrfVrfSignature (497) */ + /** @name SpCoreSr25519VrfVrfSignature (500) */ interface SpCoreSr25519VrfVrfSignature extends Struct { readonly preOutput: U8aFixed; readonly proof: U8aFixed; } - /** @name SpConsensusBabeDigestsSecondaryPlainPreDigest (498) */ + /** @name SpConsensusBabeDigestsSecondaryPlainPreDigest (501) */ interface SpConsensusBabeDigestsSecondaryPlainPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; } - /** @name SpConsensusBabeDigestsSecondaryVRFPreDigest (499) */ + /** @name SpConsensusBabeDigestsSecondaryVRFPreDigest (502) */ interface SpConsensusBabeDigestsSecondaryVRFPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; readonly vrfSignature: SpCoreSr25519VrfVrfSignature; } - /** @name SpConsensusBabeBabeEpochConfiguration (500) */ + /** @name SpConsensusBabeBabeEpochConfiguration (503) */ interface SpConsensusBabeBabeEpochConfiguration extends Struct { readonly c: ITuple<[u64, u64]>; readonly allowedSlots: SpConsensusBabeAllowedSlots; } - /** @name PalletBabeError (504) */ + /** @name PalletBabeError (507) */ interface PalletBabeError extends Enum { readonly isInvalidEquivocationProof: boolean; readonly isInvalidKeyOwnershipProof: boolean; @@ -6138,14 +6165,14 @@ declare module "@polkadot/types/lookup" { | "InvalidConfiguration"; } - /** @name PalletBalancesBalanceLock (506) */ + /** @name PalletBalancesBalanceLock (509) */ interface PalletBalancesBalanceLock extends Struct { readonly id: U8aFixed; readonly amount: u128; readonly reasons: PalletBalancesReasons; } - /** @name PalletBalancesReasons (507) */ + /** @name PalletBalancesReasons (510) */ interface PalletBalancesReasons extends Enum { readonly isFee: boolean; readonly isMisc: boolean; @@ -6153,13 +6180,13 @@ declare module "@polkadot/types/lookup" { readonly type: "Fee" | "Misc" | "All"; } - /** @name PalletBalancesReserveData (510) */ + /** @name PalletBalancesReserveData (513) */ interface PalletBalancesReserveData extends Struct { readonly id: U8aFixed; readonly amount: u128; } - /** @name DancelightRuntimeRuntimeHoldReason (514) */ + /** @name DancelightRuntimeRuntimeHoldReason (517) */ interface DancelightRuntimeRuntimeHoldReason extends Enum { readonly isContainerRegistrar: boolean; readonly asContainerRegistrar: PalletRegistrarHoldReason; @@ -6170,31 +6197,31 @@ declare module "@polkadot/types/lookup" { readonly type: "ContainerRegistrar" | "DataPreservers" | "Preimage"; } - /** @name PalletRegistrarHoldReason (515) */ + /** @name PalletRegistrarHoldReason (518) */ interface PalletRegistrarHoldReason extends Enum { readonly isRegistrarDeposit: boolean; readonly type: "RegistrarDeposit"; } - /** @name PalletDataPreserversHoldReason (516) */ + /** @name PalletDataPreserversHoldReason (519) */ interface PalletDataPreserversHoldReason extends Enum { readonly isProfileDeposit: boolean; readonly type: "ProfileDeposit"; } - /** @name PalletPreimageHoldReason (517) */ + /** @name PalletPreimageHoldReason (520) */ interface PalletPreimageHoldReason extends Enum { readonly isPreimage: boolean; readonly type: "Preimage"; } - /** @name FrameSupportTokensMiscIdAmount (520) */ + /** @name FrameSupportTokensMiscIdAmount (523) */ interface FrameSupportTokensMiscIdAmount extends Struct { readonly id: Null; readonly amount: u128; } - /** @name PalletBalancesError (522) */ + /** @name PalletBalancesError (525) */ interface PalletBalancesError extends Enum { readonly isVestingBalance: boolean; readonly isLiquidityRestrictions: boolean; @@ -6223,26 +6250,26 @@ declare module "@polkadot/types/lookup" { | "DeltaZero"; } - /** @name PalletTransactionPaymentReleases (523) */ + /** @name PalletTransactionPaymentReleases (526) */ interface PalletTransactionPaymentReleases extends Enum { readonly isV1Ancient: boolean; readonly isV2: boolean; readonly type: "V1Ancient" | "V2"; } - /** @name SpStakingOffenceOffenceDetails (524) */ + /** @name SpStakingOffenceOffenceDetails (527) */ interface SpStakingOffenceOffenceDetails extends Struct { readonly offender: ITuple<[AccountId32, Null]>; readonly reporters: Vec; } - /** @name PalletRegistrarDepositInfo (536) */ + /** @name PalletRegistrarDepositInfo (539) */ interface PalletRegistrarDepositInfo extends Struct { readonly creator: AccountId32; readonly deposit: u128; } - /** @name PalletRegistrarError (537) */ + /** @name PalletRegistrarError (540) */ interface PalletRegistrarError extends Enum { readonly isParaIdAlreadyRegistered: boolean; readonly isParaIdNotRegistered: boolean; @@ -6281,7 +6308,7 @@ declare module "@polkadot/types/lookup" { | "WasmCodeNecessary"; } - /** @name PalletConfigurationHostConfiguration (538) */ + /** @name PalletConfigurationHostConfiguration (541) */ interface PalletConfigurationHostConfiguration extends Struct { readonly maxCollators: u32; readonly minOrchestratorCollators: u32; @@ -6294,13 +6321,13 @@ declare module "@polkadot/types/lookup" { readonly maxParachainCoresPercentage: Option; } - /** @name PalletConfigurationError (541) */ + /** @name PalletConfigurationError (544) */ interface PalletConfigurationError extends Enum { readonly isInvalidNewValue: boolean; readonly type: "InvalidNewValue"; } - /** @name PalletInvulnerablesError (543) */ + /** @name PalletInvulnerablesError (546) */ interface PalletInvulnerablesError extends Enum { readonly isTooManyInvulnerables: boolean; readonly isAlreadyInvulnerable: boolean; @@ -6315,26 +6342,26 @@ declare module "@polkadot/types/lookup" { | "UnableToDeriveCollatorId"; } - /** @name DpCollatorAssignmentAssignedCollatorsAccountId32 (544) */ + /** @name DpCollatorAssignmentAssignedCollatorsAccountId32 (547) */ interface DpCollatorAssignmentAssignedCollatorsAccountId32 extends Struct { readonly orchestratorChain: Vec; readonly containerChains: BTreeMap>; } - /** @name DpCollatorAssignmentAssignedCollatorsPublic (549) */ + /** @name DpCollatorAssignmentAssignedCollatorsPublic (552) */ interface DpCollatorAssignmentAssignedCollatorsPublic extends Struct { readonly orchestratorChain: Vec; readonly containerChains: BTreeMap>; } - /** @name TpTraitsContainerChainBlockInfo (557) */ + /** @name TpTraitsContainerChainBlockInfo (560) */ interface TpTraitsContainerChainBlockInfo extends Struct { readonly blockNumber: u32; readonly author: AccountId32; readonly latestSlotNumber: u64; } - /** @name PalletAuthorNotingError (558) */ + /** @name PalletAuthorNotingError (561) */ interface PalletAuthorNotingError extends Enum { readonly isFailedReading: boolean; readonly isFailedDecodingHeader: boolean; @@ -6353,7 +6380,7 @@ declare module "@polkadot/types/lookup" { | "NonAuraDigest"; } - /** @name PalletServicesPaymentError (559) */ + /** @name PalletServicesPaymentError (562) */ interface PalletServicesPaymentError extends Enum { readonly isInsufficientFundsToPurchaseCredits: boolean; readonly isInsufficientCredits: boolean; @@ -6361,7 +6388,7 @@ declare module "@polkadot/types/lookup" { readonly type: "InsufficientFundsToPurchaseCredits" | "InsufficientCredits" | "CreditPriceTooExpensive"; } - /** @name PalletDataPreserversRegisteredProfile (560) */ + /** @name PalletDataPreserversRegisteredProfile (563) */ interface PalletDataPreserversRegisteredProfile extends Struct { readonly account: AccountId32; readonly deposit: u128; @@ -6369,7 +6396,7 @@ declare module "@polkadot/types/lookup" { readonly assignment: Option>; } - /** @name PalletDataPreserversError (566) */ + /** @name PalletDataPreserversError (569) */ interface PalletDataPreserversError extends Enum { readonly isNoBootNodes: boolean; readonly isUnknownProfileId: boolean; @@ -6394,13 +6421,13 @@ declare module "@polkadot/types/lookup" { | "CantDeleteAssignedProfile"; } - /** @name TpTraitsActiveEraInfo (569) */ + /** @name TpTraitsActiveEraInfo (572) */ interface TpTraitsActiveEraInfo extends Struct { readonly index: u32; readonly start: Option; } - /** @name PalletExternalValidatorsError (571) */ + /** @name PalletExternalValidatorsError (574) */ interface PalletExternalValidatorsError extends Enum { readonly isTooManyWhitelisted: boolean; readonly isAlreadyWhitelisted: boolean; @@ -6415,10 +6442,38 @@ declare module "@polkadot/types/lookup" { | "UnableToDeriveValidatorId"; } - /** @name SpCoreCryptoKeyTypeId (576) */ + /** @name PalletExternalValidatorSlashesSlash (577) */ + interface PalletExternalValidatorSlashesSlash extends Struct { + readonly validator: AccountId32; + readonly reporters: Vec; + readonly slashId: u32; + readonly percentage: Perbill; + readonly confirmed: bool; + } + + /** @name PalletExternalValidatorSlashesError (578) */ + interface PalletExternalValidatorSlashesError extends Enum { + readonly isEmptyTargets: boolean; + readonly isInvalidSlashIndex: boolean; + readonly isNotSortedAndUnique: boolean; + readonly isProvidedFutureEra: boolean; + readonly isProvidedNonSlashableEra: boolean; + readonly isDeferPeriodIsOver: boolean; + readonly isErrorComputingSlash: boolean; + readonly type: + | "EmptyTargets" + | "InvalidSlashIndex" + | "NotSortedAndUnique" + | "ProvidedFutureEra" + | "ProvidedNonSlashableEra" + | "DeferPeriodIsOver" + | "ErrorComputingSlash"; + } + + /** @name SpCoreCryptoKeyTypeId (582) */ interface SpCoreCryptoKeyTypeId extends U8aFixed {} - /** @name PalletSessionError (577) */ + /** @name PalletSessionError (583) */ interface PalletSessionError extends Enum { readonly isInvalidProof: boolean; readonly isNoAssociatedValidatorId: boolean; @@ -6428,7 +6483,7 @@ declare module "@polkadot/types/lookup" { readonly type: "InvalidProof" | "NoAssociatedValidatorId" | "DuplicatedKey" | "NoKeys" | "NoAccount"; } - /** @name PalletGrandpaStoredState (578) */ + /** @name PalletGrandpaStoredState (584) */ interface PalletGrandpaStoredState extends Enum { readonly isLive: boolean; readonly isPendingPause: boolean; @@ -6445,7 +6500,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Live" | "PendingPause" | "Paused" | "PendingResume"; } - /** @name PalletGrandpaStoredPendingChange (579) */ + /** @name PalletGrandpaStoredPendingChange (585) */ interface PalletGrandpaStoredPendingChange extends Struct { readonly scheduledAt: u32; readonly delay: u32; @@ -6453,7 +6508,7 @@ declare module "@polkadot/types/lookup" { readonly forced: Option; } - /** @name PalletGrandpaError (581) */ + /** @name PalletGrandpaError (587) */ interface PalletGrandpaError extends Enum { readonly isPauseFailed: boolean; readonly isResumeFailed: boolean; @@ -6472,13 +6527,13 @@ declare module "@polkadot/types/lookup" { | "DuplicateOffenceReport"; } - /** @name PalletInflationRewardsChainsToRewardValue (584) */ + /** @name PalletInflationRewardsChainsToRewardValue (590) */ interface PalletInflationRewardsChainsToRewardValue extends Struct { readonly paraIds: Vec; readonly rewardsPerChain: u128; } - /** @name PalletTreasuryProposal (585) */ + /** @name PalletTreasuryProposal (591) */ interface PalletTreasuryProposal extends Struct { readonly proposer: AccountId32; readonly value: u128; @@ -6486,7 +6541,7 @@ declare module "@polkadot/types/lookup" { readonly bond: u128; } - /** @name PalletTreasurySpendStatus (587) */ + /** @name PalletTreasurySpendStatus (593) */ interface PalletTreasurySpendStatus extends Struct { readonly assetKind: Null; readonly amount: u128; @@ -6496,7 +6551,7 @@ declare module "@polkadot/types/lookup" { readonly status: PalletTreasuryPaymentState; } - /** @name PalletTreasuryPaymentState (588) */ + /** @name PalletTreasuryPaymentState (594) */ interface PalletTreasuryPaymentState extends Enum { readonly isPending: boolean; readonly isAttempted: boolean; @@ -6507,10 +6562,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Pending" | "Attempted" | "Failed"; } - /** @name FrameSupportPalletId (590) */ + /** @name FrameSupportPalletId (596) */ interface FrameSupportPalletId extends U8aFixed {} - /** @name PalletTreasuryError (591) */ + /** @name PalletTreasuryError (597) */ interface PalletTreasuryError extends Enum { readonly isInvalidIndex: boolean; readonly isTooManyApprovals: boolean; @@ -6537,7 +6592,7 @@ declare module "@polkadot/types/lookup" { | "Inconclusive"; } - /** @name PalletConvictionVotingVoteVoting (593) */ + /** @name PalletConvictionVotingVoteVoting (599) */ interface PalletConvictionVotingVoteVoting extends Enum { readonly isCasting: boolean; readonly asCasting: PalletConvictionVotingVoteCasting; @@ -6546,23 +6601,23 @@ declare module "@polkadot/types/lookup" { readonly type: "Casting" | "Delegating"; } - /** @name PalletConvictionVotingVoteCasting (594) */ + /** @name PalletConvictionVotingVoteCasting (600) */ interface PalletConvictionVotingVoteCasting extends Struct { readonly votes: Vec>; readonly delegations: PalletConvictionVotingDelegations; readonly prior: PalletConvictionVotingVotePriorLock; } - /** @name PalletConvictionVotingDelegations (598) */ + /** @name PalletConvictionVotingDelegations (604) */ interface PalletConvictionVotingDelegations extends Struct { readonly votes: u128; readonly capital: u128; } - /** @name PalletConvictionVotingVotePriorLock (599) */ + /** @name PalletConvictionVotingVotePriorLock (605) */ interface PalletConvictionVotingVotePriorLock extends ITuple<[u32, u128]> {} - /** @name PalletConvictionVotingVoteDelegating (600) */ + /** @name PalletConvictionVotingVoteDelegating (606) */ interface PalletConvictionVotingVoteDelegating extends Struct { readonly balance: u128; readonly target: AccountId32; @@ -6571,7 +6626,7 @@ declare module "@polkadot/types/lookup" { readonly prior: PalletConvictionVotingVotePriorLock; } - /** @name PalletConvictionVotingError (604) */ + /** @name PalletConvictionVotingError (610) */ interface PalletConvictionVotingError extends Enum { readonly isNotOngoing: boolean; readonly isNotVoter: boolean; @@ -6600,7 +6655,7 @@ declare module "@polkadot/types/lookup" { | "BadClass"; } - /** @name PalletReferendaReferendumInfoConvictionVotingTally (605) */ + /** @name PalletReferendaReferendumInfoConvictionVotingTally (611) */ interface PalletReferendaReferendumInfoConvictionVotingTally extends Enum { readonly isOngoing: boolean; readonly asOngoing: PalletReferendaReferendumStatusConvictionVotingTally; @@ -6617,7 +6672,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ongoing" | "Approved" | "Rejected" | "Cancelled" | "TimedOut" | "Killed"; } - /** @name PalletReferendaReferendumStatusConvictionVotingTally (606) */ + /** @name PalletReferendaReferendumStatusConvictionVotingTally (612) */ interface PalletReferendaReferendumStatusConvictionVotingTally extends Struct { readonly track: u16; readonly origin: DancelightRuntimeOriginCaller; @@ -6632,19 +6687,19 @@ declare module "@polkadot/types/lookup" { readonly alarm: Option]>>; } - /** @name PalletReferendaDeposit (607) */ + /** @name PalletReferendaDeposit (613) */ interface PalletReferendaDeposit extends Struct { readonly who: AccountId32; readonly amount: u128; } - /** @name PalletReferendaDecidingStatus (610) */ + /** @name PalletReferendaDecidingStatus (616) */ interface PalletReferendaDecidingStatus extends Struct { readonly since: u32; readonly confirming: Option; } - /** @name PalletReferendaTrackInfo (618) */ + /** @name PalletReferendaTrackInfo (624) */ interface PalletReferendaTrackInfo extends Struct { readonly name: Text; readonly maxDeciding: u32; @@ -6657,7 +6712,7 @@ declare module "@polkadot/types/lookup" { readonly minSupport: PalletReferendaCurve; } - /** @name PalletReferendaCurve (619) */ + /** @name PalletReferendaCurve (625) */ interface PalletReferendaCurve extends Enum { readonly isLinearDecreasing: boolean; readonly asLinearDecreasing: { @@ -6681,7 +6736,7 @@ declare module "@polkadot/types/lookup" { readonly type: "LinearDecreasing" | "SteppedDecreasing" | "Reciprocal"; } - /** @name PalletReferendaError (622) */ + /** @name PalletReferendaError (628) */ interface PalletReferendaError extends Enum { readonly isNotOngoing: boolean; readonly isHasDeposit: boolean; @@ -6714,12 +6769,12 @@ declare module "@polkadot/types/lookup" { | "PreimageStoredWithDifferentLength"; } - /** @name PalletRankedCollectiveMemberRecord (623) */ + /** @name PalletRankedCollectiveMemberRecord (629) */ interface PalletRankedCollectiveMemberRecord extends Struct { readonly rank: u16; } - /** @name PalletRankedCollectiveError (628) */ + /** @name PalletRankedCollectiveError (633) */ interface PalletRankedCollectiveError extends Enum { readonly isAlreadyMember: boolean; readonly isNotMember: boolean; @@ -6746,7 +6801,7 @@ declare module "@polkadot/types/lookup" { | "TooManyMembers"; } - /** @name PalletReferendaReferendumInfoRankedCollectiveTally (629) */ + /** @name PalletReferendaReferendumInfoRankedCollectiveTally (634) */ interface PalletReferendaReferendumInfoRankedCollectiveTally extends Enum { readonly isOngoing: boolean; readonly asOngoing: PalletReferendaReferendumStatusRankedCollectiveTally; @@ -6763,7 +6818,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ongoing" | "Approved" | "Rejected" | "Cancelled" | "TimedOut" | "Killed"; } - /** @name PalletReferendaReferendumStatusRankedCollectiveTally (630) */ + /** @name PalletReferendaReferendumStatusRankedCollectiveTally (635) */ interface PalletReferendaReferendumStatusRankedCollectiveTally extends Struct { readonly track: u16; readonly origin: DancelightRuntimeOriginCaller; @@ -6778,7 +6833,7 @@ declare module "@polkadot/types/lookup" { readonly alarm: Option]>>; } - /** @name PalletWhitelistError (633) */ + /** @name PalletWhitelistError (638) */ interface PalletWhitelistError extends Enum { readonly isUnavailablePreImage: boolean; readonly isUndecodableCall: boolean; @@ -6793,7 +6848,7 @@ declare module "@polkadot/types/lookup" { | "CallAlreadyWhitelisted"; } - /** @name PolkadotRuntimeParachainsConfigurationHostConfiguration (634) */ + /** @name PolkadotRuntimeParachainsConfigurationHostConfiguration (639) */ interface PolkadotRuntimeParachainsConfigurationHostConfiguration extends Struct { readonly maxCodeSize: u32; readonly maxHeadDataSize: u32; @@ -6832,19 +6887,19 @@ declare module "@polkadot/types/lookup" { readonly schedulerParams: PolkadotPrimitivesVstagingSchedulerParams; } - /** @name PolkadotRuntimeParachainsConfigurationPalletError (637) */ + /** @name PolkadotRuntimeParachainsConfigurationPalletError (642) */ interface PolkadotRuntimeParachainsConfigurationPalletError extends Enum { readonly isInvalidNewValue: boolean; readonly type: "InvalidNewValue"; } - /** @name PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker (640) */ + /** @name PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker (645) */ interface PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker extends Struct { readonly buffer: Vec>; readonly latestNumber: u32; } - /** @name PolkadotRuntimeParachainsInclusionCandidatePendingAvailability (644) */ + /** @name PolkadotRuntimeParachainsInclusionCandidatePendingAvailability (649) */ interface PolkadotRuntimeParachainsInclusionCandidatePendingAvailability extends Struct { readonly core: u32; readonly hash_: H256; @@ -6857,7 +6912,7 @@ declare module "@polkadot/types/lookup" { readonly backingGroup: u32; } - /** @name PolkadotRuntimeParachainsInclusionPalletError (645) */ + /** @name PolkadotRuntimeParachainsInclusionPalletError (650) */ interface PolkadotRuntimeParachainsInclusionPalletError extends Enum { readonly isValidatorIndexOutOfBounds: boolean; readonly isUnscheduledCandidate: boolean; @@ -6898,7 +6953,7 @@ declare module "@polkadot/types/lookup" { | "ParaHeadMismatch"; } - /** @name PolkadotPrimitivesV7ScrapedOnChainVotes (646) */ + /** @name PolkadotPrimitivesV7ScrapedOnChainVotes (651) */ interface PolkadotPrimitivesV7ScrapedOnChainVotes extends Struct { readonly session: u32; readonly backingValidatorsPerCandidate: Vec< @@ -6907,7 +6962,7 @@ declare module "@polkadot/types/lookup" { readonly disputes: Vec; } - /** @name PolkadotRuntimeParachainsParasInherentPalletError (651) */ + /** @name PolkadotRuntimeParachainsParasInherentPalletError (656) */ interface PolkadotRuntimeParachainsParasInherentPalletError extends Enum { readonly isTooManyInclusionInherents: boolean; readonly isInvalidParentHeader: boolean; @@ -6922,7 +6977,7 @@ declare module "@polkadot/types/lookup" { | "UnscheduledCandidate"; } - /** @name PolkadotRuntimeParachainsSchedulerPalletCoreOccupied (654) */ + /** @name PolkadotRuntimeParachainsSchedulerPalletCoreOccupied (659) */ interface PolkadotRuntimeParachainsSchedulerPalletCoreOccupied extends Enum { readonly isFree: boolean; readonly isParas: boolean; @@ -6930,14 +6985,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Free" | "Paras"; } - /** @name PolkadotRuntimeParachainsSchedulerPalletParasEntry (655) */ + /** @name PolkadotRuntimeParachainsSchedulerPalletParasEntry (660) */ interface PolkadotRuntimeParachainsSchedulerPalletParasEntry extends Struct { readonly assignment: PolkadotRuntimeParachainsSchedulerCommonAssignment; readonly availabilityTimeouts: u32; readonly ttl: u32; } - /** @name PolkadotRuntimeParachainsSchedulerCommonAssignment (656) */ + /** @name PolkadotRuntimeParachainsSchedulerCommonAssignment (661) */ interface PolkadotRuntimeParachainsSchedulerCommonAssignment extends Enum { readonly isPool: boolean; readonly asPool: { @@ -6949,7 +7004,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Pool" | "Bulk"; } - /** @name PolkadotRuntimeParachainsParasPvfCheckActiveVoteState (661) */ + /** @name PolkadotRuntimeParachainsParasPvfCheckActiveVoteState (666) */ interface PolkadotRuntimeParachainsParasPvfCheckActiveVoteState extends Struct { readonly votesAccept: BitVec; readonly votesReject: BitVec; @@ -6958,7 +7013,7 @@ declare module "@polkadot/types/lookup" { readonly causes: Vec; } - /** @name PolkadotRuntimeParachainsParasPvfCheckCause (663) */ + /** @name PolkadotRuntimeParachainsParasPvfCheckCause (668) */ interface PolkadotRuntimeParachainsParasPvfCheckCause extends Enum { readonly isOnboarding: boolean; readonly asOnboarding: u32; @@ -6971,14 +7026,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Onboarding" | "Upgrade"; } - /** @name PolkadotRuntimeParachainsParasUpgradeStrategy (664) */ + /** @name PolkadotRuntimeParachainsParasUpgradeStrategy (669) */ interface PolkadotRuntimeParachainsParasUpgradeStrategy extends Enum { readonly isSetGoAheadSignal: boolean; readonly isApplyAtExpectedBlock: boolean; readonly type: "SetGoAheadSignal" | "ApplyAtExpectedBlock"; } - /** @name PolkadotRuntimeParachainsParasParaLifecycle (666) */ + /** @name PolkadotRuntimeParachainsParasParaLifecycle (671) */ interface PolkadotRuntimeParachainsParasParaLifecycle extends Enum { readonly isOnboarding: boolean; readonly isParathread: boolean; @@ -6997,32 +7052,32 @@ declare module "@polkadot/types/lookup" { | "OffboardingParachain"; } - /** @name PolkadotRuntimeParachainsParasParaPastCodeMeta (668) */ + /** @name PolkadotRuntimeParachainsParasParaPastCodeMeta (673) */ interface PolkadotRuntimeParachainsParasParaPastCodeMeta extends Struct { readonly upgradeTimes: Vec; readonly lastPruned: Option; } - /** @name PolkadotRuntimeParachainsParasReplacementTimes (670) */ + /** @name PolkadotRuntimeParachainsParasReplacementTimes (675) */ interface PolkadotRuntimeParachainsParasReplacementTimes extends Struct { readonly expectedAt: u32; readonly activatedAt: u32; } - /** @name PolkadotPrimitivesV7UpgradeGoAhead (672) */ + /** @name PolkadotPrimitivesV7UpgradeGoAhead (677) */ interface PolkadotPrimitivesV7UpgradeGoAhead extends Enum { readonly isAbort: boolean; readonly isGoAhead: boolean; readonly type: "Abort" | "GoAhead"; } - /** @name PolkadotPrimitivesV7UpgradeRestriction (673) */ + /** @name PolkadotPrimitivesV7UpgradeRestriction (678) */ interface PolkadotPrimitivesV7UpgradeRestriction extends Enum { readonly isPresent: boolean; readonly type: "Present"; } - /** @name PolkadotRuntimeParachainsParasPalletError (674) */ + /** @name PolkadotRuntimeParachainsParasPalletError (679) */ interface PolkadotRuntimeParachainsParasPalletError extends Enum { readonly isNotRegistered: boolean; readonly isCannotOnboard: boolean; @@ -7053,20 +7108,20 @@ declare module "@polkadot/types/lookup" { | "InvalidCode"; } - /** @name PolkadotRuntimeParachainsInitializerBufferedSessionChange (676) */ + /** @name PolkadotRuntimeParachainsInitializerBufferedSessionChange (681) */ interface PolkadotRuntimeParachainsInitializerBufferedSessionChange extends Struct { readonly validators: Vec; readonly queued: Vec; readonly sessionIndex: u32; } - /** @name PolkadotCorePrimitivesInboundDownwardMessage (678) */ + /** @name PolkadotCorePrimitivesInboundDownwardMessage (683) */ interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct { readonly sentAt: u32; readonly msg: Bytes; } - /** @name PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest (679) */ + /** @name PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest (684) */ interface PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest extends Struct { readonly confirmed: bool; readonly age: u32; @@ -7076,7 +7131,7 @@ declare module "@polkadot/types/lookup" { readonly maxTotalSize: u32; } - /** @name PolkadotRuntimeParachainsHrmpHrmpChannel (681) */ + /** @name PolkadotRuntimeParachainsHrmpHrmpChannel (686) */ interface PolkadotRuntimeParachainsHrmpHrmpChannel extends Struct { readonly maxCapacity: u32; readonly maxTotalSize: u32; @@ -7088,13 +7143,13 @@ declare module "@polkadot/types/lookup" { readonly recipientDeposit: u128; } - /** @name PolkadotCorePrimitivesInboundHrmpMessage (683) */ + /** @name PolkadotCorePrimitivesInboundHrmpMessage (688) */ interface PolkadotCorePrimitivesInboundHrmpMessage extends Struct { readonly sentAt: u32; readonly data: Bytes; } - /** @name PolkadotRuntimeParachainsHrmpPalletError (686) */ + /** @name PolkadotRuntimeParachainsHrmpPalletError (691) */ interface PolkadotRuntimeParachainsHrmpPalletError extends Enum { readonly isOpenHrmpChannelToSelf: boolean; readonly isOpenHrmpChannelInvalidRecipient: boolean; @@ -7139,7 +7194,7 @@ declare module "@polkadot/types/lookup" { | "ChannelCreationNotAuthorized"; } - /** @name PolkadotPrimitivesV7SessionInfo (688) */ + /** @name PolkadotPrimitivesV7SessionInfo (693) */ interface PolkadotPrimitivesV7SessionInfo extends Struct { readonly activeValidatorIndices: Vec; readonly randomSeed: U8aFixed; @@ -7156,13 +7211,13 @@ declare module "@polkadot/types/lookup" { readonly neededApprovals: u32; } - /** @name PolkadotPrimitivesV7IndexedVecValidatorIndex (689) */ + /** @name PolkadotPrimitivesV7IndexedVecValidatorIndex (694) */ interface PolkadotPrimitivesV7IndexedVecValidatorIndex extends Vec {} - /** @name PolkadotPrimitivesV7IndexedVecGroupIndex (690) */ + /** @name PolkadotPrimitivesV7IndexedVecGroupIndex (695) */ interface PolkadotPrimitivesV7IndexedVecGroupIndex extends Vec> {} - /** @name PolkadotPrimitivesV7DisputeState (692) */ + /** @name PolkadotPrimitivesV7DisputeState (697) */ interface PolkadotPrimitivesV7DisputeState extends Struct { readonly validatorsFor: BitVec; readonly validatorsAgainst: BitVec; @@ -7170,7 +7225,7 @@ declare module "@polkadot/types/lookup" { readonly concludedAt: Option; } - /** @name PolkadotRuntimeParachainsDisputesPalletError (694) */ + /** @name PolkadotRuntimeParachainsDisputesPalletError (699) */ interface PolkadotRuntimeParachainsDisputesPalletError extends Enum { readonly isDuplicateDisputeStatementSets: boolean; readonly isAncientDisputeStatement: boolean; @@ -7193,13 +7248,13 @@ declare module "@polkadot/types/lookup" { | "UnconfirmedDispute"; } - /** @name PolkadotPrimitivesV7SlashingPendingSlashes (695) */ + /** @name PolkadotPrimitivesV7SlashingPendingSlashes (700) */ interface PolkadotPrimitivesV7SlashingPendingSlashes extends Struct { readonly keys_: BTreeMap; readonly kind: PolkadotPrimitivesV7SlashingSlashingOffenceKind; } - /** @name PolkadotRuntimeParachainsDisputesSlashingPalletError (699) */ + /** @name PolkadotRuntimeParachainsDisputesSlashingPalletError (704) */ interface PolkadotRuntimeParachainsDisputesSlashingPalletError extends Enum { readonly isInvalidKeyOwnershipProof: boolean; readonly isInvalidSessionIndex: boolean; @@ -7216,7 +7271,7 @@ declare module "@polkadot/types/lookup" { | "DuplicateSlashingReport"; } - /** @name PalletMessageQueueBookState (700) */ + /** @name PalletMessageQueueBookState (705) */ interface PalletMessageQueueBookState extends Struct { readonly begin: u32; readonly end: u32; @@ -7226,13 +7281,13 @@ declare module "@polkadot/types/lookup" { readonly size_: u64; } - /** @name PalletMessageQueueNeighbours (702) */ + /** @name PalletMessageQueueNeighbours (707) */ interface PalletMessageQueueNeighbours extends Struct { readonly prev: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin; readonly next: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin; } - /** @name PalletMessageQueuePage (704) */ + /** @name PalletMessageQueuePage (709) */ interface PalletMessageQueuePage extends Struct { readonly remaining: u32; readonly remainingSize: u32; @@ -7242,7 +7297,7 @@ declare module "@polkadot/types/lookup" { readonly heap: Bytes; } - /** @name PalletMessageQueueError (706) */ + /** @name PalletMessageQueueError (711) */ interface PalletMessageQueueError extends Enum { readonly isNotReapable: boolean; readonly isNoPage: boolean; @@ -7265,13 +7320,13 @@ declare module "@polkadot/types/lookup" { | "RecursiveDisallowed"; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount (707) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount (712) */ interface PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount extends Struct { readonly coreIndex: u32; readonly count: u32; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType (708) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType (713) */ interface PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType extends Struct { readonly traffic: u128; readonly nextIndex: u32; @@ -7279,33 +7334,33 @@ declare module "@polkadot/types/lookup" { readonly freedIndices: BinaryHeapReverseQueueIndex; } - /** @name BinaryHeapReverseQueueIndex (710) */ + /** @name BinaryHeapReverseQueueIndex (715) */ interface BinaryHeapReverseQueueIndex extends Vec {} - /** @name BinaryHeapEnqueuedOrder (713) */ + /** @name BinaryHeapEnqueuedOrder (718) */ interface BinaryHeapEnqueuedOrder extends Vec {} - /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder (714) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder (719) */ interface PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder extends Struct { readonly paraId: u32; readonly idx: u32; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletError (718) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletError (723) */ interface PolkadotRuntimeParachainsAssignerOnDemandPalletError extends Enum { readonly isQueueFull: boolean; readonly isSpotPriceHigherThanMaxAmount: boolean; readonly type: "QueueFull" | "SpotPriceHigherThanMaxAmount"; } - /** @name PolkadotRuntimeCommonParasRegistrarParaInfo (719) */ + /** @name PolkadotRuntimeCommonParasRegistrarParaInfo (724) */ interface PolkadotRuntimeCommonParasRegistrarParaInfo extends Struct { readonly manager: AccountId32; readonly deposit: u128; readonly locked: Option; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletError (721) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletError (726) */ interface PolkadotRuntimeCommonParasRegistrarPalletError extends Enum { readonly isNotRegistered: boolean; readonly isAlreadyRegistered: boolean; @@ -7338,33 +7393,33 @@ declare module "@polkadot/types/lookup" { | "CannotSwap"; } - /** @name PalletUtilityError (722) */ + /** @name PalletUtilityError (727) */ interface PalletUtilityError extends Enum { readonly isTooManyCalls: boolean; readonly type: "TooManyCalls"; } - /** @name PalletIdentityRegistration (724) */ + /** @name PalletIdentityRegistration (729) */ interface PalletIdentityRegistration extends Struct { readonly judgements: Vec>; readonly deposit: u128; readonly info: PalletIdentityLegacyIdentityInfo; } - /** @name PalletIdentityRegistrarInfo (733) */ + /** @name PalletIdentityRegistrarInfo (738) */ interface PalletIdentityRegistrarInfo extends Struct { readonly account: AccountId32; readonly fee: u128; readonly fields: u64; } - /** @name PalletIdentityAuthorityProperties (735) */ + /** @name PalletIdentityAuthorityProperties (740) */ interface PalletIdentityAuthorityProperties extends Struct { readonly suffix: Bytes; readonly allocation: u32; } - /** @name PalletIdentityError (738) */ + /** @name PalletIdentityError (743) */ interface PalletIdentityError extends Enum { readonly isTooManySubAccounts: boolean; readonly isNotFound: boolean; @@ -7421,7 +7476,7 @@ declare module "@polkadot/types/lookup" { | "NotExpired"; } - /** @name PalletSchedulerScheduled (741) */ + /** @name PalletSchedulerScheduled (746) */ interface PalletSchedulerScheduled extends Struct { readonly maybeId: Option; readonly priority: u8; @@ -7430,14 +7485,14 @@ declare module "@polkadot/types/lookup" { readonly origin: DancelightRuntimeOriginCaller; } - /** @name PalletSchedulerRetryConfig (743) */ + /** @name PalletSchedulerRetryConfig (748) */ interface PalletSchedulerRetryConfig extends Struct { readonly totalRetries: u8; readonly remaining: u8; readonly period: u32; } - /** @name PalletSchedulerError (744) */ + /** @name PalletSchedulerError (749) */ interface PalletSchedulerError extends Enum { readonly isFailedToSchedule: boolean; readonly isNotFound: boolean; @@ -7447,21 +7502,21 @@ declare module "@polkadot/types/lookup" { readonly type: "FailedToSchedule" | "NotFound" | "TargetBlockNumberInPast" | "RescheduleNoChange" | "Named"; } - /** @name PalletProxyProxyDefinition (747) */ + /** @name PalletProxyProxyDefinition (752) */ interface PalletProxyProxyDefinition extends Struct { readonly delegate: AccountId32; readonly proxyType: DancelightRuntimeProxyType; readonly delay: u32; } - /** @name PalletProxyAnnouncement (751) */ + /** @name PalletProxyAnnouncement (756) */ interface PalletProxyAnnouncement extends Struct { readonly real: AccountId32; readonly callHash: H256; readonly height: u32; } - /** @name PalletProxyError (753) */ + /** @name PalletProxyError (758) */ interface PalletProxyError extends Enum { readonly isTooMany: boolean; readonly isNotFound: boolean; @@ -7482,7 +7537,7 @@ declare module "@polkadot/types/lookup" { | "NoSelfProxy"; } - /** @name PalletMultisigMultisig (755) */ + /** @name PalletMultisigMultisig (760) */ interface PalletMultisigMultisig extends Struct { readonly when: PalletMultisigTimepoint; readonly deposit: u128; @@ -7490,7 +7545,7 @@ declare module "@polkadot/types/lookup" { readonly approvals: Vec; } - /** @name PalletMultisigError (757) */ + /** @name PalletMultisigError (762) */ interface PalletMultisigError extends Enum { readonly isMinimumThreshold: boolean; readonly isAlreadyApproved: boolean; @@ -7523,7 +7578,7 @@ declare module "@polkadot/types/lookup" { | "AlreadyStored"; } - /** @name PalletPreimageOldRequestStatus (758) */ + /** @name PalletPreimageOldRequestStatus (763) */ interface PalletPreimageOldRequestStatus extends Enum { readonly isUnrequested: boolean; readonly asUnrequested: { @@ -7539,7 +7594,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unrequested" | "Requested"; } - /** @name PalletPreimageRequestStatus (761) */ + /** @name PalletPreimageRequestStatus (766) */ interface PalletPreimageRequestStatus extends Enum { readonly isUnrequested: boolean; readonly asUnrequested: { @@ -7555,7 +7610,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unrequested" | "Requested"; } - /** @name PalletPreimageError (766) */ + /** @name PalletPreimageError (771) */ interface PalletPreimageError extends Enum { readonly isTooBig: boolean; readonly isAlreadyNoted: boolean; @@ -7578,7 +7633,7 @@ declare module "@polkadot/types/lookup" { | "NoCost"; } - /** @name PalletAssetRateError (767) */ + /** @name PalletAssetRateError (772) */ interface PalletAssetRateError extends Enum { readonly isUnknownAssetKind: boolean; readonly isAlreadyExists: boolean; @@ -7586,7 +7641,7 @@ declare module "@polkadot/types/lookup" { readonly type: "UnknownAssetKind" | "AlreadyExists" | "Overflow"; } - /** @name PalletXcmQueryStatus (768) */ + /** @name PalletXcmQueryStatus (773) */ interface PalletXcmQueryStatus extends Enum { readonly isPending: boolean; readonly asPending: { @@ -7608,7 +7663,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Pending" | "VersionNotifier" | "Ready"; } - /** @name XcmVersionedResponse (772) */ + /** @name XcmVersionedResponse (777) */ interface XcmVersionedResponse extends Enum { readonly isV2: boolean; readonly asV2: XcmV2Response; @@ -7619,7 +7674,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name PalletXcmVersionMigrationStage (778) */ + /** @name PalletXcmVersionMigrationStage (783) */ interface PalletXcmVersionMigrationStage extends Enum { readonly isMigrateSupportedVersion: boolean; readonly isMigrateVersionNotifiers: boolean; @@ -7633,7 +7688,7 @@ declare module "@polkadot/types/lookup" { | "MigrateAndNotifyOldTargets"; } - /** @name PalletXcmRemoteLockedFungibleRecord (780) */ + /** @name PalletXcmRemoteLockedFungibleRecord (785) */ interface PalletXcmRemoteLockedFungibleRecord extends Struct { readonly amount: u128; readonly owner: XcmVersionedLocation; @@ -7641,7 +7696,7 @@ declare module "@polkadot/types/lookup" { readonly consumers: Vec>; } - /** @name PalletXcmError (787) */ + /** @name PalletXcmError (792) */ interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -7694,7 +7749,7 @@ declare module "@polkadot/types/lookup" { | "LocalExecutionIncomplete"; } - /** @name PalletMigrationsError (788) */ + /** @name PalletMigrationsError (793) */ interface PalletMigrationsError extends Enum { readonly isPreimageMissing: boolean; readonly isWrongUpperBound: boolean; @@ -7703,7 +7758,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PreimageMissing" | "WrongUpperBound" | "PreimageIsTooBig" | "PreimageAlreadyExists"; } - /** @name PalletBeefyError (792) */ + /** @name PalletBeefyError (797) */ interface PalletBeefyError extends Enum { readonly isInvalidKeyOwnershipProof: boolean; readonly isInvalidDoubleVotingProof: boolean; @@ -7722,50 +7777,50 @@ declare module "@polkadot/types/lookup" { | "InvalidConfiguration"; } - /** @name SpConsensusBeefyMmrBeefyAuthoritySet (793) */ + /** @name SpConsensusBeefyMmrBeefyAuthoritySet (798) */ interface SpConsensusBeefyMmrBeefyAuthoritySet extends Struct { readonly id: u64; readonly len: u32; readonly keysetCommitment: H256; } - /** @name SnowbridgeBeaconPrimitivesCompactBeaconState (794) */ + /** @name SnowbridgeBeaconPrimitivesCompactBeaconState (799) */ interface SnowbridgeBeaconPrimitivesCompactBeaconState extends Struct { readonly slot: Compact; readonly blockRootsRoot: H256; } - /** @name SnowbridgeBeaconPrimitivesSyncCommitteePrepared (795) */ + /** @name SnowbridgeBeaconPrimitivesSyncCommitteePrepared (800) */ interface SnowbridgeBeaconPrimitivesSyncCommitteePrepared extends Struct { readonly root: H256; readonly pubkeys: Vec; readonly aggregatePubkey: SnowbridgeMilagroBlsKeysPublicKey; } - /** @name SnowbridgeMilagroBlsKeysPublicKey (797) */ + /** @name SnowbridgeMilagroBlsKeysPublicKey (802) */ interface SnowbridgeMilagroBlsKeysPublicKey extends Struct { readonly point: SnowbridgeAmclBls381Ecp; } - /** @name SnowbridgeAmclBls381Ecp (798) */ + /** @name SnowbridgeAmclBls381Ecp (803) */ interface SnowbridgeAmclBls381Ecp extends Struct { readonly x: SnowbridgeAmclBls381Fp; readonly y: SnowbridgeAmclBls381Fp; readonly z: SnowbridgeAmclBls381Fp; } - /** @name SnowbridgeAmclBls381Fp (799) */ + /** @name SnowbridgeAmclBls381Fp (804) */ interface SnowbridgeAmclBls381Fp extends Struct { readonly x: SnowbridgeAmclBls381Big; readonly xes: i32; } - /** @name SnowbridgeAmclBls381Big (800) */ + /** @name SnowbridgeAmclBls381Big (805) */ interface SnowbridgeAmclBls381Big extends Struct { readonly w: Vec; } - /** @name SnowbridgeBeaconPrimitivesForkVersions (803) */ + /** @name SnowbridgeBeaconPrimitivesForkVersions (808) */ interface SnowbridgeBeaconPrimitivesForkVersions extends Struct { readonly genesis: SnowbridgeBeaconPrimitivesFork; readonly altair: SnowbridgeBeaconPrimitivesFork; @@ -7774,13 +7829,13 @@ declare module "@polkadot/types/lookup" { readonly deneb: SnowbridgeBeaconPrimitivesFork; } - /** @name SnowbridgeBeaconPrimitivesFork (804) */ + /** @name SnowbridgeBeaconPrimitivesFork (809) */ interface SnowbridgeBeaconPrimitivesFork extends Struct { readonly version: U8aFixed; readonly epoch: u64; } - /** @name SnowbridgePalletEthereumClientError (805) */ + /** @name SnowbridgePalletEthereumClientError (810) */ interface SnowbridgePalletEthereumClientError extends Enum { readonly isSkippedSyncCommitteePeriod: boolean; readonly isSyncCommitteeUpdateRequired: boolean; @@ -7836,7 +7891,7 @@ declare module "@polkadot/types/lookup" { | "Halted"; } - /** @name SnowbridgeBeaconPrimitivesBlsBlsError (806) */ + /** @name SnowbridgeBeaconPrimitivesBlsBlsError (811) */ interface SnowbridgeBeaconPrimitivesBlsBlsError extends Enum { readonly isInvalidSignature: boolean; readonly isInvalidPublicKey: boolean; @@ -7849,7 +7904,7 @@ declare module "@polkadot/types/lookup" { | "SignatureVerificationFailed"; } - /** @name PolkadotRuntimeCommonParasSudoWrapperPalletError (807) */ + /** @name PolkadotRuntimeCommonParasSudoWrapperPalletError (812) */ interface PolkadotRuntimeCommonParasSudoWrapperPalletError extends Enum { readonly isParaDoesntExist: boolean; readonly isParaAlreadyExists: boolean; @@ -7872,45 +7927,45 @@ declare module "@polkadot/types/lookup" { | "TooManyCores"; } - /** @name PalletSudoError (808) */ + /** @name PalletSudoError (813) */ interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: "RequireSudo"; } - /** @name FrameSystemExtensionsCheckNonZeroSender (811) */ + /** @name FrameSystemExtensionsCheckNonZeroSender (816) */ type FrameSystemExtensionsCheckNonZeroSender = Null; - /** @name FrameSystemExtensionsCheckSpecVersion (812) */ + /** @name FrameSystemExtensionsCheckSpecVersion (817) */ type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckTxVersion (813) */ + /** @name FrameSystemExtensionsCheckTxVersion (818) */ type FrameSystemExtensionsCheckTxVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (814) */ + /** @name FrameSystemExtensionsCheckGenesis (819) */ type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (817) */ + /** @name FrameSystemExtensionsCheckNonce (822) */ interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (818) */ + /** @name FrameSystemExtensionsCheckWeight (823) */ type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTransactionPaymentChargeTransactionPayment (819) */ + /** @name PalletTransactionPaymentChargeTransactionPayment (824) */ interface PalletTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name FrameMetadataHashExtensionCheckMetadataHash (820) */ + /** @name FrameMetadataHashExtensionCheckMetadataHash (825) */ interface FrameMetadataHashExtensionCheckMetadataHash extends Struct { readonly mode: FrameMetadataHashExtensionMode; } - /** @name FrameMetadataHashExtensionMode (821) */ + /** @name FrameMetadataHashExtensionMode (826) */ interface FrameMetadataHashExtensionMode extends Enum { readonly isDisabled: boolean; readonly isEnabled: boolean; readonly type: "Disabled" | "Enabled"; } - /** @name DancelightRuntimeRuntime (822) */ + /** @name DancelightRuntimeRuntime (827) */ type DancelightRuntimeRuntime = Null; } // declare module