diff --git a/Cargo.lock b/Cargo.lock index 0a1cdf691..2c8ac5511 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3288,12 +3288,16 @@ dependencies = [ "polkadot-primitives", "polkadot-runtime-common", "polkadot-runtime-parachains", + "rand", "scale-info", "separator", "serde", "serde_derive", "serde_json", "smallvec", + "snowbridge-beacon-primitives", + "snowbridge-milagro-bls", + "snowbridge-pallet-ethereum-client", "sp-api", "sp-arithmetic", "sp-authority-discovery", @@ -4028,6 +4032,16 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "ethabi-decode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09d398648d65820a727d6a81e58b962f874473396a047e4c30bafe3240953417" +dependencies = [ + "ethereum-types", + "tiny-keccak", +] + [[package]] name = "ethbloom" version = "0.13.0" @@ -10507,6 +10521,12 @@ dependencies = [ "unicode-normalization", ] +[[package]] +name = "parity-bytes" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16b56e3a2420138bdb970f84dfb9c774aea80fa0e7371549eedec0d80c209c67" + [[package]] name = "parity-db" version = "0.4.13" @@ -15119,6 +15139,15 @@ dependencies = [ "serde_derive", ] +[[package]] +name = "serde-big-array" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd31f59f6fe2b0c055371bb2f16d7f0aa7d8881676c04a55b1596d1a17cd10a4" +dependencies = [ + "serde", +] + [[package]] name = "serde_bytes" version = "0.11.14" @@ -15569,6 +15598,134 @@ dependencies = [ "subtle 2.5.0", ] +[[package]] +name = "snowbridge-amcl" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460a9ed63cdf03c1b9847e8a12a5f5ba19c4efd5869e4a737e05be25d7c427e5" +dependencies = [ + "parity-scale-codec", + "scale-info", +] + +[[package]] +name = "snowbridge-beacon-primitives" +version = "0.9.0" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2407#28cdd1c8b6c59b1f72a934d04608bf8af82caa72" +dependencies = [ + "byte-slice-cast", + "frame-support", + "hex", + "parity-scale-codec", + "rlp", + "scale-info", + "serde", + "snowbridge-ethereum", + "snowbridge-milagro-bls", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "ssz_rs", + "ssz_rs_derive", +] + +[[package]] +name = "snowbridge-core" +version = "0.9.0" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2407#28cdd1c8b6c59b1f72a934d04608bf8af82caa72" +dependencies = [ + "ethabi-decode", + "frame-support", + "frame-system", + "hex-literal 0.4.1", + "parity-scale-codec", + "polkadot-parachain-primitives", + "scale-info", + "serde", + "snowbridge-beacon-primitives", + "sp-arithmetic", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "staging-xcm", + "staging-xcm-builder", +] + +[[package]] +name = "snowbridge-ethereum" +version = "0.9.0" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2407#28cdd1c8b6c59b1f72a934d04608bf8af82caa72" +dependencies = [ + "ethabi-decode", + "ethbloom", + "ethereum-types", + "hex-literal 0.4.1", + "parity-bytes", + "parity-scale-codec", + "rlp", + "scale-info", + "serde", + "serde-big-array", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "snowbridge-milagro-bls" +version = "1.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "026aa8638f690a53e3f7676024b9e913b1cab0111d1b7b92669d40a188f9d7e6" +dependencies = [ + "hex", + "lazy_static", + "parity-scale-codec", + "rand", + "scale-info", + "snowbridge-amcl", + "zeroize", +] + +[[package]] +name = "snowbridge-pallet-ethereum-client" +version = "0.9.0" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2407#28cdd1c8b6c59b1f72a934d04608bf8af82caa72" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "hex-literal 0.4.1", + "log", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "serde", + "serde_json", + "snowbridge-beacon-primitives", + "snowbridge-core", + "snowbridge-ethereum", + "snowbridge-pallet-ethereum-client-fixtures", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "static_assertions", +] + +[[package]] +name = "snowbridge-pallet-ethereum-client-fixtures" +version = "0.17.0" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2407#28cdd1c8b6c59b1f72a934d04608bf8af82caa72" +dependencies = [ + "hex-literal 0.4.1", + "snowbridge-beacon-primitives", + "snowbridge-core", + "sp-core", + "sp-std", +] + [[package]] name = "socket2" version = "0.4.10" @@ -16530,6 +16687,29 @@ dependencies = [ "unicode-xid", ] +[[package]] +name = "ssz_rs" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "057291e5631f280978fa9c8009390663ca4613359fc1318e36a8c24c392f6d1f" +dependencies = [ + "bitvec", + "num-bigint", + "sha2 0.9.9", + "ssz_rs_derive", +] + +[[package]] +name = "ssz_rs_derive" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f07d54c4d01a1713eb363b55ba51595da15f6f1211435b71466460da022aa140" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + [[package]] name = "stable_deref_trait" version = "1.2.0" diff --git a/Cargo.toml b/Cargo.toml index b15f706a7..7f295cd92 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -252,6 +252,12 @@ westend-runtime = { git = "https://github.com/moondance-labs/polkadot-sdk", bran westend-runtime-constants = { git = "https://github.com/moondance-labs/polkadot-sdk", branch = "tanssi-polkadot-stable2407", default-features = false } xcm-runtime-apis = { git = "https://github.com/moondance-labs/polkadot-sdk", branch = "tanssi-polkadot-stable2407", default-features = false } + +# Bridges (wasm) +milagro-bls = { package = "snowbridge-milagro-bls", version = "1.5.4", default-features = false } +snowbridge-beacon-primitives = { git = "https://github.com/moondance-labs/polkadot-sdk", branch = "tanssi-polkadot-stable2407", default-features = false } +snowbridge-pallet-ethereum-client = { git = "https://github.com/moondance-labs/polkadot-sdk", branch = "tanssi-polkadot-stable2407", default-features = false } + # Polkadot (client) polkadot-cli = { git = "https://github.com/moondance-labs/polkadot-sdk", branch = "tanssi-polkadot-stable2407" } polkadot-node-subsystem = { git = "https://github.com/moondance-labs/polkadot-sdk", branch = "tanssi-polkadot-stable2407" } diff --git a/solo-chains/runtime/dancelight/Cargo.toml b/solo-chains/runtime/dancelight/Cargo.toml index 18a018646..edff6fa7c 100644 --- a/solo-chains/runtime/dancelight/Cargo.toml +++ b/solo-chains/runtime/dancelight/Cargo.toml @@ -138,8 +138,14 @@ tanssi-runtime-common = { workspace = true } # Moonkit pallet-migrations = { workspace = true } +# Bridges +snowbridge-beacon-primitives = { workspace = true } +snowbridge-pallet-ethereum-client = { workspace = true } + [dev-dependencies] keyring = { workspace = true } +milagro-bls = { workspace = true, features = [ "std" ] } +rand = { workspace = true, features = [ "std", "std_rng" ] } remote-externalities = { workspace = true } separator = { workspace = true } serde_json = { workspace = true } @@ -177,6 +183,7 @@ std = [ "inherents/std", "keyring/std", "log/std", + "milagro-bls/std", "nimbus-primitives/std", "offchain-primitives/std", "pallet-asset-rate/std", @@ -235,12 +242,16 @@ std = [ "parity-scale-codec/std", "polkadot-parachain-primitives/std", "primitives/std", + "rand/std", "runtime-common/std", "runtime-parachains/std", "scale-info/std", "serde/std", "serde_derive", "serde_json/std", + "snowbridge-beacon-primitives/std", + "snowbridge-pallet-ethereum-client/fuzzing", + "snowbridge-pallet-ethereum-client/std", "sp-api/std", "sp-arithmetic/std", "sp-consensus-aura/std", @@ -270,6 +281,7 @@ std = [ "xcm/std", ] no_std = [] + runtime-benchmarks = [ "cumulus-pallet-parachain-system/runtime-benchmarks", "cumulus-primitives-core/runtime-benchmarks", @@ -323,6 +335,7 @@ runtime-benchmarks = [ "primitives/runtime-benchmarks", "runtime-common/runtime-benchmarks", "runtime-parachains/runtime-benchmarks", + "snowbridge-pallet-ethereum-client/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", "tanssi-runtime-common/runtime-benchmarks", @@ -389,6 +402,7 @@ try-runtime = [ "pallet-xcm/try-runtime", "runtime-common/try-runtime", "runtime-parachains/try-runtime", + "snowbridge-pallet-ethereum-client/try-runtime", "sp-runtime/try-runtime", "tanssi-runtime-common/try-runtime", ] diff --git a/solo-chains/runtime/dancelight/src/bridge_to_ethereum_config.rs b/solo-chains/runtime/dancelight/src/bridge_to_ethereum_config.rs new file mode 100644 index 000000000..887aa9df5 --- /dev/null +++ b/solo-chains/runtime/dancelight/src/bridge_to_ethereum_config.rs @@ -0,0 +1,91 @@ +// 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 + +//! The bridge to ethereum config + +pub const SLOTS_PER_EPOCH: u32 = snowbridge_pallet_ethereum_client::config::SLOTS_PER_EPOCH as u32; +use crate::{parameter_types, weights, Runtime, RuntimeEvent}; +use snowbridge_beacon_primitives::{Fork, ForkVersions}; + +// For tests, benchmarks and fast-runtime configurations we use the mocked fork versions +#[cfg(any( + feature = "std", + feature = "fast-runtime", + feature = "runtime-benchmarks", + test +))] +parameter_types! { + pub const ChainForkVersions: ForkVersions = ForkVersions { + genesis: Fork { + version: [0, 0, 0, 0], // 0x00000000 + epoch: 0, + }, + altair: Fork { + version: [1, 0, 0, 0], // 0x01000000 + epoch: 0, + }, + bellatrix: Fork { + version: [2, 0, 0, 0], // 0x02000000 + epoch: 0, + }, + capella: Fork { + version: [3, 0, 0, 0], // 0x03000000 + epoch: 0, + }, + deneb: Fork { + version: [4, 0, 0, 0], // 0x04000000 + epoch: 0, + } + }; +} + +// Holesky: https://github.com/eth-clients/holesky +#[cfg(not(any( + feature = "std", + feature = "fast-runtime", + feature = "runtime-benchmarks", + test +)))] +parameter_types! { + pub const ChainForkVersions: ForkVersions = ForkVersions { + genesis: Fork { + version: hex_literal::hex!("01017000"), // 0x01017000 + epoch: 0, + }, + altair: Fork { + version: hex_literal::hex!("01017000"), // 0x01017000 + epoch: 0, + }, + bellatrix: Fork { + version: hex_literal::hex!("01017000"), // 0x01017000 + epoch: 0, + }, + capella: Fork { + version: hex_literal::hex!("01017001"), // 0x01017001 + epoch: 256, + }, + deneb: Fork { + version: hex_literal::hex!("01017002"), // 0x01017002 + epoch: 29696, + }, + }; +} + +impl snowbridge_pallet_ethereum_client::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type ForkVersions = ChainForkVersions; + type WeightInfo = weights::snowbridge_pallet_ethereum_client::SubstrateWeight; +} diff --git a/solo-chains/runtime/dancelight/src/lib.rs b/solo-chains/runtime/dancelight/src/lib.rs index 89281b3ea..e31216f5e 100644 --- a/solo-chains/runtime/dancelight/src/lib.rs +++ b/solo-chains/runtime/dancelight/src/lib.rs @@ -143,6 +143,8 @@ use dancelight_runtime_constants::{currency::*, fee::*, time::*}; // XCM configurations. pub mod xcm_config; +pub mod bridge_to_ethereum_config; + // Weights mod weights; @@ -1573,9 +1575,10 @@ construct_runtime! { // BEEFY Bridges support. Beefy: pallet_beefy = 240, // MMR leaf construction must be after session in order to have a leaf's next_auth_set - // refer to block. See issue polkadot-fellows/runtimes#160 for details. + // refer to block. Mmr: pallet_mmr = 241, MmrLeaf: pallet_beefy_mmr = 242, + EthereumBeaconClient: snowbridge_pallet_ethereum_client = 243, ParasSudoWrapper: paras_sudo_wrapper = 250, @@ -1903,6 +1906,9 @@ mod benches { [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 85562f84d..fc873e13e 100644 --- a/solo-chains/runtime/dancelight/src/tests/common/mod.rs +++ b/solo-chains/runtime/dancelight/src/tests/common/mod.rs @@ -1179,3 +1179,13 @@ pub fn set_dummy_boot_node(para_manager: RuntimeOrigin, para_id: ParaId) { "profile should be correctly assigned" ); } +use milagro_bls::Keypair; +pub fn generate_ethereum_pub_keys(n: u32) -> Vec { + let mut keys = vec![]; + + for _i in 0..n { + let keypair = Keypair::random(&mut rand::thread_rng()); + keys.push(keypair); + } + keys +} diff --git a/solo-chains/runtime/dancelight/src/tests/ethereum_client.rs b/solo-chains/runtime/dancelight/src/tests/ethereum_client.rs new file mode 100644 index 000000000..6545750c2 --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/ethereum_client.rs @@ -0,0 +1,309 @@ +// 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 + +#![cfg(test)] + +use { + crate::tests::common::*, + crate::EthereumBeaconClient, + frame_support::{assert_noop, assert_ok}, + snowbridge_pallet_ethereum_client::functions::*, + snowbridge_pallet_ethereum_client::mock::*, + sp_core::H256, + sp_std::vec, +}; +#[test] +fn test_ethereum_force_checkpoint() { + 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(|| { + // This tests submits the initial checkpoint that contains the initial sync committee + let checkpoint = + Box::new(snowbridge_pallet_ethereum_client::mock::load_checkpoint_update_fixture()); + assert_ok!(EthereumBeaconClient::force_checkpoint( + root_origin(), + checkpoint.clone() + )); + // assert checkpoint has updated storages + assert_eq!( + EthereumBeaconClient::initial_checkpoint_root(), + checkpoint.header.hash_tree_root().unwrap() + ); + // sync committee is correct + let unwrap_keys: Vec = + snowbridge_pallet_ethereum_client::CurrentSyncCommittee::::get() + .pubkeys + .iter() + .map(|key| { + let unwrapped = key.as_bytes(); + let pubkey: snowbridge_beacon_primitives::PublicKey = unwrapped.into(); + pubkey + }) + .collect(); + assert_eq!( + unwrap_keys, + checkpoint.current_sync_committee.pubkeys.to_vec() + ); + }) +} + +#[test] +fn test_invalid_initial_checkpoint() { + 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(|| { + let mut checkpoint_invalid_sync_committee_proof = Box::new(snowbridge_pallet_ethereum_client::mock::load_checkpoint_update_fixture()); + + let mut checkpoint_invalid_blocks_root_proof = checkpoint_invalid_sync_committee_proof.clone(); + + let mut check_invalid_sync_committee = checkpoint_invalid_sync_committee_proof.clone(); + + checkpoint_invalid_sync_committee_proof.current_sync_committee_branch[0] = H256::default(); + checkpoint_invalid_blocks_root_proof.block_roots_branch[0] = H256::default(); + let new_random_keys: Vec = generate_ethereum_pub_keys(snowbridge_pallet_ethereum_client::config::SYNC_COMMITTEE_SIZE as u32).iter().map(|key| { + let public: snowbridge_beacon_primitives::PublicKey = key.pk.as_bytes().into(); + public + }).collect(); + check_invalid_sync_committee.current_sync_committee.pubkeys = new_random_keys.try_into().expect("cannot convert keys"); + assert_noop!( + EthereumBeaconClient::force_checkpoint(root_origin(), checkpoint_invalid_sync_committee_proof), + snowbridge_pallet_ethereum_client::Error::::InvalidSyncCommitteeMerkleProof + ); + + assert_noop!( + EthereumBeaconClient::force_checkpoint(root_origin(), checkpoint_invalid_blocks_root_proof), + snowbridge_pallet_ethereum_client::Error::::InvalidBlockRootsRootMerkleProof + ); + + assert_noop!( + EthereumBeaconClient::force_checkpoint(root_origin(), check_invalid_sync_committee), + snowbridge_pallet_ethereum_client::Error::::InvalidSyncCommitteeMerkleProof + ); + }); +} + +#[test] +fn test_submit_update_using_same_committee_same_checkpoint() { + 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(|| { + // This tests submits a new header signed by the sync committee members within the same + // period BUT without injecting the next sync committee + let initial_checkpoint = + Box::new(snowbridge_pallet_ethereum_client::mock::load_checkpoint_update_fixture()); + let update_header = Box::new( + snowbridge_pallet_ethereum_client::mock::load_finalized_header_update_fixture(), + ); + + let initial_period = compute_period(initial_checkpoint.header.slot); + let update_period = compute_period(update_header.finalized_header.slot); + assert_eq!(initial_period, update_period); + assert_ok!(EthereumBeaconClient::force_checkpoint( + root_origin(), + initial_checkpoint.clone() + )); + assert_ok!(EthereumBeaconClient::submit( + origin_of(ALICE.into()), + update_header.clone() + )); + let block_root: H256 = update_header.finalized_header.hash_tree_root().unwrap(); + assert!(snowbridge_pallet_ethereum_client::FinalizedBeaconState::< + Runtime, + >::contains_key(block_root)); + }); +} + +#[test] +fn test_submit_update_with_next_sync_committee_in_current_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(|| { + // This tests submits a new header signed by the sync committee members within the same + // period AND injecting the next sync committee + let initial_checkpoint = Box::new(load_checkpoint_update_fixture()); + let update_header = Box::new(load_sync_committee_update_fixture()); + let initial_period = compute_period(initial_checkpoint.header.slot); + let update_period = compute_period(update_header.finalized_header.slot); + assert_eq!(initial_period, update_period); + assert_ok!(EthereumBeaconClient::force_checkpoint( + root_origin(), + initial_checkpoint.clone() + )); + assert!(!snowbridge_pallet_ethereum_client::NextSyncCommittee::< + Runtime, + >::exists()); + assert_ok!(EthereumBeaconClient::submit( + origin_of(ALICE.into()), + update_header.clone() + )); + assert!(snowbridge_pallet_ethereum_client::NextSyncCommittee::< + Runtime, + >::exists()); + }); +} + +#[test] +fn test_submit_update_with_next_sync_committee_in_current_period_without_majority() { + 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(|| { + // This tests submits a new header signed by the sync committee members within the same + // period BUT putting all signed bits to 0 + let initial_checkpoint = Box::new(load_checkpoint_update_fixture()); + let mut update_header = Box::new(load_sync_committee_update_fixture()); + update_header.sync_aggregate.sync_committee_bits = [0u8; snowbridge_pallet_ethereum_client::config::SYNC_COMMITTEE_BITS_SIZE]; + let initial_period = compute_period(initial_checkpoint.header.slot); + let update_period = compute_period(update_header.finalized_header.slot); + assert_eq!(initial_period, update_period); + assert_ok!(EthereumBeaconClient::force_checkpoint( + root_origin(), + initial_checkpoint.clone() + )); + assert_noop!(EthereumBeaconClient::submit(origin_of(ALICE.into()), update_header.clone()), snowbridge_pallet_ethereum_client::Error::::SyncCommitteeParticipantsNotSupermajority); + }); +} + +#[test] +fn test_submit_update_in_next_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(|| { + // This test submits, assuming current period is n: + // 1. A header in the next period n+1 but without having set the next sync committee, which fails + // 2. Then submits a proper sync committee update for this period (n), indicating who the next sync committee will be + // 3. Then submits an update on the next period (n+1), but without indicating who the next committee is going to be again (in period n+2), which fails + // 4. Then submits a header on the next period(n+1), this time indicating who the next sync committee is going to be + // 4. Then submits an update on the next period(n+1) + + // Generate fixtures using a separate thread with 50MB stack size because those structs are huge + let ( + initial_checkpoint, + sync_committee_update, + next_sync_committee_update, + next_update, + ) = with_increased_stack_size(50, || { + let initial_checkpoint = Box::new(load_checkpoint_update_fixture()); + let sync_committee_update = Box::new(load_sync_committee_update_fixture()); + let next_sync_committee_update = + Box::new(load_next_sync_committee_update_fixture()); + let next_update = Box::new(load_next_finalized_header_update_fixture()); + + ( + initial_checkpoint, + sync_committee_update, + next_sync_committee_update, + next_update, + ) + }); + + let initial_period = compute_period(initial_checkpoint.header.slot); + + assert_ok!(EthereumBeaconClient::force_checkpoint( + root_origin(), + initial_checkpoint.clone() + )); + + // we need an update about the sync committee before we proceed + assert_noop!( + EthereumBeaconClient::submit(origin_of(ALICE.into()), next_update.clone()), + snowbridge_pallet_ethereum_client::Error::::SkippedSyncCommitteePeriod + ); + + assert_ok!(EthereumBeaconClient::submit( + origin_of(ALICE.into()), + sync_committee_update.clone() + )); + + // we need an update about the next sync committee + assert_noop!( + EthereumBeaconClient::submit(origin_of(ALICE.into()), next_update.clone()), + snowbridge_pallet_ethereum_client::Error::::SyncCommitteeUpdateRequired + ); + + assert_ok!(EthereumBeaconClient::submit( + origin_of(ALICE.into()), + next_sync_committee_update.clone() + )); + + // check we are now in period +1 + let latest_finalized_block_root = + snowbridge_pallet_ethereum_client::LatestFinalizedBlockRoot::::get(); + let last_finalized_state = snowbridge_pallet_ethereum_client::FinalizedBeaconState::< + Runtime, + >::get(latest_finalized_block_root) + .unwrap(); + let last_synced_period = compute_period(last_finalized_state.slot); + assert_eq!(last_synced_period, initial_period + 1); + + assert_ok!(EthereumBeaconClient::submit( + origin_of(ALICE.into()), + next_update.clone() + )); + }); +} + +fn with_increased_stack_size(stack_size_mb: usize, closure: F) -> T +where + F: FnOnce() -> T + Send + 'static, + T: Send + 'static, +{ + let builder = std::thread::Builder::new().stack_size(stack_size_mb * 1024 * 1024); + let handle = builder.spawn(closure).unwrap(); + + handle.join().unwrap() +} diff --git a/solo-chains/runtime/dancelight/src/tests/mod.rs b/solo-chains/runtime/dancelight/src/tests/mod.rs index 4bfb9e8b2..48445c337 100644 --- a/solo-chains/runtime/dancelight/src/tests/mod.rs +++ b/solo-chains/runtime/dancelight/src/tests/mod.rs @@ -24,6 +24,7 @@ mod author_noting_tests; mod collator_assignment_tests; mod common; mod core_scheduling_tests; +mod ethereum_client; mod inflation_rewards; mod integration_test; mod relay_configuration; diff --git a/solo-chains/runtime/dancelight/src/weights/mod.rs b/solo-chains/runtime/dancelight/src/weights/mod.rs index 99e117472..5e91a36c3 100644 --- a/solo-chains/runtime/dancelight/src/weights/mod.rs +++ b/solo-chains/runtime/dancelight/src/weights/mod.rs @@ -45,3 +45,4 @@ pub mod runtime_parachains_inclusion; pub mod runtime_parachains_initializer; pub mod runtime_parachains_paras; pub mod runtime_parachains_paras_inherent; +pub mod snowbridge_pallet_ethereum_client; diff --git a/solo-chains/runtime/dancelight/src/weights/snowbridge_pallet_ethereum_client.rs b/solo-chains/runtime/dancelight/src/weights/snowbridge_pallet_ethereum_client.rs new file mode 100644 index 000000000..7c9bceeaf --- /dev/null +++ b/solo-chains/runtime/dancelight/src/weights/snowbridge_pallet_ethereum_client.rs @@ -0,0 +1,123 @@ +// 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 snowbridge_pallet_ethereum_client +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 42.0.0 +//! DATE: 2024-10-11, 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 +// snowbridge_pallet_ethereum_client +// --extrinsic +// * +// --chain=dev +// --steps +// 50 +// --repeat +// 20 +// --template=./benchmarking/frame-weight-runtime-template.hbs +// --json-file +// raw.json +// --output +// tmp/snowbridge_pallet_ethereum_client.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 snowbridge_pallet_ethereum_client using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl snowbridge_pallet_ethereum_client::WeightInfo for SubstrateWeight { + /// Storage: `EthereumBeaconClient::FinalizedBeaconStateIndex` (r:1 w:1) + /// Proof: `EthereumBeaconClient::FinalizedBeaconStateIndex` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconStateMapping` (r:1 w:1) + /// Proof: `EthereumBeaconClient::FinalizedBeaconStateMapping` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::NextSyncCommittee` (r:0 w:1) + /// Proof: `EthereumBeaconClient::NextSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::InitialCheckpointRoot` (r:0 w:1) + /// Proof: `EthereumBeaconClient::InitialCheckpointRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::ValidatorsRoot` (r:0 w:1) + /// Proof: `EthereumBeaconClient::ValidatorsRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::LatestFinalizedBlockRoot` (r:0 w:1) + /// Proof: `EthereumBeaconClient::LatestFinalizedBlockRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::CurrentSyncCommittee` (r:0 w:1) + /// Proof: `EthereumBeaconClient::CurrentSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconState` (r:0 w:1) + /// Proof: `EthereumBeaconClient::FinalizedBeaconState` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + fn force_checkpoint() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `3501` + // Minimum execution time: 74_948_835_000 picoseconds. + Weight::from_parts(75_200_136_000, 3501) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) + } + /// Storage: `EthereumBeaconClient::OperatingMode` (r:1 w:0) + /// Proof: `EthereumBeaconClient::OperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::LatestFinalizedBlockRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::LatestFinalizedBlockRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconState` (r:1 w:0) + /// Proof: `EthereumBeaconClient::FinalizedBeaconState` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::NextSyncCommittee` (r:1 w:0) + /// Proof: `EthereumBeaconClient::NextSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::CurrentSyncCommittee` (r:1 w:0) + /// Proof: `EthereumBeaconClient::CurrentSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::ValidatorsRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::ValidatorsRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + fn submit() -> Weight { + // Proof Size summary in bytes: + // Measured: `92782` + // Estimated: `93857` + // Minimum execution time: 18_237_384_000 picoseconds. + Weight::from_parts(18_313_625_000, 93857) + .saturating_add(T::DbWeight::get().reads(6_u64)) + } + /// Storage: `EthereumBeaconClient::OperatingMode` (r:1 w:0) + /// Proof: `EthereumBeaconClient::OperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::LatestFinalizedBlockRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::LatestFinalizedBlockRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconState` (r:1 w:0) + /// Proof: `EthereumBeaconClient::FinalizedBeaconState` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::NextSyncCommittee` (r:1 w:1) + /// Proof: `EthereumBeaconClient::NextSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::CurrentSyncCommittee` (r:1 w:0) + /// Proof: `EthereumBeaconClient::CurrentSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::ValidatorsRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::ValidatorsRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + fn submit_with_sync_committee() -> Weight { + // Proof Size summary in bytes: + // Measured: `92782` + // Estimated: `93857` + // Minimum execution time: 93_102_798_000 picoseconds. + Weight::from_parts(93_339_834_000, 93857) + .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } +} \ No newline at end of file diff --git a/test/moonwall.config.json b/test/moonwall.config.json index 84d97d283..faa710c1d 100644 --- a/test/moonwall.config.json +++ b/test/moonwall.config.json @@ -51,6 +51,7 @@ "name": "dev_tanssi_relay", "envVars": ["DEBUG_COLORS=1"], "testFileDir": ["suites/dev-tanssi-relay", "suites/common-all", "suites/common-tanssi"], + "runScripts": ["download-ethereum-client-test-files.sh"], "multiThreads": true, "timeout": 240000, "reporters": ["basic"], diff --git a/test/scripts/download-ethereum-client-test-files.sh b/test/scripts/download-ethereum-client-test-files.sh new file mode 100755 index 000000000..008ede140 --- /dev/null +++ b/test/scripts/download-ethereum-client-test-files.sh @@ -0,0 +1,24 @@ +#!/bin/bash + +# Exit on any error +set -e + +# Always run the commands from the "test" dir +cd $(dirname $0)/.. + +# Grab Polkadot version +branch=$(egrep -o '/polkadot-sdk.*#([^\"]*)' ../Cargo.lock | head -1) +polkadot_release=$(echo $branch | sed 's/.*branch=//' | sed 's/#.*//') +if [ -f tmp/ethereum_client_test/latest_version.txt ]; then + stored_version=$(< tmp/ethereum_client_test/latest_version.txt) + if [[ "$polkadot_release" == "$stored_version" ]]; then + echo "Stored version is latest, nothing to do" + exit 0; + fi +fi +mkdir -p tmp +wget -O - tmp/ethereum_client_test https://github.com/moondance-labs/polkadot-sdk/archive/$polkadot_release.tar.gz | tar -xz --strip=6 "polkadot-sdk-$polkadot_release/bridges/snowbridge/pallets/ethereum-client/tests/fixtures" +# remove for a clean move +rm -rf tmp/ethereum_client_test +mv -u fixtures tmp/ethereum_client_test +echo $polkadot_release > tmp/ethereum_client_test/latest_version.txt \ No newline at end of file diff --git a/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-initial-checkpoint.ts b/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-initial-checkpoint.ts new file mode 100644 index 000000000..b955ecc32 --- /dev/null +++ b/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-initial-checkpoint.ts @@ -0,0 +1,43 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { readFileSync } from "fs"; +import { KeyringPair } from "@moonwall/util"; + +describeSuite({ + id: "DTR1201", + title: "Ethereum Beacon Client tests", + foundationMethods: "dev", + + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + + beforeAll(async () => { + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + }); + + it({ + id: "E01", + title: "Ethreum client should accept an intiial checkpoint", + test: async function () { + const initialCheckpoint = JSON.parse( + readFileSync("tmp/ethereum_client_test/initial-checkpoint.json").toString() + ); + const tx = polkadotJs.tx.ethereumBeaconClient.forceCheckpoint(initialCheckpoint); + const signedTx = await polkadotJs.tx.sudo.sudo(tx).signAsync(alice); + await context.createBlock([signedTx]); + const checkpointRoot = await polkadotJs.query.ethereumBeaconClient.validatorsRoot(); + expect(checkpointRoot.toHuman()).to.equal(initialCheckpoint["validators_root"]); + + const latestFinalizedBlockRoot = await polkadotJs.query.ethereumBeaconClient.latestFinalizedBlockRoot(); + const latestFinalizedSlot = await polkadotJs.query.ethereumBeaconClient.finalizedBeaconState( + latestFinalizedBlockRoot + ); + + expect(latestFinalizedSlot.toHuman().slot).to.equal(initialCheckpoint["header"]["slot"].toString()); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-submit-update-for-next-period-without-committee.ts b/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-submit-update-for-next-period-without-committee.ts new file mode 100644 index 000000000..ee4c859c5 --- /dev/null +++ b/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-submit-update-for-next-period-without-committee.ts @@ -0,0 +1,56 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { readFileSync } from "fs"; +import { KeyringPair } from "@moonwall/util"; + +describeSuite({ + id: "DTR1202", + title: "Ethereum Beacon Client tests", + foundationMethods: "dev", + + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let initialSlot; + String; + + beforeAll(async () => { + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + + const initialCheckpoint = JSON.parse( + readFileSync("tmp/ethereum_client_test/initial-checkpoint.json").toString() + ); + initialSlot = initialCheckpoint["header"]["slot"].toString(); + const tx = polkadotJs.tx.ethereumBeaconClient.forceCheckpoint(initialCheckpoint); + const signedTx = await polkadotJs.tx.sudo.sudo(tx).signAsync(alice); + await context.createBlock([signedTx]); + }); + + it({ + id: "E02", + title: "Ethreum client should not be able to receive an update for the next period without the next sync committee", + test: async function () { + const nextPeriodUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/next-finalized-header-update.json").toString() + ); + const tx = polkadotJs.tx.ethereumBeaconClient.submit(nextPeriodUpdate); + const signedTx = await tx.signAsync(alice); + const { result } = await context.createBlock([signedTx]); + + expect(result[0].successful).to.be.false; + expect(result[0].error.section).to.eq("ethereumBeaconClient"); + expect(result[0].error.name).to.eq("SkippedSyncCommitteePeriod"); + + const latestFinalizedBlockRoot = await polkadotJs.query.ethereumBeaconClient.latestFinalizedBlockRoot(); + const latestFinalizedSlot = await polkadotJs.query.ethereumBeaconClient.finalizedBeaconState( + latestFinalizedBlockRoot + ); + + // The update did not go through, so the slot is the same as the initial one + expect(latestFinalizedSlot.toHuman().slot).to.equal(initialSlot); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-submit-update-same-period.ts b/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-submit-update-same-period.ts new file mode 100644 index 000000000..c6bdd0c0b --- /dev/null +++ b/test/suites/dev-tanssi-relay/eth-client/test-eth-ciient-submit-update-same-period.ts @@ -0,0 +1,50 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { readFileSync } from "fs"; +import { KeyringPair } from "@moonwall/util"; + +describeSuite({ + id: "DTR1203", + title: "Ethereum Beacon Client tests", + foundationMethods: "dev", + + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + + beforeAll(async () => { + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + + const initialCheckpoint = JSON.parse( + readFileSync("tmp/ethereum_client_test/initial-checkpoint.json").toString() + ); + const tx = polkadotJs.tx.ethereumBeaconClient.forceCheckpoint(initialCheckpoint); + const signedTx = await polkadotJs.tx.sudo.sudo(tx).signAsync(alice); + await context.createBlock([signedTx]); + }); + + it({ + id: "E02", + title: "Ethreum client should be able to receive an update within the same period by same committee", + test: async function () { + const samePeriodUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/finalized-header-update.json").toString() + ); + const tx = polkadotJs.tx.ethereumBeaconClient.submit(samePeriodUpdate); + const signedTx = await tx.signAsync(alice); + await context.createBlock([signedTx]); + + const latestFinalizedBlockRoot = await polkadotJs.query.ethereumBeaconClient.latestFinalizedBlockRoot(); + const latestFinalizedSlot = await polkadotJs.query.ethereumBeaconClient.finalizedBeaconState( + latestFinalizedBlockRoot + ); + + expect(latestFinalizedSlot.toHuman().slot).to.equal( + samePeriodUpdate["finalized_header"]["slot"].toString() + ); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/eth-client/test-eth-client-submit-update-cannot-be-done-without-injecting-new-committee.ts b/test/suites/dev-tanssi-relay/eth-client/test-eth-client-submit-update-cannot-be-done-without-injecting-new-committee.ts new file mode 100644 index 000000000..2230da068 --- /dev/null +++ b/test/suites/dev-tanssi-relay/eth-client/test-eth-client-submit-update-cannot-be-done-without-injecting-new-committee.ts @@ -0,0 +1,79 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { readFileSync } from "fs"; +import { KeyringPair } from "@moonwall/util"; + +describeSuite({ + id: "DTR1204", + title: "Ethereum Beacon Client tests", + foundationMethods: "dev", + + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + let initialSlot; + String; + + beforeAll(async () => { + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + + const initialCheckpoint = JSON.parse( + readFileSync("tmp/ethereum_client_test/initial-checkpoint.json").toString() + ); + initialSlot = initialCheckpoint["header"]["slot"].toString(); + const tx = polkadotJs.tx.ethereumBeaconClient.forceCheckpoint(initialCheckpoint); + const signedTx = await polkadotJs.tx.sudo.sudo(tx).signAsync(alice); + await context.createBlock([signedTx]); + }); + + it({ + id: "E01", + title: "Ethreum client should not be able to receive an update for the next period without pushing the following sync committee", + test: async function () { + // Next sync committee shold give us the default values + const nextSyncCommitteeBeforeUpdate = await polkadotJs.query.ethereumBeaconClient.nextSyncCommittee(); + expect(nextSyncCommitteeBeforeUpdate.root.toHuman()).to.be.eq( + "0x0000000000000000000000000000000000000000000000000000000000000000" + ); + + const thisPeriodNextSyncCommitteeUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/sync-committee-update.json").toString() + ); + await context.createBlock([ + await polkadotJs.tx.ethereumBeaconClient.submit(thisPeriodNextSyncCommitteeUpdate).signAsync(alice), + ]); + + // Now the next sync committee should have been populated + const nextSyncCommittee = await polkadotJs.query.ethereumBeaconClient.nextSyncCommittee(); + expect(nextSyncCommittee.root.toHuman()).to.not.be.eq( + "0x0000000000000000000000000000000000000000000000000000000000000000" + ); + + // Now we are injecting an update for the next period, but without specifying who the next committee is. + // this will fail, if you push an update in a new period, you always need to push the new sync committee + const nextPeriodUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/next-finalized-header-update.json").toString() + ); + const tx = polkadotJs.tx.ethereumBeaconClient.submit(nextPeriodUpdate); + const signedTx = await tx.signAsync(alice); + const { result } = await context.createBlock([signedTx]); + + expect(result[0].successful).to.be.false; + expect(result[0].error.section).to.eq("ethereumBeaconClient"); + expect(result[0].error.name).to.eq("SyncCommitteeUpdateRequired"); + + const latestFinalizedBlockRoot = await polkadotJs.query.ethereumBeaconClient.latestFinalizedBlockRoot(); + const latestFinalizedSlot = await polkadotJs.query.ethereumBeaconClient.finalizedBeaconState( + latestFinalizedBlockRoot + ); + + // The update did not go through, so the slot is the same as the latest one we pushed + // The sync committee update has a a finalized slot lower than the initial, so we keep the + // initial + expect(latestFinalizedSlot.toHuman().slot).to.equal(initialSlot); + }, + }); + }, +}); diff --git a/test/suites/dev-tanssi-relay/eth-client/test-eth-client-submit-update-next-period-with-proper-committees.ts b/test/suites/dev-tanssi-relay/eth-client/test-eth-client-submit-update-next-period-with-proper-committees.ts new file mode 100644 index 000000000..09a286f8d --- /dev/null +++ b/test/suites/dev-tanssi-relay/eth-client/test-eth-client-submit-update-next-period-with-proper-committees.ts @@ -0,0 +1,82 @@ +import "@tanssi/api-augment"; +import { describeSuite, expect, beforeAll } from "@moonwall/cli"; +import { ApiPromise } from "@polkadot/api"; +import { readFileSync } from "fs"; +import { KeyringPair } from "@moonwall/util"; + +describeSuite({ + id: "DTR1205", + title: "Ethereum Beacon Client tests", + foundationMethods: "dev", + + testCases: ({ it, context }) => { + let polkadotJs: ApiPromise; + let alice: KeyringPair; + + beforeAll(async () => { + polkadotJs = context.polkadotJs(); + alice = context.keyring.alice; + + const initialCheckpoint = JSON.parse( + readFileSync("tmp/ethereum_client_test/initial-checkpoint.json").toString() + ); + const tx = polkadotJs.tx.ethereumBeaconClient.forceCheckpoint(initialCheckpoint); + const signedTx = await polkadotJs.tx.sudo.sudo(tx).signAsync(alice); + await context.createBlock([signedTx]); + }); + + it({ + id: "E01", + title: "Ethreum client should be able to receive an update for the next period when pushing all committee info", + test: async function () { + // Next sync committee shold give us the default values + const nextSyncCommitteeBeforeUpdate = await polkadotJs.query.ethereumBeaconClient.nextSyncCommittee(); + expect(nextSyncCommitteeBeforeUpdate.root.toHuman()).to.be.eq( + "0x0000000000000000000000000000000000000000000000000000000000000000" + ); + + const thisPeriodNextSyncCommitteeUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/sync-committee-update.json").toString() + ); + await context.createBlock([ + await polkadotJs.tx.ethereumBeaconClient.submit(thisPeriodNextSyncCommitteeUpdate).signAsync(alice), + ]); + + // Now the next sync committee should have been populated + const nextSyncCommittee = await polkadotJs.query.ethereumBeaconClient.nextSyncCommittee(); + expect(nextSyncCommittee.root.toHuman()).to.not.be.eq( + "0x0000000000000000000000000000000000000000000000000000000000000000" + ); + + // Now we are injecting the first update of the next period + // this should contain the next sync committee + const nextPeriodSyncCommitteeUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/next-sync-committee-update.json").toString() + ); + await context.createBlock([ + await polkadotJs.tx.ethereumBeaconClient.submit(nextPeriodSyncCommitteeUpdate).signAsync(alice), + ]); + + // Now we are injecting an update for the period 'intial period +1' for which + // we have already pushed the sync committee update. Since this needs to be done + // only once per period, we shoudl be good + const nextPeriodUpdate = JSON.parse( + readFileSync("tmp/ethereum_client_test/next-finalized-header-update.json").toString() + ); + + await context.createBlock([ + await polkadotJs.tx.ethereumBeaconClient.submit(nextPeriodUpdate).signAsync(alice), + ]); + + const latestFinalizedBlockRoot = await polkadotJs.query.ethereumBeaconClient.latestFinalizedBlockRoot(); + const latestFinalizedSlot = await polkadotJs.query.ethereumBeaconClient.finalizedBeaconState( + latestFinalizedBlockRoot + ); + + // The update did go through, we should have the latest state + const expectedSlot = nextPeriodUpdate["finalized_header"]["slot"]; + expect(latestFinalizedSlot.toHuman().slot.replace(/,/g, "")).to.equal(expectedSlot.toString()); + }, + }); + }, +}); diff --git a/typescript-api/src/dancelight/interfaces/augment-api-consts.ts b/typescript-api/src/dancelight/interfaces/augment-api-consts.ts index 4da72612c..6a5c3382f 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-consts.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-consts.ts @@ -14,6 +14,7 @@ import type { FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletReferendaTrackInfo, + SnowbridgeBeaconPrimitivesForkVersions, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight, @@ -127,6 +128,11 @@ declare module "@polkadot/api-base/types/consts" { /** Generic const */ [key: string]: Codec; }; + ethereumBeaconClient: { + forkVersions: SnowbridgeBeaconPrimitivesForkVersions & 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 1c5c4bcf5..ddcc575ff 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-errors.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-errors.ts @@ -191,6 +191,44 @@ declare module "@polkadot/api-base/types/errors" { /** Generic error */ [key: string]: AugmentedError; }; + ethereumBeaconClient: { + BlockBodyHashTreeRootFailed: AugmentedError; + BLSPreparePublicKeysFailed: AugmentedError; + BLSVerificationFailed: AugmentedError; + ExecutionHeaderSkippedBlock: AugmentedError; + ExecutionHeaderTooFarBehind: AugmentedError; + ExpectedFinalizedHeaderNotStored: AugmentedError; + ForkDataHashTreeRootFailed: AugmentedError; + Halted: AugmentedError; + HeaderHashTreeRootFailed: AugmentedError; + HeaderNotFinalized: AugmentedError; + InvalidAncestryMerkleProof: AugmentedError; + InvalidBlockRootsRootMerkleProof: AugmentedError; + InvalidExecutionHeaderProof: AugmentedError; + /** + * The gap between the finalized headers is larger than the sync committee period, rendering execution headers + * unprovable using ancestry proofs (blocks root size is the same as the sync committee period slots). + */ + InvalidFinalizedHeaderGap: AugmentedError; + InvalidHeaderMerkleProof: AugmentedError; + InvalidSyncCommitteeMerkleProof: AugmentedError; + /** + * The given update is not in the expected period, or the given next sync committee does not match the next sync + * committee in storage. + */ + InvalidSyncCommitteeUpdate: AugmentedError; + InvalidUpdateSlot: AugmentedError; + /** Attested header is older than latest finalized header. */ + IrrelevantUpdate: AugmentedError; + NotBootstrapped: AugmentedError; + SigningRootHashTreeRootFailed: AugmentedError; + SkippedSyncCommitteePeriod: AugmentedError; + SyncCommitteeHashTreeRootFailed: AugmentedError; + SyncCommitteeParticipantsNotSupermajority: AugmentedError; + SyncCommitteeUpdateRequired: 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 14c2e043d..1d1ff8bf6 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-events.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-events.ts @@ -27,6 +27,7 @@ import type { PolkadotRuntimeParachainsDisputesDisputeLocation, PolkadotRuntimeParachainsDisputesDisputeResult, PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, + SnowbridgeCoreOperatingModeBasicOperatingMode, SpConsensusGrandpaAppPublic, SpRuntimeDispatchError, SpRuntimeDispatchErrorWithPostInfo, @@ -198,6 +199,18 @@ declare module "@polkadot/api-base/types/events" { /** Generic event */ [key: string]: AugmentedEvent; }; + ethereumBeaconClient: { + BeaconHeaderImported: AugmentedEvent; + /** Set OperatingMode */ + OperatingModeChanged: AugmentedEvent< + ApiType, + [mode: SnowbridgeCoreOperatingModeBasicOperatingMode], + { mode: SnowbridgeCoreOperatingModeBasicOperatingMode } + >; + SyncCommitteeUpdated: AugmentedEvent; + /** 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 8c2d993d8..c4db62082 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-query.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-query.ts @@ -103,6 +103,9 @@ import type { PolkadotRuntimeParachainsSchedulerPalletCoreOccupied, PolkadotRuntimeParachainsSchedulerPalletParasEntry, PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker, + SnowbridgeBeaconPrimitivesCompactBeaconState, + SnowbridgeBeaconPrimitivesSyncCommitteePrepared, + SnowbridgeCoreOperatingModeBasicOperatingMode, SpAuthorityDiscoveryAppPublic, SpConsensusBabeAppPublic, SpConsensusBabeBabeEpochConfiguration, @@ -607,6 +610,55 @@ declare module "@polkadot/api-base/types/storage" { /** Generic query */ [key: string]: QueryableStorageEntry; }; + ethereumBeaconClient: { + /** Sync committee for current period */ + currentSyncCommittee: AugmentedQuery< + ApiType, + () => Observable, + [] + > & + QueryableStorageEntry; + /** Beacon state by finalized block root */ + finalizedBeaconState: AugmentedQuery< + ApiType, + (arg: H256 | string | Uint8Array) => Observable>, + [H256] + > & + QueryableStorageEntry; + /** Finalized Headers: Current position in ring buffer */ + finalizedBeaconStateIndex: AugmentedQuery Observable, []> & + QueryableStorageEntry; + /** Finalized Headers: Mapping of ring buffer index to a pruning candidate */ + finalizedBeaconStateMapping: AugmentedQuery< + ApiType, + (arg: u32 | AnyNumber | Uint8Array) => Observable, + [u32] + > & + QueryableStorageEntry; + /** Latest imported checkpoint root */ + initialCheckpointRoot: AugmentedQuery Observable, []> & + QueryableStorageEntry; + /** Latest imported finalized block root */ + latestFinalizedBlockRoot: AugmentedQuery Observable, []> & + QueryableStorageEntry; + /** Sync committee for next period */ + nextSyncCommittee: AugmentedQuery< + ApiType, + () => Observable, + [] + > & + QueryableStorageEntry; + /** The current operating mode of the pallet. */ + operatingMode: AugmentedQuery< + ApiType, + () => Observable, + [] + > & + QueryableStorageEntry; + validatorsRoot: AugmentedQuery Observable, []> & 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 5a2489c86..0e866c463 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-tx.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-tx.ts @@ -45,6 +45,9 @@ import type { PolkadotPrimitivesVstagingSchedulerParams, PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, PolkadotRuntimeParachainsParasParaGenesisArgs, + SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate, + SnowbridgeBeaconPrimitivesUpdatesUpdate, + SnowbridgeCoreOperatingModeBasicOperatingMode, SpConsensusBabeDigestsNextConfigDescriptor, SpConsensusBeefyDoubleVotingProof, SpConsensusBeefyForkVotingProof, @@ -1222,6 +1225,55 @@ declare module "@polkadot/api-base/types/submittable" { /** Generic tx */ [key: string]: SubmittableExtrinsicFunction; }; + ethereumBeaconClient: { + /** Used for pallet initialization and light client resetting. Needs to be called by the root origin. */ + forceCheckpoint: AugmentedSubmittable< + ( + update: + | SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate + | { + header?: any; + currentSyncCommittee?: any; + currentSyncCommitteeBranch?: any; + validatorsRoot?: any; + blockRootsRoot?: any; + blockRootsBranch?: any; + } + | string + | Uint8Array + ) => SubmittableExtrinsic, + [SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate] + >; + /** Halt or resume all pallet operations. May only be called by root. */ + setOperatingMode: AugmentedSubmittable< + ( + mode: SnowbridgeCoreOperatingModeBasicOperatingMode | "Normal" | "Halted" | number | Uint8Array + ) => SubmittableExtrinsic, + [SnowbridgeCoreOperatingModeBasicOperatingMode] + >; + /** Submits a new finalized beacon header update. The update may contain the next sync committee. */ + submit: AugmentedSubmittable< + ( + update: + | SnowbridgeBeaconPrimitivesUpdatesUpdate + | { + attestedHeader?: any; + syncAggregate?: any; + signatureSlot?: any; + nextSyncCommitteeUpdate?: any; + finalizedHeader?: any; + finalityBranch?: any; + blockRootsRoot?: any; + blockRootsBranch?: any; + } + | string + | Uint8Array + ) => SubmittableExtrinsic, + [SnowbridgeBeaconPrimitivesUpdatesUpdate] + >; + /** 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 4844c0eb2..73c481a47 100644 --- a/typescript-api/src/dancelight/interfaces/lookup.ts +++ b/typescript-api/src/dancelight/interfaces/lookup.ts @@ -3784,7 +3784,73 @@ export default { SpConsensusBeefyFutureBlockVotingProof: { vote: "SpConsensusBeefyVoteMessage", }, - /** Lookup411: polkadot_runtime_common::paras_sudo_wrapper::pallet::Call */ + /** Lookup411: snowbridge_pallet_ethereum_client::pallet::Call */ + SnowbridgePalletEthereumClientCall: { + _enum: { + force_checkpoint: { + update: "SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate", + }, + submit: { + update: "SnowbridgeBeaconPrimitivesUpdatesUpdate", + }, + __Unused2: "Null", + set_operating_mode: { + mode: "SnowbridgeCoreOperatingModeBasicOperatingMode", + }, + }, + }, + /** Lookup412: snowbridge_beacon_primitives::updates::CheckpointUpdate */ + SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate: { + header: "SnowbridgeBeaconPrimitivesBeaconHeader", + currentSyncCommittee: "SnowbridgeBeaconPrimitivesSyncCommittee", + currentSyncCommitteeBranch: "Vec", + validatorsRoot: "H256", + blockRootsRoot: "H256", + blockRootsBranch: "Vec", + }, + /** Lookup413: snowbridge_beacon_primitives::types::BeaconHeader */ + SnowbridgeBeaconPrimitivesBeaconHeader: { + slot: "u64", + proposerIndex: "u64", + parentRoot: "H256", + stateRoot: "H256", + bodyRoot: "H256", + }, + /** Lookup414: snowbridge_beacon_primitives::types::SyncCommittee */ + SnowbridgeBeaconPrimitivesSyncCommittee: { + pubkeys: "[[u8;48];512]", + aggregatePubkey: "SnowbridgeBeaconPrimitivesPublicKey", + }, + /** Lookup416: snowbridge_beacon_primitives::types::PublicKey */ + SnowbridgeBeaconPrimitivesPublicKey: "[u8;48]", + /** Lookup418: snowbridge_beacon_primitives::updates::Update */ + SnowbridgeBeaconPrimitivesUpdatesUpdate: { + attestedHeader: "SnowbridgeBeaconPrimitivesBeaconHeader", + syncAggregate: "SnowbridgeBeaconPrimitivesSyncAggregate", + signatureSlot: "u64", + nextSyncCommitteeUpdate: "Option", + finalizedHeader: "SnowbridgeBeaconPrimitivesBeaconHeader", + finalityBranch: "Vec", + blockRootsRoot: "H256", + blockRootsBranch: "Vec", + }, + /** Lookup419: snowbridge_beacon_primitives::types::SyncAggregate */ + SnowbridgeBeaconPrimitivesSyncAggregate: { + syncCommitteeBits: "[u8;64]", + syncCommitteeSignature: "SnowbridgeBeaconPrimitivesSignature", + }, + /** Lookup420: snowbridge_beacon_primitives::types::Signature */ + SnowbridgeBeaconPrimitivesSignature: "[u8;96]", + /** Lookup423: snowbridge_beacon_primitives::updates::NextSyncCommitteeUpdate */ + SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate: { + nextSyncCommittee: "SnowbridgeBeaconPrimitivesSyncCommittee", + nextSyncCommitteeBranch: "Vec", + }, + /** Lookup424: snowbridge_core::operating_mode::BasicOperatingMode */ + SnowbridgeCoreOperatingModeBasicOperatingMode: { + _enum: ["Normal", "Halted"], + }, + /** Lookup425: polkadot_runtime_common::paras_sudo_wrapper::pallet::Call */ PolkadotRuntimeCommonParasSudoWrapperPalletCall: { _enum: { sudo_schedule_para_initialize: { @@ -3812,13 +3878,13 @@ export default { }, }, }, - /** Lookup412: polkadot_runtime_parachains::paras::ParaGenesisArgs */ + /** Lookup426: polkadot_runtime_parachains::paras::ParaGenesisArgs */ PolkadotRuntimeParachainsParasParaGenesisArgs: { genesisHead: "Bytes", validationCode: "Bytes", paraKind: "bool", }, - /** Lookup413: dancelight_runtime::validator_manager::pallet::Call */ + /** Lookup427: dancelight_runtime::validator_manager::pallet::Call */ DancelightRuntimeValidatorManagerPalletCall: { _enum: { register_validators: { @@ -3829,7 +3895,7 @@ export default { }, }, }, - /** Lookup414: pallet_root_testing::pallet::Call */ + /** Lookup428: pallet_root_testing::pallet::Call */ PalletRootTestingCall: { _enum: { fill_block: { @@ -3838,7 +3904,7 @@ export default { trigger_defensive: "Null", }, }, - /** Lookup415: pallet_sudo::pallet::Call */ + /** Lookup429: pallet_sudo::pallet::Call */ PalletSudoCall: { _enum: { sudo: { @@ -3861,15 +3927,15 @@ export default { remove_key: "Null", }, }, - /** Lookup416: sp_runtime::traits::BlakeTwo256 */ + /** Lookup430: sp_runtime::traits::BlakeTwo256 */ SpRuntimeBlakeTwo256: "Null", - /** Lookup418: pallet_conviction_voting::types::Tally */ + /** Lookup432: pallet_conviction_voting::types::Tally */ PalletConvictionVotingTally: { ayes: "u128", nays: "u128", support: "u128", }, - /** Lookup419: pallet_ranked_collective::pallet::Event */ + /** Lookup433: pallet_ranked_collective::pallet::Event */ PalletRankedCollectiveEvent: { _enum: { MemberAdded: { @@ -3895,20 +3961,20 @@ export default { }, }, }, - /** Lookup420: pallet_ranked_collective::VoteRecord */ + /** Lookup434: pallet_ranked_collective::VoteRecord */ PalletRankedCollectiveVoteRecord: { _enum: { Aye: "u32", Nay: "u32", }, }, - /** Lookup421: pallet_ranked_collective::Tally */ + /** Lookup435: pallet_ranked_collective::Tally */ PalletRankedCollectiveTally: { bareAyes: "u32", ayes: "u32", nays: "u32", }, - /** Lookup423: pallet_whitelist::pallet::Event */ + /** Lookup437: pallet_whitelist::pallet::Event */ PalletWhitelistEvent: { _enum: { CallWhitelisted: { @@ -3923,17 +3989,17 @@ export default { }, }, }, - /** Lookup425: frame_support::dispatch::PostDispatchInfo */ + /** Lookup439: frame_support::dispatch::PostDispatchInfo */ FrameSupportDispatchPostDispatchInfo: { actualWeight: "Option", paysFee: "FrameSupportDispatchPays", }, - /** Lookup427: sp_runtime::DispatchErrorWithPostInfo */ + /** Lookup441: sp_runtime::DispatchErrorWithPostInfo */ SpRuntimeDispatchErrorWithPostInfo: { postInfo: "FrameSupportDispatchPostDispatchInfo", error: "SpRuntimeDispatchError", }, - /** Lookup428: polkadot_runtime_parachains::inclusion::pallet::Event */ + /** Lookup442: polkadot_runtime_parachains::inclusion::pallet::Event */ PolkadotRuntimeParachainsInclusionPalletEvent: { _enum: { CandidateBacked: "(PolkadotPrimitivesV7CandidateReceipt,Bytes,u32,u32)", @@ -3945,12 +4011,12 @@ export default { }, }, }, - /** Lookup429: polkadot_primitives::v7::CandidateReceipt */ + /** Lookup443: polkadot_primitives::v7::CandidateReceipt */ PolkadotPrimitivesV7CandidateReceipt: { descriptor: "PolkadotPrimitivesV7CandidateDescriptor", commitmentsHash: "H256", }, - /** Lookup432: polkadot_runtime_parachains::paras::pallet::Event */ + /** Lookup446: polkadot_runtime_parachains::paras::pallet::Event */ PolkadotRuntimeParachainsParasPalletEvent: { _enum: { CurrentCodeUpdated: "u32", @@ -3963,7 +4029,7 @@ export default { PvfCheckRejected: "(H256,u32)", }, }, - /** Lookup433: polkadot_runtime_parachains::hrmp::pallet::Event */ + /** Lookup447: polkadot_runtime_parachains::hrmp::pallet::Event */ PolkadotRuntimeParachainsHrmpPalletEvent: { _enum: { OpenChannelRequested: { @@ -4002,7 +4068,7 @@ export default { }, }, }, - /** Lookup434: polkadot_runtime_parachains::disputes::pallet::Event */ + /** Lookup448: polkadot_runtime_parachains::disputes::pallet::Event */ PolkadotRuntimeParachainsDisputesPalletEvent: { _enum: { DisputeInitiated: "(H256,PolkadotRuntimeParachainsDisputesDisputeLocation)", @@ -4010,15 +4076,15 @@ export default { Revert: "u32", }, }, - /** Lookup435: polkadot_runtime_parachains::disputes::DisputeLocation */ + /** Lookup449: polkadot_runtime_parachains::disputes::DisputeLocation */ PolkadotRuntimeParachainsDisputesDisputeLocation: { _enum: ["Local", "Remote"], }, - /** Lookup436: polkadot_runtime_parachains::disputes::DisputeResult */ + /** Lookup450: polkadot_runtime_parachains::disputes::DisputeResult */ PolkadotRuntimeParachainsDisputesDisputeResult: { _enum: ["Valid", "Invalid"], }, - /** Lookup437: pallet_message_queue::pallet::Event */ + /** Lookup451: pallet_message_queue::pallet::Event */ PalletMessageQueueEvent: { _enum: { ProcessingFailed: { @@ -4044,7 +4110,7 @@ export default { }, }, }, - /** Lookup438: frame_support::traits::messages::ProcessMessageError */ + /** Lookup452: frame_support::traits::messages::ProcessMessageError */ FrameSupportMessagesProcessMessageError: { _enum: { BadFormat: "Null", @@ -4055,7 +4121,7 @@ export default { StackLimitReached: "Null", }, }, - /** Lookup439: polkadot_runtime_parachains::assigner_on_demand::pallet::Event */ + /** Lookup453: polkadot_runtime_parachains::assigner_on_demand::pallet::Event */ PolkadotRuntimeParachainsAssignerOnDemandPalletEvent: { _enum: { OnDemandOrderPlaced: { @@ -4068,7 +4134,7 @@ export default { }, }, }, - /** Lookup440: polkadot_runtime_common::paras_registrar::pallet::Event */ + /** Lookup454: polkadot_runtime_common::paras_registrar::pallet::Event */ PolkadotRuntimeCommonParasRegistrarPalletEvent: { _enum: { Registered: { @@ -4088,7 +4154,7 @@ export default { }, }, }, - /** Lookup441: pallet_utility::pallet::Event */ + /** Lookup455: pallet_utility::pallet::Event */ PalletUtilityEvent: { _enum: { BatchInterrupted: { @@ -4106,7 +4172,7 @@ export default { }, }, }, - /** Lookup443: pallet_identity::pallet::Event */ + /** Lookup457: pallet_identity::pallet::Event */ PalletIdentityEvent: { _enum: { IdentitySet: { @@ -4178,7 +4244,7 @@ export default { }, }, }, - /** Lookup444: pallet_scheduler::pallet::Event */ + /** Lookup458: pallet_scheduler::pallet::Event */ PalletSchedulerEvent: { _enum: { Scheduled: { @@ -4222,7 +4288,7 @@ export default { }, }, }, - /** Lookup446: pallet_proxy::pallet::Event */ + /** Lookup460: pallet_proxy::pallet::Event */ PalletProxyEvent: { _enum: { ProxyExecuted: { @@ -4253,7 +4319,7 @@ export default { }, }, }, - /** Lookup447: pallet_multisig::pallet::Event */ + /** Lookup461: pallet_multisig::pallet::Event */ PalletMultisigEvent: { _enum: { NewMultisig: { @@ -4282,7 +4348,7 @@ export default { }, }, }, - /** Lookup448: pallet_preimage::pallet::Event */ + /** Lookup462: pallet_preimage::pallet::Event */ PalletPreimageEvent: { _enum: { Noted: { @@ -4305,7 +4371,7 @@ export default { }, }, }, - /** Lookup449: pallet_asset_rate::pallet::Event */ + /** Lookup463: pallet_asset_rate::pallet::Event */ PalletAssetRateEvent: { _enum: { AssetRateCreated: { @@ -4325,7 +4391,7 @@ export default { }, }, }, - /** Lookup450: pallet_xcm::pallet::Event */ + /** Lookup464: pallet_xcm::pallet::Event */ PalletXcmEvent: { _enum: { Attempted: { @@ -4448,7 +4514,7 @@ export default { }, }, }, - /** Lookup451: staging_xcm::v4::traits::Outcome */ + /** Lookup465: staging_xcm::v4::traits::Outcome */ StagingXcmV4TraitsOutcome: { _enum: { Complete: { @@ -4463,7 +4529,7 @@ export default { }, }, }, - /** Lookup452: pallet_migrations::pallet::Event */ + /** Lookup466: pallet_migrations::pallet::Event */ PalletMigrationsEvent: { _enum: { RuntimeUpgradeStarted: "Null", @@ -4485,18 +4551,33 @@ export default { }, }, }, - /** Lookup454: dancelight_runtime::validator_manager::pallet::Event */ + /** Lookup468: snowbridge_pallet_ethereum_client::pallet::Event */ + SnowbridgePalletEthereumClientEvent: { + _enum: { + BeaconHeaderImported: { + blockHash: "H256", + slot: "u64", + }, + SyncCommitteeUpdated: { + period: "u64", + }, + OperatingModeChanged: { + mode: "SnowbridgeCoreOperatingModeBasicOperatingMode", + }, + }, + }, + /** Lookup469: dancelight_runtime::validator_manager::pallet::Event */ DancelightRuntimeValidatorManagerPalletEvent: { _enum: { ValidatorsRegistered: "Vec", ValidatorsDeregistered: "Vec", }, }, - /** Lookup455: pallet_root_testing::pallet::Event */ + /** Lookup470: pallet_root_testing::pallet::Event */ PalletRootTestingEvent: { _enum: ["DefensiveTestCall"], }, - /** Lookup456: pallet_sudo::pallet::Event */ + /** Lookup471: pallet_sudo::pallet::Event */ PalletSudoEvent: { _enum: { Sudid: { @@ -4515,7 +4596,7 @@ export default { }, }, }, - /** Lookup457: frame_system::Phase */ + /** Lookup472: frame_system::Phase */ FrameSystemPhase: { _enum: { ApplyExtrinsic: "u32", @@ -4523,51 +4604,51 @@ export default { Initialization: "Null", }, }, - /** Lookup459: frame_system::LastRuntimeUpgradeInfo */ + /** Lookup474: frame_system::LastRuntimeUpgradeInfo */ FrameSystemLastRuntimeUpgradeInfo: { specVersion: "Compact", specName: "Text", }, - /** Lookup461: frame_system::CodeUpgradeAuthorization */ + /** Lookup476: frame_system::CodeUpgradeAuthorization */ FrameSystemCodeUpgradeAuthorization: { codeHash: "H256", checkVersion: "bool", }, - /** Lookup462: frame_system::limits::BlockWeights */ + /** Lookup477: frame_system::limits::BlockWeights */ FrameSystemLimitsBlockWeights: { baseBlock: "SpWeightsWeightV2Weight", maxBlock: "SpWeightsWeightV2Weight", perClass: "FrameSupportDispatchPerDispatchClassWeightsPerClass", }, - /** Lookup463: frame_support::dispatch::PerDispatchClass */ + /** Lookup478: frame_support::dispatch::PerDispatchClass */ FrameSupportDispatchPerDispatchClassWeightsPerClass: { normal: "FrameSystemLimitsWeightsPerClass", operational: "FrameSystemLimitsWeightsPerClass", mandatory: "FrameSystemLimitsWeightsPerClass", }, - /** Lookup464: frame_system::limits::WeightsPerClass */ + /** Lookup479: frame_system::limits::WeightsPerClass */ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: "SpWeightsWeightV2Weight", maxExtrinsic: "Option", maxTotal: "Option", reserved: "Option", }, - /** Lookup465: frame_system::limits::BlockLength */ + /** Lookup480: frame_system::limits::BlockLength */ FrameSystemLimitsBlockLength: { max: "FrameSupportDispatchPerDispatchClassU32", }, - /** Lookup466: frame_support::dispatch::PerDispatchClass */ + /** Lookup481: frame_support::dispatch::PerDispatchClass */ FrameSupportDispatchPerDispatchClassU32: { normal: "u32", operational: "u32", mandatory: "u32", }, - /** Lookup467: sp_weights::RuntimeDbWeight */ + /** Lookup482: sp_weights::RuntimeDbWeight */ SpWeightsRuntimeDbWeight: { read: "u64", write: "u64", }, - /** Lookup468: sp_version::RuntimeVersion */ + /** Lookup483: sp_version::RuntimeVersion */ SpVersionRuntimeVersion: { specName: "Text", implName: "Text", @@ -4578,7 +4659,7 @@ export default { transactionVersion: "u32", stateVersion: "u8", }, - /** Lookup472: frame_system::pallet::Error */ + /** Lookup487: frame_system::pallet::Error */ FrameSystemError: { _enum: [ "InvalidSpecName", @@ -4592,7 +4673,7 @@ export default { "Unauthorized", ], }, - /** Lookup479: sp_consensus_babe::digests::PreDigest */ + /** Lookup494: sp_consensus_babe::digests::PreDigest */ SpConsensusBabeDigestsPreDigest: { _enum: { __Unused0: "Null", @@ -4601,34 +4682,34 @@ export default { SecondaryVRF: "SpConsensusBabeDigestsSecondaryVRFPreDigest", }, }, - /** Lookup480: sp_consensus_babe::digests::PrimaryPreDigest */ + /** Lookup495: sp_consensus_babe::digests::PrimaryPreDigest */ SpConsensusBabeDigestsPrimaryPreDigest: { authorityIndex: "u32", slot: "u64", vrfSignature: "SpCoreSr25519VrfVrfSignature", }, - /** Lookup481: sp_core::sr25519::vrf::VrfSignature */ + /** Lookup496: sp_core::sr25519::vrf::VrfSignature */ SpCoreSr25519VrfVrfSignature: { preOutput: "[u8;32]", proof: "[u8;64]", }, - /** Lookup482: sp_consensus_babe::digests::SecondaryPlainPreDigest */ + /** Lookup497: sp_consensus_babe::digests::SecondaryPlainPreDigest */ SpConsensusBabeDigestsSecondaryPlainPreDigest: { authorityIndex: "u32", slot: "u64", }, - /** Lookup483: sp_consensus_babe::digests::SecondaryVRFPreDigest */ + /** Lookup498: sp_consensus_babe::digests::SecondaryVRFPreDigest */ SpConsensusBabeDigestsSecondaryVRFPreDigest: { authorityIndex: "u32", slot: "u64", vrfSignature: "SpCoreSr25519VrfVrfSignature", }, - /** Lookup484: sp_consensus_babe::BabeEpochConfiguration */ + /** Lookup499: sp_consensus_babe::BabeEpochConfiguration */ SpConsensusBabeBabeEpochConfiguration: { c: "(u64,u64)", allowedSlots: "SpConsensusBabeAllowedSlots", }, - /** Lookup488: pallet_babe::pallet::Error */ + /** Lookup503: pallet_babe::pallet::Error */ PalletBabeError: { _enum: [ "InvalidEquivocationProof", @@ -4637,22 +4718,22 @@ export default { "InvalidConfiguration", ], }, - /** Lookup490: pallet_balances::types::BalanceLock */ + /** Lookup505: pallet_balances::types::BalanceLock */ PalletBalancesBalanceLock: { id: "[u8;8]", amount: "u128", reasons: "PalletBalancesReasons", }, - /** Lookup491: pallet_balances::types::Reasons */ + /** Lookup506: pallet_balances::types::Reasons */ PalletBalancesReasons: { _enum: ["Fee", "Misc", "All"], }, - /** Lookup494: pallet_balances::types::ReserveData */ + /** Lookup509: pallet_balances::types::ReserveData */ PalletBalancesReserveData: { id: "[u8;8]", amount: "u128", }, - /** Lookup498: dancelight_runtime::RuntimeHoldReason */ + /** Lookup513: dancelight_runtime::RuntimeHoldReason */ DancelightRuntimeRuntimeHoldReason: { _enum: { __Unused0: "Null", @@ -4743,24 +4824,24 @@ export default { Preimage: "PalletPreimageHoldReason", }, }, - /** Lookup499: pallet_registrar::pallet::HoldReason */ + /** Lookup514: pallet_registrar::pallet::HoldReason */ PalletRegistrarHoldReason: { _enum: ["RegistrarDeposit"], }, - /** Lookup500: pallet_data_preservers::pallet::HoldReason */ + /** Lookup515: pallet_data_preservers::pallet::HoldReason */ PalletDataPreserversHoldReason: { _enum: ["ProfileDeposit"], }, - /** Lookup501: pallet_preimage::pallet::HoldReason */ + /** Lookup516: pallet_preimage::pallet::HoldReason */ PalletPreimageHoldReason: { _enum: ["Preimage"], }, - /** Lookup504: frame_support::traits::tokens::misc::IdAmount */ + /** Lookup519: frame_support::traits::tokens::misc::IdAmount */ FrameSupportTokensMiscIdAmount: { id: "Null", amount: "u128", }, - /** Lookup506: pallet_balances::pallet::Error */ + /** Lookup521: pallet_balances::pallet::Error */ PalletBalancesError: { _enum: [ "VestingBalance", @@ -4777,21 +4858,21 @@ export default { "DeltaZero", ], }, - /** Lookup507: pallet_transaction_payment::Releases */ + /** Lookup522: pallet_transaction_payment::Releases */ PalletTransactionPaymentReleases: { _enum: ["V1Ancient", "V2"], }, - /** Lookup508: sp_staking::offence::OffenceDetails */ + /** Lookup523: sp_staking::offence::OffenceDetails */ SpStakingOffenceOffenceDetails: { offender: "(AccountId32,Null)", reporters: "Vec", }, - /** Lookup520: pallet_registrar::pallet::DepositInfo */ + /** Lookup535: pallet_registrar::pallet::DepositInfo */ PalletRegistrarDepositInfo: { creator: "AccountId32", deposit: "u128", }, - /** Lookup521: pallet_registrar::pallet::Error */ + /** Lookup536: pallet_registrar::pallet::Error */ PalletRegistrarError: { _enum: [ "ParaIdAlreadyRegistered", @@ -4813,7 +4894,7 @@ export default { "WasmCodeNecessary", ], }, - /** Lookup522: pallet_configuration::HostConfiguration */ + /** Lookup537: pallet_configuration::HostConfiguration */ PalletConfigurationHostConfiguration: { maxCollators: "u32", minOrchestratorCollators: "u32", @@ -4825,11 +4906,11 @@ export default { targetContainerChainFullness: "Perbill", maxParachainCoresPercentage: "Option", }, - /** Lookup525: pallet_configuration::pallet::Error */ + /** Lookup540: pallet_configuration::pallet::Error */ PalletConfigurationError: { _enum: ["InvalidNewValue"], }, - /** Lookup527: pallet_invulnerables::pallet::Error */ + /** Lookup542: pallet_invulnerables::pallet::Error */ PalletInvulnerablesError: { _enum: [ "TooManyInvulnerables", @@ -4839,23 +4920,23 @@ export default { "UnableToDeriveCollatorId", ], }, - /** Lookup528: dp_collator_assignment::AssignedCollators */ + /** Lookup543: dp_collator_assignment::AssignedCollators */ DpCollatorAssignmentAssignedCollatorsAccountId32: { orchestratorChain: "Vec", containerChains: "BTreeMap>", }, - /** Lookup533: dp_collator_assignment::AssignedCollators */ + /** Lookup548: dp_collator_assignment::AssignedCollators */ DpCollatorAssignmentAssignedCollatorsPublic: { orchestratorChain: "Vec", containerChains: "BTreeMap>", }, - /** Lookup541: tp_traits::ContainerChainBlockInfo */ + /** Lookup556: tp_traits::ContainerChainBlockInfo */ TpTraitsContainerChainBlockInfo: { blockNumber: "u32", author: "AccountId32", latestSlotNumber: "u64", }, - /** Lookup542: pallet_author_noting::pallet::Error */ + /** Lookup557: pallet_author_noting::pallet::Error */ PalletAuthorNotingError: { _enum: [ "FailedReading", @@ -4867,18 +4948,18 @@ export default { "NonAuraDigest", ], }, - /** Lookup543: pallet_services_payment::pallet::Error */ + /** Lookup558: pallet_services_payment::pallet::Error */ PalletServicesPaymentError: { _enum: ["InsufficientFundsToPurchaseCredits", "InsufficientCredits", "CreditPriceTooExpensive"], }, - /** Lookup544: pallet_data_preservers::types::RegisteredProfile */ + /** Lookup559: pallet_data_preservers::types::RegisteredProfile */ PalletDataPreserversRegisteredProfile: { account: "AccountId32", deposit: "u128", profile: "PalletDataPreserversProfile", assignment: "Option<(u32,DancelightRuntimePreserversAssignmentPaymentWitness)>", }, - /** Lookup550: pallet_data_preservers::pallet::Error */ + /** Lookup565: pallet_data_preservers::pallet::Error */ PalletDataPreserversError: { _enum: [ "NoBootNodes", @@ -4893,13 +4974,13 @@ export default { "CantDeleteAssignedProfile", ], }, - /** Lookup555: sp_core::crypto::KeyTypeId */ + /** Lookup570: sp_core::crypto::KeyTypeId */ SpCoreCryptoKeyTypeId: "[u8;4]", - /** Lookup556: pallet_session::pallet::Error */ + /** Lookup571: pallet_session::pallet::Error */ PalletSessionError: { _enum: ["InvalidProof", "NoAssociatedValidatorId", "DuplicatedKey", "NoKeys", "NoAccount"], }, - /** Lookup557: pallet_grandpa::StoredState */ + /** Lookup572: pallet_grandpa::StoredState */ PalletGrandpaStoredState: { _enum: { Live: "Null", @@ -4914,14 +4995,14 @@ export default { }, }, }, - /** Lookup558: pallet_grandpa::StoredPendingChange */ + /** Lookup573: pallet_grandpa::StoredPendingChange */ PalletGrandpaStoredPendingChange: { scheduledAt: "u32", delay: "u32", nextAuthorities: "Vec<(SpConsensusGrandpaAppPublic,u64)>", forced: "Option", }, - /** Lookup560: pallet_grandpa::pallet::Error */ + /** Lookup575: pallet_grandpa::pallet::Error */ PalletGrandpaError: { _enum: [ "PauseFailed", @@ -4933,12 +5014,12 @@ export default { "DuplicateOffenceReport", ], }, - /** Lookup563: pallet_inflation_rewards::pallet::ChainsToRewardValue */ + /** Lookup578: pallet_inflation_rewards::pallet::ChainsToRewardValue */ PalletInflationRewardsChainsToRewardValue: { paraIds: "Vec", rewardsPerChain: "u128", }, - /** Lookup564: pallet_treasury::Proposal */ + /** Lookup579: pallet_treasury::Proposal */ PalletTreasuryProposal: { proposer: "AccountId32", value: "u128", @@ -4946,7 +5027,7 @@ export default { bond: "u128", }, /** - * Lookup566: pallet_treasury::SpendStatus */ PalletTreasurySpendStatus: { @@ -4957,7 +5038,7 @@ export default { expireAt: "u32", status: "PalletTreasuryPaymentState", }, - /** Lookup567: pallet_treasury::PaymentState */ + /** Lookup582: pallet_treasury::PaymentState */ PalletTreasuryPaymentState: { _enum: { Pending: "Null", @@ -4967,9 +5048,9 @@ export default { Failed: "Null", }, }, - /** Lookup569: frame_support::PalletId */ + /** Lookup584: frame_support::PalletId */ FrameSupportPalletId: "[u8;8]", - /** Lookup570: pallet_treasury::pallet::Error */ + /** Lookup585: pallet_treasury::pallet::Error */ PalletTreasuryError: { _enum: [ "InvalidIndex", @@ -4986,7 +5067,7 @@ export default { ], }, /** - * Lookup572: pallet_conviction_voting::vote::Voting */ PalletConvictionVotingVoteVoting: { @@ -4995,20 +5076,20 @@ export default { Delegating: "PalletConvictionVotingVoteDelegating", }, }, - /** Lookup573: pallet_conviction_voting::vote::Casting */ + /** Lookup588: pallet_conviction_voting::vote::Casting */ PalletConvictionVotingVoteCasting: { votes: "Vec<(u32,PalletConvictionVotingVoteAccountVote)>", delegations: "PalletConvictionVotingDelegations", prior: "PalletConvictionVotingVotePriorLock", }, - /** Lookup577: pallet_conviction_voting::types::Delegations */ + /** Lookup592: pallet_conviction_voting::types::Delegations */ PalletConvictionVotingDelegations: { votes: "u128", capital: "u128", }, - /** Lookup578: pallet_conviction_voting::vote::PriorLock */ + /** Lookup593: pallet_conviction_voting::vote::PriorLock */ PalletConvictionVotingVotePriorLock: "(u32,u128)", - /** Lookup579: pallet_conviction_voting::vote::Delegating */ + /** Lookup594: pallet_conviction_voting::vote::Delegating */ PalletConvictionVotingVoteDelegating: { balance: "u128", target: "AccountId32", @@ -5016,7 +5097,7 @@ export default { delegations: "PalletConvictionVotingDelegations", prior: "PalletConvictionVotingVotePriorLock", }, - /** Lookup583: pallet_conviction_voting::pallet::Error */ + /** Lookup598: pallet_conviction_voting::pallet::Error */ PalletConvictionVotingError: { _enum: [ "NotOngoing", @@ -5034,7 +5115,7 @@ export default { ], }, /** - * Lookup584: pallet_referenda::types::ReferendumInfo, * Balance, pallet_conviction_voting::types::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5049,7 +5130,7 @@ export default { }, }, /** - * Lookup585: pallet_referenda::types::ReferendumStatus, * Balance, pallet_conviction_voting::types::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5066,17 +5147,17 @@ export default { inQueue: "bool", alarm: "Option<(u32,(u32,u32))>", }, - /** Lookup586: pallet_referenda::types::Deposit */ + /** Lookup601: pallet_referenda::types::Deposit */ PalletReferendaDeposit: { who: "AccountId32", amount: "u128", }, - /** Lookup589: pallet_referenda::types::DecidingStatus */ + /** Lookup604: pallet_referenda::types::DecidingStatus */ PalletReferendaDecidingStatus: { since: "u32", confirming: "Option", }, - /** Lookup597: pallet_referenda::types::TrackInfo */ + /** Lookup612: pallet_referenda::types::TrackInfo */ PalletReferendaTrackInfo: { name: "Text", maxDeciding: "u32", @@ -5088,7 +5169,7 @@ export default { minApproval: "PalletReferendaCurve", minSupport: "PalletReferendaCurve", }, - /** Lookup598: pallet_referenda::types::Curve */ + /** Lookup613: pallet_referenda::types::Curve */ PalletReferendaCurve: { _enum: { LinearDecreasing: { @@ -5109,7 +5190,7 @@ export default { }, }, }, - /** Lookup601: pallet_referenda::pallet::Error */ + /** Lookup616: pallet_referenda::pallet::Error */ PalletReferendaError: { _enum: [ "NotOngoing", @@ -5128,11 +5209,11 @@ export default { "PreimageStoredWithDifferentLength", ], }, - /** Lookup602: pallet_ranked_collective::MemberRecord */ + /** Lookup617: pallet_ranked_collective::MemberRecord */ PalletRankedCollectiveMemberRecord: { rank: "u16", }, - /** Lookup607: pallet_ranked_collective::pallet::Error */ + /** Lookup622: pallet_ranked_collective::pallet::Error */ PalletRankedCollectiveError: { _enum: [ "AlreadyMember", @@ -5149,7 +5230,7 @@ export default { ], }, /** - * Lookup608: pallet_referenda::types::ReferendumInfo, * Balance, pallet_ranked_collective::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5164,7 +5245,7 @@ export default { }, }, /** - * Lookup609: pallet_referenda::types::ReferendumStatus, * Balance, pallet_ranked_collective::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5181,7 +5262,7 @@ export default { inQueue: "bool", alarm: "Option<(u32,(u32,u32))>", }, - /** Lookup612: pallet_whitelist::pallet::Error */ + /** Lookup627: pallet_whitelist::pallet::Error */ PalletWhitelistError: { _enum: [ "UnavailablePreImage", @@ -5191,7 +5272,7 @@ export default { "CallAlreadyWhitelisted", ], }, - /** Lookup613: polkadot_runtime_parachains::configuration::HostConfiguration */ + /** Lookup628: polkadot_runtime_parachains::configuration::HostConfiguration */ PolkadotRuntimeParachainsConfigurationHostConfiguration: { maxCodeSize: "u32", maxHeadDataSize: "u32", @@ -5229,16 +5310,16 @@ export default { approvalVotingParams: "PolkadotPrimitivesV7ApprovalVotingParams", schedulerParams: "PolkadotPrimitivesVstagingSchedulerParams", }, - /** Lookup616: polkadot_runtime_parachains::configuration::pallet::Error */ + /** Lookup631: polkadot_runtime_parachains::configuration::pallet::Error */ PolkadotRuntimeParachainsConfigurationPalletError: { _enum: ["InvalidNewValue"], }, - /** Lookup619: polkadot_runtime_parachains::shared::AllowedRelayParentsTracker */ + /** Lookup634: polkadot_runtime_parachains::shared::AllowedRelayParentsTracker */ PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker: { buffer: "Vec<(H256,H256)>", latestNumber: "u32", }, - /** Lookup623: polkadot_runtime_parachains::inclusion::CandidatePendingAvailability */ + /** Lookup638: polkadot_runtime_parachains::inclusion::CandidatePendingAvailability */ PolkadotRuntimeParachainsInclusionCandidatePendingAvailability: { _alias: { hash_: "hash", @@ -5253,7 +5334,7 @@ export default { backedInNumber: "u32", backingGroup: "u32", }, - /** Lookup624: polkadot_runtime_parachains::inclusion::pallet::Error */ + /** Lookup639: polkadot_runtime_parachains::inclusion::pallet::Error */ PolkadotRuntimeParachainsInclusionPalletError: { _enum: [ "ValidatorIndexOutOfBounds", @@ -5276,14 +5357,14 @@ export default { "ParaHeadMismatch", ], }, - /** Lookup625: polkadot_primitives::v7::ScrapedOnChainVotes */ + /** Lookup640: polkadot_primitives::v7::ScrapedOnChainVotes */ PolkadotPrimitivesV7ScrapedOnChainVotes: { session: "u32", backingValidatorsPerCandidate: "Vec<(PolkadotPrimitivesV7CandidateReceipt,Vec<(u32,PolkadotPrimitivesV7ValidityAttestation)>)>", disputes: "Vec", }, - /** Lookup630: polkadot_runtime_parachains::paras_inherent::pallet::Error */ + /** Lookup645: polkadot_runtime_parachains::paras_inherent::pallet::Error */ PolkadotRuntimeParachainsParasInherentPalletError: { _enum: [ "TooManyInclusionInherents", @@ -5293,20 +5374,20 @@ export default { "UnscheduledCandidate", ], }, - /** Lookup633: polkadot_runtime_parachains::scheduler::pallet::CoreOccupied */ + /** Lookup648: polkadot_runtime_parachains::scheduler::pallet::CoreOccupied */ PolkadotRuntimeParachainsSchedulerPalletCoreOccupied: { _enum: { Free: "Null", Paras: "PolkadotRuntimeParachainsSchedulerPalletParasEntry", }, }, - /** Lookup634: polkadot_runtime_parachains::scheduler::pallet::ParasEntry */ + /** Lookup649: polkadot_runtime_parachains::scheduler::pallet::ParasEntry */ PolkadotRuntimeParachainsSchedulerPalletParasEntry: { assignment: "PolkadotRuntimeParachainsSchedulerCommonAssignment", availabilityTimeouts: "u32", ttl: "u32", }, - /** Lookup635: polkadot_runtime_parachains::scheduler::common::Assignment */ + /** Lookup650: polkadot_runtime_parachains::scheduler::common::Assignment */ PolkadotRuntimeParachainsSchedulerCommonAssignment: { _enum: { Pool: { @@ -5316,7 +5397,7 @@ export default { Bulk: "u32", }, }, - /** Lookup640: polkadot_runtime_parachains::paras::PvfCheckActiveVoteState */ + /** Lookup655: polkadot_runtime_parachains::paras::PvfCheckActiveVoteState */ PolkadotRuntimeParachainsParasPvfCheckActiveVoteState: { votesAccept: "BitVec", votesReject: "BitVec", @@ -5324,7 +5405,7 @@ export default { createdAt: "u32", causes: "Vec", }, - /** Lookup642: polkadot_runtime_parachains::paras::PvfCheckCause */ + /** Lookup657: polkadot_runtime_parachains::paras::PvfCheckCause */ PolkadotRuntimeParachainsParasPvfCheckCause: { _enum: { Onboarding: "u32", @@ -5335,11 +5416,11 @@ export default { }, }, }, - /** Lookup643: polkadot_runtime_parachains::paras::UpgradeStrategy */ + /** Lookup658: polkadot_runtime_parachains::paras::UpgradeStrategy */ PolkadotRuntimeParachainsParasUpgradeStrategy: { _enum: ["SetGoAheadSignal", "ApplyAtExpectedBlock"], }, - /** Lookup645: polkadot_runtime_parachains::paras::ParaLifecycle */ + /** Lookup660: polkadot_runtime_parachains::paras::ParaLifecycle */ PolkadotRuntimeParachainsParasParaLifecycle: { _enum: [ "Onboarding", @@ -5351,25 +5432,25 @@ export default { "OffboardingParachain", ], }, - /** Lookup647: polkadot_runtime_parachains::paras::ParaPastCodeMeta */ + /** Lookup662: polkadot_runtime_parachains::paras::ParaPastCodeMeta */ PolkadotRuntimeParachainsParasParaPastCodeMeta: { upgradeTimes: "Vec", lastPruned: "Option", }, - /** Lookup649: polkadot_runtime_parachains::paras::ReplacementTimes */ + /** Lookup664: polkadot_runtime_parachains::paras::ReplacementTimes */ PolkadotRuntimeParachainsParasReplacementTimes: { expectedAt: "u32", activatedAt: "u32", }, - /** Lookup651: polkadot_primitives::v7::UpgradeGoAhead */ + /** Lookup666: polkadot_primitives::v7::UpgradeGoAhead */ PolkadotPrimitivesV7UpgradeGoAhead: { _enum: ["Abort", "GoAhead"], }, - /** Lookup652: polkadot_primitives::v7::UpgradeRestriction */ + /** Lookup667: polkadot_primitives::v7::UpgradeRestriction */ PolkadotPrimitivesV7UpgradeRestriction: { _enum: ["Present"], }, - /** Lookup653: polkadot_runtime_parachains::paras::pallet::Error */ + /** Lookup668: polkadot_runtime_parachains::paras::pallet::Error */ PolkadotRuntimeParachainsParasPalletError: { _enum: [ "NotRegistered", @@ -5387,18 +5468,18 @@ export default { "InvalidCode", ], }, - /** Lookup655: polkadot_runtime_parachains::initializer::BufferedSessionChange */ + /** Lookup670: polkadot_runtime_parachains::initializer::BufferedSessionChange */ PolkadotRuntimeParachainsInitializerBufferedSessionChange: { validators: "Vec", queued: "Vec", sessionIndex: "u32", }, - /** Lookup657: polkadot_core_primitives::InboundDownwardMessage */ + /** Lookup672: polkadot_core_primitives::InboundDownwardMessage */ PolkadotCorePrimitivesInboundDownwardMessage: { sentAt: "u32", msg: "Bytes", }, - /** Lookup658: polkadot_runtime_parachains::hrmp::HrmpOpenChannelRequest */ + /** Lookup673: polkadot_runtime_parachains::hrmp::HrmpOpenChannelRequest */ PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest: { confirmed: "bool", age: "u32", @@ -5407,7 +5488,7 @@ export default { maxCapacity: "u32", maxTotalSize: "u32", }, - /** Lookup660: polkadot_runtime_parachains::hrmp::HrmpChannel */ + /** Lookup675: polkadot_runtime_parachains::hrmp::HrmpChannel */ PolkadotRuntimeParachainsHrmpHrmpChannel: { maxCapacity: "u32", maxTotalSize: "u32", @@ -5418,12 +5499,12 @@ export default { senderDeposit: "u128", recipientDeposit: "u128", }, - /** Lookup662: polkadot_core_primitives::InboundHrmpMessage */ + /** Lookup677: polkadot_core_primitives::InboundHrmpMessage */ PolkadotCorePrimitivesInboundHrmpMessage: { sentAt: "u32", data: "Bytes", }, - /** Lookup665: polkadot_runtime_parachains::hrmp::pallet::Error */ + /** Lookup680: polkadot_runtime_parachains::hrmp::pallet::Error */ PolkadotRuntimeParachainsHrmpPalletError: { _enum: [ "OpenHrmpChannelToSelf", @@ -5448,7 +5529,7 @@ export default { "ChannelCreationNotAuthorized", ], }, - /** Lookup667: polkadot_primitives::v7::SessionInfo */ + /** Lookup682: polkadot_primitives::v7::SessionInfo */ PolkadotPrimitivesV7SessionInfo: { activeValidatorIndices: "Vec", randomSeed: "[u8;32]", @@ -5465,20 +5546,20 @@ export default { neededApprovals: "u32", }, /** - * Lookup668: polkadot_primitives::v7::IndexedVec */ PolkadotPrimitivesV7IndexedVecValidatorIndex: "Vec", - /** Lookup669: polkadot_primitives::v7::IndexedVec */ + /** Lookup684: polkadot_primitives::v7::IndexedVec */ PolkadotPrimitivesV7IndexedVecGroupIndex: "Vec>", - /** Lookup671: polkadot_primitives::v7::DisputeState */ + /** Lookup686: polkadot_primitives::v7::DisputeState */ PolkadotPrimitivesV7DisputeState: { validatorsFor: "BitVec", validatorsAgainst: "BitVec", start: "u32", concludedAt: "Option", }, - /** Lookup673: polkadot_runtime_parachains::disputes::pallet::Error */ + /** Lookup688: polkadot_runtime_parachains::disputes::pallet::Error */ PolkadotRuntimeParachainsDisputesPalletError: { _enum: [ "DuplicateDisputeStatementSets", @@ -5492,7 +5573,7 @@ export default { "UnconfirmedDispute", ], }, - /** Lookup674: polkadot_primitives::v7::slashing::PendingSlashes */ + /** Lookup689: polkadot_primitives::v7::slashing::PendingSlashes */ PolkadotPrimitivesV7SlashingPendingSlashes: { _alias: { keys_: "keys", @@ -5500,7 +5581,7 @@ export default { keys_: "BTreeMap", kind: "PolkadotPrimitivesV7SlashingSlashingOffenceKind", }, - /** Lookup678: polkadot_runtime_parachains::disputes::slashing::pallet::Error */ + /** Lookup693: polkadot_runtime_parachains::disputes::slashing::pallet::Error */ PolkadotRuntimeParachainsDisputesSlashingPalletError: { _enum: [ "InvalidKeyOwnershipProof", @@ -5511,7 +5592,7 @@ export default { "DuplicateSlashingReport", ], }, - /** Lookup679: pallet_message_queue::BookState */ + /** Lookup694: pallet_message_queue::BookState */ PalletMessageQueueBookState: { _alias: { size_: "size", @@ -5523,12 +5604,12 @@ export default { messageCount: "u64", size_: "u64", }, - /** Lookup681: pallet_message_queue::Neighbours */ + /** Lookup696: pallet_message_queue::Neighbours */ PalletMessageQueueNeighbours: { prev: "PolkadotRuntimeParachainsInclusionAggregateMessageOrigin", next: "PolkadotRuntimeParachainsInclusionAggregateMessageOrigin", }, - /** Lookup683: pallet_message_queue::Page */ + /** Lookup698: pallet_message_queue::Page */ PalletMessageQueuePage: { remaining: "u32", remainingSize: "u32", @@ -5537,7 +5618,7 @@ export default { last: "u32", heap: "Bytes", }, - /** Lookup685: pallet_message_queue::pallet::Error */ + /** Lookup700: pallet_message_queue::pallet::Error */ PalletMessageQueueError: { _enum: [ "NotReapable", @@ -5551,38 +5632,38 @@ export default { "RecursiveDisallowed", ], }, - /** Lookup686: polkadot_runtime_parachains::assigner_on_demand::types::CoreAffinityCount */ + /** Lookup701: polkadot_runtime_parachains::assigner_on_demand::types::CoreAffinityCount */ PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount: { coreIndex: "u32", count: "u32", }, - /** Lookup687: polkadot_runtime_parachains::assigner_on_demand::types::QueueStatusType */ + /** Lookup702: polkadot_runtime_parachains::assigner_on_demand::types::QueueStatusType */ PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType: { traffic: "u128", nextIndex: "u32", smallestIndex: "u32", freedIndices: "BinaryHeapReverseQueueIndex", }, - /** Lookup689: BinaryHeap */ + /** Lookup704: BinaryHeap */ BinaryHeapReverseQueueIndex: "Vec", - /** Lookup692: BinaryHeap */ + /** Lookup707: BinaryHeap */ BinaryHeapEnqueuedOrder: "Vec", - /** Lookup693: polkadot_runtime_parachains::assigner_on_demand::types::EnqueuedOrder */ + /** Lookup708: polkadot_runtime_parachains::assigner_on_demand::types::EnqueuedOrder */ PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder: { paraId: "u32", idx: "u32", }, - /** Lookup697: polkadot_runtime_parachains::assigner_on_demand::pallet::Error */ + /** Lookup712: polkadot_runtime_parachains::assigner_on_demand::pallet::Error */ PolkadotRuntimeParachainsAssignerOnDemandPalletError: { _enum: ["QueueFull", "SpotPriceHigherThanMaxAmount"], }, - /** Lookup698: polkadot_runtime_common::paras_registrar::ParaInfo */ + /** Lookup713: polkadot_runtime_common::paras_registrar::ParaInfo */ PolkadotRuntimeCommonParasRegistrarParaInfo: { manager: "AccountId32", deposit: "u128", locked: "Option", }, - /** Lookup700: polkadot_runtime_common::paras_registrar::pallet::Error */ + /** Lookup715: polkadot_runtime_common::paras_registrar::pallet::Error */ PolkadotRuntimeCommonParasRegistrarPalletError: { _enum: [ "NotRegistered", @@ -5601,12 +5682,12 @@ export default { "CannotSwap", ], }, - /** Lookup701: pallet_utility::pallet::Error */ + /** Lookup716: pallet_utility::pallet::Error */ PalletUtilityError: { _enum: ["TooManyCalls"], }, /** - * Lookup703: pallet_identity::types::Registration> */ PalletIdentityRegistration: { @@ -5614,18 +5695,18 @@ export default { deposit: "u128", info: "PalletIdentityLegacyIdentityInfo", }, - /** Lookup712: pallet_identity::types::RegistrarInfo */ + /** Lookup727: pallet_identity::types::RegistrarInfo */ PalletIdentityRegistrarInfo: { account: "AccountId32", fee: "u128", fields: "u64", }, - /** Lookup714: pallet_identity::types::AuthorityProperties> */ + /** Lookup729: pallet_identity::types::AuthorityProperties> */ PalletIdentityAuthorityProperties: { suffix: "Bytes", allocation: "u32", }, - /** Lookup717: pallet_identity::pallet::Error */ + /** Lookup732: pallet_identity::pallet::Error */ PalletIdentityError: { _enum: [ "TooManySubAccounts", @@ -5657,7 +5738,7 @@ export default { ], }, /** - * Lookup720: pallet_scheduler::Scheduled, * BlockNumber, dancelight_runtime::OriginCaller, sp_core::crypto::AccountId32> */ @@ -5668,29 +5749,29 @@ export default { maybePeriodic: "Option<(u32,u32)>", origin: "DancelightRuntimeOriginCaller", }, - /** Lookup722: pallet_scheduler::RetryConfig */ + /** Lookup737: pallet_scheduler::RetryConfig */ PalletSchedulerRetryConfig: { totalRetries: "u8", remaining: "u8", period: "u32", }, - /** Lookup723: pallet_scheduler::pallet::Error */ + /** Lookup738: pallet_scheduler::pallet::Error */ PalletSchedulerError: { _enum: ["FailedToSchedule", "NotFound", "TargetBlockNumberInPast", "RescheduleNoChange", "Named"], }, - /** Lookup726: pallet_proxy::ProxyDefinition */ + /** Lookup741: pallet_proxy::ProxyDefinition */ PalletProxyProxyDefinition: { delegate: "AccountId32", proxyType: "DancelightRuntimeProxyType", delay: "u32", }, - /** Lookup730: pallet_proxy::Announcement */ + /** Lookup745: pallet_proxy::Announcement */ PalletProxyAnnouncement: { real: "AccountId32", callHash: "H256", height: "u32", }, - /** Lookup732: pallet_proxy::pallet::Error */ + /** Lookup747: pallet_proxy::pallet::Error */ PalletProxyError: { _enum: [ "TooMany", @@ -5703,14 +5784,14 @@ export default { "NoSelfProxy", ], }, - /** Lookup734: pallet_multisig::Multisig */ + /** Lookup749: pallet_multisig::Multisig */ PalletMultisigMultisig: { when: "PalletMultisigTimepoint", deposit: "u128", depositor: "AccountId32", approvals: "Vec", }, - /** Lookup736: pallet_multisig::pallet::Error */ + /** Lookup751: pallet_multisig::pallet::Error */ PalletMultisigError: { _enum: [ "MinimumThreshold", @@ -5729,7 +5810,7 @@ export default { "AlreadyStored", ], }, - /** Lookup737: pallet_preimage::OldRequestStatus */ + /** Lookup752: pallet_preimage::OldRequestStatus */ PalletPreimageOldRequestStatus: { _enum: { Unrequested: { @@ -5744,7 +5825,7 @@ export default { }, }, /** - * Lookup740: pallet_preimage::RequestStatus> */ PalletPreimageRequestStatus: { @@ -5760,7 +5841,7 @@ export default { }, }, }, - /** Lookup745: pallet_preimage::pallet::Error */ + /** Lookup760: pallet_preimage::pallet::Error */ PalletPreimageError: { _enum: [ "TooBig", @@ -5774,11 +5855,11 @@ export default { "NoCost", ], }, - /** Lookup746: pallet_asset_rate::pallet::Error */ + /** Lookup761: pallet_asset_rate::pallet::Error */ PalletAssetRateError: { _enum: ["UnknownAssetKind", "AlreadyExists", "Overflow"], }, - /** Lookup747: pallet_xcm::pallet::QueryStatus */ + /** Lookup762: pallet_xcm::pallet::QueryStatus */ PalletXcmQueryStatus: { _enum: { Pending: { @@ -5797,7 +5878,7 @@ export default { }, }, }, - /** Lookup751: xcm::VersionedResponse */ + /** Lookup766: xcm::VersionedResponse */ XcmVersionedResponse: { _enum: { __Unused0: "Null", @@ -5807,7 +5888,7 @@ export default { V4: "StagingXcmV4Response", }, }, - /** Lookup757: pallet_xcm::pallet::VersionMigrationStage */ + /** Lookup772: pallet_xcm::pallet::VersionMigrationStage */ PalletXcmVersionMigrationStage: { _enum: { MigrateSupportedVersion: "Null", @@ -5816,14 +5897,14 @@ export default { MigrateAndNotifyOldTargets: "Null", }, }, - /** Lookup759: pallet_xcm::pallet::RemoteLockedFungibleRecord */ + /** Lookup774: pallet_xcm::pallet::RemoteLockedFungibleRecord */ PalletXcmRemoteLockedFungibleRecord: { amount: "u128", owner: "XcmVersionedLocation", locker: "XcmVersionedLocation", consumers: "Vec<(Null,u128)>", }, - /** Lookup766: pallet_xcm::pallet::Error */ + /** Lookup781: pallet_xcm::pallet::Error */ PalletXcmError: { _enum: [ "Unreachable", @@ -5853,11 +5934,11 @@ export default { "LocalExecutionIncomplete", ], }, - /** Lookup767: pallet_migrations::pallet::Error */ + /** Lookup782: pallet_migrations::pallet::Error */ PalletMigrationsError: { _enum: ["PreimageMissing", "WrongUpperBound", "PreimageIsTooBig", "PreimageAlreadyExists"], }, - /** Lookup771: pallet_beefy::pallet::Error */ + /** Lookup786: pallet_beefy::pallet::Error */ PalletBeefyError: { _enum: [ "InvalidKeyOwnershipProof", @@ -5869,13 +5950,90 @@ export default { "InvalidConfiguration", ], }, - /** Lookup772: sp_consensus_beefy::mmr::BeefyAuthoritySet */ + /** Lookup787: sp_consensus_beefy::mmr::BeefyAuthoritySet */ SpConsensusBeefyMmrBeefyAuthoritySet: { id: "u64", len: "u32", keysetCommitment: "H256", }, - /** Lookup773: polkadot_runtime_common::paras_sudo_wrapper::pallet::Error */ + /** Lookup788: snowbridge_beacon_primitives::types::CompactBeaconState */ + SnowbridgeBeaconPrimitivesCompactBeaconState: { + slot: "Compact", + blockRootsRoot: "H256", + }, + /** Lookup789: snowbridge_beacon_primitives::types::SyncCommitteePrepared */ + SnowbridgeBeaconPrimitivesSyncCommitteePrepared: { + root: "H256", + pubkeys: "[Lookup791;512]", + aggregatePubkey: "SnowbridgeMilagroBlsKeysPublicKey", + }, + /** Lookup791: snowbridge_milagro_bls::keys::PublicKey */ + SnowbridgeMilagroBlsKeysPublicKey: { + point: "SnowbridgeAmclBls381Ecp", + }, + /** Lookup792: snowbridge_amcl::bls381::ecp::ECP */ + SnowbridgeAmclBls381Ecp: { + x: "SnowbridgeAmclBls381Fp", + y: "SnowbridgeAmclBls381Fp", + z: "SnowbridgeAmclBls381Fp", + }, + /** Lookup793: snowbridge_amcl::bls381::fp::FP */ + SnowbridgeAmclBls381Fp: { + x: "SnowbridgeAmclBls381Big", + xes: "i32", + }, + /** Lookup794: snowbridge_amcl::bls381::big::Big */ + SnowbridgeAmclBls381Big: { + w: "[i32;14]", + }, + /** Lookup797: snowbridge_beacon_primitives::types::ForkVersions */ + SnowbridgeBeaconPrimitivesForkVersions: { + genesis: "SnowbridgeBeaconPrimitivesFork", + altair: "SnowbridgeBeaconPrimitivesFork", + bellatrix: "SnowbridgeBeaconPrimitivesFork", + capella: "SnowbridgeBeaconPrimitivesFork", + deneb: "SnowbridgeBeaconPrimitivesFork", + }, + /** Lookup798: snowbridge_beacon_primitives::types::Fork */ + SnowbridgeBeaconPrimitivesFork: { + version: "[u8;4]", + epoch: "u64", + }, + /** Lookup799: snowbridge_pallet_ethereum_client::pallet::Error */ + SnowbridgePalletEthereumClientError: { + _enum: { + SkippedSyncCommitteePeriod: "Null", + SyncCommitteeUpdateRequired: "Null", + IrrelevantUpdate: "Null", + NotBootstrapped: "Null", + SyncCommitteeParticipantsNotSupermajority: "Null", + InvalidHeaderMerkleProof: "Null", + InvalidSyncCommitteeMerkleProof: "Null", + InvalidExecutionHeaderProof: "Null", + InvalidAncestryMerkleProof: "Null", + InvalidBlockRootsRootMerkleProof: "Null", + InvalidFinalizedHeaderGap: "Null", + HeaderNotFinalized: "Null", + BlockBodyHashTreeRootFailed: "Null", + HeaderHashTreeRootFailed: "Null", + SyncCommitteeHashTreeRootFailed: "Null", + SigningRootHashTreeRootFailed: "Null", + ForkDataHashTreeRootFailed: "Null", + ExpectedFinalizedHeaderNotStored: "Null", + BLSPreparePublicKeysFailed: "Null", + BLSVerificationFailed: "SnowbridgeBeaconPrimitivesBlsBlsError", + InvalidUpdateSlot: "Null", + InvalidSyncCommitteeUpdate: "Null", + ExecutionHeaderTooFarBehind: "Null", + ExecutionHeaderSkippedBlock: "Null", + Halted: "Null", + }, + }, + /** Lookup800: snowbridge_beacon_primitives::bls::BlsError */ + SnowbridgeBeaconPrimitivesBlsBlsError: { + _enum: ["InvalidSignature", "InvalidPublicKey", "InvalidAggregatePublicKeys", "SignatureVerificationFailed"], + }, + /** Lookup801: polkadot_runtime_common::paras_sudo_wrapper::pallet::Error */ PolkadotRuntimeCommonParasSudoWrapperPalletError: { _enum: [ "ParaDoesntExist", @@ -5889,24 +6047,24 @@ export default { "TooManyCores", ], }, - /** Lookup774: pallet_sudo::pallet::Error */ + /** Lookup802: pallet_sudo::pallet::Error */ PalletSudoError: { _enum: ["RequireSudo"], }, - /** Lookup777: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender */ + /** Lookup805: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender */ FrameSystemExtensionsCheckNonZeroSender: "Null", - /** Lookup778: frame_system::extensions::check_spec_version::CheckSpecVersion */ + /** Lookup806: frame_system::extensions::check_spec_version::CheckSpecVersion */ FrameSystemExtensionsCheckSpecVersion: "Null", - /** Lookup779: frame_system::extensions::check_tx_version::CheckTxVersion */ + /** Lookup807: frame_system::extensions::check_tx_version::CheckTxVersion */ FrameSystemExtensionsCheckTxVersion: "Null", - /** Lookup780: frame_system::extensions::check_genesis::CheckGenesis */ + /** Lookup808: frame_system::extensions::check_genesis::CheckGenesis */ FrameSystemExtensionsCheckGenesis: "Null", - /** Lookup783: frame_system::extensions::check_nonce::CheckNonce */ + /** Lookup811: frame_system::extensions::check_nonce::CheckNonce */ FrameSystemExtensionsCheckNonce: "Compact", - /** Lookup784: frame_system::extensions::check_weight::CheckWeight */ + /** Lookup812: frame_system::extensions::check_weight::CheckWeight */ FrameSystemExtensionsCheckWeight: "Null", - /** Lookup785: pallet_transaction_payment::ChargeTransactionPayment */ + /** Lookup813: pallet_transaction_payment::ChargeTransactionPayment */ PalletTransactionPaymentChargeTransactionPayment: "Compact", - /** Lookup786: dancelight_runtime::Runtime */ + /** Lookup814: dancelight_runtime::Runtime */ DancelightRuntimeRuntime: "Null", }; diff --git a/typescript-api/src/dancelight/interfaces/registry.ts b/typescript-api/src/dancelight/interfaces/registry.ts index a7a722d12..6136abcfd 100644 --- a/typescript-api/src/dancelight/interfaces/registry.ts +++ b/typescript-api/src/dancelight/interfaces/registry.ts @@ -316,6 +316,27 @@ import type { PolkadotRuntimeParachainsSchedulerPalletParasEntry, PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker, PolkadotRuntimeParachainsSharedPalletCall, + SnowbridgeAmclBls381Big, + SnowbridgeAmclBls381Ecp, + SnowbridgeAmclBls381Fp, + SnowbridgeBeaconPrimitivesBeaconHeader, + SnowbridgeBeaconPrimitivesBlsBlsError, + SnowbridgeBeaconPrimitivesCompactBeaconState, + SnowbridgeBeaconPrimitivesFork, + SnowbridgeBeaconPrimitivesForkVersions, + SnowbridgeBeaconPrimitivesPublicKey, + SnowbridgeBeaconPrimitivesSignature, + SnowbridgeBeaconPrimitivesSyncAggregate, + SnowbridgeBeaconPrimitivesSyncCommittee, + SnowbridgeBeaconPrimitivesSyncCommitteePrepared, + SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate, + SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate, + SnowbridgeBeaconPrimitivesUpdatesUpdate, + SnowbridgeCoreOperatingModeBasicOperatingMode, + SnowbridgeMilagroBlsKeysPublicKey, + SnowbridgePalletEthereumClientCall, + SnowbridgePalletEthereumClientError, + SnowbridgePalletEthereumClientEvent, SpArithmeticArithmeticError, SpAuthorityDiscoveryAppPublic, SpConsensusBabeAllowedSlots, @@ -745,6 +766,27 @@ declare module "@polkadot/types/types/registry" { PolkadotRuntimeParachainsSchedulerPalletParasEntry: PolkadotRuntimeParachainsSchedulerPalletParasEntry; PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker: PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker; PolkadotRuntimeParachainsSharedPalletCall: PolkadotRuntimeParachainsSharedPalletCall; + SnowbridgeAmclBls381Big: SnowbridgeAmclBls381Big; + SnowbridgeAmclBls381Ecp: SnowbridgeAmclBls381Ecp; + SnowbridgeAmclBls381Fp: SnowbridgeAmclBls381Fp; + SnowbridgeBeaconPrimitivesBeaconHeader: SnowbridgeBeaconPrimitivesBeaconHeader; + SnowbridgeBeaconPrimitivesBlsBlsError: SnowbridgeBeaconPrimitivesBlsBlsError; + SnowbridgeBeaconPrimitivesCompactBeaconState: SnowbridgeBeaconPrimitivesCompactBeaconState; + SnowbridgeBeaconPrimitivesFork: SnowbridgeBeaconPrimitivesFork; + SnowbridgeBeaconPrimitivesForkVersions: SnowbridgeBeaconPrimitivesForkVersions; + SnowbridgeBeaconPrimitivesPublicKey: SnowbridgeBeaconPrimitivesPublicKey; + SnowbridgeBeaconPrimitivesSignature: SnowbridgeBeaconPrimitivesSignature; + SnowbridgeBeaconPrimitivesSyncAggregate: SnowbridgeBeaconPrimitivesSyncAggregate; + SnowbridgeBeaconPrimitivesSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; + SnowbridgeBeaconPrimitivesSyncCommitteePrepared: SnowbridgeBeaconPrimitivesSyncCommitteePrepared; + SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate: SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate; + SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate: SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate; + SnowbridgeBeaconPrimitivesUpdatesUpdate: SnowbridgeBeaconPrimitivesUpdatesUpdate; + SnowbridgeCoreOperatingModeBasicOperatingMode: SnowbridgeCoreOperatingModeBasicOperatingMode; + SnowbridgeMilagroBlsKeysPublicKey: SnowbridgeMilagroBlsKeysPublicKey; + SnowbridgePalletEthereumClientCall: SnowbridgePalletEthereumClientCall; + SnowbridgePalletEthereumClientError: SnowbridgePalletEthereumClientError; + SnowbridgePalletEthereumClientEvent: SnowbridgePalletEthereumClientEvent; SpArithmeticArithmeticError: SpArithmeticArithmeticError; SpAuthorityDiscoveryAppPublic: SpAuthorityDiscoveryAppPublic; SpConsensusBabeAllowedSlots: SpConsensusBabeAllowedSlots; diff --git a/typescript-api/src/dancelight/interfaces/types-lookup.ts b/typescript-api/src/dancelight/interfaces/types-lookup.ts index 24c2f0d71..878bb13b0 100644 --- a/typescript-api/src/dancelight/interfaces/types-lookup.ts +++ b/typescript-api/src/dancelight/interfaces/types-lookup.ts @@ -21,6 +21,7 @@ import type { U8aFixed, Vec, bool, + i32, i64, u128, u16, @@ -4923,7 +4924,86 @@ declare module "@polkadot/types/lookup" { readonly vote: SpConsensusBeefyVoteMessage; } - /** @name PolkadotRuntimeCommonParasSudoWrapperPalletCall (411) */ + /** @name SnowbridgePalletEthereumClientCall (411) */ + interface SnowbridgePalletEthereumClientCall extends Enum { + readonly isForceCheckpoint: boolean; + readonly asForceCheckpoint: { + readonly update: SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate; + } & Struct; + readonly isSubmit: boolean; + readonly asSubmit: { + readonly update: SnowbridgeBeaconPrimitivesUpdatesUpdate; + } & Struct; + readonly isSetOperatingMode: boolean; + readonly asSetOperatingMode: { + readonly mode: SnowbridgeCoreOperatingModeBasicOperatingMode; + } & Struct; + readonly type: "ForceCheckpoint" | "Submit" | "SetOperatingMode"; + } + + /** @name SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate (412) */ + interface SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate extends Struct { + readonly header: SnowbridgeBeaconPrimitivesBeaconHeader; + readonly currentSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; + readonly currentSyncCommitteeBranch: Vec; + readonly validatorsRoot: H256; + readonly blockRootsRoot: H256; + readonly blockRootsBranch: Vec; + } + + /** @name SnowbridgeBeaconPrimitivesBeaconHeader (413) */ + interface SnowbridgeBeaconPrimitivesBeaconHeader extends Struct { + readonly slot: u64; + readonly proposerIndex: u64; + readonly parentRoot: H256; + readonly stateRoot: H256; + readonly bodyRoot: H256; + } + + /** @name SnowbridgeBeaconPrimitivesSyncCommittee (414) */ + interface SnowbridgeBeaconPrimitivesSyncCommittee extends Struct { + readonly pubkeys: Vec; + readonly aggregatePubkey: SnowbridgeBeaconPrimitivesPublicKey; + } + + /** @name SnowbridgeBeaconPrimitivesPublicKey (416) */ + interface SnowbridgeBeaconPrimitivesPublicKey extends U8aFixed {} + + /** @name SnowbridgeBeaconPrimitivesUpdatesUpdate (418) */ + interface SnowbridgeBeaconPrimitivesUpdatesUpdate extends Struct { + readonly attestedHeader: SnowbridgeBeaconPrimitivesBeaconHeader; + readonly syncAggregate: SnowbridgeBeaconPrimitivesSyncAggregate; + readonly signatureSlot: u64; + readonly nextSyncCommitteeUpdate: Option; + readonly finalizedHeader: SnowbridgeBeaconPrimitivesBeaconHeader; + readonly finalityBranch: Vec; + readonly blockRootsRoot: H256; + readonly blockRootsBranch: Vec; + } + + /** @name SnowbridgeBeaconPrimitivesSyncAggregate (419) */ + interface SnowbridgeBeaconPrimitivesSyncAggregate extends Struct { + readonly syncCommitteeBits: U8aFixed; + readonly syncCommitteeSignature: SnowbridgeBeaconPrimitivesSignature; + } + + /** @name SnowbridgeBeaconPrimitivesSignature (420) */ + interface SnowbridgeBeaconPrimitivesSignature extends U8aFixed {} + + /** @name SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate (423) */ + interface SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate extends Struct { + readonly nextSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; + readonly nextSyncCommitteeBranch: Vec; + } + + /** @name SnowbridgeCoreOperatingModeBasicOperatingMode (424) */ + interface SnowbridgeCoreOperatingModeBasicOperatingMode extends Enum { + readonly isNormal: boolean; + readonly isHalted: boolean; + readonly type: "Normal" | "Halted"; + } + + /** @name PolkadotRuntimeCommonParasSudoWrapperPalletCall (425) */ interface PolkadotRuntimeCommonParasSudoWrapperPalletCall extends Enum { readonly isSudoScheduleParaInitialize: boolean; readonly asSudoScheduleParaInitialize: { @@ -4963,14 +5043,14 @@ declare module "@polkadot/types/lookup" { | "SudoEstablishHrmpChannel"; } - /** @name PolkadotRuntimeParachainsParasParaGenesisArgs (412) */ + /** @name PolkadotRuntimeParachainsParasParaGenesisArgs (426) */ interface PolkadotRuntimeParachainsParasParaGenesisArgs extends Struct { readonly genesisHead: Bytes; readonly validationCode: Bytes; readonly paraKind: bool; } - /** @name DancelightRuntimeValidatorManagerPalletCall (413) */ + /** @name DancelightRuntimeValidatorManagerPalletCall (427) */ interface DancelightRuntimeValidatorManagerPalletCall extends Enum { readonly isRegisterValidators: boolean; readonly asRegisterValidators: { @@ -4983,7 +5063,7 @@ declare module "@polkadot/types/lookup" { readonly type: "RegisterValidators" | "DeregisterValidators"; } - /** @name PalletRootTestingCall (414) */ + /** @name PalletRootTestingCall (428) */ interface PalletRootTestingCall extends Enum { readonly isFillBlock: boolean; readonly asFillBlock: { @@ -4993,7 +5073,7 @@ declare module "@polkadot/types/lookup" { readonly type: "FillBlock" | "TriggerDefensive"; } - /** @name PalletSudoCall (415) */ + /** @name PalletSudoCall (429) */ interface PalletSudoCall extends Enum { readonly isSudo: boolean; readonly asSudo: { @@ -5017,17 +5097,17 @@ declare module "@polkadot/types/lookup" { readonly type: "Sudo" | "SudoUncheckedWeight" | "SetKey" | "SudoAs" | "RemoveKey"; } - /** @name SpRuntimeBlakeTwo256 (416) */ + /** @name SpRuntimeBlakeTwo256 (430) */ type SpRuntimeBlakeTwo256 = Null; - /** @name PalletConvictionVotingTally (418) */ + /** @name PalletConvictionVotingTally (432) */ interface PalletConvictionVotingTally extends Struct { readonly ayes: u128; readonly nays: u128; readonly support: u128; } - /** @name PalletRankedCollectiveEvent (419) */ + /** @name PalletRankedCollectiveEvent (433) */ interface PalletRankedCollectiveEvent extends Enum { readonly isMemberAdded: boolean; readonly asMemberAdded: { @@ -5058,7 +5138,7 @@ declare module "@polkadot/types/lookup" { readonly type: "MemberAdded" | "RankChanged" | "MemberRemoved" | "Voted" | "MemberExchanged"; } - /** @name PalletRankedCollectiveVoteRecord (420) */ + /** @name PalletRankedCollectiveVoteRecord (434) */ interface PalletRankedCollectiveVoteRecord extends Enum { readonly isAye: boolean; readonly asAye: u32; @@ -5067,14 +5147,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Aye" | "Nay"; } - /** @name PalletRankedCollectiveTally (421) */ + /** @name PalletRankedCollectiveTally (435) */ interface PalletRankedCollectiveTally extends Struct { readonly bareAyes: u32; readonly ayes: u32; readonly nays: u32; } - /** @name PalletWhitelistEvent (423) */ + /** @name PalletWhitelistEvent (437) */ interface PalletWhitelistEvent extends Enum { readonly isCallWhitelisted: boolean; readonly asCallWhitelisted: { @@ -5092,19 +5172,19 @@ declare module "@polkadot/types/lookup" { readonly type: "CallWhitelisted" | "WhitelistedCallRemoved" | "WhitelistedCallDispatched"; } - /** @name FrameSupportDispatchPostDispatchInfo (425) */ + /** @name FrameSupportDispatchPostDispatchInfo (439) */ interface FrameSupportDispatchPostDispatchInfo extends Struct { readonly actualWeight: Option; readonly paysFee: FrameSupportDispatchPays; } - /** @name SpRuntimeDispatchErrorWithPostInfo (427) */ + /** @name SpRuntimeDispatchErrorWithPostInfo (441) */ interface SpRuntimeDispatchErrorWithPostInfo extends Struct { readonly postInfo: FrameSupportDispatchPostDispatchInfo; readonly error: SpRuntimeDispatchError; } - /** @name PolkadotRuntimeParachainsInclusionPalletEvent (428) */ + /** @name PolkadotRuntimeParachainsInclusionPalletEvent (442) */ interface PolkadotRuntimeParachainsInclusionPalletEvent extends Enum { readonly isCandidateBacked: boolean; readonly asCandidateBacked: ITuple<[PolkadotPrimitivesV7CandidateReceipt, Bytes, u32, u32]>; @@ -5120,13 +5200,13 @@ declare module "@polkadot/types/lookup" { readonly type: "CandidateBacked" | "CandidateIncluded" | "CandidateTimedOut" | "UpwardMessagesReceived"; } - /** @name PolkadotPrimitivesV7CandidateReceipt (429) */ + /** @name PolkadotPrimitivesV7CandidateReceipt (443) */ interface PolkadotPrimitivesV7CandidateReceipt extends Struct { readonly descriptor: PolkadotPrimitivesV7CandidateDescriptor; readonly commitmentsHash: H256; } - /** @name PolkadotRuntimeParachainsParasPalletEvent (432) */ + /** @name PolkadotRuntimeParachainsParasPalletEvent (446) */ interface PolkadotRuntimeParachainsParasPalletEvent extends Enum { readonly isCurrentCodeUpdated: boolean; readonly asCurrentCodeUpdated: u32; @@ -5155,7 +5235,7 @@ declare module "@polkadot/types/lookup" { | "PvfCheckRejected"; } - /** @name PolkadotRuntimeParachainsHrmpPalletEvent (433) */ + /** @name PolkadotRuntimeParachainsHrmpPalletEvent (447) */ interface PolkadotRuntimeParachainsHrmpPalletEvent extends Enum { readonly isOpenChannelRequested: boolean; readonly asOpenChannelRequested: { @@ -5208,7 +5288,7 @@ declare module "@polkadot/types/lookup" { | "OpenChannelDepositsUpdated"; } - /** @name PolkadotRuntimeParachainsDisputesPalletEvent (434) */ + /** @name PolkadotRuntimeParachainsDisputesPalletEvent (448) */ interface PolkadotRuntimeParachainsDisputesPalletEvent extends Enum { readonly isDisputeInitiated: boolean; readonly asDisputeInitiated: ITuple<[H256, PolkadotRuntimeParachainsDisputesDisputeLocation]>; @@ -5219,21 +5299,21 @@ declare module "@polkadot/types/lookup" { readonly type: "DisputeInitiated" | "DisputeConcluded" | "Revert"; } - /** @name PolkadotRuntimeParachainsDisputesDisputeLocation (435) */ + /** @name PolkadotRuntimeParachainsDisputesDisputeLocation (449) */ interface PolkadotRuntimeParachainsDisputesDisputeLocation extends Enum { readonly isLocal: boolean; readonly isRemote: boolean; readonly type: "Local" | "Remote"; } - /** @name PolkadotRuntimeParachainsDisputesDisputeResult (436) */ + /** @name PolkadotRuntimeParachainsDisputesDisputeResult (450) */ interface PolkadotRuntimeParachainsDisputesDisputeResult extends Enum { readonly isValid: boolean; readonly isInvalid: boolean; readonly type: "Valid" | "Invalid"; } - /** @name PalletMessageQueueEvent (437) */ + /** @name PalletMessageQueueEvent (451) */ interface PalletMessageQueueEvent extends Enum { readonly isProcessingFailed: boolean; readonly asProcessingFailed: { @@ -5263,7 +5343,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ProcessingFailed" | "Processed" | "OverweightEnqueued" | "PageReaped"; } - /** @name FrameSupportMessagesProcessMessageError (438) */ + /** @name FrameSupportMessagesProcessMessageError (452) */ interface FrameSupportMessagesProcessMessageError extends Enum { readonly isBadFormat: boolean; readonly isCorrupt: boolean; @@ -5275,7 +5355,7 @@ declare module "@polkadot/types/lookup" { readonly type: "BadFormat" | "Corrupt" | "Unsupported" | "Overweight" | "Yield" | "StackLimitReached"; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletEvent (439) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletEvent (453) */ interface PolkadotRuntimeParachainsAssignerOnDemandPalletEvent extends Enum { readonly isOnDemandOrderPlaced: boolean; readonly asOnDemandOrderPlaced: { @@ -5290,7 +5370,7 @@ declare module "@polkadot/types/lookup" { readonly type: "OnDemandOrderPlaced" | "SpotPriceSet"; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletEvent (440) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletEvent (454) */ interface PolkadotRuntimeCommonParasRegistrarPalletEvent extends Enum { readonly isRegistered: boolean; readonly asRegistered: { @@ -5314,7 +5394,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Registered" | "Deregistered" | "Reserved" | "Swapped"; } - /** @name PalletUtilityEvent (441) */ + /** @name PalletUtilityEvent (455) */ interface PalletUtilityEvent extends Enum { readonly isBatchInterrupted: boolean; readonly asBatchInterrupted: { @@ -5341,7 +5421,7 @@ declare module "@polkadot/types/lookup" { | "DispatchedAs"; } - /** @name PalletIdentityEvent (443) */ + /** @name PalletIdentityEvent (457) */ interface PalletIdentityEvent extends Enum { readonly isIdentitySet: boolean; readonly asIdentitySet: { @@ -5447,7 +5527,7 @@ declare module "@polkadot/types/lookup" { | "DanglingUsernameRemoved"; } - /** @name PalletSchedulerEvent (444) */ + /** @name PalletSchedulerEvent (458) */ interface PalletSchedulerEvent extends Enum { readonly isScheduled: boolean; readonly asScheduled: { @@ -5509,7 +5589,7 @@ declare module "@polkadot/types/lookup" { | "PermanentlyOverweight"; } - /** @name PalletProxyEvent (446) */ + /** @name PalletProxyEvent (460) */ interface PalletProxyEvent extends Enum { readonly isProxyExecuted: boolean; readonly asProxyExecuted: { @@ -5545,7 +5625,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ProxyExecuted" | "PureCreated" | "Announced" | "ProxyAdded" | "ProxyRemoved"; } - /** @name PalletMultisigEvent (447) */ + /** @name PalletMultisigEvent (461) */ interface PalletMultisigEvent extends Enum { readonly isNewMultisig: boolean; readonly asNewMultisig: { @@ -5578,7 +5658,7 @@ declare module "@polkadot/types/lookup" { readonly type: "NewMultisig" | "MultisigApproval" | "MultisigExecuted" | "MultisigCancelled"; } - /** @name PalletPreimageEvent (448) */ + /** @name PalletPreimageEvent (462) */ interface PalletPreimageEvent extends Enum { readonly isNoted: boolean; readonly asNoted: { @@ -5595,7 +5675,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Noted" | "Requested" | "Cleared"; } - /** @name PalletAssetRateEvent (449) */ + /** @name PalletAssetRateEvent (463) */ interface PalletAssetRateEvent extends Enum { readonly isAssetRateCreated: boolean; readonly asAssetRateCreated: { @@ -5615,7 +5695,7 @@ declare module "@polkadot/types/lookup" { readonly type: "AssetRateCreated" | "AssetRateRemoved" | "AssetRateUpdated"; } - /** @name PalletXcmEvent (450) */ + /** @name PalletXcmEvent (464) */ interface PalletXcmEvent extends Enum { readonly isAttempted: boolean; readonly asAttempted: { @@ -5780,7 +5860,7 @@ declare module "@polkadot/types/lookup" { | "VersionMigrationFinished"; } - /** @name StagingXcmV4TraitsOutcome (451) */ + /** @name StagingXcmV4TraitsOutcome (465) */ interface StagingXcmV4TraitsOutcome extends Enum { readonly isComplete: boolean; readonly asComplete: { @@ -5798,7 +5878,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Complete" | "Incomplete" | "Error"; } - /** @name PalletMigrationsEvent (452) */ + /** @name PalletMigrationsEvent (466) */ interface PalletMigrationsEvent extends Enum { readonly isRuntimeUpgradeStarted: boolean; readonly isRuntimeUpgradeCompleted: boolean; @@ -5831,7 +5911,25 @@ declare module "@polkadot/types/lookup" { | "FailedToResumeIdleXcmExecution"; } - /** @name DancelightRuntimeValidatorManagerPalletEvent (454) */ + /** @name SnowbridgePalletEthereumClientEvent (468) */ + interface SnowbridgePalletEthereumClientEvent extends Enum { + readonly isBeaconHeaderImported: boolean; + readonly asBeaconHeaderImported: { + readonly blockHash: H256; + readonly slot: u64; + } & Struct; + readonly isSyncCommitteeUpdated: boolean; + readonly asSyncCommitteeUpdated: { + readonly period: u64; + } & Struct; + readonly isOperatingModeChanged: boolean; + readonly asOperatingModeChanged: { + readonly mode: SnowbridgeCoreOperatingModeBasicOperatingMode; + } & Struct; + readonly type: "BeaconHeaderImported" | "SyncCommitteeUpdated" | "OperatingModeChanged"; + } + + /** @name DancelightRuntimeValidatorManagerPalletEvent (469) */ interface DancelightRuntimeValidatorManagerPalletEvent extends Enum { readonly isValidatorsRegistered: boolean; readonly asValidatorsRegistered: Vec; @@ -5840,13 +5938,13 @@ declare module "@polkadot/types/lookup" { readonly type: "ValidatorsRegistered" | "ValidatorsDeregistered"; } - /** @name PalletRootTestingEvent (455) */ + /** @name PalletRootTestingEvent (470) */ interface PalletRootTestingEvent extends Enum { readonly isDefensiveTestCall: boolean; readonly type: "DefensiveTestCall"; } - /** @name PalletSudoEvent (456) */ + /** @name PalletSudoEvent (471) */ interface PalletSudoEvent extends Enum { readonly isSudid: boolean; readonly asSudid: { @@ -5865,7 +5963,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Sudid" | "KeyChanged" | "KeyRemoved" | "SudoAsDone"; } - /** @name FrameSystemPhase (457) */ + /** @name FrameSystemPhase (472) */ interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -5874,33 +5972,33 @@ declare module "@polkadot/types/lookup" { readonly type: "ApplyExtrinsic" | "Finalization" | "Initialization"; } - /** @name FrameSystemLastRuntimeUpgradeInfo (459) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (474) */ interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemCodeUpgradeAuthorization (461) */ + /** @name FrameSystemCodeUpgradeAuthorization (476) */ interface FrameSystemCodeUpgradeAuthorization extends Struct { readonly codeHash: H256; readonly checkVersion: bool; } - /** @name FrameSystemLimitsBlockWeights (462) */ + /** @name FrameSystemLimitsBlockWeights (477) */ interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: SpWeightsWeightV2Weight; readonly maxBlock: SpWeightsWeightV2Weight; readonly perClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; } - /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (463) */ + /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (478) */ interface FrameSupportDispatchPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (464) */ + /** @name FrameSystemLimitsWeightsPerClass (479) */ interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: SpWeightsWeightV2Weight; readonly maxExtrinsic: Option; @@ -5908,25 +6006,25 @@ declare module "@polkadot/types/lookup" { readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (465) */ + /** @name FrameSystemLimitsBlockLength (480) */ interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportDispatchPerDispatchClassU32; } - /** @name FrameSupportDispatchPerDispatchClassU32 (466) */ + /** @name FrameSupportDispatchPerDispatchClassU32 (481) */ interface FrameSupportDispatchPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name SpWeightsRuntimeDbWeight (467) */ + /** @name SpWeightsRuntimeDbWeight (482) */ interface SpWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (468) */ + /** @name SpVersionRuntimeVersion (483) */ interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -5938,7 +6036,7 @@ declare module "@polkadot/types/lookup" { readonly stateVersion: u8; } - /** @name FrameSystemError (472) */ + /** @name FrameSystemError (487) */ interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -5961,7 +6059,7 @@ declare module "@polkadot/types/lookup" { | "Unauthorized"; } - /** @name SpConsensusBabeDigestsPreDigest (479) */ + /** @name SpConsensusBabeDigestsPreDigest (494) */ interface SpConsensusBabeDigestsPreDigest extends Enum { readonly isPrimary: boolean; readonly asPrimary: SpConsensusBabeDigestsPrimaryPreDigest; @@ -5972,39 +6070,39 @@ declare module "@polkadot/types/lookup" { readonly type: "Primary" | "SecondaryPlain" | "SecondaryVRF"; } - /** @name SpConsensusBabeDigestsPrimaryPreDigest (480) */ + /** @name SpConsensusBabeDigestsPrimaryPreDigest (495) */ interface SpConsensusBabeDigestsPrimaryPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; readonly vrfSignature: SpCoreSr25519VrfVrfSignature; } - /** @name SpCoreSr25519VrfVrfSignature (481) */ + /** @name SpCoreSr25519VrfVrfSignature (496) */ interface SpCoreSr25519VrfVrfSignature extends Struct { readonly preOutput: U8aFixed; readonly proof: U8aFixed; } - /** @name SpConsensusBabeDigestsSecondaryPlainPreDigest (482) */ + /** @name SpConsensusBabeDigestsSecondaryPlainPreDigest (497) */ interface SpConsensusBabeDigestsSecondaryPlainPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; } - /** @name SpConsensusBabeDigestsSecondaryVRFPreDigest (483) */ + /** @name SpConsensusBabeDigestsSecondaryVRFPreDigest (498) */ interface SpConsensusBabeDigestsSecondaryVRFPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; readonly vrfSignature: SpCoreSr25519VrfVrfSignature; } - /** @name SpConsensusBabeBabeEpochConfiguration (484) */ + /** @name SpConsensusBabeBabeEpochConfiguration (499) */ interface SpConsensusBabeBabeEpochConfiguration extends Struct { readonly c: ITuple<[u64, u64]>; readonly allowedSlots: SpConsensusBabeAllowedSlots; } - /** @name PalletBabeError (488) */ + /** @name PalletBabeError (503) */ interface PalletBabeError extends Enum { readonly isInvalidEquivocationProof: boolean; readonly isInvalidKeyOwnershipProof: boolean; @@ -6017,14 +6115,14 @@ declare module "@polkadot/types/lookup" { | "InvalidConfiguration"; } - /** @name PalletBalancesBalanceLock (490) */ + /** @name PalletBalancesBalanceLock (505) */ interface PalletBalancesBalanceLock extends Struct { readonly id: U8aFixed; readonly amount: u128; readonly reasons: PalletBalancesReasons; } - /** @name PalletBalancesReasons (491) */ + /** @name PalletBalancesReasons (506) */ interface PalletBalancesReasons extends Enum { readonly isFee: boolean; readonly isMisc: boolean; @@ -6032,13 +6130,13 @@ declare module "@polkadot/types/lookup" { readonly type: "Fee" | "Misc" | "All"; } - /** @name PalletBalancesReserveData (494) */ + /** @name PalletBalancesReserveData (509) */ interface PalletBalancesReserveData extends Struct { readonly id: U8aFixed; readonly amount: u128; } - /** @name DancelightRuntimeRuntimeHoldReason (498) */ + /** @name DancelightRuntimeRuntimeHoldReason (513) */ interface DancelightRuntimeRuntimeHoldReason extends Enum { readonly isContainerRegistrar: boolean; readonly asContainerRegistrar: PalletRegistrarHoldReason; @@ -6049,31 +6147,31 @@ declare module "@polkadot/types/lookup" { readonly type: "ContainerRegistrar" | "DataPreservers" | "Preimage"; } - /** @name PalletRegistrarHoldReason (499) */ + /** @name PalletRegistrarHoldReason (514) */ interface PalletRegistrarHoldReason extends Enum { readonly isRegistrarDeposit: boolean; readonly type: "RegistrarDeposit"; } - /** @name PalletDataPreserversHoldReason (500) */ + /** @name PalletDataPreserversHoldReason (515) */ interface PalletDataPreserversHoldReason extends Enum { readonly isProfileDeposit: boolean; readonly type: "ProfileDeposit"; } - /** @name PalletPreimageHoldReason (501) */ + /** @name PalletPreimageHoldReason (516) */ interface PalletPreimageHoldReason extends Enum { readonly isPreimage: boolean; readonly type: "Preimage"; } - /** @name FrameSupportTokensMiscIdAmount (504) */ + /** @name FrameSupportTokensMiscIdAmount (519) */ interface FrameSupportTokensMiscIdAmount extends Struct { readonly id: Null; readonly amount: u128; } - /** @name PalletBalancesError (506) */ + /** @name PalletBalancesError (521) */ interface PalletBalancesError extends Enum { readonly isVestingBalance: boolean; readonly isLiquidityRestrictions: boolean; @@ -6102,26 +6200,26 @@ declare module "@polkadot/types/lookup" { | "DeltaZero"; } - /** @name PalletTransactionPaymentReleases (507) */ + /** @name PalletTransactionPaymentReleases (522) */ interface PalletTransactionPaymentReleases extends Enum { readonly isV1Ancient: boolean; readonly isV2: boolean; readonly type: "V1Ancient" | "V2"; } - /** @name SpStakingOffenceOffenceDetails (508) */ + /** @name SpStakingOffenceOffenceDetails (523) */ interface SpStakingOffenceOffenceDetails extends Struct { readonly offender: ITuple<[AccountId32, Null]>; readonly reporters: Vec; } - /** @name PalletRegistrarDepositInfo (520) */ + /** @name PalletRegistrarDepositInfo (535) */ interface PalletRegistrarDepositInfo extends Struct { readonly creator: AccountId32; readonly deposit: u128; } - /** @name PalletRegistrarError (521) */ + /** @name PalletRegistrarError (536) */ interface PalletRegistrarError extends Enum { readonly isParaIdAlreadyRegistered: boolean; readonly isParaIdNotRegistered: boolean; @@ -6160,7 +6258,7 @@ declare module "@polkadot/types/lookup" { | "WasmCodeNecessary"; } - /** @name PalletConfigurationHostConfiguration (522) */ + /** @name PalletConfigurationHostConfiguration (537) */ interface PalletConfigurationHostConfiguration extends Struct { readonly maxCollators: u32; readonly minOrchestratorCollators: u32; @@ -6173,13 +6271,13 @@ declare module "@polkadot/types/lookup" { readonly maxParachainCoresPercentage: Option; } - /** @name PalletConfigurationError (525) */ + /** @name PalletConfigurationError (540) */ interface PalletConfigurationError extends Enum { readonly isInvalidNewValue: boolean; readonly type: "InvalidNewValue"; } - /** @name PalletInvulnerablesError (527) */ + /** @name PalletInvulnerablesError (542) */ interface PalletInvulnerablesError extends Enum { readonly isTooManyInvulnerables: boolean; readonly isAlreadyInvulnerable: boolean; @@ -6194,26 +6292,26 @@ declare module "@polkadot/types/lookup" { | "UnableToDeriveCollatorId"; } - /** @name DpCollatorAssignmentAssignedCollatorsAccountId32 (528) */ + /** @name DpCollatorAssignmentAssignedCollatorsAccountId32 (543) */ interface DpCollatorAssignmentAssignedCollatorsAccountId32 extends Struct { readonly orchestratorChain: Vec; readonly containerChains: BTreeMap>; } - /** @name DpCollatorAssignmentAssignedCollatorsPublic (533) */ + /** @name DpCollatorAssignmentAssignedCollatorsPublic (548) */ interface DpCollatorAssignmentAssignedCollatorsPublic extends Struct { readonly orchestratorChain: Vec; readonly containerChains: BTreeMap>; } - /** @name TpTraitsContainerChainBlockInfo (541) */ + /** @name TpTraitsContainerChainBlockInfo (556) */ interface TpTraitsContainerChainBlockInfo extends Struct { readonly blockNumber: u32; readonly author: AccountId32; readonly latestSlotNumber: u64; } - /** @name PalletAuthorNotingError (542) */ + /** @name PalletAuthorNotingError (557) */ interface PalletAuthorNotingError extends Enum { readonly isFailedReading: boolean; readonly isFailedDecodingHeader: boolean; @@ -6232,7 +6330,7 @@ declare module "@polkadot/types/lookup" { | "NonAuraDigest"; } - /** @name PalletServicesPaymentError (543) */ + /** @name PalletServicesPaymentError (558) */ interface PalletServicesPaymentError extends Enum { readonly isInsufficientFundsToPurchaseCredits: boolean; readonly isInsufficientCredits: boolean; @@ -6240,7 +6338,7 @@ declare module "@polkadot/types/lookup" { readonly type: "InsufficientFundsToPurchaseCredits" | "InsufficientCredits" | "CreditPriceTooExpensive"; } - /** @name PalletDataPreserversRegisteredProfile (544) */ + /** @name PalletDataPreserversRegisteredProfile (559) */ interface PalletDataPreserversRegisteredProfile extends Struct { readonly account: AccountId32; readonly deposit: u128; @@ -6248,7 +6346,7 @@ declare module "@polkadot/types/lookup" { readonly assignment: Option>; } - /** @name PalletDataPreserversError (550) */ + /** @name PalletDataPreserversError (565) */ interface PalletDataPreserversError extends Enum { readonly isNoBootNodes: boolean; readonly isUnknownProfileId: boolean; @@ -6273,10 +6371,10 @@ declare module "@polkadot/types/lookup" { | "CantDeleteAssignedProfile"; } - /** @name SpCoreCryptoKeyTypeId (555) */ + /** @name SpCoreCryptoKeyTypeId (570) */ interface SpCoreCryptoKeyTypeId extends U8aFixed {} - /** @name PalletSessionError (556) */ + /** @name PalletSessionError (571) */ interface PalletSessionError extends Enum { readonly isInvalidProof: boolean; readonly isNoAssociatedValidatorId: boolean; @@ -6286,7 +6384,7 @@ declare module "@polkadot/types/lookup" { readonly type: "InvalidProof" | "NoAssociatedValidatorId" | "DuplicatedKey" | "NoKeys" | "NoAccount"; } - /** @name PalletGrandpaStoredState (557) */ + /** @name PalletGrandpaStoredState (572) */ interface PalletGrandpaStoredState extends Enum { readonly isLive: boolean; readonly isPendingPause: boolean; @@ -6303,7 +6401,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Live" | "PendingPause" | "Paused" | "PendingResume"; } - /** @name PalletGrandpaStoredPendingChange (558) */ + /** @name PalletGrandpaStoredPendingChange (573) */ interface PalletGrandpaStoredPendingChange extends Struct { readonly scheduledAt: u32; readonly delay: u32; @@ -6311,7 +6409,7 @@ declare module "@polkadot/types/lookup" { readonly forced: Option; } - /** @name PalletGrandpaError (560) */ + /** @name PalletGrandpaError (575) */ interface PalletGrandpaError extends Enum { readonly isPauseFailed: boolean; readonly isResumeFailed: boolean; @@ -6330,13 +6428,13 @@ declare module "@polkadot/types/lookup" { | "DuplicateOffenceReport"; } - /** @name PalletInflationRewardsChainsToRewardValue (563) */ + /** @name PalletInflationRewardsChainsToRewardValue (578) */ interface PalletInflationRewardsChainsToRewardValue extends Struct { readonly paraIds: Vec; readonly rewardsPerChain: u128; } - /** @name PalletTreasuryProposal (564) */ + /** @name PalletTreasuryProposal (579) */ interface PalletTreasuryProposal extends Struct { readonly proposer: AccountId32; readonly value: u128; @@ -6344,7 +6442,7 @@ declare module "@polkadot/types/lookup" { readonly bond: u128; } - /** @name PalletTreasurySpendStatus (566) */ + /** @name PalletTreasurySpendStatus (581) */ interface PalletTreasurySpendStatus extends Struct { readonly assetKind: Null; readonly amount: u128; @@ -6354,7 +6452,7 @@ declare module "@polkadot/types/lookup" { readonly status: PalletTreasuryPaymentState; } - /** @name PalletTreasuryPaymentState (567) */ + /** @name PalletTreasuryPaymentState (582) */ interface PalletTreasuryPaymentState extends Enum { readonly isPending: boolean; readonly isAttempted: boolean; @@ -6365,10 +6463,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Pending" | "Attempted" | "Failed"; } - /** @name FrameSupportPalletId (569) */ + /** @name FrameSupportPalletId (584) */ interface FrameSupportPalletId extends U8aFixed {} - /** @name PalletTreasuryError (570) */ + /** @name PalletTreasuryError (585) */ interface PalletTreasuryError extends Enum { readonly isInvalidIndex: boolean; readonly isTooManyApprovals: boolean; @@ -6395,7 +6493,7 @@ declare module "@polkadot/types/lookup" { | "Inconclusive"; } - /** @name PalletConvictionVotingVoteVoting (572) */ + /** @name PalletConvictionVotingVoteVoting (587) */ interface PalletConvictionVotingVoteVoting extends Enum { readonly isCasting: boolean; readonly asCasting: PalletConvictionVotingVoteCasting; @@ -6404,23 +6502,23 @@ declare module "@polkadot/types/lookup" { readonly type: "Casting" | "Delegating"; } - /** @name PalletConvictionVotingVoteCasting (573) */ + /** @name PalletConvictionVotingVoteCasting (588) */ interface PalletConvictionVotingVoteCasting extends Struct { readonly votes: Vec>; readonly delegations: PalletConvictionVotingDelegations; readonly prior: PalletConvictionVotingVotePriorLock; } - /** @name PalletConvictionVotingDelegations (577) */ + /** @name PalletConvictionVotingDelegations (592) */ interface PalletConvictionVotingDelegations extends Struct { readonly votes: u128; readonly capital: u128; } - /** @name PalletConvictionVotingVotePriorLock (578) */ + /** @name PalletConvictionVotingVotePriorLock (593) */ interface PalletConvictionVotingVotePriorLock extends ITuple<[u32, u128]> {} - /** @name PalletConvictionVotingVoteDelegating (579) */ + /** @name PalletConvictionVotingVoteDelegating (594) */ interface PalletConvictionVotingVoteDelegating extends Struct { readonly balance: u128; readonly target: AccountId32; @@ -6429,7 +6527,7 @@ declare module "@polkadot/types/lookup" { readonly prior: PalletConvictionVotingVotePriorLock; } - /** @name PalletConvictionVotingError (583) */ + /** @name PalletConvictionVotingError (598) */ interface PalletConvictionVotingError extends Enum { readonly isNotOngoing: boolean; readonly isNotVoter: boolean; @@ -6458,7 +6556,7 @@ declare module "@polkadot/types/lookup" { | "BadClass"; } - /** @name PalletReferendaReferendumInfoConvictionVotingTally (584) */ + /** @name PalletReferendaReferendumInfoConvictionVotingTally (599) */ interface PalletReferendaReferendumInfoConvictionVotingTally extends Enum { readonly isOngoing: boolean; readonly asOngoing: PalletReferendaReferendumStatusConvictionVotingTally; @@ -6475,7 +6573,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ongoing" | "Approved" | "Rejected" | "Cancelled" | "TimedOut" | "Killed"; } - /** @name PalletReferendaReferendumStatusConvictionVotingTally (585) */ + /** @name PalletReferendaReferendumStatusConvictionVotingTally (600) */ interface PalletReferendaReferendumStatusConvictionVotingTally extends Struct { readonly track: u16; readonly origin: DancelightRuntimeOriginCaller; @@ -6490,19 +6588,19 @@ declare module "@polkadot/types/lookup" { readonly alarm: Option]>>; } - /** @name PalletReferendaDeposit (586) */ + /** @name PalletReferendaDeposit (601) */ interface PalletReferendaDeposit extends Struct { readonly who: AccountId32; readonly amount: u128; } - /** @name PalletReferendaDecidingStatus (589) */ + /** @name PalletReferendaDecidingStatus (604) */ interface PalletReferendaDecidingStatus extends Struct { readonly since: u32; readonly confirming: Option; } - /** @name PalletReferendaTrackInfo (597) */ + /** @name PalletReferendaTrackInfo (612) */ interface PalletReferendaTrackInfo extends Struct { readonly name: Text; readonly maxDeciding: u32; @@ -6515,7 +6613,7 @@ declare module "@polkadot/types/lookup" { readonly minSupport: PalletReferendaCurve; } - /** @name PalletReferendaCurve (598) */ + /** @name PalletReferendaCurve (613) */ interface PalletReferendaCurve extends Enum { readonly isLinearDecreasing: boolean; readonly asLinearDecreasing: { @@ -6539,7 +6637,7 @@ declare module "@polkadot/types/lookup" { readonly type: "LinearDecreasing" | "SteppedDecreasing" | "Reciprocal"; } - /** @name PalletReferendaError (601) */ + /** @name PalletReferendaError (616) */ interface PalletReferendaError extends Enum { readonly isNotOngoing: boolean; readonly isHasDeposit: boolean; @@ -6572,12 +6670,12 @@ declare module "@polkadot/types/lookup" { | "PreimageStoredWithDifferentLength"; } - /** @name PalletRankedCollectiveMemberRecord (602) */ + /** @name PalletRankedCollectiveMemberRecord (617) */ interface PalletRankedCollectiveMemberRecord extends Struct { readonly rank: u16; } - /** @name PalletRankedCollectiveError (607) */ + /** @name PalletRankedCollectiveError (622) */ interface PalletRankedCollectiveError extends Enum { readonly isAlreadyMember: boolean; readonly isNotMember: boolean; @@ -6604,7 +6702,7 @@ declare module "@polkadot/types/lookup" { | "TooManyMembers"; } - /** @name PalletReferendaReferendumInfoRankedCollectiveTally (608) */ + /** @name PalletReferendaReferendumInfoRankedCollectiveTally (623) */ interface PalletReferendaReferendumInfoRankedCollectiveTally extends Enum { readonly isOngoing: boolean; readonly asOngoing: PalletReferendaReferendumStatusRankedCollectiveTally; @@ -6621,7 +6719,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ongoing" | "Approved" | "Rejected" | "Cancelled" | "TimedOut" | "Killed"; } - /** @name PalletReferendaReferendumStatusRankedCollectiveTally (609) */ + /** @name PalletReferendaReferendumStatusRankedCollectiveTally (624) */ interface PalletReferendaReferendumStatusRankedCollectiveTally extends Struct { readonly track: u16; readonly origin: DancelightRuntimeOriginCaller; @@ -6636,7 +6734,7 @@ declare module "@polkadot/types/lookup" { readonly alarm: Option]>>; } - /** @name PalletWhitelistError (612) */ + /** @name PalletWhitelistError (627) */ interface PalletWhitelistError extends Enum { readonly isUnavailablePreImage: boolean; readonly isUndecodableCall: boolean; @@ -6651,7 +6749,7 @@ declare module "@polkadot/types/lookup" { | "CallAlreadyWhitelisted"; } - /** @name PolkadotRuntimeParachainsConfigurationHostConfiguration (613) */ + /** @name PolkadotRuntimeParachainsConfigurationHostConfiguration (628) */ interface PolkadotRuntimeParachainsConfigurationHostConfiguration extends Struct { readonly maxCodeSize: u32; readonly maxHeadDataSize: u32; @@ -6690,19 +6788,19 @@ declare module "@polkadot/types/lookup" { readonly schedulerParams: PolkadotPrimitivesVstagingSchedulerParams; } - /** @name PolkadotRuntimeParachainsConfigurationPalletError (616) */ + /** @name PolkadotRuntimeParachainsConfigurationPalletError (631) */ interface PolkadotRuntimeParachainsConfigurationPalletError extends Enum { readonly isInvalidNewValue: boolean; readonly type: "InvalidNewValue"; } - /** @name PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker (619) */ + /** @name PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker (634) */ interface PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker extends Struct { readonly buffer: Vec>; readonly latestNumber: u32; } - /** @name PolkadotRuntimeParachainsInclusionCandidatePendingAvailability (623) */ + /** @name PolkadotRuntimeParachainsInclusionCandidatePendingAvailability (638) */ interface PolkadotRuntimeParachainsInclusionCandidatePendingAvailability extends Struct { readonly core: u32; readonly hash_: H256; @@ -6715,7 +6813,7 @@ declare module "@polkadot/types/lookup" { readonly backingGroup: u32; } - /** @name PolkadotRuntimeParachainsInclusionPalletError (624) */ + /** @name PolkadotRuntimeParachainsInclusionPalletError (639) */ interface PolkadotRuntimeParachainsInclusionPalletError extends Enum { readonly isValidatorIndexOutOfBounds: boolean; readonly isUnscheduledCandidate: boolean; @@ -6756,7 +6854,7 @@ declare module "@polkadot/types/lookup" { | "ParaHeadMismatch"; } - /** @name PolkadotPrimitivesV7ScrapedOnChainVotes (625) */ + /** @name PolkadotPrimitivesV7ScrapedOnChainVotes (640) */ interface PolkadotPrimitivesV7ScrapedOnChainVotes extends Struct { readonly session: u32; readonly backingValidatorsPerCandidate: Vec< @@ -6765,7 +6863,7 @@ declare module "@polkadot/types/lookup" { readonly disputes: Vec; } - /** @name PolkadotRuntimeParachainsParasInherentPalletError (630) */ + /** @name PolkadotRuntimeParachainsParasInherentPalletError (645) */ interface PolkadotRuntimeParachainsParasInherentPalletError extends Enum { readonly isTooManyInclusionInherents: boolean; readonly isInvalidParentHeader: boolean; @@ -6780,7 +6878,7 @@ declare module "@polkadot/types/lookup" { | "UnscheduledCandidate"; } - /** @name PolkadotRuntimeParachainsSchedulerPalletCoreOccupied (633) */ + /** @name PolkadotRuntimeParachainsSchedulerPalletCoreOccupied (648) */ interface PolkadotRuntimeParachainsSchedulerPalletCoreOccupied extends Enum { readonly isFree: boolean; readonly isParas: boolean; @@ -6788,14 +6886,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Free" | "Paras"; } - /** @name PolkadotRuntimeParachainsSchedulerPalletParasEntry (634) */ + /** @name PolkadotRuntimeParachainsSchedulerPalletParasEntry (649) */ interface PolkadotRuntimeParachainsSchedulerPalletParasEntry extends Struct { readonly assignment: PolkadotRuntimeParachainsSchedulerCommonAssignment; readonly availabilityTimeouts: u32; readonly ttl: u32; } - /** @name PolkadotRuntimeParachainsSchedulerCommonAssignment (635) */ + /** @name PolkadotRuntimeParachainsSchedulerCommonAssignment (650) */ interface PolkadotRuntimeParachainsSchedulerCommonAssignment extends Enum { readonly isPool: boolean; readonly asPool: { @@ -6807,7 +6905,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Pool" | "Bulk"; } - /** @name PolkadotRuntimeParachainsParasPvfCheckActiveVoteState (640) */ + /** @name PolkadotRuntimeParachainsParasPvfCheckActiveVoteState (655) */ interface PolkadotRuntimeParachainsParasPvfCheckActiveVoteState extends Struct { readonly votesAccept: BitVec; readonly votesReject: BitVec; @@ -6816,7 +6914,7 @@ declare module "@polkadot/types/lookup" { readonly causes: Vec; } - /** @name PolkadotRuntimeParachainsParasPvfCheckCause (642) */ + /** @name PolkadotRuntimeParachainsParasPvfCheckCause (657) */ interface PolkadotRuntimeParachainsParasPvfCheckCause extends Enum { readonly isOnboarding: boolean; readonly asOnboarding: u32; @@ -6829,14 +6927,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Onboarding" | "Upgrade"; } - /** @name PolkadotRuntimeParachainsParasUpgradeStrategy (643) */ + /** @name PolkadotRuntimeParachainsParasUpgradeStrategy (658) */ interface PolkadotRuntimeParachainsParasUpgradeStrategy extends Enum { readonly isSetGoAheadSignal: boolean; readonly isApplyAtExpectedBlock: boolean; readonly type: "SetGoAheadSignal" | "ApplyAtExpectedBlock"; } - /** @name PolkadotRuntimeParachainsParasParaLifecycle (645) */ + /** @name PolkadotRuntimeParachainsParasParaLifecycle (660) */ interface PolkadotRuntimeParachainsParasParaLifecycle extends Enum { readonly isOnboarding: boolean; readonly isParathread: boolean; @@ -6855,32 +6953,32 @@ declare module "@polkadot/types/lookup" { | "OffboardingParachain"; } - /** @name PolkadotRuntimeParachainsParasParaPastCodeMeta (647) */ + /** @name PolkadotRuntimeParachainsParasParaPastCodeMeta (662) */ interface PolkadotRuntimeParachainsParasParaPastCodeMeta extends Struct { readonly upgradeTimes: Vec; readonly lastPruned: Option; } - /** @name PolkadotRuntimeParachainsParasReplacementTimes (649) */ + /** @name PolkadotRuntimeParachainsParasReplacementTimes (664) */ interface PolkadotRuntimeParachainsParasReplacementTimes extends Struct { readonly expectedAt: u32; readonly activatedAt: u32; } - /** @name PolkadotPrimitivesV7UpgradeGoAhead (651) */ + /** @name PolkadotPrimitivesV7UpgradeGoAhead (666) */ interface PolkadotPrimitivesV7UpgradeGoAhead extends Enum { readonly isAbort: boolean; readonly isGoAhead: boolean; readonly type: "Abort" | "GoAhead"; } - /** @name PolkadotPrimitivesV7UpgradeRestriction (652) */ + /** @name PolkadotPrimitivesV7UpgradeRestriction (667) */ interface PolkadotPrimitivesV7UpgradeRestriction extends Enum { readonly isPresent: boolean; readonly type: "Present"; } - /** @name PolkadotRuntimeParachainsParasPalletError (653) */ + /** @name PolkadotRuntimeParachainsParasPalletError (668) */ interface PolkadotRuntimeParachainsParasPalletError extends Enum { readonly isNotRegistered: boolean; readonly isCannotOnboard: boolean; @@ -6911,20 +7009,20 @@ declare module "@polkadot/types/lookup" { | "InvalidCode"; } - /** @name PolkadotRuntimeParachainsInitializerBufferedSessionChange (655) */ + /** @name PolkadotRuntimeParachainsInitializerBufferedSessionChange (670) */ interface PolkadotRuntimeParachainsInitializerBufferedSessionChange extends Struct { readonly validators: Vec; readonly queued: Vec; readonly sessionIndex: u32; } - /** @name PolkadotCorePrimitivesInboundDownwardMessage (657) */ + /** @name PolkadotCorePrimitivesInboundDownwardMessage (672) */ interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct { readonly sentAt: u32; readonly msg: Bytes; } - /** @name PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest (658) */ + /** @name PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest (673) */ interface PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest extends Struct { readonly confirmed: bool; readonly age: u32; @@ -6934,7 +7032,7 @@ declare module "@polkadot/types/lookup" { readonly maxTotalSize: u32; } - /** @name PolkadotRuntimeParachainsHrmpHrmpChannel (660) */ + /** @name PolkadotRuntimeParachainsHrmpHrmpChannel (675) */ interface PolkadotRuntimeParachainsHrmpHrmpChannel extends Struct { readonly maxCapacity: u32; readonly maxTotalSize: u32; @@ -6946,13 +7044,13 @@ declare module "@polkadot/types/lookup" { readonly recipientDeposit: u128; } - /** @name PolkadotCorePrimitivesInboundHrmpMessage (662) */ + /** @name PolkadotCorePrimitivesInboundHrmpMessage (677) */ interface PolkadotCorePrimitivesInboundHrmpMessage extends Struct { readonly sentAt: u32; readonly data: Bytes; } - /** @name PolkadotRuntimeParachainsHrmpPalletError (665) */ + /** @name PolkadotRuntimeParachainsHrmpPalletError (680) */ interface PolkadotRuntimeParachainsHrmpPalletError extends Enum { readonly isOpenHrmpChannelToSelf: boolean; readonly isOpenHrmpChannelInvalidRecipient: boolean; @@ -6997,7 +7095,7 @@ declare module "@polkadot/types/lookup" { | "ChannelCreationNotAuthorized"; } - /** @name PolkadotPrimitivesV7SessionInfo (667) */ + /** @name PolkadotPrimitivesV7SessionInfo (682) */ interface PolkadotPrimitivesV7SessionInfo extends Struct { readonly activeValidatorIndices: Vec; readonly randomSeed: U8aFixed; @@ -7014,13 +7112,13 @@ declare module "@polkadot/types/lookup" { readonly neededApprovals: u32; } - /** @name PolkadotPrimitivesV7IndexedVecValidatorIndex (668) */ + /** @name PolkadotPrimitivesV7IndexedVecValidatorIndex (683) */ interface PolkadotPrimitivesV7IndexedVecValidatorIndex extends Vec {} - /** @name PolkadotPrimitivesV7IndexedVecGroupIndex (669) */ + /** @name PolkadotPrimitivesV7IndexedVecGroupIndex (684) */ interface PolkadotPrimitivesV7IndexedVecGroupIndex extends Vec> {} - /** @name PolkadotPrimitivesV7DisputeState (671) */ + /** @name PolkadotPrimitivesV7DisputeState (686) */ interface PolkadotPrimitivesV7DisputeState extends Struct { readonly validatorsFor: BitVec; readonly validatorsAgainst: BitVec; @@ -7028,7 +7126,7 @@ declare module "@polkadot/types/lookup" { readonly concludedAt: Option; } - /** @name PolkadotRuntimeParachainsDisputesPalletError (673) */ + /** @name PolkadotRuntimeParachainsDisputesPalletError (688) */ interface PolkadotRuntimeParachainsDisputesPalletError extends Enum { readonly isDuplicateDisputeStatementSets: boolean; readonly isAncientDisputeStatement: boolean; @@ -7051,13 +7149,13 @@ declare module "@polkadot/types/lookup" { | "UnconfirmedDispute"; } - /** @name PolkadotPrimitivesV7SlashingPendingSlashes (674) */ + /** @name PolkadotPrimitivesV7SlashingPendingSlashes (689) */ interface PolkadotPrimitivesV7SlashingPendingSlashes extends Struct { readonly keys_: BTreeMap; readonly kind: PolkadotPrimitivesV7SlashingSlashingOffenceKind; } - /** @name PolkadotRuntimeParachainsDisputesSlashingPalletError (678) */ + /** @name PolkadotRuntimeParachainsDisputesSlashingPalletError (693) */ interface PolkadotRuntimeParachainsDisputesSlashingPalletError extends Enum { readonly isInvalidKeyOwnershipProof: boolean; readonly isInvalidSessionIndex: boolean; @@ -7074,7 +7172,7 @@ declare module "@polkadot/types/lookup" { | "DuplicateSlashingReport"; } - /** @name PalletMessageQueueBookState (679) */ + /** @name PalletMessageQueueBookState (694) */ interface PalletMessageQueueBookState extends Struct { readonly begin: u32; readonly end: u32; @@ -7084,13 +7182,13 @@ declare module "@polkadot/types/lookup" { readonly size_: u64; } - /** @name PalletMessageQueueNeighbours (681) */ + /** @name PalletMessageQueueNeighbours (696) */ interface PalletMessageQueueNeighbours extends Struct { readonly prev: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin; readonly next: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin; } - /** @name PalletMessageQueuePage (683) */ + /** @name PalletMessageQueuePage (698) */ interface PalletMessageQueuePage extends Struct { readonly remaining: u32; readonly remainingSize: u32; @@ -7100,7 +7198,7 @@ declare module "@polkadot/types/lookup" { readonly heap: Bytes; } - /** @name PalletMessageQueueError (685) */ + /** @name PalletMessageQueueError (700) */ interface PalletMessageQueueError extends Enum { readonly isNotReapable: boolean; readonly isNoPage: boolean; @@ -7123,13 +7221,13 @@ declare module "@polkadot/types/lookup" { | "RecursiveDisallowed"; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount (686) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount (701) */ interface PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount extends Struct { readonly coreIndex: u32; readonly count: u32; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType (687) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType (702) */ interface PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType extends Struct { readonly traffic: u128; readonly nextIndex: u32; @@ -7137,33 +7235,33 @@ declare module "@polkadot/types/lookup" { readonly freedIndices: BinaryHeapReverseQueueIndex; } - /** @name BinaryHeapReverseQueueIndex (689) */ + /** @name BinaryHeapReverseQueueIndex (704) */ interface BinaryHeapReverseQueueIndex extends Vec {} - /** @name BinaryHeapEnqueuedOrder (692) */ + /** @name BinaryHeapEnqueuedOrder (707) */ interface BinaryHeapEnqueuedOrder extends Vec {} - /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder (693) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder (708) */ interface PolkadotRuntimeParachainsAssignerOnDemandTypesEnqueuedOrder extends Struct { readonly paraId: u32; readonly idx: u32; } - /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletError (697) */ + /** @name PolkadotRuntimeParachainsAssignerOnDemandPalletError (712) */ interface PolkadotRuntimeParachainsAssignerOnDemandPalletError extends Enum { readonly isQueueFull: boolean; readonly isSpotPriceHigherThanMaxAmount: boolean; readonly type: "QueueFull" | "SpotPriceHigherThanMaxAmount"; } - /** @name PolkadotRuntimeCommonParasRegistrarParaInfo (698) */ + /** @name PolkadotRuntimeCommonParasRegistrarParaInfo (713) */ interface PolkadotRuntimeCommonParasRegistrarParaInfo extends Struct { readonly manager: AccountId32; readonly deposit: u128; readonly locked: Option; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletError (700) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletError (715) */ interface PolkadotRuntimeCommonParasRegistrarPalletError extends Enum { readonly isNotRegistered: boolean; readonly isAlreadyRegistered: boolean; @@ -7196,33 +7294,33 @@ declare module "@polkadot/types/lookup" { | "CannotSwap"; } - /** @name PalletUtilityError (701) */ + /** @name PalletUtilityError (716) */ interface PalletUtilityError extends Enum { readonly isTooManyCalls: boolean; readonly type: "TooManyCalls"; } - /** @name PalletIdentityRegistration (703) */ + /** @name PalletIdentityRegistration (718) */ interface PalletIdentityRegistration extends Struct { readonly judgements: Vec>; readonly deposit: u128; readonly info: PalletIdentityLegacyIdentityInfo; } - /** @name PalletIdentityRegistrarInfo (712) */ + /** @name PalletIdentityRegistrarInfo (727) */ interface PalletIdentityRegistrarInfo extends Struct { readonly account: AccountId32; readonly fee: u128; readonly fields: u64; } - /** @name PalletIdentityAuthorityProperties (714) */ + /** @name PalletIdentityAuthorityProperties (729) */ interface PalletIdentityAuthorityProperties extends Struct { readonly suffix: Bytes; readonly allocation: u32; } - /** @name PalletIdentityError (717) */ + /** @name PalletIdentityError (732) */ interface PalletIdentityError extends Enum { readonly isTooManySubAccounts: boolean; readonly isNotFound: boolean; @@ -7279,7 +7377,7 @@ declare module "@polkadot/types/lookup" { | "NotExpired"; } - /** @name PalletSchedulerScheduled (720) */ + /** @name PalletSchedulerScheduled (735) */ interface PalletSchedulerScheduled extends Struct { readonly maybeId: Option; readonly priority: u8; @@ -7288,14 +7386,14 @@ declare module "@polkadot/types/lookup" { readonly origin: DancelightRuntimeOriginCaller; } - /** @name PalletSchedulerRetryConfig (722) */ + /** @name PalletSchedulerRetryConfig (737) */ interface PalletSchedulerRetryConfig extends Struct { readonly totalRetries: u8; readonly remaining: u8; readonly period: u32; } - /** @name PalletSchedulerError (723) */ + /** @name PalletSchedulerError (738) */ interface PalletSchedulerError extends Enum { readonly isFailedToSchedule: boolean; readonly isNotFound: boolean; @@ -7305,21 +7403,21 @@ declare module "@polkadot/types/lookup" { readonly type: "FailedToSchedule" | "NotFound" | "TargetBlockNumberInPast" | "RescheduleNoChange" | "Named"; } - /** @name PalletProxyProxyDefinition (726) */ + /** @name PalletProxyProxyDefinition (741) */ interface PalletProxyProxyDefinition extends Struct { readonly delegate: AccountId32; readonly proxyType: DancelightRuntimeProxyType; readonly delay: u32; } - /** @name PalletProxyAnnouncement (730) */ + /** @name PalletProxyAnnouncement (745) */ interface PalletProxyAnnouncement extends Struct { readonly real: AccountId32; readonly callHash: H256; readonly height: u32; } - /** @name PalletProxyError (732) */ + /** @name PalletProxyError (747) */ interface PalletProxyError extends Enum { readonly isTooMany: boolean; readonly isNotFound: boolean; @@ -7340,7 +7438,7 @@ declare module "@polkadot/types/lookup" { | "NoSelfProxy"; } - /** @name PalletMultisigMultisig (734) */ + /** @name PalletMultisigMultisig (749) */ interface PalletMultisigMultisig extends Struct { readonly when: PalletMultisigTimepoint; readonly deposit: u128; @@ -7348,7 +7446,7 @@ declare module "@polkadot/types/lookup" { readonly approvals: Vec; } - /** @name PalletMultisigError (736) */ + /** @name PalletMultisigError (751) */ interface PalletMultisigError extends Enum { readonly isMinimumThreshold: boolean; readonly isAlreadyApproved: boolean; @@ -7381,7 +7479,7 @@ declare module "@polkadot/types/lookup" { | "AlreadyStored"; } - /** @name PalletPreimageOldRequestStatus (737) */ + /** @name PalletPreimageOldRequestStatus (752) */ interface PalletPreimageOldRequestStatus extends Enum { readonly isUnrequested: boolean; readonly asUnrequested: { @@ -7397,7 +7495,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unrequested" | "Requested"; } - /** @name PalletPreimageRequestStatus (740) */ + /** @name PalletPreimageRequestStatus (755) */ interface PalletPreimageRequestStatus extends Enum { readonly isUnrequested: boolean; readonly asUnrequested: { @@ -7413,7 +7511,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unrequested" | "Requested"; } - /** @name PalletPreimageError (745) */ + /** @name PalletPreimageError (760) */ interface PalletPreimageError extends Enum { readonly isTooBig: boolean; readonly isAlreadyNoted: boolean; @@ -7436,7 +7534,7 @@ declare module "@polkadot/types/lookup" { | "NoCost"; } - /** @name PalletAssetRateError (746) */ + /** @name PalletAssetRateError (761) */ interface PalletAssetRateError extends Enum { readonly isUnknownAssetKind: boolean; readonly isAlreadyExists: boolean; @@ -7444,7 +7542,7 @@ declare module "@polkadot/types/lookup" { readonly type: "UnknownAssetKind" | "AlreadyExists" | "Overflow"; } - /** @name PalletXcmQueryStatus (747) */ + /** @name PalletXcmQueryStatus (762) */ interface PalletXcmQueryStatus extends Enum { readonly isPending: boolean; readonly asPending: { @@ -7466,7 +7564,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Pending" | "VersionNotifier" | "Ready"; } - /** @name XcmVersionedResponse (751) */ + /** @name XcmVersionedResponse (766) */ interface XcmVersionedResponse extends Enum { readonly isV2: boolean; readonly asV2: XcmV2Response; @@ -7477,7 +7575,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name PalletXcmVersionMigrationStage (757) */ + /** @name PalletXcmVersionMigrationStage (772) */ interface PalletXcmVersionMigrationStage extends Enum { readonly isMigrateSupportedVersion: boolean; readonly isMigrateVersionNotifiers: boolean; @@ -7491,7 +7589,7 @@ declare module "@polkadot/types/lookup" { | "MigrateAndNotifyOldTargets"; } - /** @name PalletXcmRemoteLockedFungibleRecord (759) */ + /** @name PalletXcmRemoteLockedFungibleRecord (774) */ interface PalletXcmRemoteLockedFungibleRecord extends Struct { readonly amount: u128; readonly owner: XcmVersionedLocation; @@ -7499,7 +7597,7 @@ declare module "@polkadot/types/lookup" { readonly consumers: Vec>; } - /** @name PalletXcmError (766) */ + /** @name PalletXcmError (781) */ interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -7552,7 +7650,7 @@ declare module "@polkadot/types/lookup" { | "LocalExecutionIncomplete"; } - /** @name PalletMigrationsError (767) */ + /** @name PalletMigrationsError (782) */ interface PalletMigrationsError extends Enum { readonly isPreimageMissing: boolean; readonly isWrongUpperBound: boolean; @@ -7561,7 +7659,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PreimageMissing" | "WrongUpperBound" | "PreimageIsTooBig" | "PreimageAlreadyExists"; } - /** @name PalletBeefyError (771) */ + /** @name PalletBeefyError (786) */ interface PalletBeefyError extends Enum { readonly isInvalidKeyOwnershipProof: boolean; readonly isInvalidDoubleVotingProof: boolean; @@ -7580,14 +7678,134 @@ declare module "@polkadot/types/lookup" { | "InvalidConfiguration"; } - /** @name SpConsensusBeefyMmrBeefyAuthoritySet (772) */ + /** @name SpConsensusBeefyMmrBeefyAuthoritySet (787) */ interface SpConsensusBeefyMmrBeefyAuthoritySet extends Struct { readonly id: u64; readonly len: u32; readonly keysetCommitment: H256; } - /** @name PolkadotRuntimeCommonParasSudoWrapperPalletError (773) */ + /** @name SnowbridgeBeaconPrimitivesCompactBeaconState (788) */ + interface SnowbridgeBeaconPrimitivesCompactBeaconState extends Struct { + readonly slot: Compact; + readonly blockRootsRoot: H256; + } + + /** @name SnowbridgeBeaconPrimitivesSyncCommitteePrepared (789) */ + interface SnowbridgeBeaconPrimitivesSyncCommitteePrepared extends Struct { + readonly root: H256; + readonly pubkeys: Vec; + readonly aggregatePubkey: SnowbridgeMilagroBlsKeysPublicKey; + } + + /** @name SnowbridgeMilagroBlsKeysPublicKey (791) */ + interface SnowbridgeMilagroBlsKeysPublicKey extends Struct { + readonly point: SnowbridgeAmclBls381Ecp; + } + + /** @name SnowbridgeAmclBls381Ecp (792) */ + interface SnowbridgeAmclBls381Ecp extends Struct { + readonly x: SnowbridgeAmclBls381Fp; + readonly y: SnowbridgeAmclBls381Fp; + readonly z: SnowbridgeAmclBls381Fp; + } + + /** @name SnowbridgeAmclBls381Fp (793) */ + interface SnowbridgeAmclBls381Fp extends Struct { + readonly x: SnowbridgeAmclBls381Big; + readonly xes: i32; + } + + /** @name SnowbridgeAmclBls381Big (794) */ + interface SnowbridgeAmclBls381Big extends Struct { + readonly w: Vec; + } + + /** @name SnowbridgeBeaconPrimitivesForkVersions (797) */ + interface SnowbridgeBeaconPrimitivesForkVersions extends Struct { + readonly genesis: SnowbridgeBeaconPrimitivesFork; + readonly altair: SnowbridgeBeaconPrimitivesFork; + readonly bellatrix: SnowbridgeBeaconPrimitivesFork; + readonly capella: SnowbridgeBeaconPrimitivesFork; + readonly deneb: SnowbridgeBeaconPrimitivesFork; + } + + /** @name SnowbridgeBeaconPrimitivesFork (798) */ + interface SnowbridgeBeaconPrimitivesFork extends Struct { + readonly version: U8aFixed; + readonly epoch: u64; + } + + /** @name SnowbridgePalletEthereumClientError (799) */ + interface SnowbridgePalletEthereumClientError extends Enum { + readonly isSkippedSyncCommitteePeriod: boolean; + readonly isSyncCommitteeUpdateRequired: boolean; + readonly isIrrelevantUpdate: boolean; + readonly isNotBootstrapped: boolean; + readonly isSyncCommitteeParticipantsNotSupermajority: boolean; + readonly isInvalidHeaderMerkleProof: boolean; + readonly isInvalidSyncCommitteeMerkleProof: boolean; + readonly isInvalidExecutionHeaderProof: boolean; + readonly isInvalidAncestryMerkleProof: boolean; + readonly isInvalidBlockRootsRootMerkleProof: boolean; + readonly isInvalidFinalizedHeaderGap: boolean; + readonly isHeaderNotFinalized: boolean; + readonly isBlockBodyHashTreeRootFailed: boolean; + readonly isHeaderHashTreeRootFailed: boolean; + readonly isSyncCommitteeHashTreeRootFailed: boolean; + readonly isSigningRootHashTreeRootFailed: boolean; + readonly isForkDataHashTreeRootFailed: boolean; + readonly isExpectedFinalizedHeaderNotStored: boolean; + readonly isBlsPreparePublicKeysFailed: boolean; + readonly isBlsVerificationFailed: boolean; + readonly asBlsVerificationFailed: SnowbridgeBeaconPrimitivesBlsBlsError; + readonly isInvalidUpdateSlot: boolean; + readonly isInvalidSyncCommitteeUpdate: boolean; + readonly isExecutionHeaderTooFarBehind: boolean; + readonly isExecutionHeaderSkippedBlock: boolean; + readonly isHalted: boolean; + readonly type: + | "SkippedSyncCommitteePeriod" + | "SyncCommitteeUpdateRequired" + | "IrrelevantUpdate" + | "NotBootstrapped" + | "SyncCommitteeParticipantsNotSupermajority" + | "InvalidHeaderMerkleProof" + | "InvalidSyncCommitteeMerkleProof" + | "InvalidExecutionHeaderProof" + | "InvalidAncestryMerkleProof" + | "InvalidBlockRootsRootMerkleProof" + | "InvalidFinalizedHeaderGap" + | "HeaderNotFinalized" + | "BlockBodyHashTreeRootFailed" + | "HeaderHashTreeRootFailed" + | "SyncCommitteeHashTreeRootFailed" + | "SigningRootHashTreeRootFailed" + | "ForkDataHashTreeRootFailed" + | "ExpectedFinalizedHeaderNotStored" + | "BlsPreparePublicKeysFailed" + | "BlsVerificationFailed" + | "InvalidUpdateSlot" + | "InvalidSyncCommitteeUpdate" + | "ExecutionHeaderTooFarBehind" + | "ExecutionHeaderSkippedBlock" + | "Halted"; + } + + /** @name SnowbridgeBeaconPrimitivesBlsBlsError (800) */ + interface SnowbridgeBeaconPrimitivesBlsBlsError extends Enum { + readonly isInvalidSignature: boolean; + readonly isInvalidPublicKey: boolean; + readonly isInvalidAggregatePublicKeys: boolean; + readonly isSignatureVerificationFailed: boolean; + readonly type: + | "InvalidSignature" + | "InvalidPublicKey" + | "InvalidAggregatePublicKeys" + | "SignatureVerificationFailed"; + } + + /** @name PolkadotRuntimeCommonParasSudoWrapperPalletError (801) */ interface PolkadotRuntimeCommonParasSudoWrapperPalletError extends Enum { readonly isParaDoesntExist: boolean; readonly isParaAlreadyExists: boolean; @@ -7610,33 +7828,33 @@ declare module "@polkadot/types/lookup" { | "TooManyCores"; } - /** @name PalletSudoError (774) */ + /** @name PalletSudoError (802) */ interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: "RequireSudo"; } - /** @name FrameSystemExtensionsCheckNonZeroSender (777) */ + /** @name FrameSystemExtensionsCheckNonZeroSender (805) */ type FrameSystemExtensionsCheckNonZeroSender = Null; - /** @name FrameSystemExtensionsCheckSpecVersion (778) */ + /** @name FrameSystemExtensionsCheckSpecVersion (806) */ type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckTxVersion (779) */ + /** @name FrameSystemExtensionsCheckTxVersion (807) */ type FrameSystemExtensionsCheckTxVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (780) */ + /** @name FrameSystemExtensionsCheckGenesis (808) */ type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (783) */ + /** @name FrameSystemExtensionsCheckNonce (811) */ interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (784) */ + /** @name FrameSystemExtensionsCheckWeight (812) */ type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTransactionPaymentChargeTransactionPayment (785) */ + /** @name PalletTransactionPaymentChargeTransactionPayment (813) */ interface PalletTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name DancelightRuntimeRuntime (786) */ + /** @name DancelightRuntimeRuntime (814) */ type DancelightRuntimeRuntime = Null; } // declare module