From ebf3c8610af320bc2bc14ba17213532ae0ae46a4 Mon Sep 17 00:00:00 2001 From: girazoki Date: Wed, 11 Dec 2024 16:53:26 +0100 Subject: [PATCH 1/6] Bridge test to work with sha (#780) * girazoki bridge test * log * add v7 * allow forks true * use sha * try again * work with sha instead of workflow id * log sha * false --- .github/workflows/e2e-test-bridge.yml | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/.github/workflows/e2e-test-bridge.yml b/.github/workflows/e2e-test-bridge.yml index 744332906..2366f5d40 100644 --- a/.github/workflows/e2e-test-bridge.yml +++ b/.github/workflows/e2e-test-bridge.yml @@ -7,8 +7,8 @@ on: types: [completed] workflow_dispatch: inputs: - run_id: - description: "Run id from which artifacts are taken" + run_sha: + description: "Sha commit from which artifacts are taken" required: true jobs: @@ -19,9 +19,9 @@ jobs: id: retrieve-run-id run: | if [[ -n "${{ github.event_name == 'workflow_dispatch' }}" ]]; then - echo "run_id=${{ github.event.inputs.run_id }}" >> $GITHUB_OUTPUT + echo "run_sha=${{ github.event.inputs.run_sha }}" >> $GITHUB_OUTPUT else - echo "run_id=${{ github.event.workflow_run.id }}" >> $GITHUB_OUTPUT + echo "run_sha=${{ github.event.workflow_run.head_sha }}" >> $GITHUB_OUTPUT fi - name: Recognize sha ref id: sharef @@ -93,13 +93,18 @@ jobs: id: check_date run: | date --version + - name: Check output + id: check_output + run: | + echo ${{ steps.retrieve-run-id.outputs.run_sha }} - name: Download build artifact from triggered workflow - uses: dawidd6/action-download-artifact@v2 + uses: dawidd6/action-download-artifact@v7 with: - run_id: ${{ steps.retrieve-run-id.outputs.run_id }} + commit: ${{ steps.retrieve-run-id.outputs.run_sha }} + workflow: release.yml name: binaries path: target/release - search_artifacts: true + allow_forks: false - name: "Make binaries executable" shell: bash run: | From 414749618b5cdc9b60fc411e0a45d5b7ff4cf704 Mon Sep 17 00:00:00 2001 From: tmpolaczyk <44604217+tmpolaczyk@users.noreply.github.com> Date: Thu, 12 Dec 2024 16:47:01 +0100 Subject: [PATCH 2/6] Add pallet_pooled_staking to Dancelight (#774) * Add pallet_pooled_staking to Dancelight * zepter * toml-maid * Fix benchmark compilation * Fix tests The max_collators config item was being ignored in Dancelight before this PR * Fix benchmark compilation * Add weights * typescript-api * Delay instead of G * Add staking integration tests * Add special accounts that need existential deposit to genesis * Fix total issuance test --- Cargo.lock | 1 + runtime/dancebox/src/lib.rs | 10 +- solo-chains/runtime/dancelight/Cargo.toml | 4 + .../dancelight/src/genesis_config_presets.rs | 17 +- solo-chains/runtime/dancelight/src/lib.rs | 129 +- .../src/tests/collator_assignment_tests.rs | 56 +- .../runtime/dancelight/src/tests/mod.rs | 1 + .../runtime/dancelight/src/tests/staking.rs | 1145 +++++++++++++++ .../runtime/dancelight/src/weights/mod.rs | 1 + .../src/weights/pallet_pooled_staking.rs | 205 +++ .../balances/test_balances.ts | 2 +- .../interfaces/augment-api-consts.ts | 33 + .../interfaces/augment-api-errors.ts | 18 + .../interfaces/augment-api-events.ts | 145 ++ .../interfaces/augment-api-query.ts | 65 + .../dancelight/interfaces/augment-api-tx.ts | 79 ++ .../src/dancelight/interfaces/lookup.ts | 1146 +++++++++------ .../src/dancelight/interfaces/registry.ts | 22 + .../src/dancelight/interfaces/types-lookup.ts | 1234 +++++++++++------ 19 files changed, 3376 insertions(+), 937 deletions(-) create mode 100644 solo-chains/runtime/dancelight/src/tests/staking.rs create mode 100644 solo-chains/runtime/dancelight/src/weights/pallet_pooled_staking.rs diff --git a/Cargo.lock b/Cargo.lock index 2a9e669c4..0b11d9005 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3419,6 +3419,7 @@ dependencies = [ "pallet-multisig", "pallet-offences", "pallet-parameters", + "pallet-pooled-staking", "pallet-preimage", "pallet-proxy", "pallet-ranked-collective", diff --git a/runtime/dancebox/src/lib.rs b/runtime/dancebox/src/lib.rs index d549d3f18..195698190 100644 --- a/runtime/dancebox/src/lib.rs +++ b/runtime/dancebox/src/lib.rs @@ -1569,11 +1569,11 @@ parameter_types! { pub const StakingSessionDelay: u32 = 2; } -pub struct SessionTimer(PhantomData); +pub struct SessionTimer(PhantomData); -impl Timer for SessionTimer +impl Timer for SessionTimer where - G: Get, + Delay: Get, { type Instant = u32; @@ -1582,7 +1582,7 @@ where } fn is_elapsed(instant: &Self::Instant) -> bool { - let delay = G::get(); + let delay = Delay::get(); let Some(end) = instant.checked_add(delay) else { return false; }; @@ -1591,7 +1591,7 @@ where #[cfg(feature = "runtime-benchmarks")] fn elapsed_instant() -> Self::Instant { - let delay = G::get(); + let delay = Delay::get(); Self::now() .checked_add(delay) .expect("overflow when computing valid elapsed instant") diff --git a/solo-chains/runtime/dancelight/Cargo.toml b/solo-chains/runtime/dancelight/Cargo.toml index 868e9faf5..80b2df3ee 100644 --- a/solo-chains/runtime/dancelight/Cargo.toml +++ b/solo-chains/runtime/dancelight/Cargo.toml @@ -135,6 +135,7 @@ pallet-author-noting-runtime-api = { workspace = true } pallet-configuration = { workspace = true } pallet-data-preservers = { workspace = true } pallet-inflation-rewards = { workspace = true } +pallet-pooled-staking = { workspace = true } pallet-registrar = { workspace = true } pallet-registrar-runtime-api = { workspace = true } pallet-services-payment = { workspace = true } @@ -237,6 +238,7 @@ std = [ "pallet-multisig/std", "pallet-offences/std", "pallet-parameters/std", + "pallet-pooled-staking/std", "pallet-preimage/std", "pallet-proxy/std", "pallet-ranked-collective/std", @@ -347,6 +349,7 @@ runtime-benchmarks = [ "pallet-multisig/runtime-benchmarks", "pallet-offences/runtime-benchmarks", "pallet-parameters/runtime-benchmarks", + "pallet-pooled-staking/runtime-benchmarks", "pallet-preimage/runtime-benchmarks", "pallet-proxy/runtime-benchmarks", "pallet-ranked-collective/runtime-benchmarks", @@ -425,6 +428,7 @@ try-runtime = [ "pallet-multisig/try-runtime", "pallet-offences/try-runtime", "pallet-parameters/try-runtime", + "pallet-pooled-staking/try-runtime", "pallet-preimage/try-runtime", "pallet-proxy/try-runtime", "pallet-ranked-collective/try-runtime", diff --git a/solo-chains/runtime/dancelight/src/genesis_config_presets.rs b/solo-chains/runtime/dancelight/src/genesis_config_presets.rs index 2747ce09a..98d448311 100644 --- a/solo-chains/runtime/dancelight/src/genesis_config_presets.rs +++ b/solo-chains/runtime/dancelight/src/genesis_config_presets.rs @@ -335,10 +335,25 @@ fn dancelight_testnet_genesis( let next_free_para_id = max_para_id .map(|x| ParaId::from(u32::from(*x) + 1)) .unwrap_or(primitives::LOWEST_PUBLIC_ID); + let accounts_with_ed = [ + crate::StakingAccount::get(), + crate::DancelightBondAccount::get(), + crate::PendingRewardsAccount::get(), + ]; serde_json::json!({ "balances": { - "balances": endowed_accounts.iter().map(|k| (k.clone(), ENDOWMENT)).collect::>(), + "balances": endowed_accounts + .iter() + .cloned() + .map(|k| (k, ENDOWMENT)) + .chain( + accounts_with_ed + .iter() + .cloned() + .map(|k| (k, crate::EXISTENTIAL_DEPOSIT)), + ) + .collect::>(), }, "session": { "keys": initial_authorities diff --git a/solo-chains/runtime/dancelight/src/lib.rs b/solo-chains/runtime/dancelight/src/lib.rs index 16b22c516..4107d791f 100644 --- a/solo-chains/runtime/dancelight/src/lib.rs +++ b/solo-chains/runtime/dancelight/src/lib.rs @@ -602,7 +602,9 @@ pub struct TreasuryBenchmarkHelper(PhantomData); #[cfg(feature = "runtime-benchmarks")] use frame_support::traits::Currency; -use frame_support::traits::{ExistenceRequirement, OnUnbalanced, WithdrawReasons}; +use frame_support::traits::{ + ExistenceRequirement, OnUnbalanced, ValidatorRegistration, WithdrawReasons, +}; use pallet_services_payment::BalanceOf; #[cfg(feature = "runtime-benchmarks")] use pallet_treasury::ArgumentsFactory; @@ -1307,7 +1309,9 @@ impl pallet_beefy_mmr::Config for Runtime { impl paras_sudo_wrapper::Config for Runtime {} +use pallet_pooled_staking::traits::{IsCandidateEligible, Timer}; use pallet_staking::SessionInterface; + pub struct DancelightSessionInterface; impl SessionInterface for DancelightSessionInterface { fn disable_validator(validator_index: u32) -> bool { @@ -1654,10 +1658,106 @@ impl pallet_inflation_rewards::Config for Runtime { type InflationRate = InflationRate; type OnUnbalanced = OnUnbalancedInflation; type PendingRewardsAccount = PendingRewardsAccount; - type StakingRewardsDistributor = InvulnerableRewardDistribution; + type StakingRewardsDistributor = InvulnerableRewardDistribution; type RewardsPortion = RewardsPortion; } +parameter_types! { + pub StakingAccount: AccountId32 = PalletId(*b"POOLSTAK").into_account_truncating(); + pub const InitialManualClaimShareValue: u128 = MILLIUNITS; + pub const InitialAutoCompoundingShareValue: u128 = MILLIUNITS; + pub const MinimumSelfDelegation: u128 = 10_000 * UNITS; + pub const RewardsCollatorCommission: Perbill = Perbill::from_percent(20); + // Need to wait 2 sessions before being able to join or leave staking pools + pub const StakingSessionDelay: u32 = 2; +} + +pub struct SessionTimer(PhantomData); + +impl Timer for SessionTimer +where + Delay: Get, +{ + type Instant = u32; + + fn now() -> Self::Instant { + Session::current_index() + } + + fn is_elapsed(instant: &Self::Instant) -> bool { + let delay = Delay::get(); + let Some(end) = instant.checked_add(delay) else { + return false; + }; + end <= Self::now() + } + + #[cfg(feature = "runtime-benchmarks")] + fn elapsed_instant() -> Self::Instant { + let delay = Delay::get(); + Self::now() + .checked_add(delay) + .expect("overflow when computing valid elapsed instant") + } + + #[cfg(feature = "runtime-benchmarks")] + fn skip_to_elapsed() { + let session_to_reach = Self::elapsed_instant(); + while Self::now() < session_to_reach { + Session::rotate_session(); + } + } +} + +pub struct CandidateHasRegisteredKeys; +impl IsCandidateEligible for CandidateHasRegisteredKeys { + fn is_candidate_eligible(a: &AccountId) -> bool { + >::is_registered(a) + } + #[cfg(feature = "runtime-benchmarks")] + fn make_candidate_eligible(a: &AccountId, eligible: bool) { + use crate::genesis_config_presets::get_authority_keys_from_seed; + + if eligible { + let a_u8: &[u8] = a.as_ref(); + let seed = sp_runtime::format!("{:?}", a_u8); + let authority_keys = get_authority_keys_from_seed(&seed, None); + let _ = Session::set_keys( + RuntimeOrigin::signed(a.clone()), + SessionKeys { + grandpa: authority_keys.grandpa, + babe: authority_keys.babe, + para_validator: authority_keys.para_validator, + para_assignment: authority_keys.para_assignment, + authority_discovery: authority_keys.authority_discovery, + beefy: authority_keys.beefy, + nimbus: authority_keys.nimbus, + }, + vec![], + ); + } else { + let _ = Session::purge_keys(RuntimeOrigin::signed(a.clone())); + } + } +} + +impl pallet_pooled_staking::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type Balance = Balance; + type StakingAccount = StakingAccount; + type InitialManualClaimShareValue = InitialManualClaimShareValue; + type InitialAutoCompoundingShareValue = InitialAutoCompoundingShareValue; + type MinimumSelfDelegation = MinimumSelfDelegation; + type RuntimeHoldReason = RuntimeHoldReason; + type RewardsCollatorCommission = RewardsCollatorCommission; + type JoiningRequestTimer = SessionTimer; + type LeavingRequestTimer = SessionTimer; + type EligibleCandidatesBufferSize = ConstU32<100>; + type EligibleCandidatesFilter = CandidateHasRegisteredKeys; + type WeightInfo = weights::pallet_pooled_staking::SubstrateWeight; +} + construct_runtime! { pub enum Runtime { @@ -1703,6 +1803,7 @@ construct_runtime! { // InflationRewards must be after Session InflationRewards: pallet_inflation_rewards = 33, + PooledStaking: pallet_pooled_staking = 34, // Governance stuff; uncallable initially. Treasury: pallet_treasury = 40, @@ -2101,6 +2202,7 @@ mod benches { [pallet_external_validators_rewards, ExternalValidatorsRewards] [pallet_external_validator_slashes, ExternalValidatorSlashes] [pallet_invulnerables, TanssiInvulnerables] + [pallet_pooled_staking, PooledStaking] // XCM [pallet_xcm, PalletXcmExtrinsicsBenchmark::] [pallet_xcm_benchmarks::fungible, pallet_xcm_benchmarks::fungible::Pallet::] @@ -3041,8 +3143,27 @@ impl tanssi_initializer::ApplyNewSession for OwnApplySession { ContainerRegistrar::initializer_on_new_session(&session_index); let invulnerables = TanssiInvulnerables::invulnerables().to_vec(); - - let next_collators = invulnerables; + let candidates_staking = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + // Max number of collators is set in pallet_configuration + let target_session_index = session_index.saturating_add(1); + let max_collators = >::max_collators( + target_session_index, + ); + let next_collators: Vec<_> = invulnerables + .iter() + .cloned() + .chain(candidates_staking.into_iter().filter_map(|elig| { + let cand = elig.candidate; + if invulnerables.contains(&cand) { + // If a candidate is both in pallet_invulnerables and pallet_staking, do not count it twice + None + } else { + Some(cand) + } + })) + .take(max_collators as usize) + .collect(); // Queue next session keys. let queued_amalgamated = next_collators diff --git a/solo-chains/runtime/dancelight/src/tests/collator_assignment_tests.rs b/solo-chains/runtime/dancelight/src/tests/collator_assignment_tests.rs index 7402ee76e..5e067ae67 100644 --- a/solo-chains/runtime/dancelight/src/tests/collator_assignment_tests.rs +++ b/solo-chains/runtime/dancelight/src/tests/collator_assignment_tests.rs @@ -185,27 +185,33 @@ fn test_author_collation_aura_change_of_authorities_on_session() { DAVE.into() )); - assert!( - authorities_for_container(1000u32.into()) - == Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) + assert_eq!( + authorities_for_container(1000u32.into()), + Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) ); // SESSION CHANGE. First session. it takes 2 sessions to see the change run_to_session(1u32); - assert!(babe_authorities() == vec![alice_keys.babe.clone(), bob_keys.babe.clone()]); - assert!( - authorities_for_container(1000u32.into()) - == Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) + assert_eq!( + babe_authorities(), + vec![alice_keys.babe.clone(), bob_keys.babe.clone()] + ); + assert_eq!( + authorities_for_container(1000u32.into()), + Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) ); // Invulnerables should have triggered on new session authorities change run_to_session(2u32); - assert!(babe_authorities() == vec![alice_keys.babe.clone(), bob_keys.babe.clone()]); - assert!( - authorities_for_container(1000u32.into()) - == Some(vec![charlie_keys.nimbus.clone(), dave_keys.nimbus.clone()]) + assert_eq!( + babe_authorities(), + vec![alice_keys.babe.clone(), bob_keys.babe.clone()] + ); + assert_eq!( + authorities_for_container(1000u32.into()), + Some(vec![charlie_keys.nimbus.clone(), dave_keys.nimbus.clone()]) ); }); } @@ -225,7 +231,7 @@ fn test_collators_per_container() { (AccountId::from(BOB), 100 * UNIT), ]) .with_config(pallet_configuration::HostConfiguration { - max_collators: 2, + max_collators: 100, min_orchestrator_collators: 0, max_orchestrator_collators: 0, collators_per_container: 2, @@ -261,9 +267,9 @@ fn test_collators_per_container() { )); // Initial assignment: Alice & Bob collating for container 1000 - assert!( - authorities_for_container(1000u32.into()) - == Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) + assert_eq!( + authorities_for_container(1000u32.into()), + Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) ); // Change the collators_per_container param to 3. @@ -275,20 +281,20 @@ fn test_collators_per_container() { // SESSION CHANGE. First session. it takes 2 sessions to see the change run_to_session(1u32); - assert!( - authorities_for_container(1000u32.into()) - == Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) + assert_eq!( + authorities_for_container(1000u32.into()), + Some(vec![alice_keys.nimbus.clone(), bob_keys.nimbus.clone()]) ); // We should see Charlie included in the authorities now run_to_session(2u32); - assert!( - authorities_for_container(1000u32.into()) - == Some(vec![ - alice_keys.nimbus.clone(), - bob_keys.nimbus.clone(), - charlie_keys.nimbus.clone() - ]) + assert_eq!( + authorities_for_container(1000u32.into()), + Some(vec![ + alice_keys.nimbus.clone(), + bob_keys.nimbus.clone(), + charlie_keys.nimbus.clone() + ]) ); }); } diff --git a/solo-chains/runtime/dancelight/src/tests/mod.rs b/solo-chains/runtime/dancelight/src/tests/mod.rs index f131f2c4f..9b6b57bee 100644 --- a/solo-chains/runtime/dancelight/src/tests/mod.rs +++ b/solo-chains/runtime/dancelight/src/tests/mod.rs @@ -36,6 +36,7 @@ mod relay_registrar; mod services_payment; mod session_keys; mod slashes; +mod staking; mod sudo; #[test] diff --git a/solo-chains/runtime/dancelight/src/tests/staking.rs b/solo-chains/runtime/dancelight/src/tests/staking.rs new file mode 100644 index 000000000..5ab67b29c --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/staking.rs @@ -0,0 +1,1145 @@ +// 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::*, MinimumSelfDelegation, PooledStaking}, + frame_support::{assert_noop, assert_ok, error::BadOrigin}, + pallet_pooled_staking::{ + traits::IsCandidateEligible, AllTargetPool, EligibleCandidate, PendingOperationKey, + PendingOperationQuery, PoolsKey, SharesOrStake, TargetPool, + }, + sp_std::vec, +}; + +#[test] +fn test_staking_no_candidates_in_genesis() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let initial_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + + assert_eq!(initial_candidates, vec![]); + }); +} + +#[test] +fn test_staking_join() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let balance_before = System::account(AccountId::from(ALICE)).data.free; + assert_eq!(System::account(AccountId::from(ALICE)).data.reserved, 0); + let stake = MinimumSelfDelegation::get() * 10; + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake + )); + + // Immediately after joining, Alice is the top candidate + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake + }] + ); + + // And staked amount is immediately marked as "reserved" + let balance_after = System::account(AccountId::from(ALICE)).data.free; + assert_eq!(balance_before - balance_after, stake); + assert_eq!(System::account(AccountId::from(ALICE)).data.reserved, stake); + }); +} + +#[test] +fn test_staking_join_no_keys_registered() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![ + 1001, + 1002, + ]) + + .build() + .execute_with(|| { + run_to_block(2); + + let stake = MinimumSelfDelegation::get() * 10; + let new_account = AccountId::from([42u8; 32]); + assert_ok!(Balances::transfer_allow_death( + origin_of(ALICE.into()), + new_account.clone().into(), + stake * 2 + )); + let balance_before = System::account(new_account.clone()).data.free; + assert_eq!(System::account(new_account.clone()).data.reserved, 0); + assert_ok!(PooledStaking::request_delegate( + origin_of(new_account.clone()), + new_account.clone(), + TargetPool::AutoCompounding, + stake + )); + + // The new account should be the top candidate but it has no keys registered in + // pallet_session, so it is not eligible + assert!(!::EligibleCandidatesFilter::is_candidate_eligible(&new_account)); + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + + assert_eq!(eligible_candidates, vec![]); + + // And staked amount is immediately marked as "reserved" + let balance_after = System::account(new_account.clone()).data.free; + assert_eq!(balance_before - balance_after, stake); + assert_eq!(System::account(new_account.clone()).data.reserved, stake); + }); +} + +#[test] +fn test_staking_register_keys_after_joining() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![ + 1001, + 1002, + ]) + + .build() + .execute_with(|| { + run_to_block(2); + + let stake = MinimumSelfDelegation::get() * 10; + let new_account = AccountId::from([42u8; 32]); + assert_ok!(Balances::transfer_allow_death( + origin_of(ALICE.into()), + new_account.clone().into(), + stake * 2 + )); + let balance_before = System::account(new_account.clone()).data.free; + assert_eq!(System::account(new_account.clone()).data.reserved, 0); + assert_ok!(PooledStaking::request_delegate( + origin_of(new_account.clone()), + new_account.clone(), + TargetPool::AutoCompounding, + stake + )); + + // The new account should be the top candidate but it has no keys registered in + // pallet_session, so it is not eligible + assert!(!::EligibleCandidatesFilter::is_candidate_eligible(&new_account)); + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![]); + + // And staked amount is immediately marked as "reserved" + let balance_after = System::account(new_account.clone()).data.free; + assert_eq!(balance_before - balance_after, stake); + assert_eq!(System::account(new_account.clone()).data.reserved, stake); + + // Now register the keys + let new_keys = get_authority_keys_from_seed(&new_account.to_string(), None); + assert_ok!(Session::set_keys( + origin_of(new_account.clone()), + crate::SessionKeys { + grandpa: new_keys.grandpa,babe: new_keys.babe,para_validator: new_keys.para_validator,para_assignment: new_keys.para_assignment,authority_discovery: new_keys.authority_discovery,beefy: new_keys.beefy,nimbus: new_keys.nimbus, + }, + vec![] + )); + + // Now eligible according to filter + assert!(::EligibleCandidatesFilter::is_candidate_eligible(&new_account)); + // But not eligible according to pallet_pooled_staking, need to manually update candidate list + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![]); + + // Update candidate list + assert_ok!(PooledStaking::update_candidate_position( + origin_of(BOB.into()), + vec![new_account.clone()] + )); + + // Now it is eligible + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: new_account.clone(), + stake + }] + ); + }); +} + +#[test] +fn test_staking_join_bad_origin() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let stake = 10 * MinimumSelfDelegation::get(); + assert_noop!( + PooledStaking::request_delegate( + root_origin(), + ALICE.into(), + TargetPool::AutoCompounding, + stake + ), + BadOrigin, + ); + }); +} + +#[test] +fn test_staking_join_below_self_delegation_min() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let stake1 = MinimumSelfDelegation::get() / 3; + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake1 + )); + + // Since stake is below MinimumSelfDelegation, the join operation succeeds + // but the candidate is not eligible + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![],); + + let stake2 = MinimumSelfDelegation::get() - stake1 - 1; + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake2, + )); + + // Still below, missing 1 unit + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![],); + + let stake3 = 1; + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake3, + )); + + // Increasing the stake to above MinimumSelfDelegation makes the candidate eligible + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake: stake1 + stake2 + stake3 + }], + ); + }); +} + +#[test] +fn test_staking_join_no_self_delegation() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + // Bob delegates to Alice, but Alice is not a valid candidate (not enough self-delegation) + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(BOB.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake, + )); + + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![],); + }); +} + +#[test] +fn test_staking_join_before_self_delegation() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + // Bob delegates to Alice, but Alice is not a valid candidate (not enough self-delegation) + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(BOB.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake + )); + + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![],); + + run_to_session(2); + assert_ok!(PooledStaking::execute_pending_operations( + origin_of(ALICE.into()), + vec![PendingOperationQuery { + delegator: BOB.into(), + operation: PendingOperationKey::JoiningAutoCompounding { + candidate: ALICE.into(), + at: 0, + } + }] + ),); + + // Now Alice joins with enough self-delegation + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake + )); + + // Alice is a valid candidate, and Bob's stake is also counted + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake: stake * 2, + }], + ); + }); +} + +#[test] +fn test_staking_join_twice_in_same_block() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let stake1 = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake1 + )); + + let stake2 = 9 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake2 + )); + + // Both operations succeed and the total stake is the sum of the individual stakes + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake: stake1 + stake2, + }] + ); + + run_to_session(2); + + assert_ok!(PooledStaking::execute_pending_operations( + origin_of(ALICE.into()), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::JoiningAutoCompounding { + candidate: ALICE.into(), + at: 0, + } + }] + ),); + + // TODO: ensure the total stake has been moved to auto compounding pool + }); +} + +#[test] +fn test_staking_join_execute_before_time() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake + )); + + // Immediately after joining, Alice is the top candidate + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake + }] + ); + + // We called request_delegate in session 0, we will be able to execute it starting from session 2 + let start_of_session_2 = session_to_block(2); + // Session 2 starts at block 600, but run_to_session runs to block 601, so subtract 2 here to go to 599 + run_to_block(start_of_session_2 - 2); + assert_noop!( + PooledStaking::execute_pending_operations( + origin_of(ALICE.into()), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::JoiningAutoCompounding { + candidate: ALICE.into(), + at: 0, + } + }] + ), + pallet_pooled_staking::Error::::RequestCannotBeExecuted(0), + ); + + run_to_block(start_of_session_2); + assert_ok!(PooledStaking::execute_pending_operations( + origin_of(ALICE.into()), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::JoiningAutoCompounding { + candidate: ALICE.into(), + at: 0, + } + }] + ),); + }); +} + +#[test] +fn test_staking_join_execute_any_origin() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake + )); + + // Immediately after joining, Alice is the top candidate + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake + }] + ); + + // We called request_delegate in session 0, we will be able to execute it starting from session 2 + run_to_session(2); + // Anyone can execute pending operations for anyone else + assert_ok!(PooledStaking::execute_pending_operations( + origin_of(BOB.into()), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::JoiningAutoCompounding { + candidate: ALICE.into(), + at: 0, + } + }] + ),); + }); +} + +#[test] +fn test_staking_join_execute_bad_origin() { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_delegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + stake + )); + + // Immediately after joining, Alice is the top candidate + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake + }] + ); + + // We called request_delegate in session 0, we will be able to execute it starting from session 2 + run_to_session(2); + assert_noop!( + PooledStaking::execute_pending_operations( + root_origin(), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::JoiningAutoCompounding { + candidate: ALICE.into(), + at: 0, + } + }] + ), + BadOrigin, + ); + }); +} + +struct A { + delegator: AccountId, + candidate: AccountId, + target_pool: TargetPool, + stake: u128, +} + +// Setup test environment with provided delegations already being executed. Input function f gets executed at start session 2 +fn setup_staking_join_and_execute(ops: Vec, f: impl FnOnce() -> R) { + ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (AccountId::from(ALICE), 210_000 * UNIT), + (AccountId::from(BOB), 100_000 * UNIT), + (AccountId::from(CHARLIE), 100_000 * UNIT), + (AccountId::from(DAVE), 100_000 * UNIT), + ]) + .with_collators(vec![ + (AccountId::from(ALICE), 210 * UNIT), + (AccountId::from(BOB), 100 * UNIT), + (AccountId::from(CHARLIE), 100 * UNIT), + (AccountId::from(DAVE), 100 * UNIT), + ]) + .with_empty_parachains(vec![1001, 1002]) + .build() + .execute_with(|| { + run_to_block(2); + + for op in ops.iter() { + assert_ok!(PooledStaking::request_delegate( + origin_of(op.delegator.clone()), + op.candidate.clone(), + op.target_pool, + op.stake, + )); + } + + // We called request_delegate in session 0, we will be able to execute it starting from session 2 + run_to_session(2); + + for op in ops.iter() { + let operation = match op.target_pool { + TargetPool::AutoCompounding => PendingOperationKey::JoiningAutoCompounding { + candidate: op.candidate.clone(), + at: 0, + }, + TargetPool::ManualRewards => PendingOperationKey::JoiningManualRewards { + candidate: op.candidate.clone(), + at: 0, + }, + }; + + assert_ok!(PooledStaking::execute_pending_operations( + origin_of(op.delegator.clone()), + vec![PendingOperationQuery { + delegator: op.delegator.clone(), + operation, + }] + )); + } + + f() + }); +} + +#[test] +fn test_staking_leave_exact_amount() { + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake: 10 * MinimumSelfDelegation::get(), + }], + || { + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake), + )); + + // Immediately after calling request_undelegate, Alice is no longer a candidate + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![]); + }, + ) +} + +#[test] +fn test_staking_leave_bad_origin() { + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake: 10 * MinimumSelfDelegation::get(), + }], + || { + let stake = 10 * MinimumSelfDelegation::get(); + assert_noop!( + PooledStaking::request_undelegate( + root_origin(), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake), + ), + BadOrigin + ); + }, + ) +} + +#[test] +fn test_staking_leave_more_than_allowed() { + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake: 10 * MinimumSelfDelegation::get(), + }], + || { + let stake = 10 * MinimumSelfDelegation::get(); + assert_noop!( + PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake + 1 * MinimumSelfDelegation::get()), + ), + pallet_pooled_staking::Error::::MathUnderflow, + ); + }, + ); +} + +#[test] +fn test_staking_leave_in_separate_transactions() { + let stake = 10 * MinimumSelfDelegation::get(); + + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake, + }], + || { + let half_stake = stake / 2; + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(half_stake), + )); + + // Alice is still a valid candidate, now with less stake + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + let remaining_stake = stake - half_stake; + assert_eq!( + eligible_candidates, + vec![EligibleCandidate { + candidate: ALICE.into(), + stake: remaining_stake, + }], + ); + + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(remaining_stake), + )); + + // Unstaked remaining stake, so no longer a valid candidate + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![],); + }, + ); +} + +#[test] +fn test_staking_leave_all_except_some_dust() { + let stake = 10 * MinimumSelfDelegation::get(); + + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake, + }], + || { + let dust = MinimumSelfDelegation::get() / 2; + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake - dust), + )); + + // Alice still has some stake left, but not enough to reach MinimumSelfDelegation + assert_eq!( + pallet_pooled_staking::Pools::::get( + AccountId::from(ALICE), + PoolsKey::CandidateTotalStake + ), + dust, + ); + + let eligible_candidates = + pallet_pooled_staking::SortedEligibleCandidates::::get().to_vec(); + assert_eq!(eligible_candidates, vec![],); + + // Leave with remaining stake + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(dust), + )); + + // Alice has no more stake left + assert_eq!( + pallet_pooled_staking::Pools::::get( + AccountId::from(ALICE), + PoolsKey::CandidateTotalStake + ), + 0, + ); + }, + ); +} + +#[test] +fn test_staking_leave_execute_before_time() { + let stake = 10 * MinimumSelfDelegation::get(); + + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake, + }], + || { + let balance_before = System::account(AccountId::from(ALICE)).data.free; + let at = Session::current_index(); + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake), + )); + + // Request undelegate does not change account balance + assert_eq!( + balance_before, + System::account(AccountId::from(ALICE)).data.free + ); + + // We called request_delegate in session 0, we will be able to execute it starting from session 2 + let start_of_session_4 = session_to_block(4); + // Session 4 starts at block 1200, but run_to_session runs to block 1201, so subtract 2 here to go to 1999 + run_to_block(start_of_session_4 - 2); + + assert_noop!( + PooledStaking::execute_pending_operations( + origin_of(ALICE.into()), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::Leaving { + candidate: ALICE.into(), + at, + } + }] + ), + pallet_pooled_staking::Error::::RequestCannotBeExecuted(0) + ); + }, + ); +} + +#[test] +fn test_staking_leave_execute_any_origin() { + let stake = 10 * MinimumSelfDelegation::get(); + + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake, + }], + || { + let balance_before = System::account(AccountId::from(ALICE)).data.free; + let at = Session::current_index(); + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake), + )); + + // Request undelegate does not change account balance + assert_eq!( + balance_before, + System::account(AccountId::from(ALICE)).data.free + ); + + run_to_session(4); + + let balance_before = System::account(AccountId::from(ALICE)).data.free; + + assert_ok!(PooledStaking::execute_pending_operations( + // Any signed origin can execute this, the stake will go to Alice account + origin_of(BOB.into()), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::Leaving { + candidate: ALICE.into(), + at, + } + }] + ),); + + let balance_after = System::account(AccountId::from(ALICE)).data.free; + assert_eq!(balance_after - balance_before, stake); + }, + ); +} + +#[test] +fn test_staking_leave_execute_bad_origin() { + let stake = 10 * MinimumSelfDelegation::get(); + + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake, + }], + || { + let at = Session::current_index(); + assert_ok!(PooledStaking::request_undelegate( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake), + )); + + run_to_session(4); + + assert_noop!( + PooledStaking::execute_pending_operations( + root_origin(), + vec![PendingOperationQuery { + delegator: ALICE.into(), + operation: PendingOperationKey::Leaving { + candidate: ALICE.into(), + at, + } + }] + ), + BadOrigin + ); + }, + ); +} + +#[test] +fn test_staking_swap() { + setup_staking_join_and_execute( + vec![A { + delegator: ALICE.into(), + candidate: ALICE.into(), + target_pool: TargetPool::AutoCompounding, + stake: 10 * MinimumSelfDelegation::get(), + }], + || { + let stake = 10 * MinimumSelfDelegation::get(); + assert_ok!(PooledStaking::swap_pool( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::AutoCompounding, + SharesOrStake::Stake(stake), + )); + + assert_eq!( + PooledStaking::computed_stake( + ALICE.into(), + ALICE.into(), + AllTargetPool::AutoCompounding + ), + Some(0u32.into()) + ); + assert_eq!( + PooledStaking::computed_stake( + ALICE.into(), + ALICE.into(), + AllTargetPool::ManualRewards + ), + Some(stake) + ); + + assert_ok!(PooledStaking::swap_pool( + origin_of(ALICE.into()), + ALICE.into(), + TargetPool::ManualRewards, + SharesOrStake::Stake(stake), + )); + + assert_eq!( + PooledStaking::computed_stake( + ALICE.into(), + ALICE.into(), + AllTargetPool::AutoCompounding + ), + Some(stake) + ); + assert_eq!( + PooledStaking::computed_stake( + ALICE.into(), + ALICE.into(), + AllTargetPool::ManualRewards + ), + Some(0u32.into()) + ); + }, + ) +} diff --git a/solo-chains/runtime/dancelight/src/weights/mod.rs b/solo-chains/runtime/dancelight/src/weights/mod.rs index 1673a91c3..46cb008b3 100644 --- a/solo-chains/runtime/dancelight/src/weights/mod.rs +++ b/solo-chains/runtime/dancelight/src/weights/mod.rs @@ -28,6 +28,7 @@ pub mod pallet_invulnerables; pub mod pallet_message_queue; pub mod pallet_multisig; pub mod pallet_parameters; +pub mod pallet_pooled_staking; pub mod pallet_preimage; pub mod pallet_proxy; pub mod pallet_ranked_collective; diff --git a/solo-chains/runtime/dancelight/src/weights/pallet_pooled_staking.rs b/solo-chains/runtime/dancelight/src/weights/pallet_pooled_staking.rs new file mode 100644 index 000000000..f070ab42a --- /dev/null +++ b/solo-chains/runtime/dancelight/src/weights/pallet_pooled_staking.rs @@ -0,0 +1,205 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Tanssi is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Tanssi. If not, see + + +//! Autogenerated weights for pallet_pooled_staking +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 43.0.0 +//! DATE: 2024-12-03, STEPS: `16`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `tomasz-XPS-15-9520`, CPU: `12th Gen Intel(R) Core(TM) i7-12700H` +//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("dancelight-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/tanssi-relay +// benchmark +// pallet +// --execution=wasm +// --wasm-execution=compiled +// --pallet +// pallet_pooled_staking +// --extrinsic +// * +// --chain=dancelight-dev +// --steps +// 16 +// --repeat +// 1 +// --template=benchmarking/frame-weight-runtime-template.hbs +// --json-file +// raw.json +// --output +// tmp/dancelight_weights/pallet_pooled_staking.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weights for pallet_pooled_staking using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl pallet_pooled_staking::WeightInfo for SubstrateWeight { + /// Storage: `PooledStaking::Pools` (r:12 w:5) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(121), added: 2596, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::SortedEligibleCandidates` (r:1 w:1) + /// Proof: `PooledStaking::SortedEligibleCandidates` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`) + /// Storage: `Session::NextKeys` (r:1 w:0) + /// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Session::CurrentIndex` (r:1 w:0) + /// Proof: `Session::CurrentIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `PooledStaking::PendingOperations` (r:1 w:1) + /// Proof: `PooledStaking::PendingOperations` (`max_values`: None, `max_size`: Some(117), added: 2592, mode: `MaxEncodedLen`) + fn request_delegate() -> Weight { + // Proof Size summary in bytes: + // Measured: `1693` + // Estimated: `32046` + // Minimum execution time: 223_276_000 picoseconds. + Weight::from_parts(223_276_000, 32046) + .saturating_add(T::DbWeight::get().reads(18_u64)) + .saturating_add(T::DbWeight::get().writes(9_u64)) + } + /// Storage: `PooledStaking::PendingOperations` (r:100 w:100) + /// Proof: `PooledStaking::PendingOperations` (`max_values`: None, `max_size`: Some(117), added: 2592, mode: `MaxEncodedLen`) + /// Storage: `Session::CurrentIndex` (r:1 w:0) + /// Proof: `Session::CurrentIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `PooledStaking::Pools` (r:1000 w:800) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(121), added: 2596, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// The range of component `b` is `[1, 100]`. + fn execute_pending_operations(b: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `537 + b * (390 ±0)` + // Estimated: `3593 + b * (25880 ±0)` + // Minimum execution time: 223_896_000 picoseconds. + Weight::from_parts(923_209_974, 3593) + // Standard Error: 7_529_273 + .saturating_add(Weight::from_parts(62_374_026, 0).saturating_mul(b.into())) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().reads((11_u64).saturating_mul(b.into()))) + .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes((9_u64).saturating_mul(b.into()))) + .saturating_add(Weight::from_parts(0, 25880).saturating_mul(b.into())) + } + /// Storage: `PooledStaking::Pools` (r:13 w:9) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::SortedEligibleCandidates` (r:1 w:1) + /// Proof: `PooledStaking::SortedEligibleCandidates` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`) + /// Storage: `Session::CurrentIndex` (r:1 w:0) + /// Proof: `Session::CurrentIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `PooledStaking::PendingOperations` (r:1 w:1) + /// Proof: `PooledStaking::PendingOperations` (`max_values`: None, `max_size`: Some(117), added: 2592, mode: `MaxEncodedLen`) + fn request_undelegate() -> Weight { + // Proof Size summary in bytes: + // Measured: `725` + // Estimated: `34634` + // Minimum execution time: 126_682_000 picoseconds. + Weight::from_parts(126_682_000, 34634) + .saturating_add(T::DbWeight::get().reads(16_u64)) + .saturating_add(T::DbWeight::get().writes(11_u64)) + } + /// Storage: `PooledStaking::Pools` (r:300 w:100) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// The range of component `b` is `[1, 100]`. + fn claim_manual_rewards(b: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `378 + b * (456 ±0)` + // Estimated: `6196 + b * (7764 ±0)` + // Minimum execution time: 70_722_000 picoseconds. + Weight::from_parts(46_724_962, 6196) + // Standard Error: 152_961 + .saturating_add(Weight::from_parts(35_593_574, 0).saturating_mul(b.into())) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(b.into()))) + .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(b.into()))) + .saturating_add(Weight::from_parts(0, 7764).saturating_mul(b.into())) + } + /// Storage: `PooledStaking::Pools` (r:4 w:1) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(121), added: 2596, mode: `MaxEncodedLen`) + fn rebalance_hold() -> Weight { + // Proof Size summary in bytes: + // Measured: `981` + // Estimated: `11342` + // Minimum execution time: 132_493_000 picoseconds. + Weight::from_parts(132_493_000, 11342) + .saturating_add(T::DbWeight::get().reads(7_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) + } + /// Storage: `PooledStaking::Pools` (r:600 w:100) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::SortedEligibleCandidates` (r:1 w:1) + /// Proof: `PooledStaking::SortedEligibleCandidates` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`) + /// Storage: `Session::NextKeys` (r:100 w:0) + /// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `b` is `[1, 100]`. + fn update_candidate_position(b: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `432 + b * (551 ±0)` + // Estimated: `6287 + b * (15528 ±0)` + // Minimum execution time: 57_935_000 picoseconds. + Weight::from_parts(37_904_366, 6287) + // Standard Error: 220_015 + .saturating_add(Weight::from_parts(30_769_001, 0).saturating_mul(b.into())) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(b.into()))) + .saturating_add(T::DbWeight::get().writes(1_u64)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(b.into()))) + .saturating_add(Weight::from_parts(0, 15528).saturating_mul(b.into())) + } + /// Storage: `PooledStaking::Pools` (r:12 w:8) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + fn swap_pool() -> Weight { + // Proof Size summary in bytes: + // Measured: `478` + // Estimated: `32046` + // Minimum execution time: 97_472_000 picoseconds. + Weight::from_parts(97_472_000, 32046) + .saturating_add(T::DbWeight::get().reads(12_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) + } + /// Storage: `PooledStaking::Pools` (r:9 w:5) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::SortedEligibleCandidates` (r:1 w:1) + /// Proof: `PooledStaking::SortedEligibleCandidates` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`) + /// Storage: `Session::NextKeys` (r:1 w:0) + /// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + fn distribute_rewards() -> Weight { + // Proof Size summary in bytes: + // Measured: `1531` + // Estimated: `24282` + // Minimum execution time: 156_958_000 picoseconds. + Weight::from_parts(156_958_000, 24282) + .saturating_add(T::DbWeight::get().reads(13_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) + } +} \ No newline at end of file diff --git a/test/suites/dev-tanssi-relay/balances/test_balances.ts b/test/suites/dev-tanssi-relay/balances/test_balances.ts index 3286a2d54..0da240587 100644 --- a/test/suites/dev-tanssi-relay/balances/test_balances.ts +++ b/test/suites/dev-tanssi-relay/balances/test_balances.ts @@ -20,7 +20,7 @@ describeSuite({ title: "Checking total issuance is correct on genesis", test: async function () { const totalIssuance = (await polkadotJs.query.balances.totalIssuance()).toBigInt(); - expect(totalIssuance).toBe(12_000_000_000_033_333_333n); + expect(totalIssuance).toBe(12_000_000_000_133_333_332n); }, }); diff --git a/typescript-api/src/dancelight/interfaces/augment-api-consts.ts b/typescript-api/src/dancelight/interfaces/augment-api-consts.ts index ee8966278..3b04ac5eb 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-consts.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-consts.ts @@ -364,6 +364,39 @@ declare module "@polkadot/api-base/types/consts" { /** Generic const */ [key: string]: Codec; }; + pooledStaking: { + /** + * All eligible candidates are stored in a sorted list that is modified each time delegations changes. It is safer + * to bound this list, in which case eligible candidate could fall out of this list if they have less stake than + * the top `EligibleCandidatesBufferSize` eligible candidates. One of this top candidates leaving will then not + * bring the dropped candidate in the list. An extrinsic is available to manually bring back such dropped + * candidate. + */ + eligibleCandidatesBufferSize: u32 & AugmentedConst; + /** + * When creating the first Shares for a candidate the supply can arbitrary. Picking a value too high is a barrier + * of entry for staking, which will increase overtime as the value of each share will increase due to auto + * compounding. + */ + initialAutoCompoundingShareValue: u128 & AugmentedConst; + /** + * When creating the first Shares for a candidate the supply can be arbitrary. Picking a value too low will make + * an higher supply, which means each share will get less rewards, and rewards calculations will have more + * impactful rounding errors. Picking a value too high is a barrier of entry for staking. + */ + initialManualClaimShareValue: u128 & AugmentedConst; + /** + * Minimum amount of stake a Candidate must delegate (stake) towards itself. Not reaching this minimum prevents + * from being elected. + */ + minimumSelfDelegation: u128 & AugmentedConst; + /** Part of the rewards that will be sent exclusively to the collator. */ + rewardsCollatorCommission: Perbill & AugmentedConst; + /** Account holding Currency of all delegators. */ + stakingAccount: AccountId32 & AugmentedConst; + /** Generic const */ + [key: string]: Codec; + }; proxy: { /** * The base amount of currency needed to reserve for creating an announcement. diff --git a/typescript-api/src/dancelight/interfaces/augment-api-errors.ts b/typescript-api/src/dancelight/interfaces/augment-api-errors.ts index a15a81103..a5c05c4cb 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-errors.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-errors.ts @@ -731,6 +731,24 @@ declare module "@polkadot/api-base/types/errors" { /** Generic error */ [key: string]: AugmentedError; }; + pooledStaking: { + CandidateTransferingOwnSharesForbidden: AugmentedError; + DisabledFeature: AugmentedError; + InconsistentState: AugmentedError; + InvalidPalletSetting: AugmentedError; + MathOverflow: AugmentedError; + MathUnderflow: AugmentedError; + NoOneIsStaking: AugmentedError; + NotEnoughShares: AugmentedError; + RequestCannotBeExecuted: AugmentedError; + RewardsMustBeNonZero: AugmentedError; + StakeMustBeNonZero: AugmentedError; + SwapResultsInZeroShares: AugmentedError; + TryingToLeaveTooSoon: AugmentedError; + UnsufficientSharesForTransfer: AugmentedError; + /** Generic error */ + [key: string]: AugmentedError; + }; preimage: { /** Preimage has already been noted on-chain. */ AlreadyNoted: AugmentedError; diff --git a/typescript-api/src/dancelight/interfaces/augment-api-events.ts b/typescript-api/src/dancelight/interfaces/augment-api-events.ts index 4baa55272..7b1a5caf1 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-events.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-events.ts @@ -37,6 +37,7 @@ import type { PalletConvictionVotingVoteAccountVote, PalletExternalValidatorsForcing, PalletMultisigTimepoint, + PalletPooledStakingTargetPool, PalletRankedCollectiveTally, PalletRankedCollectiveVoteRecord, PolkadotParachainPrimitivesPrimitivesHrmpChannelId, @@ -899,6 +900,150 @@ declare module "@polkadot/api-base/types/events" { /** Generic event */ [key: string]: AugmentedEvent; }; + pooledStaking: { + /** Rewards manually claimed. */ + ClaimedManualRewards: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, rewards: u128], + { candidate: AccountId32; delegator: AccountId32; rewards: u128 } + >; + /** Stake of that Candidate decreased. */ + DecreasedStake: AugmentedEvent< + ApiType, + [candidate: AccountId32, stakeDiff: u128], + { candidate: AccountId32; stakeDiff: u128 } + >; + /** + * Delegation request was executed. `staked` has been properly staked in `pool`, while the rounding when + * converting to shares has been `released`. + */ + ExecutedDelegate: AugmentedEvent< + ApiType, + [ + candidate: AccountId32, + delegator: AccountId32, + pool: PalletPooledStakingTargetPool, + staked: u128, + released: u128, + ], + { + candidate: AccountId32; + delegator: AccountId32; + pool: PalletPooledStakingTargetPool; + staked: u128; + released: u128; + } + >; + /** Undelegation request was executed. */ + ExecutedUndelegate: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, released: u128], + { candidate: AccountId32; delegator: AccountId32; released: u128 } + >; + /** Stake of that Candidate increased. */ + IncreasedStake: AugmentedEvent< + ApiType, + [candidate: AccountId32, stakeDiff: u128], + { candidate: AccountId32; stakeDiff: u128 } + >; + /** User requested to delegate towards a candidate. */ + RequestedDelegate: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, pool: PalletPooledStakingTargetPool, pending: u128], + { candidate: AccountId32; delegator: AccountId32; pool: PalletPooledStakingTargetPool; pending: u128 } + >; + /** + * User requested to undelegate from a candidate. Stake was removed from a `pool` and is `pending` for the request + * to be executed. The rounding when converting to leaving shares has been `released` immediately. + */ + RequestedUndelegate: AugmentedEvent< + ApiType, + [ + candidate: AccountId32, + delegator: AccountId32, + from: PalletPooledStakingTargetPool, + pending: u128, + released: u128, + ], + { + candidate: AccountId32; + delegator: AccountId32; + from: PalletPooledStakingTargetPool; + pending: u128; + released: u128; + } + >; + /** Collator has been rewarded. */ + RewardedCollator: AugmentedEvent< + ApiType, + [collator: AccountId32, autoCompoundingRewards: u128, manualClaimRewards: u128], + { collator: AccountId32; autoCompoundingRewards: u128; manualClaimRewards: u128 } + >; + /** Delegators have been rewarded. */ + RewardedDelegators: AugmentedEvent< + ApiType, + [collator: AccountId32, autoCompoundingRewards: u128, manualClaimRewards: u128], + { collator: AccountId32; autoCompoundingRewards: u128; manualClaimRewards: u128 } + >; + /** Delegator staked towards a Candidate for AutoCompounding Shares. */ + StakedAutoCompounding: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, shares: u128, stake: u128], + { candidate: AccountId32; delegator: AccountId32; shares: u128; stake: u128 } + >; + /** Delegator staked towards a candidate for ManualRewards Shares. */ + StakedManualRewards: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, shares: u128, stake: u128], + { candidate: AccountId32; delegator: AccountId32; shares: u128; stake: u128 } + >; + /** Swapped between AutoCompounding and ManualReward shares */ + SwappedPool: AugmentedEvent< + ApiType, + [ + candidate: AccountId32, + delegator: AccountId32, + sourcePool: PalletPooledStakingTargetPool, + sourceShares: u128, + sourceStake: u128, + targetShares: u128, + targetStake: u128, + pendingLeaving: u128, + released: u128, + ], + { + candidate: AccountId32; + delegator: AccountId32; + sourcePool: PalletPooledStakingTargetPool; + sourceShares: u128; + sourceStake: u128; + targetShares: u128; + targetStake: u128; + pendingLeaving: u128; + released: u128; + } + >; + /** Delegator unstaked towards a candidate with AutoCompounding Shares. */ + UnstakedAutoCompounding: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, shares: u128, stake: u128], + { candidate: AccountId32; delegator: AccountId32; shares: u128; stake: u128 } + >; + /** Delegator unstaked towards a candidate with ManualRewards Shares. */ + UnstakedManualRewards: AugmentedEvent< + ApiType, + [candidate: AccountId32, delegator: AccountId32, shares: u128, stake: u128], + { candidate: AccountId32; delegator: AccountId32; shares: u128; stake: u128 } + >; + /** Stake of the candidate has changed, which may have modified its position in the eligible candidates list. */ + UpdatedCandidatePosition: AugmentedEvent< + ApiType, + [candidate: AccountId32, stake: u128, selfDelegation: u128, before: Option, after: Option], + { candidate: AccountId32; stake: u128; selfDelegation: u128; before: Option; after: Option } + >; + /** Generic event */ + [key: string]: AugmentedEvent; + }; preimage: { /** A preimage has ben cleared. */ Cleared: AugmentedEvent; diff --git a/typescript-api/src/dancelight/interfaces/augment-api-query.ts b/typescript-api/src/dancelight/interfaces/augment-api-query.ts index 5cd107e2c..31258afa5 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-query.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-query.ts @@ -61,6 +61,9 @@ import type { PalletMessageQueuePage, PalletMigrationsMigrationCursor, PalletMultisigMultisig, + PalletPooledStakingCandidateEligibleCandidate, + PalletPooledStakingPendingOperationKey, + PalletPooledStakingPoolsKey, PalletPreimageOldRequestStatus, PalletPreimageRequestStatus, PalletProxyAnnouncement, @@ -1885,6 +1888,68 @@ declare module "@polkadot/api-base/types/storage" { /** Generic query */ [key: string]: QueryableStorageEntry; }; + pooledStaking: { + /** Pending operations balances. Balances are expressed in joining/leaving shares amounts. */ + pendingOperations: AugmentedQuery< + ApiType, + ( + arg1: AccountId32 | string | Uint8Array, + arg2: + | PalletPooledStakingPendingOperationKey + | { JoiningAutoCompounding: any } + | { JoiningManualRewards: any } + | { Leaving: any } + | string + | Uint8Array + ) => Observable, + [AccountId32, PalletPooledStakingPendingOperationKey] + > & + QueryableStorageEntry; + /** Pools balances. */ + pools: AugmentedQuery< + ApiType, + ( + arg1: AccountId32 | string | Uint8Array, + arg2: + | PalletPooledStakingPoolsKey + | { CandidateTotalStake: any } + | { JoiningShares: any } + | { JoiningSharesSupply: any } + | { JoiningSharesTotalStaked: any } + | { JoiningSharesHeldStake: any } + | { AutoCompoundingShares: any } + | { AutoCompoundingSharesSupply: any } + | { AutoCompoundingSharesTotalStaked: any } + | { AutoCompoundingSharesHeldStake: any } + | { ManualRewardsShares: any } + | { ManualRewardsSharesSupply: any } + | { ManualRewardsSharesTotalStaked: any } + | { ManualRewardsSharesHeldStake: any } + | { ManualRewardsCounter: any } + | { ManualRewardsCheckpoint: any } + | { LeavingShares: any } + | { LeavingSharesSupply: any } + | { LeavingSharesTotalStaked: any } + | { LeavingSharesHeldStake: any } + | string + | Uint8Array + ) => Observable, + [AccountId32, PalletPooledStakingPoolsKey] + > & + QueryableStorageEntry; + /** + * Keeps a list of all eligible candidates, sorted by the amount of stake backing them. This can be quickly + * updated using a binary search, and allow to easily take the top `MaxCollatorSetSize`. + */ + sortedEligibleCandidates: AugmentedQuery< + ApiType, + () => Observable>, + [] + > & + QueryableStorageEntry; + /** Generic query */ + [key: string]: QueryableStorageEntry; + }; preimage: { preimageFor: AugmentedQuery< ApiType, diff --git a/typescript-api/src/dancelight/interfaces/augment-api-tx.ts b/typescript-api/src/dancelight/interfaces/augment-api-tx.ts index 60a6b0622..28a7e93a4 100644 --- a/typescript-api/src/dancelight/interfaces/augment-api-tx.ts +++ b/typescript-api/src/dancelight/interfaces/augment-api-tx.ts @@ -50,6 +50,10 @@ import type { PalletMigrationsHistoricCleanupSelector, PalletMigrationsMigrationCursor, PalletMultisigTimepoint, + PalletPooledStakingAllTargetPool, + PalletPooledStakingPendingOperationQuery, + PalletPooledStakingSharesOrStake, + PalletPooledStakingTargetPool, PolkadotParachainPrimitivesPrimitivesHrmpChannelId, PolkadotPrimitivesV8ApprovalVotingParams, PolkadotPrimitivesV8AsyncBackingAsyncBackingParams, @@ -3169,6 +3173,81 @@ declare module "@polkadot/api-base/types/submittable" { /** Generic tx */ [key: string]: SubmittableExtrinsicFunction; }; + pooledStaking: { + claimManualRewards: AugmentedSubmittable< + ( + pairs: + | Vec> + | [AccountId32 | string | Uint8Array, AccountId32 | string | Uint8Array][] + ) => SubmittableExtrinsic, + [Vec>] + >; + /** Execute pending operations can incur in claim manual rewards per operation, we simply add the worst case */ + executePendingOperations: AugmentedSubmittable< + ( + operations: + | Vec + | ( + | PalletPooledStakingPendingOperationQuery + | { delegator?: any; operation?: any } + | string + | Uint8Array + )[] + ) => SubmittableExtrinsic, + [Vec] + >; + rebalanceHold: AugmentedSubmittable< + ( + candidate: AccountId32 | string | Uint8Array, + delegator: AccountId32 | string | Uint8Array, + pool: + | PalletPooledStakingAllTargetPool + | "Joining" + | "AutoCompounding" + | "ManualRewards" + | "Leaving" + | number + | Uint8Array + ) => SubmittableExtrinsic, + [AccountId32, AccountId32, PalletPooledStakingAllTargetPool] + >; + requestDelegate: AugmentedSubmittable< + ( + candidate: AccountId32 | string | Uint8Array, + pool: PalletPooledStakingTargetPool | "AutoCompounding" | "ManualRewards" | number | Uint8Array, + stake: u128 | AnyNumber | Uint8Array + ) => SubmittableExtrinsic, + [AccountId32, PalletPooledStakingTargetPool, u128] + >; + /** Request undelegate can incur in either claim manual rewards or hold rebalances, we simply add the worst case */ + requestUndelegate: AugmentedSubmittable< + ( + candidate: AccountId32 | string | Uint8Array, + pool: PalletPooledStakingTargetPool | "AutoCompounding" | "ManualRewards" | number | Uint8Array, + amount: PalletPooledStakingSharesOrStake | { Shares: any } | { Stake: any } | string | Uint8Array + ) => SubmittableExtrinsic, + [AccountId32, PalletPooledStakingTargetPool, PalletPooledStakingSharesOrStake] + >; + swapPool: AugmentedSubmittable< + ( + candidate: AccountId32 | string | Uint8Array, + sourcePool: + | PalletPooledStakingTargetPool + | "AutoCompounding" + | "ManualRewards" + | number + | Uint8Array, + amount: PalletPooledStakingSharesOrStake | { Shares: any } | { Stake: any } | string | Uint8Array + ) => SubmittableExtrinsic, + [AccountId32, PalletPooledStakingTargetPool, PalletPooledStakingSharesOrStake] + >; + updateCandidatePosition: AugmentedSubmittable< + (candidates: Vec | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic, + [Vec] + >; + /** Generic tx */ + [key: string]: SubmittableExtrinsicFunction; + }; preimage: { /** * Ensure that the a bulk of pre-images is upgraded. diff --git a/typescript-api/src/dancelight/interfaces/lookup.ts b/typescript-api/src/dancelight/interfaces/lookup.ts index 595045a22..cfd65a0a2 100644 --- a/typescript-api/src/dancelight/interfaces/lookup.ts +++ b/typescript-api/src/dancelight/interfaces/lookup.ts @@ -497,7 +497,106 @@ export default { }, }, }, - /** Lookup64: pallet_treasury::pallet::Event */ + /** Lookup64: pallet_pooled_staking::pallet::Event */ + PalletPooledStakingEvent: { + _enum: { + UpdatedCandidatePosition: { + candidate: "AccountId32", + stake: "u128", + selfDelegation: "u128", + before: "Option", + after: "Option", + }, + RequestedDelegate: { + candidate: "AccountId32", + delegator: "AccountId32", + pool: "PalletPooledStakingTargetPool", + pending: "u128", + }, + ExecutedDelegate: { + candidate: "AccountId32", + delegator: "AccountId32", + pool: "PalletPooledStakingTargetPool", + staked: "u128", + released: "u128", + }, + RequestedUndelegate: { + candidate: "AccountId32", + delegator: "AccountId32", + from: "PalletPooledStakingTargetPool", + pending: "u128", + released: "u128", + }, + ExecutedUndelegate: { + candidate: "AccountId32", + delegator: "AccountId32", + released: "u128", + }, + IncreasedStake: { + candidate: "AccountId32", + stakeDiff: "u128", + }, + DecreasedStake: { + candidate: "AccountId32", + stakeDiff: "u128", + }, + StakedAutoCompounding: { + candidate: "AccountId32", + delegator: "AccountId32", + shares: "u128", + stake: "u128", + }, + UnstakedAutoCompounding: { + candidate: "AccountId32", + delegator: "AccountId32", + shares: "u128", + stake: "u128", + }, + StakedManualRewards: { + candidate: "AccountId32", + delegator: "AccountId32", + shares: "u128", + stake: "u128", + }, + UnstakedManualRewards: { + candidate: "AccountId32", + delegator: "AccountId32", + shares: "u128", + stake: "u128", + }, + RewardedCollator: { + collator: "AccountId32", + autoCompoundingRewards: "u128", + manualClaimRewards: "u128", + }, + RewardedDelegators: { + collator: "AccountId32", + autoCompoundingRewards: "u128", + manualClaimRewards: "u128", + }, + ClaimedManualRewards: { + candidate: "AccountId32", + delegator: "AccountId32", + rewards: "u128", + }, + SwappedPool: { + candidate: "AccountId32", + delegator: "AccountId32", + sourcePool: "PalletPooledStakingTargetPool", + sourceShares: "u128", + sourceStake: "u128", + targetShares: "u128", + targetStake: "u128", + pendingLeaving: "u128", + released: "u128", + }, + }, + }, + /** Lookup66: pallet_pooled_staking::pallet::TargetPool */ + PalletPooledStakingTargetPool: { + _enum: ["AutoCompounding", "ManualRewards"], + }, + /** Lookup67: pallet_treasury::pallet::Event */ PalletTreasuryEvent: { _enum: { Spending: { @@ -550,7 +649,7 @@ export default { }, }, }, - /** Lookup66: pallet_conviction_voting::pallet::Event */ + /** Lookup69: pallet_conviction_voting::pallet::Event */ PalletConvictionVotingEvent: { _enum: { Delegated: "(AccountId32,AccountId32)", @@ -565,7 +664,7 @@ export default { }, }, }, - /** Lookup67: pallet_conviction_voting::vote::AccountVote */ + /** Lookup70: pallet_conviction_voting::vote::AccountVote */ PalletConvictionVotingVoteAccountVote: { _enum: { Standard: { @@ -583,7 +682,7 @@ export default { }, }, }, - /** Lookup69: pallet_referenda::pallet::Event */ + /** Lookup72: pallet_referenda::pallet::Event */ PalletReferendaEvent: { _enum: { Submitted: { @@ -662,7 +761,7 @@ export default { }, }, /** - * Lookup71: frame_support::traits::preimages::Bounded */ FrameSupportPreimagesBounded: { @@ -683,7 +782,7 @@ export default { }, }, }, - /** Lookup73: frame_system::pallet::Call */ + /** Lookup76: frame_system::pallet::Call */ FrameSystemCall: { _enum: { remark: { @@ -726,7 +825,7 @@ export default { }, }, }, - /** Lookup77: pallet_babe::pallet::Call */ + /** Lookup80: pallet_babe::pallet::Call */ PalletBabeCall: { _enum: { report_equivocation: { @@ -743,7 +842,7 @@ export default { }, }, /** - * Lookup78: sp_consensus_slots::EquivocationProof, + * Lookup81: sp_consensus_slots::EquivocationProof, * sp_consensus_babe::app::Public> */ SpConsensusSlotsEquivocationProof: { @@ -752,7 +851,7 @@ export default { firstHeader: "SpRuntimeHeader", secondHeader: "SpRuntimeHeader", }, - /** Lookup79: sp_runtime::generic::header::Header */ + /** Lookup82: sp_runtime::generic::header::Header */ SpRuntimeHeader: { parentHash: "H256", number: "Compact", @@ -760,15 +859,15 @@ export default { extrinsicsRoot: "H256", digest: "SpRuntimeDigest", }, - /** Lookup81: sp_consensus_babe::app::Public */ + /** Lookup84: sp_consensus_babe::app::Public */ SpConsensusBabeAppPublic: "[u8;32]", - /** Lookup82: sp_session::MembershipProof */ + /** Lookup85: sp_session::MembershipProof */ SpSessionMembershipProof: { session: "u32", trieNodes: "Vec", validatorCount: "u32", }, - /** Lookup83: sp_consensus_babe::digests::NextConfigDescriptor */ + /** Lookup86: sp_consensus_babe::digests::NextConfigDescriptor */ SpConsensusBabeDigestsNextConfigDescriptor: { _enum: { __Unused0: "Null", @@ -778,11 +877,11 @@ export default { }, }, }, - /** Lookup85: sp_consensus_babe::AllowedSlots */ + /** Lookup88: sp_consensus_babe::AllowedSlots */ SpConsensusBabeAllowedSlots: { _enum: ["PrimarySlots", "PrimaryAndSecondaryPlainSlots", "PrimaryAndSecondaryVRFSlots"], }, - /** Lookup86: pallet_timestamp::pallet::Call */ + /** Lookup89: pallet_timestamp::pallet::Call */ PalletTimestampCall: { _enum: { set: { @@ -790,7 +889,7 @@ export default { }, }, }, - /** Lookup87: pallet_balances::pallet::Call */ + /** Lookup90: pallet_balances::pallet::Call */ PalletBalancesCall: { _enum: { transfer_allow_death: { @@ -833,11 +932,11 @@ export default { }, }, }, - /** Lookup93: pallet_balances::types::AdjustmentDirection */ + /** Lookup96: pallet_balances::types::AdjustmentDirection */ PalletBalancesAdjustmentDirection: { _enum: ["Increase", "Decrease"], }, - /** Lookup94: pallet_parameters::pallet::Call */ + /** Lookup97: pallet_parameters::pallet::Call */ PalletParametersCall: { _enum: { set_parameter: { @@ -845,20 +944,20 @@ export default { }, }, }, - /** Lookup95: dancelight_runtime::RuntimeParameters */ + /** Lookup98: dancelight_runtime::RuntimeParameters */ DancelightRuntimeRuntimeParameters: { _enum: { Preimage: "DancelightRuntimeDynamicParamsPreimageParameters", }, }, - /** Lookup96: dancelight_runtime::dynamic_params::preimage::Parameters */ + /** Lookup99: dancelight_runtime::dynamic_params::preimage::Parameters */ DancelightRuntimeDynamicParamsPreimageParameters: { _enum: { BaseDeposit: "(DancelightRuntimeDynamicParamsPreimageBaseDeposit,Option)", ByteDeposit: "(DancelightRuntimeDynamicParamsPreimageByteDeposit,Option)", }, }, - /** Lookup97: pallet_registrar::pallet::Call */ + /** Lookup100: pallet_registrar::pallet::Call */ PalletRegistrarCall: { _enum: { register: { @@ -909,7 +1008,7 @@ export default { }, }, }, - /** Lookup98: dp_container_chain_genesis_data::ContainerChainGenesisData */ + /** Lookup101: dp_container_chain_genesis_data::ContainerChainGenesisData */ DpContainerChainGenesisDataContainerChainGenesisData: { storage: "Vec", name: "Bytes", @@ -918,36 +1017,36 @@ export default { extensions: "Bytes", properties: "DpContainerChainGenesisDataProperties", }, - /** Lookup100: dp_container_chain_genesis_data::ContainerChainGenesisDataItem */ + /** Lookup103: dp_container_chain_genesis_data::ContainerChainGenesisDataItem */ DpContainerChainGenesisDataContainerChainGenesisDataItem: { key: "Bytes", value: "Bytes", }, - /** Lookup102: dp_container_chain_genesis_data::Properties */ + /** Lookup105: dp_container_chain_genesis_data::Properties */ DpContainerChainGenesisDataProperties: { tokenMetadata: "DpContainerChainGenesisDataTokenMetadata", isEthereum: "bool", }, - /** Lookup103: dp_container_chain_genesis_data::TokenMetadata */ + /** Lookup106: dp_container_chain_genesis_data::TokenMetadata */ DpContainerChainGenesisDataTokenMetadata: { tokenSymbol: "Bytes", ss58Format: "u32", tokenDecimals: "u32", }, - /** Lookup107: tp_traits::SlotFrequency */ + /** Lookup110: tp_traits::SlotFrequency */ TpTraitsSlotFrequency: { min: "u32", max: "u32", }, - /** Lookup109: tp_traits::ParathreadParams */ + /** Lookup112: tp_traits::ParathreadParams */ TpTraitsParathreadParams: { slotFrequency: "TpTraitsSlotFrequency", }, - /** Lookup110: sp_trie::storage_proof::StorageProof */ + /** Lookup113: sp_trie::storage_proof::StorageProof */ SpTrieStorageProof: { trieNodes: "BTreeSet", }, - /** Lookup112: sp_runtime::MultiSignature */ + /** Lookup115: sp_runtime::MultiSignature */ SpRuntimeMultiSignature: { _enum: { Ed25519: "[u8;64]", @@ -955,7 +1054,7 @@ export default { Ecdsa: "[u8;65]", }, }, - /** Lookup115: pallet_configuration::pallet::Call */ + /** Lookup118: pallet_configuration::pallet::Call */ PalletConfigurationCall: { _enum: { set_max_collators: { @@ -1055,7 +1154,7 @@ export default { }, }, }, - /** Lookup117: pallet_invulnerables::pallet::Call */ + /** Lookup120: pallet_invulnerables::pallet::Call */ PalletInvulnerablesCall: { _enum: { __Unused0: "Null", @@ -1067,11 +1166,11 @@ export default { }, }, }, - /** Lookup118: pallet_collator_assignment::pallet::Call */ + /** Lookup121: pallet_collator_assignment::pallet::Call */ PalletCollatorAssignmentCall: "Null", - /** Lookup119: pallet_authority_assignment::pallet::Call */ + /** Lookup122: pallet_authority_assignment::pallet::Call */ PalletAuthorityAssignmentCall: "Null", - /** Lookup120: pallet_author_noting::pallet::Call */ + /** Lookup123: pallet_author_noting::pallet::Call */ PalletAuthorNotingCall: { _enum: { set_latest_author_data: { @@ -1088,7 +1187,7 @@ export default { }, }, }, - /** Lookup121: pallet_services_payment::pallet::Call */ + /** Lookup124: pallet_services_payment::pallet::Call */ PalletServicesPaymentCall: { _enum: { purchase_credits: { @@ -1121,7 +1220,7 @@ export default { }, }, }, - /** Lookup122: pallet_data_preservers::pallet::Call */ + /** Lookup125: pallet_data_preservers::pallet::Call */ PalletDataPreserversCall: { _enum: { __Unused0: "Null", @@ -1162,14 +1261,14 @@ export default { }, }, }, - /** Lookup123: pallet_data_preservers::types::Profile */ + /** Lookup126: pallet_data_preservers::types::Profile */ PalletDataPreserversProfile: { url: "Bytes", paraIds: "PalletDataPreserversParaIdsFilter", mode: "PalletDataPreserversProfileMode", assignmentRequest: "DancelightRuntimePreserversAssignmentPaymentRequest", }, - /** Lookup125: pallet_data_preservers::types::ParaIdsFilter */ + /** Lookup128: pallet_data_preservers::types::ParaIdsFilter */ PalletDataPreserversParaIdsFilter: { _enum: { AnyParaId: "Null", @@ -1177,7 +1276,7 @@ export default { Blacklist: "BTreeSet", }, }, - /** Lookup129: pallet_data_preservers::types::ProfileMode */ + /** Lookup132: pallet_data_preservers::types::ProfileMode */ PalletDataPreserversProfileMode: { _enum: { Bootnode: "Null", @@ -1186,19 +1285,19 @@ export default { }, }, }, - /** Lookup130: dancelight_runtime::PreserversAssignmentPaymentRequest */ + /** Lookup133: dancelight_runtime::PreserversAssignmentPaymentRequest */ DancelightRuntimePreserversAssignmentPaymentRequest: { _enum: ["Free"], }, - /** Lookup131: dancelight_runtime::PreserversAssignmentPaymentExtra */ + /** Lookup134: dancelight_runtime::PreserversAssignmentPaymentExtra */ DancelightRuntimePreserversAssignmentPaymentExtra: { _enum: ["Free"], }, - /** Lookup132: dancelight_runtime::PreserversAssignmentPaymentWitness */ + /** Lookup135: dancelight_runtime::PreserversAssignmentPaymentWitness */ DancelightRuntimePreserversAssignmentPaymentWitness: { _enum: ["Free"], }, - /** Lookup133: pallet_external_validators::pallet::Call */ + /** Lookup136: pallet_external_validators::pallet::Call */ PalletExternalValidatorsCall: { _enum: { skip_external_validators: { @@ -1215,7 +1314,7 @@ export default { }, }, }, - /** Lookup134: pallet_external_validator_slashes::pallet::Call */ + /** Lookup137: pallet_external_validator_slashes::pallet::Call */ PalletExternalValidatorSlashesCall: { _enum: { cancel_deferred_slash: { @@ -1234,7 +1333,7 @@ export default { }, }, }, - /** Lookup136: pallet_session::pallet::Call */ + /** Lookup139: pallet_session::pallet::Call */ PalletSessionCall: { _enum: { set_keys: { @@ -1247,7 +1346,7 @@ export default { purge_keys: "Null", }, }, - /** Lookup137: dancelight_runtime::SessionKeys */ + /** Lookup140: dancelight_runtime::SessionKeys */ DancelightRuntimeSessionKeys: { grandpa: "SpConsensusGrandpaAppPublic", babe: "SpConsensusBabeAppPublic", @@ -1257,17 +1356,17 @@ export default { beefy: "SpConsensusBeefyEcdsaCryptoPublic", nimbus: "NimbusPrimitivesNimbusCryptoPublic", }, - /** Lookup138: polkadot_primitives::v8::validator_app::Public */ + /** Lookup141: polkadot_primitives::v8::validator_app::Public */ PolkadotPrimitivesV8ValidatorAppPublic: "[u8;32]", - /** Lookup139: polkadot_primitives::v8::assignment_app::Public */ + /** Lookup142: polkadot_primitives::v8::assignment_app::Public */ PolkadotPrimitivesV8AssignmentAppPublic: "[u8;32]", - /** Lookup140: sp_authority_discovery::app::Public */ + /** Lookup143: sp_authority_discovery::app::Public */ SpAuthorityDiscoveryAppPublic: "[u8;32]", - /** Lookup141: sp_consensus_beefy::ecdsa_crypto::Public */ + /** Lookup144: sp_consensus_beefy::ecdsa_crypto::Public */ SpConsensusBeefyEcdsaCryptoPublic: "[u8;33]", - /** Lookup143: nimbus_primitives::nimbus_crypto::Public */ + /** Lookup146: nimbus_primitives::nimbus_crypto::Public */ NimbusPrimitivesNimbusCryptoPublic: "[u8;32]", - /** Lookup144: pallet_grandpa::pallet::Call */ + /** Lookup147: pallet_grandpa::pallet::Call */ PalletGrandpaCall: { _enum: { report_equivocation: { @@ -1284,12 +1383,12 @@ export default { }, }, }, - /** Lookup145: sp_consensus_grandpa::EquivocationProof */ + /** Lookup148: sp_consensus_grandpa::EquivocationProof */ SpConsensusGrandpaEquivocationProof: { setId: "u64", equivocation: "SpConsensusGrandpaEquivocation", }, - /** Lookup146: sp_consensus_grandpa::Equivocation */ + /** Lookup149: sp_consensus_grandpa::Equivocation */ SpConsensusGrandpaEquivocation: { _enum: { Prevote: "FinalityGrandpaEquivocationPrevote", @@ -1297,7 +1396,7 @@ export default { }, }, /** - * Lookup147: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> */ FinalityGrandpaEquivocationPrevote: { @@ -1306,15 +1405,15 @@ export default { first: "(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)", second: "(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)", }, - /** Lookup148: finality_grandpa::Prevote */ + /** Lookup151: finality_grandpa::Prevote */ FinalityGrandpaPrevote: { targetHash: "H256", targetNumber: "u32", }, - /** Lookup149: sp_consensus_grandpa::app::Signature */ + /** Lookup152: sp_consensus_grandpa::app::Signature */ SpConsensusGrandpaAppSignature: "[u8;64]", /** - * Lookup151: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> */ FinalityGrandpaEquivocationPrecommit: { @@ -1323,12 +1422,79 @@ export default { first: "(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)", second: "(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)", }, - /** Lookup152: finality_grandpa::Precommit */ + /** Lookup155: finality_grandpa::Precommit */ FinalityGrandpaPrecommit: { targetHash: "H256", targetNumber: "u32", }, - /** Lookup154: pallet_treasury::pallet::Call */ + /** Lookup157: pallet_pooled_staking::pallet::Call */ + PalletPooledStakingCall: { + _enum: { + rebalance_hold: { + candidate: "AccountId32", + delegator: "AccountId32", + pool: "PalletPooledStakingAllTargetPool", + }, + request_delegate: { + candidate: "AccountId32", + pool: "PalletPooledStakingTargetPool", + stake: "u128", + }, + execute_pending_operations: { + operations: "Vec", + }, + request_undelegate: { + candidate: "AccountId32", + pool: "PalletPooledStakingTargetPool", + amount: "PalletPooledStakingSharesOrStake", + }, + claim_manual_rewards: { + pairs: "Vec<(AccountId32,AccountId32)>", + }, + update_candidate_position: { + candidates: "Vec", + }, + swap_pool: { + candidate: "AccountId32", + sourcePool: "PalletPooledStakingTargetPool", + amount: "PalletPooledStakingSharesOrStake", + }, + }, + }, + /** Lookup158: pallet_pooled_staking::pallet::AllTargetPool */ + PalletPooledStakingAllTargetPool: { + _enum: ["Joining", "AutoCompounding", "ManualRewards", "Leaving"], + }, + /** Lookup160: pallet_pooled_staking::pallet::PendingOperationQuery */ + PalletPooledStakingPendingOperationQuery: { + delegator: "AccountId32", + operation: "PalletPooledStakingPendingOperationKey", + }, + /** Lookup161: pallet_pooled_staking::pallet::PendingOperationKey */ + PalletPooledStakingPendingOperationKey: { + _enum: { + JoiningAutoCompounding: { + candidate: "AccountId32", + at: "u32", + }, + JoiningManualRewards: { + candidate: "AccountId32", + at: "u32", + }, + Leaving: { + candidate: "AccountId32", + at: "u32", + }, + }, + }, + /** Lookup162: pallet_pooled_staking::pallet::SharesOrStake */ + PalletPooledStakingSharesOrStake: { + _enum: { + Shares: "u128", + Stake: "u128", + }, + }, + /** Lookup165: pallet_treasury::pallet::Call */ PalletTreasuryCall: { _enum: { __Unused0: "Null", @@ -1358,7 +1524,7 @@ export default { }, }, }, - /** Lookup156: pallet_conviction_voting::pallet::Call */ + /** Lookup166: pallet_conviction_voting::pallet::Call */ PalletConvictionVotingCall: { _enum: { vote: { @@ -1389,11 +1555,11 @@ export default { }, }, }, - /** Lookup157: pallet_conviction_voting::conviction::Conviction */ + /** Lookup167: pallet_conviction_voting::conviction::Conviction */ PalletConvictionVotingConviction: { _enum: ["None", "Locked1x", "Locked2x", "Locked3x", "Locked4x", "Locked5x", "Locked6x"], }, - /** Lookup159: pallet_referenda::pallet::Call */ + /** Lookup169: pallet_referenda::pallet::Call */ PalletReferendaCall: { _enum: { submit: { @@ -1428,7 +1594,7 @@ export default { }, }, }, - /** Lookup160: dancelight_runtime::OriginCaller */ + /** Lookup170: dancelight_runtime::OriginCaller */ DancelightRuntimeOriginCaller: { _enum: { system: "FrameSupportDispatchRawOrigin", @@ -1524,7 +1690,7 @@ export default { XcmPallet: "PalletXcmOrigin", }, }, - /** Lookup161: frame_support::dispatch::RawOrigin */ + /** Lookup171: frame_support::dispatch::RawOrigin */ FrameSupportDispatchRawOrigin: { _enum: { Root: "Null", @@ -1532,7 +1698,7 @@ export default { None: "Null", }, }, - /** Lookup162: dancelight_runtime::governance::origins::pallet_custom_origins::Origin */ + /** Lookup172: dancelight_runtime::governance::origins::pallet_custom_origins::Origin */ DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin: { _enum: [ "StakingAdmin", @@ -1564,39 +1730,39 @@ export default { "Fellowship9Dan", ], }, - /** Lookup163: polkadot_runtime_parachains::origin::pallet::Origin */ + /** Lookup173: polkadot_runtime_parachains::origin::pallet::Origin */ PolkadotRuntimeParachainsOriginPalletOrigin: { _enum: { Parachain: "u32", }, }, - /** Lookup164: pallet_xcm::pallet::Origin */ + /** Lookup174: pallet_xcm::pallet::Origin */ PalletXcmOrigin: { _enum: { Xcm: "StagingXcmV4Location", Response: "StagingXcmV4Location", }, }, - /** Lookup165: staging_xcm::v4::location::Location */ + /** Lookup175: staging_xcm::v4::location::Location */ StagingXcmV4Location: { parents: "u8", interior: "StagingXcmV4Junctions", }, - /** Lookup166: staging_xcm::v4::junctions::Junctions */ + /** Lookup176: staging_xcm::v4::junctions::Junctions */ StagingXcmV4Junctions: { _enum: { Here: "Null", - X1: "[Lookup168;1]", - X2: "[Lookup168;2]", - X3: "[Lookup168;3]", - X4: "[Lookup168;4]", - X5: "[Lookup168;5]", - X6: "[Lookup168;6]", - X7: "[Lookup168;7]", - X8: "[Lookup168;8]", + X1: "[Lookup178;1]", + X2: "[Lookup178;2]", + X3: "[Lookup178;3]", + X4: "[Lookup178;4]", + X5: "[Lookup178;5]", + X6: "[Lookup178;6]", + X7: "[Lookup178;7]", + X8: "[Lookup178;8]", }, }, - /** Lookup168: staging_xcm::v4::junction::Junction */ + /** Lookup178: staging_xcm::v4::junction::Junction */ StagingXcmV4Junction: { _enum: { Parachain: "Compact", @@ -1626,7 +1792,7 @@ export default { GlobalConsensus: "StagingXcmV4JunctionNetworkId", }, }, - /** Lookup170: staging_xcm::v4::junction::NetworkId */ + /** Lookup180: staging_xcm::v4::junction::NetworkId */ StagingXcmV4JunctionNetworkId: { _enum: { ByGenesis: "[u8;32]", @@ -1647,7 +1813,7 @@ export default { PolkadotBulletin: "Null", }, }, - /** Lookup171: xcm::v3::junction::BodyId */ + /** Lookup181: xcm::v3::junction::BodyId */ XcmV3JunctionBodyId: { _enum: { Unit: "Null", @@ -1662,7 +1828,7 @@ export default { Treasury: "Null", }, }, - /** Lookup172: xcm::v3::junction::BodyPart */ + /** Lookup182: xcm::v3::junction::BodyPart */ XcmV3JunctionBodyPart: { _enum: { Voice: "Null", @@ -1683,16 +1849,16 @@ export default { }, }, }, - /** Lookup180: sp_core::Void */ + /** Lookup190: sp_core::Void */ SpCoreVoid: "Null", - /** Lookup181: frame_support::traits::schedule::DispatchTime */ + /** Lookup191: frame_support::traits::schedule::DispatchTime */ FrameSupportScheduleDispatchTime: { _enum: { At: "u32", After: "u32", }, }, - /** Lookup183: pallet_ranked_collective::pallet::Call */ + /** Lookup193: pallet_ranked_collective::pallet::Call */ PalletRankedCollectiveCall: { _enum: { add_member: { @@ -1722,7 +1888,7 @@ export default { }, }, }, - /** Lookup185: pallet_whitelist::pallet::Call */ + /** Lookup195: pallet_whitelist::pallet::Call */ PalletWhitelistCall: { _enum: { whitelist_call: { @@ -1741,7 +1907,7 @@ export default { }, }, }, - /** Lookup186: polkadot_runtime_parachains::configuration::pallet::Call */ + /** Lookup196: polkadot_runtime_parachains::configuration::pallet::Call */ PolkadotRuntimeParachainsConfigurationPalletCall: { _enum: { set_validation_upgrade_cooldown: { @@ -2040,14 +2206,14 @@ export default { }, }, }, - /** Lookup187: polkadot_primitives::v8::async_backing::AsyncBackingParams */ + /** Lookup197: polkadot_primitives::v8::async_backing::AsyncBackingParams */ PolkadotPrimitivesV8AsyncBackingAsyncBackingParams: { maxCandidateDepth: "u32", allowedAncestryLen: "u32", }, - /** Lookup188: polkadot_primitives::v8::executor_params::ExecutorParams */ + /** Lookup198: polkadot_primitives::v8::executor_params::ExecutorParams */ PolkadotPrimitivesV8ExecutorParams: "Vec", - /** Lookup190: polkadot_primitives::v8::executor_params::ExecutorParam */ + /** Lookup200: polkadot_primitives::v8::executor_params::ExecutorParam */ PolkadotPrimitivesV8ExecutorParamsExecutorParam: { _enum: { __Unused0: "Null", @@ -2060,19 +2226,19 @@ export default { WasmExtBulkMemory: "Null", }, }, - /** Lookup191: polkadot_primitives::v8::PvfPrepKind */ + /** Lookup201: polkadot_primitives::v8::PvfPrepKind */ PolkadotPrimitivesV8PvfPrepKind: { _enum: ["Precheck", "Prepare"], }, - /** Lookup192: polkadot_primitives::v8::PvfExecKind */ + /** Lookup202: polkadot_primitives::v8::PvfExecKind */ PolkadotPrimitivesV8PvfExecKind: { _enum: ["Backing", "Approval"], }, - /** Lookup193: polkadot_primitives::v8::ApprovalVotingParams */ + /** Lookup203: polkadot_primitives::v8::ApprovalVotingParams */ PolkadotPrimitivesV8ApprovalVotingParams: { maxApprovalCoalesceCount: "u32", }, - /** Lookup194: polkadot_primitives::v8::SchedulerParams */ + /** Lookup204: polkadot_primitives::v8::SchedulerParams */ PolkadotPrimitivesV8SchedulerParams: { groupRotationFrequency: "u32", parasAvailabilityPeriod: "u32", @@ -2086,11 +2252,11 @@ export default { onDemandBaseFee: "u128", ttl: "u32", }, - /** Lookup195: polkadot_runtime_parachains::shared::pallet::Call */ + /** Lookup205: polkadot_runtime_parachains::shared::pallet::Call */ PolkadotRuntimeParachainsSharedPalletCall: "Null", - /** Lookup196: polkadot_runtime_parachains::inclusion::pallet::Call */ + /** Lookup206: polkadot_runtime_parachains::inclusion::pallet::Call */ PolkadotRuntimeParachainsInclusionPalletCall: "Null", - /** Lookup197: polkadot_runtime_parachains::paras_inherent::pallet::Call */ + /** Lookup207: polkadot_runtime_parachains::paras_inherent::pallet::Call */ PolkadotRuntimeParachainsParasInherentPalletCall: { _enum: { enter: { @@ -2098,7 +2264,7 @@ export default { }, }, }, - /** Lookup198: polkadot_primitives::v8::InherentData> */ + /** Lookup208: polkadot_primitives::v8::InherentData> */ PolkadotPrimitivesV8InherentData: { bitfields: "Vec", backedCandidates: "Vec", @@ -2106,7 +2272,7 @@ export default { parentHeader: "SpRuntimeHeader", }, /** - * Lookup200: polkadot_primitives::v8::signed::UncheckedSigned */ PolkadotPrimitivesV8SignedUncheckedSigned: { @@ -2114,22 +2280,22 @@ export default { validatorIndex: "u32", signature: "PolkadotPrimitivesV8ValidatorAppSignature", }, - /** Lookup203: bitvec::order::Lsb0 */ + /** Lookup213: bitvec::order::Lsb0 */ BitvecOrderLsb0: "Null", - /** Lookup205: polkadot_primitives::v8::validator_app::Signature */ + /** Lookup215: polkadot_primitives::v8::validator_app::Signature */ PolkadotPrimitivesV8ValidatorAppSignature: "[u8;64]", - /** Lookup207: polkadot_primitives::v8::BackedCandidate */ + /** Lookup217: polkadot_primitives::v8::BackedCandidate */ PolkadotPrimitivesV8BackedCandidate: { candidate: "PolkadotPrimitivesV8CommittedCandidateReceipt", validityVotes: "Vec", validatorIndices: "BitVec", }, - /** Lookup208: polkadot_primitives::v8::CommittedCandidateReceipt */ + /** Lookup218: polkadot_primitives::v8::CommittedCandidateReceipt */ PolkadotPrimitivesV8CommittedCandidateReceipt: { descriptor: "PolkadotPrimitivesV8CandidateDescriptor", commitments: "PolkadotPrimitivesV8CandidateCommitments", }, - /** Lookup209: polkadot_primitives::v8::CandidateDescriptor */ + /** Lookup219: polkadot_primitives::v8::CandidateDescriptor */ PolkadotPrimitivesV8CandidateDescriptor: { paraId: "u32", relayParent: "H256", @@ -2141,11 +2307,11 @@ export default { paraHead: "H256", validationCodeHash: "H256", }, - /** Lookup210: polkadot_primitives::v8::collator_app::Public */ + /** Lookup220: polkadot_primitives::v8::collator_app::Public */ PolkadotPrimitivesV8CollatorAppPublic: "[u8;32]", - /** Lookup211: polkadot_primitives::v8::collator_app::Signature */ + /** Lookup221: polkadot_primitives::v8::collator_app::Signature */ PolkadotPrimitivesV8CollatorAppSignature: "[u8;64]", - /** Lookup213: polkadot_primitives::v8::CandidateCommitments */ + /** Lookup223: polkadot_primitives::v8::CandidateCommitments */ PolkadotPrimitivesV8CandidateCommitments: { upwardMessages: "Vec", horizontalMessages: "Vec", @@ -2154,12 +2320,12 @@ export default { processedDownwardMessages: "u32", hrmpWatermark: "u32", }, - /** Lookup216: polkadot_core_primitives::OutboundHrmpMessage */ + /** Lookup226: polkadot_core_primitives::OutboundHrmpMessage */ PolkadotCorePrimitivesOutboundHrmpMessage: { recipient: "u32", data: "Bytes", }, - /** Lookup221: polkadot_primitives::v8::ValidityAttestation */ + /** Lookup231: polkadot_primitives::v8::ValidityAttestation */ PolkadotPrimitivesV8ValidityAttestation: { _enum: { __Unused0: "Null", @@ -2167,20 +2333,20 @@ export default { Explicit: "PolkadotPrimitivesV8ValidatorAppSignature", }, }, - /** Lookup223: polkadot_primitives::v8::DisputeStatementSet */ + /** Lookup233: polkadot_primitives::v8::DisputeStatementSet */ PolkadotPrimitivesV8DisputeStatementSet: { candidateHash: "H256", session: "u32", statements: "Vec<(PolkadotPrimitivesV8DisputeStatement,u32,PolkadotPrimitivesV8ValidatorAppSignature)>", }, - /** Lookup227: polkadot_primitives::v8::DisputeStatement */ + /** Lookup237: polkadot_primitives::v8::DisputeStatement */ PolkadotPrimitivesV8DisputeStatement: { _enum: { Valid: "PolkadotPrimitivesV8ValidDisputeStatementKind", Invalid: "PolkadotPrimitivesV8InvalidDisputeStatementKind", }, }, - /** Lookup228: polkadot_primitives::v8::ValidDisputeStatementKind */ + /** Lookup238: polkadot_primitives::v8::ValidDisputeStatementKind */ PolkadotPrimitivesV8ValidDisputeStatementKind: { _enum: { Explicit: "Null", @@ -2190,11 +2356,11 @@ export default { ApprovalCheckingMultipleCandidates: "Vec", }, }, - /** Lookup230: polkadot_primitives::v8::InvalidDisputeStatementKind */ + /** Lookup240: polkadot_primitives::v8::InvalidDisputeStatementKind */ PolkadotPrimitivesV8InvalidDisputeStatementKind: { _enum: ["Explicit"], }, - /** Lookup231: polkadot_runtime_parachains::paras::pallet::Call */ + /** Lookup241: polkadot_runtime_parachains::paras::pallet::Call */ PolkadotRuntimeParachainsParasPalletCall: { _enum: { force_set_current_code: { @@ -2233,14 +2399,14 @@ export default { }, }, }, - /** Lookup232: polkadot_primitives::v8::PvfCheckStatement */ + /** Lookup242: polkadot_primitives::v8::PvfCheckStatement */ PolkadotPrimitivesV8PvfCheckStatement: { accept: "bool", subject: "H256", sessionIndex: "u32", validatorIndex: "u32", }, - /** Lookup233: polkadot_runtime_parachains::initializer::pallet::Call */ + /** Lookup243: polkadot_runtime_parachains::initializer::pallet::Call */ PolkadotRuntimeParachainsInitializerPalletCall: { _enum: { force_approve: { @@ -2248,7 +2414,7 @@ export default { }, }, }, - /** Lookup234: polkadot_runtime_parachains::hrmp::pallet::Call */ + /** Lookup244: polkadot_runtime_parachains::hrmp::pallet::Call */ PolkadotRuntimeParachainsHrmpPalletCall: { _enum: { hrmp_init_open_channel: { @@ -2296,16 +2462,16 @@ export default { }, }, }, - /** Lookup235: polkadot_parachain_primitives::primitives::HrmpChannelId */ + /** Lookup245: polkadot_parachain_primitives::primitives::HrmpChannelId */ PolkadotParachainPrimitivesPrimitivesHrmpChannelId: { sender: "u32", recipient: "u32", }, - /** Lookup236: polkadot_runtime_parachains::disputes::pallet::Call */ + /** Lookup246: polkadot_runtime_parachains::disputes::pallet::Call */ PolkadotRuntimeParachainsDisputesPalletCall: { _enum: ["force_unfreeze"], }, - /** Lookup237: polkadot_runtime_parachains::disputes::slashing::pallet::Call */ + /** Lookup247: polkadot_runtime_parachains::disputes::slashing::pallet::Call */ PolkadotRuntimeParachainsDisputesSlashingPalletCall: { _enum: { report_dispute_lost_unsigned: { @@ -2314,23 +2480,23 @@ export default { }, }, }, - /** Lookup238: polkadot_primitives::v8::slashing::DisputeProof */ + /** Lookup248: polkadot_primitives::v8::slashing::DisputeProof */ PolkadotPrimitivesV8SlashingDisputeProof: { timeSlot: "PolkadotPrimitivesV8SlashingDisputesTimeSlot", kind: "PolkadotPrimitivesV8SlashingSlashingOffenceKind", validatorIndex: "u32", validatorId: "PolkadotPrimitivesV8ValidatorAppPublic", }, - /** Lookup239: polkadot_primitives::v8::slashing::DisputesTimeSlot */ + /** Lookup249: polkadot_primitives::v8::slashing::DisputesTimeSlot */ PolkadotPrimitivesV8SlashingDisputesTimeSlot: { sessionIndex: "u32", candidateHash: "H256", }, - /** Lookup240: polkadot_primitives::v8::slashing::SlashingOffenceKind */ + /** Lookup250: polkadot_primitives::v8::slashing::SlashingOffenceKind */ PolkadotPrimitivesV8SlashingSlashingOffenceKind: { _enum: ["ForInvalid", "AgainstValid"], }, - /** Lookup241: pallet_message_queue::pallet::Call */ + /** Lookup251: pallet_message_queue::pallet::Call */ PalletMessageQueueCall: { _enum: { reap_page: { @@ -2345,7 +2511,7 @@ export default { }, }, }, - /** Lookup242: dancelight_runtime::AggregateMessageOrigin */ + /** Lookup252: dancelight_runtime::AggregateMessageOrigin */ DancelightRuntimeAggregateMessageOrigin: { _enum: { Ump: "PolkadotRuntimeParachainsInclusionUmpQueueId", @@ -2353,15 +2519,15 @@ export default { SnowbridgeTanssi: "SnowbridgeCoreChannelId", }, }, - /** Lookup243: polkadot_runtime_parachains::inclusion::UmpQueueId */ + /** Lookup253: polkadot_runtime_parachains::inclusion::UmpQueueId */ PolkadotRuntimeParachainsInclusionUmpQueueId: { _enum: { Para: "u32", }, }, - /** Lookup244: snowbridge_core::ChannelId */ + /** Lookup254: snowbridge_core::ChannelId */ SnowbridgeCoreChannelId: "[u8;32]", - /** Lookup245: polkadot_runtime_parachains::on_demand::pallet::Call */ + /** Lookup255: polkadot_runtime_parachains::on_demand::pallet::Call */ PolkadotRuntimeParachainsOnDemandPalletCall: { _enum: { place_order_allow_death: { @@ -2374,7 +2540,7 @@ export default { }, }, }, - /** Lookup246: polkadot_runtime_common::paras_registrar::pallet::Call */ + /** Lookup256: polkadot_runtime_common::paras_registrar::pallet::Call */ PolkadotRuntimeCommonParasRegistrarPalletCall: { _enum: { register: { @@ -2413,7 +2579,7 @@ export default { }, }, }, - /** Lookup247: pallet_utility::pallet::Call */ + /** Lookup257: pallet_utility::pallet::Call */ PalletUtilityCall: { _enum: { batch: { @@ -2439,7 +2605,7 @@ export default { }, }, }, - /** Lookup249: pallet_identity::pallet::Call */ + /** Lookup259: pallet_identity::pallet::Call */ PalletIdentityCall: { _enum: { add_registrar: { @@ -2522,7 +2688,7 @@ export default { }, }, }, - /** Lookup250: pallet_identity::legacy::IdentityInfo */ + /** Lookup260: pallet_identity::legacy::IdentityInfo */ PalletIdentityLegacyIdentityInfo: { additional: "Vec<(Data,Data)>", display: "Data", @@ -2534,7 +2700,7 @@ export default { image: "Data", twitter: "Data", }, - /** Lookup287: pallet_identity::types::Judgement */ + /** Lookup297: pallet_identity::types::Judgement */ PalletIdentityJudgement: { _enum: { Unknown: "Null", @@ -2546,7 +2712,7 @@ export default { Erroneous: "Null", }, }, - /** Lookup290: pallet_scheduler::pallet::Call */ + /** Lookup300: pallet_scheduler::pallet::Call */ PalletSchedulerCall: { _enum: { schedule: { @@ -2600,7 +2766,7 @@ export default { }, }, }, - /** Lookup293: pallet_proxy::pallet::Call */ + /** Lookup303: pallet_proxy::pallet::Call */ PalletProxyCall: { _enum: { proxy: { @@ -2651,7 +2817,7 @@ export default { }, }, }, - /** Lookup295: dancelight_runtime::ProxyType */ + /** Lookup305: dancelight_runtime::ProxyType */ DancelightRuntimeProxyType: { _enum: [ "Any", @@ -2664,7 +2830,7 @@ export default { "SudoRegistrar", ], }, - /** Lookup296: pallet_multisig::pallet::Call */ + /** Lookup306: pallet_multisig::pallet::Call */ PalletMultisigCall: { _enum: { as_multi_threshold_1: { @@ -2693,12 +2859,12 @@ export default { }, }, }, - /** Lookup298: pallet_multisig::Timepoint */ + /** Lookup308: pallet_multisig::Timepoint */ PalletMultisigTimepoint: { height: "u32", index: "u32", }, - /** Lookup299: pallet_preimage::pallet::Call */ + /** Lookup309: pallet_preimage::pallet::Call */ PalletPreimageCall: { _enum: { note_preimage: { @@ -2727,7 +2893,7 @@ export default { }, }, }, - /** Lookup301: pallet_asset_rate::pallet::Call */ + /** Lookup311: pallet_asset_rate::pallet::Call */ PalletAssetRateCall: { _enum: { create: { @@ -2743,7 +2909,7 @@ export default { }, }, }, - /** Lookup303: pallet_xcm::pallet::Call */ + /** Lookup313: pallet_xcm::pallet::Call */ PalletXcmCall: { _enum: { send: { @@ -2818,7 +2984,7 @@ export default { }, }, }, - /** Lookup304: xcm::VersionedLocation */ + /** Lookup314: xcm::VersionedLocation */ XcmVersionedLocation: { _enum: { __Unused0: "Null", @@ -2828,12 +2994,12 @@ export default { V4: "StagingXcmV4Location", }, }, - /** Lookup305: xcm::v2::multilocation::MultiLocation */ + /** Lookup315: xcm::v2::multilocation::MultiLocation */ XcmV2MultiLocation: { parents: "u8", interior: "XcmV2MultilocationJunctions", }, - /** Lookup306: xcm::v2::multilocation::Junctions */ + /** Lookup316: xcm::v2::multilocation::Junctions */ XcmV2MultilocationJunctions: { _enum: { Here: "Null", @@ -2847,7 +3013,7 @@ export default { X8: "(XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction,XcmV2Junction)", }, }, - /** Lookup307: xcm::v2::junction::Junction */ + /** Lookup317: xcm::v2::junction::Junction */ XcmV2Junction: { _enum: { Parachain: "Compact", @@ -2873,7 +3039,7 @@ export default { }, }, }, - /** Lookup308: xcm::v2::NetworkId */ + /** Lookup318: xcm::v2::NetworkId */ XcmV2NetworkId: { _enum: { Any: "Null", @@ -2882,7 +3048,7 @@ export default { Kusama: "Null", }, }, - /** Lookup310: xcm::v2::BodyId */ + /** Lookup320: xcm::v2::BodyId */ XcmV2BodyId: { _enum: { Unit: "Null", @@ -2897,7 +3063,7 @@ export default { Treasury: "Null", }, }, - /** Lookup311: xcm::v2::BodyPart */ + /** Lookup321: xcm::v2::BodyPart */ XcmV2BodyPart: { _enum: { Voice: "Null", @@ -2918,12 +3084,12 @@ export default { }, }, }, - /** Lookup312: staging_xcm::v3::multilocation::MultiLocation */ + /** Lookup322: staging_xcm::v3::multilocation::MultiLocation */ StagingXcmV3MultiLocation: { parents: "u8", interior: "XcmV3Junctions", }, - /** Lookup313: xcm::v3::junctions::Junctions */ + /** Lookup323: xcm::v3::junctions::Junctions */ XcmV3Junctions: { _enum: { Here: "Null", @@ -2937,7 +3103,7 @@ export default { X8: "(XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction,XcmV3Junction)", }, }, - /** Lookup314: xcm::v3::junction::Junction */ + /** Lookup324: xcm::v3::junction::Junction */ XcmV3Junction: { _enum: { Parachain: "Compact", @@ -2967,7 +3133,7 @@ export default { GlobalConsensus: "XcmV3JunctionNetworkId", }, }, - /** Lookup316: xcm::v3::junction::NetworkId */ + /** Lookup326: xcm::v3::junction::NetworkId */ XcmV3JunctionNetworkId: { _enum: { ByGenesis: "[u8;32]", @@ -2988,7 +3154,7 @@ export default { PolkadotBulletin: "Null", }, }, - /** Lookup317: xcm::VersionedXcm */ + /** Lookup327: xcm::VersionedXcm */ XcmVersionedXcm: { _enum: { __Unused0: "Null", @@ -2998,9 +3164,9 @@ export default { V4: "StagingXcmV4Xcm", }, }, - /** Lookup318: xcm::v2::Xcm */ + /** Lookup328: xcm::v2::Xcm */ XcmV2Xcm: "Vec", - /** Lookup320: xcm::v2::Instruction */ + /** Lookup330: xcm::v2::Instruction */ XcmV2Instruction: { _enum: { WithdrawAsset: "XcmV2MultiassetMultiAssets", @@ -3096,28 +3262,28 @@ export default { UnsubscribeVersion: "Null", }, }, - /** Lookup321: xcm::v2::multiasset::MultiAssets */ + /** Lookup331: xcm::v2::multiasset::MultiAssets */ XcmV2MultiassetMultiAssets: "Vec", - /** Lookup323: xcm::v2::multiasset::MultiAsset */ + /** Lookup333: xcm::v2::multiasset::MultiAsset */ XcmV2MultiAsset: { id: "XcmV2MultiassetAssetId", fun: "XcmV2MultiassetFungibility", }, - /** Lookup324: xcm::v2::multiasset::AssetId */ + /** Lookup334: xcm::v2::multiasset::AssetId */ XcmV2MultiassetAssetId: { _enum: { Concrete: "XcmV2MultiLocation", Abstract: "Bytes", }, }, - /** Lookup325: xcm::v2::multiasset::Fungibility */ + /** Lookup335: xcm::v2::multiasset::Fungibility */ XcmV2MultiassetFungibility: { _enum: { Fungible: "Compact", NonFungible: "XcmV2MultiassetAssetInstance", }, }, - /** Lookup326: xcm::v2::multiasset::AssetInstance */ + /** Lookup336: xcm::v2::multiasset::AssetInstance */ XcmV2MultiassetAssetInstance: { _enum: { Undefined: "Null", @@ -3129,7 +3295,7 @@ export default { Blob: "Bytes", }, }, - /** Lookup327: xcm::v2::Response */ + /** Lookup337: xcm::v2::Response */ XcmV2Response: { _enum: { Null: "Null", @@ -3138,7 +3304,7 @@ export default { Version: "u32", }, }, - /** Lookup330: xcm::v2::traits::Error */ + /** Lookup340: xcm::v2::traits::Error */ XcmV2TraitsError: { _enum: { Overflow: "Null", @@ -3169,22 +3335,22 @@ export default { WeightNotComputable: "Null", }, }, - /** Lookup331: xcm::v2::OriginKind */ + /** Lookup341: xcm::v2::OriginKind */ XcmV2OriginKind: { _enum: ["Native", "SovereignAccount", "Superuser", "Xcm"], }, - /** Lookup332: xcm::double_encoded::DoubleEncoded */ + /** Lookup342: xcm::double_encoded::DoubleEncoded */ XcmDoubleEncoded: { encoded: "Bytes", }, - /** Lookup333: xcm::v2::multiasset::MultiAssetFilter */ + /** Lookup343: xcm::v2::multiasset::MultiAssetFilter */ XcmV2MultiassetMultiAssetFilter: { _enum: { Definite: "XcmV2MultiassetMultiAssets", Wild: "XcmV2MultiassetWildMultiAsset", }, }, - /** Lookup334: xcm::v2::multiasset::WildMultiAsset */ + /** Lookup344: xcm::v2::multiasset::WildMultiAsset */ XcmV2MultiassetWildMultiAsset: { _enum: { All: "Null", @@ -3194,20 +3360,20 @@ export default { }, }, }, - /** Lookup335: xcm::v2::multiasset::WildFungibility */ + /** Lookup345: xcm::v2::multiasset::WildFungibility */ XcmV2MultiassetWildFungibility: { _enum: ["Fungible", "NonFungible"], }, - /** Lookup336: xcm::v2::WeightLimit */ + /** Lookup346: xcm::v2::WeightLimit */ XcmV2WeightLimit: { _enum: { Unlimited: "Null", Limited: "Compact", }, }, - /** Lookup337: xcm::v3::Xcm */ + /** Lookup347: xcm::v3::Xcm */ XcmV3Xcm: "Vec", - /** Lookup339: xcm::v3::Instruction */ + /** Lookup349: xcm::v3::Instruction */ XcmV3Instruction: { _enum: { WithdrawAsset: "XcmV3MultiassetMultiAssets", @@ -3347,28 +3513,28 @@ export default { }, }, }, - /** Lookup340: xcm::v3::multiasset::MultiAssets */ + /** Lookup350: xcm::v3::multiasset::MultiAssets */ XcmV3MultiassetMultiAssets: "Vec", - /** Lookup342: xcm::v3::multiasset::MultiAsset */ + /** Lookup352: xcm::v3::multiasset::MultiAsset */ XcmV3MultiAsset: { id: "XcmV3MultiassetAssetId", fun: "XcmV3MultiassetFungibility", }, - /** Lookup343: xcm::v3::multiasset::AssetId */ + /** Lookup353: xcm::v3::multiasset::AssetId */ XcmV3MultiassetAssetId: { _enum: { Concrete: "StagingXcmV3MultiLocation", Abstract: "[u8;32]", }, }, - /** Lookup344: xcm::v3::multiasset::Fungibility */ + /** Lookup354: xcm::v3::multiasset::Fungibility */ XcmV3MultiassetFungibility: { _enum: { Fungible: "Compact", NonFungible: "XcmV3MultiassetAssetInstance", }, }, - /** Lookup345: xcm::v3::multiasset::AssetInstance */ + /** Lookup355: xcm::v3::multiasset::AssetInstance */ XcmV3MultiassetAssetInstance: { _enum: { Undefined: "Null", @@ -3379,7 +3545,7 @@ export default { Array32: "[u8;32]", }, }, - /** Lookup346: xcm::v3::Response */ + /** Lookup356: xcm::v3::Response */ XcmV3Response: { _enum: { Null: "Null", @@ -3390,7 +3556,7 @@ export default { DispatchResult: "XcmV3MaybeErrorCode", }, }, - /** Lookup349: xcm::v3::traits::Error */ + /** Lookup359: xcm::v3::traits::Error */ XcmV3TraitsError: { _enum: { Overflow: "Null", @@ -3435,7 +3601,7 @@ export default { ExceedsStackLimit: "Null", }, }, - /** Lookup351: xcm::v3::PalletInfo */ + /** Lookup361: xcm::v3::PalletInfo */ XcmV3PalletInfo: { index: "Compact", name: "Bytes", @@ -3444,7 +3610,7 @@ export default { minor: "Compact", patch: "Compact", }, - /** Lookup354: xcm::v3::MaybeErrorCode */ + /** Lookup364: xcm::v3::MaybeErrorCode */ XcmV3MaybeErrorCode: { _enum: { Success: "Null", @@ -3452,24 +3618,24 @@ export default { TruncatedError: "Bytes", }, }, - /** Lookup357: xcm::v3::OriginKind */ + /** Lookup367: xcm::v3::OriginKind */ XcmV3OriginKind: { _enum: ["Native", "SovereignAccount", "Superuser", "Xcm"], }, - /** Lookup358: xcm::v3::QueryResponseInfo */ + /** Lookup368: xcm::v3::QueryResponseInfo */ XcmV3QueryResponseInfo: { destination: "StagingXcmV3MultiLocation", queryId: "Compact", maxWeight: "SpWeightsWeightV2Weight", }, - /** Lookup359: xcm::v3::multiasset::MultiAssetFilter */ + /** Lookup369: xcm::v3::multiasset::MultiAssetFilter */ XcmV3MultiassetMultiAssetFilter: { _enum: { Definite: "XcmV3MultiassetMultiAssets", Wild: "XcmV3MultiassetWildMultiAsset", }, }, - /** Lookup360: xcm::v3::multiasset::WildMultiAsset */ + /** Lookup370: xcm::v3::multiasset::WildMultiAsset */ XcmV3MultiassetWildMultiAsset: { _enum: { All: "Null", @@ -3485,20 +3651,20 @@ export default { }, }, }, - /** Lookup361: xcm::v3::multiasset::WildFungibility */ + /** Lookup371: xcm::v3::multiasset::WildFungibility */ XcmV3MultiassetWildFungibility: { _enum: ["Fungible", "NonFungible"], }, - /** Lookup362: xcm::v3::WeightLimit */ + /** Lookup372: xcm::v3::WeightLimit */ XcmV3WeightLimit: { _enum: { Unlimited: "Null", Limited: "SpWeightsWeightV2Weight", }, }, - /** Lookup363: staging_xcm::v4::Xcm */ + /** Lookup373: staging_xcm::v4::Xcm */ StagingXcmV4Xcm: "Vec", - /** Lookup365: staging_xcm::v4::Instruction */ + /** Lookup375: staging_xcm::v4::Instruction */ StagingXcmV4Instruction: { _enum: { WithdrawAsset: "StagingXcmV4AssetAssets", @@ -3638,23 +3804,23 @@ export default { }, }, }, - /** Lookup366: staging_xcm::v4::asset::Assets */ + /** Lookup376: staging_xcm::v4::asset::Assets */ StagingXcmV4AssetAssets: "Vec", - /** Lookup368: staging_xcm::v4::asset::Asset */ + /** Lookup378: staging_xcm::v4::asset::Asset */ StagingXcmV4Asset: { id: "StagingXcmV4AssetAssetId", fun: "StagingXcmV4AssetFungibility", }, - /** Lookup369: staging_xcm::v4::asset::AssetId */ + /** Lookup379: staging_xcm::v4::asset::AssetId */ StagingXcmV4AssetAssetId: "StagingXcmV4Location", - /** Lookup370: staging_xcm::v4::asset::Fungibility */ + /** Lookup380: staging_xcm::v4::asset::Fungibility */ StagingXcmV4AssetFungibility: { _enum: { Fungible: "Compact", NonFungible: "StagingXcmV4AssetAssetInstance", }, }, - /** Lookup371: staging_xcm::v4::asset::AssetInstance */ + /** Lookup381: staging_xcm::v4::asset::AssetInstance */ StagingXcmV4AssetAssetInstance: { _enum: { Undefined: "Null", @@ -3665,7 +3831,7 @@ export default { Array32: "[u8;32]", }, }, - /** Lookup372: staging_xcm::v4::Response */ + /** Lookup382: staging_xcm::v4::Response */ StagingXcmV4Response: { _enum: { Null: "Null", @@ -3676,7 +3842,7 @@ export default { DispatchResult: "XcmV3MaybeErrorCode", }, }, - /** Lookup374: staging_xcm::v4::PalletInfo */ + /** Lookup384: staging_xcm::v4::PalletInfo */ StagingXcmV4PalletInfo: { index: "Compact", name: "Bytes", @@ -3685,20 +3851,20 @@ export default { minor: "Compact", patch: "Compact", }, - /** Lookup378: staging_xcm::v4::QueryResponseInfo */ + /** Lookup388: staging_xcm::v4::QueryResponseInfo */ StagingXcmV4QueryResponseInfo: { destination: "StagingXcmV4Location", queryId: "Compact", maxWeight: "SpWeightsWeightV2Weight", }, - /** Lookup379: staging_xcm::v4::asset::AssetFilter */ + /** Lookup389: staging_xcm::v4::asset::AssetFilter */ StagingXcmV4AssetAssetFilter: { _enum: { Definite: "StagingXcmV4AssetAssets", Wild: "StagingXcmV4AssetWildAsset", }, }, - /** Lookup380: staging_xcm::v4::asset::WildAsset */ + /** Lookup390: staging_xcm::v4::asset::WildAsset */ StagingXcmV4AssetWildAsset: { _enum: { All: "Null", @@ -3714,11 +3880,11 @@ export default { }, }, }, - /** Lookup381: staging_xcm::v4::asset::WildFungibility */ + /** Lookup391: staging_xcm::v4::asset::WildFungibility */ StagingXcmV4AssetWildFungibility: { _enum: ["Fungible", "NonFungible"], }, - /** Lookup382: xcm::VersionedAssets */ + /** Lookup392: xcm::VersionedAssets */ XcmVersionedAssets: { _enum: { __Unused0: "Null", @@ -3728,7 +3894,7 @@ export default { V4: "StagingXcmV4AssetAssets", }, }, - /** Lookup394: staging_xcm_executor::traits::asset_transfer::TransferType */ + /** Lookup404: staging_xcm_executor::traits::asset_transfer::TransferType */ StagingXcmExecutorAssetTransferTransferType: { _enum: { Teleport: "Null", @@ -3737,7 +3903,7 @@ export default { RemoteReserve: "XcmVersionedLocation", }, }, - /** Lookup395: xcm::VersionedAssetId */ + /** Lookup405: xcm::VersionedAssetId */ XcmVersionedAssetId: { _enum: { __Unused0: "Null", @@ -3747,7 +3913,7 @@ export default { V4: "StagingXcmV4AssetAssetId", }, }, - /** Lookup396: snowbridge_pallet_inbound_queue::pallet::Call */ + /** Lookup406: snowbridge_pallet_inbound_queue::pallet::Call */ SnowbridgePalletInboundQueueCall: { _enum: { submit: { @@ -3758,30 +3924,30 @@ export default { }, }, }, - /** Lookup397: snowbridge_core::inbound::Message */ + /** Lookup407: snowbridge_core::inbound::Message */ SnowbridgeCoreInboundMessage: { eventLog: "SnowbridgeCoreInboundLog", proof: "SnowbridgeCoreInboundProof", }, - /** Lookup398: snowbridge_core::inbound::Log */ + /** Lookup408: snowbridge_core::inbound::Log */ SnowbridgeCoreInboundLog: { address: "H160", topics: "Vec", data: "Bytes", }, - /** Lookup400: snowbridge_core::inbound::Proof */ + /** Lookup410: snowbridge_core::inbound::Proof */ SnowbridgeCoreInboundProof: { receiptProof: "(Vec,Vec)", executionProof: "SnowbridgeBeaconPrimitivesExecutionProof", }, - /** Lookup402: snowbridge_beacon_primitives::types::ExecutionProof */ + /** Lookup412: snowbridge_beacon_primitives::types::ExecutionProof */ SnowbridgeBeaconPrimitivesExecutionProof: { header: "SnowbridgeBeaconPrimitivesBeaconHeader", ancestryProof: "Option", executionHeader: "SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader", executionBranch: "Vec", }, - /** Lookup403: snowbridge_beacon_primitives::types::BeaconHeader */ + /** Lookup413: snowbridge_beacon_primitives::types::BeaconHeader */ SnowbridgeBeaconPrimitivesBeaconHeader: { slot: "u64", proposerIndex: "u64", @@ -3789,19 +3955,19 @@ export default { stateRoot: "H256", bodyRoot: "H256", }, - /** Lookup405: snowbridge_beacon_primitives::types::AncestryProof */ + /** Lookup415: snowbridge_beacon_primitives::types::AncestryProof */ SnowbridgeBeaconPrimitivesAncestryProof: { headerBranch: "Vec", finalizedBlockRoot: "H256", }, - /** Lookup406: snowbridge_beacon_primitives::types::VersionedExecutionPayloadHeader */ + /** Lookup416: snowbridge_beacon_primitives::types::VersionedExecutionPayloadHeader */ SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader: { _enum: { Capella: "SnowbridgeBeaconPrimitivesExecutionPayloadHeader", Deneb: "SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader", }, }, - /** Lookup407: snowbridge_beacon_primitives::types::ExecutionPayloadHeader */ + /** Lookup417: snowbridge_beacon_primitives::types::ExecutionPayloadHeader */ SnowbridgeBeaconPrimitivesExecutionPayloadHeader: { parentHash: "H256", feeRecipient: "H160", @@ -3819,7 +3985,7 @@ export default { transactionsRoot: "H256", withdrawalsRoot: "H256", }, - /** Lookup410: snowbridge_beacon_primitives::types::deneb::ExecutionPayloadHeader */ + /** Lookup420: snowbridge_beacon_primitives::types::deneb::ExecutionPayloadHeader */ SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader: { parentHash: "H256", feeRecipient: "H160", @@ -3839,11 +4005,11 @@ export default { blobGasUsed: "u64", excessBlobGas: "u64", }, - /** Lookup411: snowbridge_core::operating_mode::BasicOperatingMode */ + /** Lookup421: snowbridge_core::operating_mode::BasicOperatingMode */ SnowbridgeCoreOperatingModeBasicOperatingMode: { _enum: ["Normal", "Halted"], }, - /** Lookup412: snowbridge_pallet_outbound_queue::pallet::Call */ + /** Lookup422: snowbridge_pallet_outbound_queue::pallet::Call */ SnowbridgePalletOutboundQueueCall: { _enum: { set_operating_mode: { @@ -3851,7 +4017,7 @@ export default { }, }, }, - /** Lookup413: snowbridge_pallet_system::pallet::Call */ + /** Lookup423: snowbridge_pallet_system::pallet::Call */ SnowbridgePalletSystemCall: { _enum: { upgrade: { @@ -3896,34 +4062,34 @@ export default { }, }, }, - /** Lookup415: snowbridge_core::outbound::v1::Initializer */ + /** Lookup425: snowbridge_core::outbound::v1::Initializer */ SnowbridgeCoreOutboundV1Initializer: { params: "Bytes", maximumRequiredGas: "u64", }, - /** Lookup416: snowbridge_core::outbound::v1::OperatingMode */ + /** Lookup426: snowbridge_core::outbound::v1::OperatingMode */ SnowbridgeCoreOutboundV1OperatingMode: { _enum: ["Normal", "RejectingOutboundMessages"], }, - /** Lookup417: snowbridge_core::pricing::PricingParameters */ + /** Lookup427: snowbridge_core::pricing::PricingParameters */ SnowbridgeCorePricingPricingParameters: { exchangeRate: "u128", rewards: "SnowbridgeCorePricingRewards", feePerGas: "U256", multiplier: "u128", }, - /** Lookup418: snowbridge_core::pricing::Rewards */ + /** Lookup428: snowbridge_core::pricing::Rewards */ SnowbridgeCorePricingRewards: { local: "u128", remote: "U256", }, - /** Lookup419: snowbridge_core::AssetMetadata */ + /** Lookup429: snowbridge_core::AssetMetadata */ SnowbridgeCoreAssetMetadata: { name: "Bytes", symbol: "Bytes", decimals: "u8", }, - /** Lookup420: pallet_migrations::pallet::Call */ + /** Lookup430: pallet_migrations::pallet::Call */ PalletMigrationsCall: { _enum: { force_set_cursor: { @@ -3940,20 +4106,20 @@ export default { }, }, }, - /** Lookup422: pallet_migrations::MigrationCursor, BlockNumber> */ + /** Lookup432: pallet_migrations::MigrationCursor, BlockNumber> */ PalletMigrationsMigrationCursor: { _enum: { Active: "PalletMigrationsActiveCursor", Stuck: "Null", }, }, - /** Lookup424: pallet_migrations::ActiveCursor, BlockNumber> */ + /** Lookup434: pallet_migrations::ActiveCursor, BlockNumber> */ PalletMigrationsActiveCursor: { index: "u32", innerCursor: "Option", startedAt: "u32", }, - /** Lookup426: pallet_migrations::HistoricCleanupSelector> */ + /** Lookup436: pallet_migrations::HistoricCleanupSelector> */ PalletMigrationsHistoricCleanupSelector: { _enum: { Specific: "Vec", @@ -3963,7 +4129,7 @@ export default { }, }, }, - /** Lookup429: pallet_beefy::pallet::Call */ + /** Lookup439: pallet_beefy::pallet::Call */ PalletBeefyCall: { _enum: { report_double_voting: { @@ -3996,17 +4162,17 @@ export default { }, }, /** - * Lookup430: sp_consensus_beefy::DoubleVotingProof */ SpConsensusBeefyDoubleVotingProof: { first: "SpConsensusBeefyVoteMessage", second: "SpConsensusBeefyVoteMessage", }, - /** Lookup431: sp_consensus_beefy::ecdsa_crypto::Signature */ + /** Lookup441: sp_consensus_beefy::ecdsa_crypto::Signature */ SpConsensusBeefyEcdsaCryptoSignature: "[u8;65]", /** - * Lookup432: sp_consensus_beefy::VoteMessage */ SpConsensusBeefyVoteMessage: { @@ -4014,16 +4180,16 @@ export default { id: "SpConsensusBeefyEcdsaCryptoPublic", signature: "SpConsensusBeefyEcdsaCryptoSignature", }, - /** Lookup433: sp_consensus_beefy::commitment::Commitment */ + /** Lookup443: sp_consensus_beefy::commitment::Commitment */ SpConsensusBeefyCommitment: { payload: "SpConsensusBeefyPayload", blockNumber: "u32", validatorSetId: "u64", }, - /** Lookup434: sp_consensus_beefy::payload::Payload */ + /** Lookup444: sp_consensus_beefy::payload::Payload */ SpConsensusBeefyPayload: "Vec<([u8;2],Bytes)>", /** - * Lookup437: sp_consensus_beefy::ForkVotingProof, + * Lookup447: sp_consensus_beefy::ForkVotingProof, * sp_consensus_beefy::ecdsa_crypto::Public, sp_mmr_primitives::AncestryProof> */ SpConsensusBeefyForkVotingProof: { @@ -4031,18 +4197,18 @@ export default { ancestryProof: "SpMmrPrimitivesAncestryProof", header: "SpRuntimeHeader", }, - /** Lookup438: sp_mmr_primitives::AncestryProof */ + /** Lookup448: sp_mmr_primitives::AncestryProof */ SpMmrPrimitivesAncestryProof: { prevPeaks: "Vec", prevLeafCount: "u64", leafCount: "u64", items: "Vec<(u64,H256)>", }, - /** Lookup441: sp_consensus_beefy::FutureBlockVotingProof */ + /** Lookup451: sp_consensus_beefy::FutureBlockVotingProof */ SpConsensusBeefyFutureBlockVotingProof: { vote: "SpConsensusBeefyVoteMessage", }, - /** Lookup442: snowbridge_pallet_ethereum_client::pallet::Call */ + /** Lookup452: snowbridge_pallet_ethereum_client::pallet::Call */ SnowbridgePalletEthereumClientCall: { _enum: { force_checkpoint: { @@ -4057,7 +4223,7 @@ export default { }, }, }, - /** Lookup443: snowbridge_beacon_primitives::updates::CheckpointUpdate */ + /** Lookup453: snowbridge_beacon_primitives::updates::CheckpointUpdate */ SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate: { header: "SnowbridgeBeaconPrimitivesBeaconHeader", currentSyncCommittee: "SnowbridgeBeaconPrimitivesSyncCommittee", @@ -4066,14 +4232,14 @@ export default { blockRootsRoot: "H256", blockRootsBranch: "Vec", }, - /** Lookup444: snowbridge_beacon_primitives::types::SyncCommittee */ + /** Lookup454: snowbridge_beacon_primitives::types::SyncCommittee */ SnowbridgeBeaconPrimitivesSyncCommittee: { pubkeys: "[[u8;48];512]", aggregatePubkey: "SnowbridgeBeaconPrimitivesPublicKey", }, - /** Lookup446: snowbridge_beacon_primitives::types::PublicKey */ + /** Lookup456: snowbridge_beacon_primitives::types::PublicKey */ SnowbridgeBeaconPrimitivesPublicKey: "[u8;48]", - /** Lookup448: snowbridge_beacon_primitives::updates::Update */ + /** Lookup458: snowbridge_beacon_primitives::updates::Update */ SnowbridgeBeaconPrimitivesUpdatesUpdate: { attestedHeader: "SnowbridgeBeaconPrimitivesBeaconHeader", syncAggregate: "SnowbridgeBeaconPrimitivesSyncAggregate", @@ -4084,19 +4250,19 @@ export default { blockRootsRoot: "H256", blockRootsBranch: "Vec", }, - /** Lookup449: snowbridge_beacon_primitives::types::SyncAggregate */ + /** Lookup459: snowbridge_beacon_primitives::types::SyncAggregate */ SnowbridgeBeaconPrimitivesSyncAggregate: { syncCommitteeBits: "[u8;64]", syncCommitteeSignature: "SnowbridgeBeaconPrimitivesSignature", }, - /** Lookup450: snowbridge_beacon_primitives::types::Signature */ + /** Lookup460: snowbridge_beacon_primitives::types::Signature */ SnowbridgeBeaconPrimitivesSignature: "[u8;96]", - /** Lookup453: snowbridge_beacon_primitives::updates::NextSyncCommitteeUpdate */ + /** Lookup463: snowbridge_beacon_primitives::updates::NextSyncCommitteeUpdate */ SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate: { nextSyncCommittee: "SnowbridgeBeaconPrimitivesSyncCommittee", nextSyncCommitteeBranch: "Vec", }, - /** Lookup454: polkadot_runtime_common::paras_sudo_wrapper::pallet::Call */ + /** Lookup464: polkadot_runtime_common::paras_sudo_wrapper::pallet::Call */ PolkadotRuntimeCommonParasSudoWrapperPalletCall: { _enum: { sudo_schedule_para_initialize: { @@ -4124,13 +4290,13 @@ export default { }, }, }, - /** Lookup455: polkadot_runtime_parachains::paras::ParaGenesisArgs */ + /** Lookup465: polkadot_runtime_parachains::paras::ParaGenesisArgs */ PolkadotRuntimeParachainsParasParaGenesisArgs: { genesisHead: "Bytes", validationCode: "Bytes", paraKind: "bool", }, - /** Lookup456: pallet_root_testing::pallet::Call */ + /** Lookup466: pallet_root_testing::pallet::Call */ PalletRootTestingCall: { _enum: { fill_block: { @@ -4139,7 +4305,7 @@ export default { trigger_defensive: "Null", }, }, - /** Lookup457: pallet_sudo::pallet::Call */ + /** Lookup467: pallet_sudo::pallet::Call */ PalletSudoCall: { _enum: { sudo: { @@ -4162,15 +4328,15 @@ export default { remove_key: "Null", }, }, - /** Lookup458: sp_runtime::traits::BlakeTwo256 */ + /** Lookup468: sp_runtime::traits::BlakeTwo256 */ SpRuntimeBlakeTwo256: "Null", - /** Lookup460: pallet_conviction_voting::types::Tally */ + /** Lookup470: pallet_conviction_voting::types::Tally */ PalletConvictionVotingTally: { ayes: "u128", nays: "u128", support: "u128", }, - /** Lookup461: pallet_ranked_collective::pallet::Event */ + /** Lookup471: pallet_ranked_collective::pallet::Event */ PalletRankedCollectiveEvent: { _enum: { MemberAdded: { @@ -4196,20 +4362,20 @@ export default { }, }, }, - /** Lookup462: pallet_ranked_collective::VoteRecord */ + /** Lookup472: pallet_ranked_collective::VoteRecord */ PalletRankedCollectiveVoteRecord: { _enum: { Aye: "u32", Nay: "u32", }, }, - /** Lookup463: pallet_ranked_collective::Tally */ + /** Lookup473: pallet_ranked_collective::Tally */ PalletRankedCollectiveTally: { bareAyes: "u32", ayes: "u32", nays: "u32", }, - /** Lookup465: pallet_whitelist::pallet::Event */ + /** Lookup475: pallet_whitelist::pallet::Event */ PalletWhitelistEvent: { _enum: { CallWhitelisted: { @@ -4224,17 +4390,17 @@ export default { }, }, }, - /** Lookup467: frame_support::dispatch::PostDispatchInfo */ + /** Lookup477: frame_support::dispatch::PostDispatchInfo */ FrameSupportDispatchPostDispatchInfo: { actualWeight: "Option", paysFee: "FrameSupportDispatchPays", }, - /** Lookup469: sp_runtime::DispatchErrorWithPostInfo */ + /** Lookup479: sp_runtime::DispatchErrorWithPostInfo */ SpRuntimeDispatchErrorWithPostInfo: { postInfo: "FrameSupportDispatchPostDispatchInfo", error: "SpRuntimeDispatchError", }, - /** Lookup470: polkadot_runtime_parachains::inclusion::pallet::Event */ + /** Lookup480: polkadot_runtime_parachains::inclusion::pallet::Event */ PolkadotRuntimeParachainsInclusionPalletEvent: { _enum: { CandidateBacked: "(PolkadotPrimitivesV8CandidateReceipt,Bytes,u32,u32)", @@ -4246,12 +4412,12 @@ export default { }, }, }, - /** Lookup471: polkadot_primitives::v8::CandidateReceipt */ + /** Lookup481: polkadot_primitives::v8::CandidateReceipt */ PolkadotPrimitivesV8CandidateReceipt: { descriptor: "PolkadotPrimitivesV8CandidateDescriptor", commitmentsHash: "H256", }, - /** Lookup474: polkadot_runtime_parachains::paras::pallet::Event */ + /** Lookup484: polkadot_runtime_parachains::paras::pallet::Event */ PolkadotRuntimeParachainsParasPalletEvent: { _enum: { CurrentCodeUpdated: "u32", @@ -4264,7 +4430,7 @@ export default { PvfCheckRejected: "(H256,u32)", }, }, - /** Lookup475: polkadot_runtime_parachains::hrmp::pallet::Event */ + /** Lookup485: polkadot_runtime_parachains::hrmp::pallet::Event */ PolkadotRuntimeParachainsHrmpPalletEvent: { _enum: { OpenChannelRequested: { @@ -4303,7 +4469,7 @@ export default { }, }, }, - /** Lookup476: polkadot_runtime_parachains::disputes::pallet::Event */ + /** Lookup486: polkadot_runtime_parachains::disputes::pallet::Event */ PolkadotRuntimeParachainsDisputesPalletEvent: { _enum: { DisputeInitiated: "(H256,PolkadotRuntimeParachainsDisputesDisputeLocation)", @@ -4311,15 +4477,15 @@ export default { Revert: "u32", }, }, - /** Lookup477: polkadot_runtime_parachains::disputes::DisputeLocation */ + /** Lookup487: polkadot_runtime_parachains::disputes::DisputeLocation */ PolkadotRuntimeParachainsDisputesDisputeLocation: { _enum: ["Local", "Remote"], }, - /** Lookup478: polkadot_runtime_parachains::disputes::DisputeResult */ + /** Lookup488: polkadot_runtime_parachains::disputes::DisputeResult */ PolkadotRuntimeParachainsDisputesDisputeResult: { _enum: ["Valid", "Invalid"], }, - /** Lookup479: pallet_message_queue::pallet::Event */ + /** Lookup489: pallet_message_queue::pallet::Event */ PalletMessageQueueEvent: { _enum: { ProcessingFailed: { @@ -4345,7 +4511,7 @@ export default { }, }, }, - /** Lookup480: frame_support::traits::messages::ProcessMessageError */ + /** Lookup490: frame_support::traits::messages::ProcessMessageError */ FrameSupportMessagesProcessMessageError: { _enum: { BadFormat: "Null", @@ -4356,7 +4522,7 @@ export default { StackLimitReached: "Null", }, }, - /** Lookup481: polkadot_runtime_parachains::on_demand::pallet::Event */ + /** Lookup491: polkadot_runtime_parachains::on_demand::pallet::Event */ PolkadotRuntimeParachainsOnDemandPalletEvent: { _enum: { OnDemandOrderPlaced: { @@ -4369,7 +4535,7 @@ export default { }, }, }, - /** Lookup482: polkadot_runtime_common::paras_registrar::pallet::Event */ + /** Lookup492: polkadot_runtime_common::paras_registrar::pallet::Event */ PolkadotRuntimeCommonParasRegistrarPalletEvent: { _enum: { Registered: { @@ -4389,7 +4555,7 @@ export default { }, }, }, - /** Lookup483: pallet_utility::pallet::Event */ + /** Lookup493: pallet_utility::pallet::Event */ PalletUtilityEvent: { _enum: { BatchInterrupted: { @@ -4407,7 +4573,7 @@ export default { }, }, }, - /** Lookup485: pallet_identity::pallet::Event */ + /** Lookup495: pallet_identity::pallet::Event */ PalletIdentityEvent: { _enum: { IdentitySet: { @@ -4479,7 +4645,7 @@ export default { }, }, }, - /** Lookup486: pallet_scheduler::pallet::Event */ + /** Lookup496: pallet_scheduler::pallet::Event */ PalletSchedulerEvent: { _enum: { Scheduled: { @@ -4523,7 +4689,7 @@ export default { }, }, }, - /** Lookup488: pallet_proxy::pallet::Event */ + /** Lookup498: pallet_proxy::pallet::Event */ PalletProxyEvent: { _enum: { ProxyExecuted: { @@ -4554,7 +4720,7 @@ export default { }, }, }, - /** Lookup489: pallet_multisig::pallet::Event */ + /** Lookup499: pallet_multisig::pallet::Event */ PalletMultisigEvent: { _enum: { NewMultisig: { @@ -4583,7 +4749,7 @@ export default { }, }, }, - /** Lookup490: pallet_preimage::pallet::Event */ + /** Lookup500: pallet_preimage::pallet::Event */ PalletPreimageEvent: { _enum: { Noted: { @@ -4606,7 +4772,7 @@ export default { }, }, }, - /** Lookup491: pallet_asset_rate::pallet::Event */ + /** Lookup501: pallet_asset_rate::pallet::Event */ PalletAssetRateEvent: { _enum: { AssetRateCreated: { @@ -4626,7 +4792,7 @@ export default { }, }, }, - /** Lookup492: pallet_xcm::pallet::Event */ + /** Lookup502: pallet_xcm::pallet::Event */ PalletXcmEvent: { _enum: { Attempted: { @@ -4749,7 +4915,7 @@ export default { }, }, }, - /** Lookup493: staging_xcm::v4::traits::Outcome */ + /** Lookup503: staging_xcm::v4::traits::Outcome */ StagingXcmV4TraitsOutcome: { _enum: { Complete: { @@ -4764,7 +4930,7 @@ export default { }, }, }, - /** Lookup494: snowbridge_pallet_inbound_queue::pallet::Event */ + /** Lookup504: snowbridge_pallet_inbound_queue::pallet::Event */ SnowbridgePalletInboundQueueEvent: { _enum: { MessageReceived: { @@ -4778,7 +4944,7 @@ export default { }, }, }, - /** Lookup495: snowbridge_pallet_outbound_queue::pallet::Event */ + /** Lookup505: snowbridge_pallet_outbound_queue::pallet::Event */ SnowbridgePalletOutboundQueueEvent: { _enum: { MessageQueued: { @@ -4797,7 +4963,7 @@ export default { }, }, }, - /** Lookup496: snowbridge_pallet_system::pallet::Event */ + /** Lookup506: snowbridge_pallet_system::pallet::Event */ SnowbridgePalletSystemEvent: { _enum: { Upgrade: { @@ -4839,7 +5005,7 @@ export default { }, }, }, - /** Lookup497: pallet_migrations::pallet::Event */ + /** Lookup507: pallet_migrations::pallet::Event */ PalletMigrationsEvent: { _enum: { RuntimeUpgradeStarted: "Null", @@ -4861,7 +5027,7 @@ export default { }, }, }, - /** Lookup499: snowbridge_pallet_ethereum_client::pallet::Event */ + /** Lookup509: snowbridge_pallet_ethereum_client::pallet::Event */ SnowbridgePalletEthereumClientEvent: { _enum: { BeaconHeaderImported: { @@ -4876,11 +5042,11 @@ export default { }, }, }, - /** Lookup500: pallet_root_testing::pallet::Event */ + /** Lookup510: pallet_root_testing::pallet::Event */ PalletRootTestingEvent: { _enum: ["DefensiveTestCall"], }, - /** Lookup501: pallet_sudo::pallet::Event */ + /** Lookup511: pallet_sudo::pallet::Event */ PalletSudoEvent: { _enum: { Sudid: { @@ -4899,7 +5065,7 @@ export default { }, }, }, - /** Lookup502: frame_system::Phase */ + /** Lookup512: frame_system::Phase */ FrameSystemPhase: { _enum: { ApplyExtrinsic: "u32", @@ -4907,51 +5073,51 @@ export default { Initialization: "Null", }, }, - /** Lookup504: frame_system::LastRuntimeUpgradeInfo */ + /** Lookup514: frame_system::LastRuntimeUpgradeInfo */ FrameSystemLastRuntimeUpgradeInfo: { specVersion: "Compact", specName: "Text", }, - /** Lookup506: frame_system::CodeUpgradeAuthorization */ + /** Lookup516: frame_system::CodeUpgradeAuthorization */ FrameSystemCodeUpgradeAuthorization: { codeHash: "H256", checkVersion: "bool", }, - /** Lookup507: frame_system::limits::BlockWeights */ + /** Lookup517: frame_system::limits::BlockWeights */ FrameSystemLimitsBlockWeights: { baseBlock: "SpWeightsWeightV2Weight", maxBlock: "SpWeightsWeightV2Weight", perClass: "FrameSupportDispatchPerDispatchClassWeightsPerClass", }, - /** Lookup508: frame_support::dispatch::PerDispatchClass */ + /** Lookup518: frame_support::dispatch::PerDispatchClass */ FrameSupportDispatchPerDispatchClassWeightsPerClass: { normal: "FrameSystemLimitsWeightsPerClass", operational: "FrameSystemLimitsWeightsPerClass", mandatory: "FrameSystemLimitsWeightsPerClass", }, - /** Lookup509: frame_system::limits::WeightsPerClass */ + /** Lookup519: frame_system::limits::WeightsPerClass */ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: "SpWeightsWeightV2Weight", maxExtrinsic: "Option", maxTotal: "Option", reserved: "Option", }, - /** Lookup510: frame_system::limits::BlockLength */ + /** Lookup520: frame_system::limits::BlockLength */ FrameSystemLimitsBlockLength: { max: "FrameSupportDispatchPerDispatchClassU32", }, - /** Lookup511: frame_support::dispatch::PerDispatchClass */ + /** Lookup521: frame_support::dispatch::PerDispatchClass */ FrameSupportDispatchPerDispatchClassU32: { normal: "u32", operational: "u32", mandatory: "u32", }, - /** Lookup512: sp_weights::RuntimeDbWeight */ + /** Lookup522: sp_weights::RuntimeDbWeight */ SpWeightsRuntimeDbWeight: { read: "u64", write: "u64", }, - /** Lookup513: sp_version::RuntimeVersion */ + /** Lookup523: sp_version::RuntimeVersion */ SpVersionRuntimeVersion: { specName: "Text", implName: "Text", @@ -4962,7 +5128,7 @@ export default { transactionVersion: "u32", stateVersion: "u8", }, - /** Lookup517: frame_system::pallet::Error */ + /** Lookup527: frame_system::pallet::Error */ FrameSystemError: { _enum: [ "InvalidSpecName", @@ -4976,7 +5142,7 @@ export default { "Unauthorized", ], }, - /** Lookup524: sp_consensus_babe::digests::PreDigest */ + /** Lookup534: sp_consensus_babe::digests::PreDigest */ SpConsensusBabeDigestsPreDigest: { _enum: { __Unused0: "Null", @@ -4985,34 +5151,34 @@ export default { SecondaryVRF: "SpConsensusBabeDigestsSecondaryVRFPreDigest", }, }, - /** Lookup525: sp_consensus_babe::digests::PrimaryPreDigest */ + /** Lookup535: sp_consensus_babe::digests::PrimaryPreDigest */ SpConsensusBabeDigestsPrimaryPreDigest: { authorityIndex: "u32", slot: "u64", vrfSignature: "SpCoreSr25519VrfVrfSignature", }, - /** Lookup526: sp_core::sr25519::vrf::VrfSignature */ + /** Lookup536: sp_core::sr25519::vrf::VrfSignature */ SpCoreSr25519VrfVrfSignature: { preOutput: "[u8;32]", proof: "[u8;64]", }, - /** Lookup527: sp_consensus_babe::digests::SecondaryPlainPreDigest */ + /** Lookup537: sp_consensus_babe::digests::SecondaryPlainPreDigest */ SpConsensusBabeDigestsSecondaryPlainPreDigest: { authorityIndex: "u32", slot: "u64", }, - /** Lookup528: sp_consensus_babe::digests::SecondaryVRFPreDigest */ + /** Lookup538: sp_consensus_babe::digests::SecondaryVRFPreDigest */ SpConsensusBabeDigestsSecondaryVRFPreDigest: { authorityIndex: "u32", slot: "u64", vrfSignature: "SpCoreSr25519VrfVrfSignature", }, - /** Lookup529: sp_consensus_babe::BabeEpochConfiguration */ + /** Lookup539: sp_consensus_babe::BabeEpochConfiguration */ SpConsensusBabeBabeEpochConfiguration: { c: "(u64,u64)", allowedSlots: "SpConsensusBabeAllowedSlots", }, - /** Lookup533: pallet_babe::pallet::Error */ + /** Lookup543: pallet_babe::pallet::Error */ PalletBabeError: { _enum: [ "InvalidEquivocationProof", @@ -5021,22 +5187,22 @@ export default { "InvalidConfiguration", ], }, - /** Lookup535: pallet_balances::types::BalanceLock */ + /** Lookup545: pallet_balances::types::BalanceLock */ PalletBalancesBalanceLock: { id: "[u8;8]", amount: "u128", reasons: "PalletBalancesReasons", }, - /** Lookup536: pallet_balances::types::Reasons */ + /** Lookup546: pallet_balances::types::Reasons */ PalletBalancesReasons: { _enum: ["Fee", "Misc", "All"], }, - /** Lookup539: pallet_balances::types::ReserveData */ + /** Lookup549: pallet_balances::types::ReserveData */ PalletBalancesReserveData: { id: "[u8;8]", amount: "u128", }, - /** Lookup543: dancelight_runtime::RuntimeHoldReason */ + /** Lookup553: dancelight_runtime::RuntimeHoldReason */ DancelightRuntimeRuntimeHoldReason: { _enum: { __Unused0: "Null", @@ -5073,7 +5239,7 @@ export default { __Unused31: "Null", __Unused32: "Null", __Unused33: "Null", - __Unused34: "Null", + PooledStaking: "PalletPooledStakingHoldReason", __Unused35: "Null", __Unused36: "Null", __Unused37: "Null", @@ -5127,24 +5293,28 @@ export default { Preimage: "PalletPreimageHoldReason", }, }, - /** Lookup544: pallet_registrar::pallet::HoldReason */ + /** Lookup554: pallet_registrar::pallet::HoldReason */ PalletRegistrarHoldReason: { _enum: ["RegistrarDeposit"], }, - /** Lookup545: pallet_data_preservers::pallet::HoldReason */ + /** Lookup555: pallet_data_preservers::pallet::HoldReason */ PalletDataPreserversHoldReason: { _enum: ["ProfileDeposit"], }, - /** Lookup546: pallet_preimage::pallet::HoldReason */ + /** Lookup556: pallet_pooled_staking::pallet::HoldReason */ + PalletPooledStakingHoldReason: { + _enum: ["PooledStake"], + }, + /** Lookup557: pallet_preimage::pallet::HoldReason */ PalletPreimageHoldReason: { _enum: ["Preimage"], }, - /** Lookup549: frame_support::traits::tokens::misc::IdAmount */ + /** Lookup560: frame_support::traits::tokens::misc::IdAmount */ FrameSupportTokensMiscIdAmount: { id: "Null", amount: "u128", }, - /** Lookup551: pallet_balances::pallet::Error */ + /** Lookup562: pallet_balances::pallet::Error */ PalletBalancesError: { _enum: [ "VestingBalance", @@ -5161,21 +5331,21 @@ export default { "DeltaZero", ], }, - /** Lookup552: pallet_transaction_payment::Releases */ + /** Lookup563: pallet_transaction_payment::Releases */ PalletTransactionPaymentReleases: { _enum: ["V1Ancient", "V2"], }, - /** Lookup553: sp_staking::offence::OffenceDetails */ + /** Lookup564: sp_staking::offence::OffenceDetails */ SpStakingOffenceOffenceDetails: { offender: "(AccountId32,Null)", reporters: "Vec", }, - /** Lookup565: pallet_registrar::pallet::DepositInfo */ + /** Lookup576: pallet_registrar::pallet::DepositInfo */ PalletRegistrarDepositInfo: { creator: "AccountId32", deposit: "u128", }, - /** Lookup566: pallet_registrar::pallet::Error */ + /** Lookup577: pallet_registrar::pallet::Error */ PalletRegistrarError: { _enum: [ "ParaIdAlreadyRegistered", @@ -5197,7 +5367,7 @@ export default { "WasmCodeNecessary", ], }, - /** Lookup567: pallet_configuration::HostConfiguration */ + /** Lookup578: pallet_configuration::HostConfiguration */ PalletConfigurationHostConfiguration: { maxCollators: "u32", minOrchestratorCollators: "u32", @@ -5209,11 +5379,11 @@ export default { targetContainerChainFullness: "Perbill", maxParachainCoresPercentage: "Option", }, - /** Lookup570: pallet_configuration::pallet::Error */ + /** Lookup581: pallet_configuration::pallet::Error */ PalletConfigurationError: { _enum: ["InvalidNewValue"], }, - /** Lookup572: pallet_invulnerables::pallet::Error */ + /** Lookup583: pallet_invulnerables::pallet::Error */ PalletInvulnerablesError: { _enum: [ "TooManyInvulnerables", @@ -5223,23 +5393,23 @@ export default { "UnableToDeriveCollatorId", ], }, - /** Lookup573: dp_collator_assignment::AssignedCollators */ + /** Lookup584: dp_collator_assignment::AssignedCollators */ DpCollatorAssignmentAssignedCollatorsAccountId32: { orchestratorChain: "Vec", containerChains: "BTreeMap>", }, - /** Lookup578: dp_collator_assignment::AssignedCollators */ + /** Lookup589: dp_collator_assignment::AssignedCollators */ DpCollatorAssignmentAssignedCollatorsPublic: { orchestratorChain: "Vec", containerChains: "BTreeMap>", }, - /** Lookup586: tp_traits::ContainerChainBlockInfo */ + /** Lookup597: tp_traits::ContainerChainBlockInfo */ TpTraitsContainerChainBlockInfo: { blockNumber: "u32", author: "AccountId32", latestSlotNumber: "u64", }, - /** Lookup587: pallet_author_noting::pallet::Error */ + /** Lookup598: pallet_author_noting::pallet::Error */ PalletAuthorNotingError: { _enum: [ "FailedReading", @@ -5251,18 +5421,18 @@ export default { "NonAuraDigest", ], }, - /** Lookup588: pallet_services_payment::pallet::Error */ + /** Lookup599: pallet_services_payment::pallet::Error */ PalletServicesPaymentError: { _enum: ["InsufficientFundsToPurchaseCredits", "InsufficientCredits", "CreditPriceTooExpensive"], }, - /** Lookup589: pallet_data_preservers::types::RegisteredProfile */ + /** Lookup600: pallet_data_preservers::types::RegisteredProfile */ PalletDataPreserversRegisteredProfile: { account: "AccountId32", deposit: "u128", profile: "PalletDataPreserversProfile", assignment: "Option<(u32,DancelightRuntimePreserversAssignmentPaymentWitness)>", }, - /** Lookup595: pallet_data_preservers::pallet::Error */ + /** Lookup606: pallet_data_preservers::pallet::Error */ PalletDataPreserversError: { _enum: [ "NoBootNodes", @@ -5277,12 +5447,12 @@ export default { "CantDeleteAssignedProfile", ], }, - /** Lookup598: tp_traits::ActiveEraInfo */ + /** Lookup609: tp_traits::ActiveEraInfo */ TpTraitsActiveEraInfo: { index: "u32", start: "Option", }, - /** Lookup600: pallet_external_validators::pallet::Error */ + /** Lookup611: pallet_external_validators::pallet::Error */ PalletExternalValidatorsError: { _enum: [ "TooManyWhitelisted", @@ -5292,7 +5462,7 @@ export default { "UnableToDeriveValidatorId", ], }, - /** Lookup603: pallet_external_validator_slashes::Slash */ + /** Lookup614: pallet_external_validator_slashes::Slash */ PalletExternalValidatorSlashesSlash: { validator: "AccountId32", reporters: "Vec", @@ -5300,7 +5470,7 @@ export default { percentage: "Perbill", confirmed: "bool", }, - /** Lookup604: pallet_external_validator_slashes::pallet::Error */ + /** Lookup615: pallet_external_validator_slashes::pallet::Error */ PalletExternalValidatorSlashesError: { _enum: [ "EmptyTargets", @@ -5314,18 +5484,18 @@ export default { "EthereumDeliverFail", ], }, - /** Lookup605: pallet_external_validators_rewards::pallet::EraRewardPoints */ + /** Lookup616: pallet_external_validators_rewards::pallet::EraRewardPoints */ PalletExternalValidatorsRewardsEraRewardPoints: { total: "u32", individual: "BTreeMap", }, - /** Lookup612: sp_core::crypto::KeyTypeId */ + /** Lookup623: sp_core::crypto::KeyTypeId */ SpCoreCryptoKeyTypeId: "[u8;4]", - /** Lookup613: pallet_session::pallet::Error */ + /** Lookup624: pallet_session::pallet::Error */ PalletSessionError: { _enum: ["InvalidProof", "NoAssociatedValidatorId", "DuplicatedKey", "NoKeys", "NoAccount"], }, - /** Lookup614: pallet_grandpa::StoredState */ + /** Lookup625: pallet_grandpa::StoredState */ PalletGrandpaStoredState: { _enum: { Live: "Null", @@ -5340,14 +5510,14 @@ export default { }, }, }, - /** Lookup615: pallet_grandpa::StoredPendingChange */ + /** Lookup626: pallet_grandpa::StoredPendingChange */ PalletGrandpaStoredPendingChange: { scheduledAt: "u32", delay: "u32", nextAuthorities: "Vec<(SpConsensusGrandpaAppPublic,u64)>", forced: "Option", }, - /** Lookup617: pallet_grandpa::pallet::Error */ + /** Lookup628: pallet_grandpa::pallet::Error */ PalletGrandpaError: { _enum: [ "PauseFailed", @@ -5359,12 +5529,78 @@ export default { "DuplicateOffenceReport", ], }, - /** Lookup620: pallet_inflation_rewards::pallet::ChainsToRewardValue */ + /** Lookup631: pallet_inflation_rewards::pallet::ChainsToRewardValue */ PalletInflationRewardsChainsToRewardValue: { paraIds: "Vec", rewardsPerChain: "u128", }, - /** Lookup621: pallet_treasury::Proposal */ + /** Lookup633: pallet_pooled_staking::candidate::EligibleCandidate */ + PalletPooledStakingCandidateEligibleCandidate: { + candidate: "AccountId32", + stake: "u128", + }, + /** Lookup636: pallet_pooled_staking::pallet::PoolsKey */ + PalletPooledStakingPoolsKey: { + _enum: { + CandidateTotalStake: "Null", + JoiningShares: { + delegator: "AccountId32", + }, + JoiningSharesSupply: "Null", + JoiningSharesTotalStaked: "Null", + JoiningSharesHeldStake: { + delegator: "AccountId32", + }, + AutoCompoundingShares: { + delegator: "AccountId32", + }, + AutoCompoundingSharesSupply: "Null", + AutoCompoundingSharesTotalStaked: "Null", + AutoCompoundingSharesHeldStake: { + delegator: "AccountId32", + }, + ManualRewardsShares: { + delegator: "AccountId32", + }, + ManualRewardsSharesSupply: "Null", + ManualRewardsSharesTotalStaked: "Null", + ManualRewardsSharesHeldStake: { + delegator: "AccountId32", + }, + ManualRewardsCounter: "Null", + ManualRewardsCheckpoint: { + delegator: "AccountId32", + }, + LeavingShares: { + delegator: "AccountId32", + }, + LeavingSharesSupply: "Null", + LeavingSharesTotalStaked: "Null", + LeavingSharesHeldStake: { + delegator: "AccountId32", + }, + }, + }, + /** Lookup638: pallet_pooled_staking::pallet::Error */ + PalletPooledStakingError: { + _enum: { + InvalidPalletSetting: "Null", + DisabledFeature: "Null", + NoOneIsStaking: "Null", + StakeMustBeNonZero: "Null", + RewardsMustBeNonZero: "Null", + MathUnderflow: "Null", + MathOverflow: "Null", + NotEnoughShares: "Null", + TryingToLeaveTooSoon: "Null", + InconsistentState: "Null", + UnsufficientSharesForTransfer: "Null", + CandidateTransferingOwnSharesForbidden: "Null", + RequestCannotBeExecuted: "u16", + SwapResultsInZeroShares: "Null", + }, + }, + /** Lookup639: pallet_treasury::Proposal */ PalletTreasuryProposal: { proposer: "AccountId32", value: "u128", @@ -5372,7 +5608,7 @@ export default { bond: "u128", }, /** - * Lookup623: pallet_treasury::SpendStatus */ PalletTreasurySpendStatus: { @@ -5383,7 +5619,7 @@ export default { expireAt: "u32", status: "PalletTreasuryPaymentState", }, - /** Lookup624: pallet_treasury::PaymentState */ + /** Lookup642: pallet_treasury::PaymentState */ PalletTreasuryPaymentState: { _enum: { Pending: "Null", @@ -5393,9 +5629,9 @@ export default { Failed: "Null", }, }, - /** Lookup626: frame_support::PalletId */ + /** Lookup644: frame_support::PalletId */ FrameSupportPalletId: "[u8;8]", - /** Lookup627: pallet_treasury::pallet::Error */ + /** Lookup645: pallet_treasury::pallet::Error */ PalletTreasuryError: { _enum: [ "InvalidIndex", @@ -5412,7 +5648,7 @@ export default { ], }, /** - * Lookup629: pallet_conviction_voting::vote::Voting */ PalletConvictionVotingVoteVoting: { @@ -5421,20 +5657,20 @@ export default { Delegating: "PalletConvictionVotingVoteDelegating", }, }, - /** Lookup630: pallet_conviction_voting::vote::Casting */ + /** Lookup648: pallet_conviction_voting::vote::Casting */ PalletConvictionVotingVoteCasting: { votes: "Vec<(u32,PalletConvictionVotingVoteAccountVote)>", delegations: "PalletConvictionVotingDelegations", prior: "PalletConvictionVotingVotePriorLock", }, - /** Lookup634: pallet_conviction_voting::types::Delegations */ + /** Lookup652: pallet_conviction_voting::types::Delegations */ PalletConvictionVotingDelegations: { votes: "u128", capital: "u128", }, - /** Lookup635: pallet_conviction_voting::vote::PriorLock */ + /** Lookup653: pallet_conviction_voting::vote::PriorLock */ PalletConvictionVotingVotePriorLock: "(u32,u128)", - /** Lookup636: pallet_conviction_voting::vote::Delegating */ + /** Lookup654: pallet_conviction_voting::vote::Delegating */ PalletConvictionVotingVoteDelegating: { balance: "u128", target: "AccountId32", @@ -5442,7 +5678,7 @@ export default { delegations: "PalletConvictionVotingDelegations", prior: "PalletConvictionVotingVotePriorLock", }, - /** Lookup640: pallet_conviction_voting::pallet::Error */ + /** Lookup658: pallet_conviction_voting::pallet::Error */ PalletConvictionVotingError: { _enum: [ "NotOngoing", @@ -5460,7 +5696,7 @@ export default { ], }, /** - * Lookup641: pallet_referenda::types::ReferendumInfo, * Balance, pallet_conviction_voting::types::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5475,7 +5711,7 @@ export default { }, }, /** - * Lookup642: pallet_referenda::types::ReferendumStatus, * Balance, pallet_conviction_voting::types::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5492,17 +5728,17 @@ export default { inQueue: "bool", alarm: "Option<(u32,(u32,u32))>", }, - /** Lookup643: pallet_referenda::types::Deposit */ + /** Lookup661: pallet_referenda::types::Deposit */ PalletReferendaDeposit: { who: "AccountId32", amount: "u128", }, - /** Lookup646: pallet_referenda::types::DecidingStatus */ + /** Lookup664: pallet_referenda::types::DecidingStatus */ PalletReferendaDecidingStatus: { since: "u32", confirming: "Option", }, - /** Lookup654: pallet_referenda::types::TrackInfo */ + /** Lookup672: pallet_referenda::types::TrackInfo */ PalletReferendaTrackInfo: { name: "Text", maxDeciding: "u32", @@ -5514,7 +5750,7 @@ export default { minApproval: "PalletReferendaCurve", minSupport: "PalletReferendaCurve", }, - /** Lookup655: pallet_referenda::types::Curve */ + /** Lookup673: pallet_referenda::types::Curve */ PalletReferendaCurve: { _enum: { LinearDecreasing: { @@ -5535,7 +5771,7 @@ export default { }, }, }, - /** Lookup658: pallet_referenda::pallet::Error */ + /** Lookup676: pallet_referenda::pallet::Error */ PalletReferendaError: { _enum: [ "NotOngoing", @@ -5554,11 +5790,11 @@ export default { "PreimageStoredWithDifferentLength", ], }, - /** Lookup659: pallet_ranked_collective::MemberRecord */ + /** Lookup677: pallet_ranked_collective::MemberRecord */ PalletRankedCollectiveMemberRecord: { rank: "u16", }, - /** Lookup663: pallet_ranked_collective::pallet::Error */ + /** Lookup681: pallet_ranked_collective::pallet::Error */ PalletRankedCollectiveError: { _enum: [ "AlreadyMember", @@ -5575,7 +5811,7 @@ export default { ], }, /** - * Lookup664: pallet_referenda::types::ReferendumInfo, * Balance, pallet_ranked_collective::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5590,7 +5826,7 @@ export default { }, }, /** - * Lookup665: pallet_referenda::types::ReferendumStatus, * Balance, pallet_ranked_collective::Tally, sp_core::crypto::AccountId32, ScheduleAddress> */ @@ -5607,7 +5843,7 @@ export default { inQueue: "bool", alarm: "Option<(u32,(u32,u32))>", }, - /** Lookup668: pallet_whitelist::pallet::Error */ + /** Lookup686: pallet_whitelist::pallet::Error */ PalletWhitelistError: { _enum: [ "UnavailablePreImage", @@ -5617,7 +5853,7 @@ export default { "CallAlreadyWhitelisted", ], }, - /** Lookup669: polkadot_runtime_parachains::configuration::HostConfiguration */ + /** Lookup687: polkadot_runtime_parachains::configuration::HostConfiguration */ PolkadotRuntimeParachainsConfigurationHostConfiguration: { maxCodeSize: "u32", maxHeadDataSize: "u32", @@ -5655,16 +5891,16 @@ export default { approvalVotingParams: "PolkadotPrimitivesV8ApprovalVotingParams", schedulerParams: "PolkadotPrimitivesV8SchedulerParams", }, - /** Lookup672: polkadot_runtime_parachains::configuration::pallet::Error */ + /** Lookup690: polkadot_runtime_parachains::configuration::pallet::Error */ PolkadotRuntimeParachainsConfigurationPalletError: { _enum: ["InvalidNewValue"], }, - /** Lookup675: polkadot_runtime_parachains::shared::AllowedRelayParentsTracker */ + /** Lookup693: polkadot_runtime_parachains::shared::AllowedRelayParentsTracker */ PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker: { buffer: "Vec<(H256,H256)>", latestNumber: "u32", }, - /** Lookup679: polkadot_runtime_parachains::inclusion::CandidatePendingAvailability */ + /** Lookup697: polkadot_runtime_parachains::inclusion::CandidatePendingAvailability */ PolkadotRuntimeParachainsInclusionCandidatePendingAvailability: { _alias: { hash_: "hash", @@ -5679,7 +5915,7 @@ export default { backedInNumber: "u32", backingGroup: "u32", }, - /** Lookup680: polkadot_runtime_parachains::inclusion::pallet::Error */ + /** Lookup698: polkadot_runtime_parachains::inclusion::pallet::Error */ PolkadotRuntimeParachainsInclusionPalletError: { _enum: [ "ValidatorIndexOutOfBounds", @@ -5701,14 +5937,14 @@ export default { "ParaHeadMismatch", ], }, - /** Lookup681: polkadot_primitives::v8::ScrapedOnChainVotes */ + /** Lookup699: polkadot_primitives::v8::ScrapedOnChainVotes */ PolkadotPrimitivesV8ScrapedOnChainVotes: { session: "u32", backingValidatorsPerCandidate: "Vec<(PolkadotPrimitivesV8CandidateReceipt,Vec<(u32,PolkadotPrimitivesV8ValidityAttestation)>)>", disputes: "Vec", }, - /** Lookup686: polkadot_runtime_parachains::paras_inherent::pallet::Error */ + /** Lookup704: polkadot_runtime_parachains::paras_inherent::pallet::Error */ PolkadotRuntimeParachainsParasInherentPalletError: { _enum: [ "TooManyInclusionInherents", @@ -5718,20 +5954,20 @@ export default { "UnscheduledCandidate", ], }, - /** Lookup689: polkadot_runtime_parachains::scheduler::pallet::CoreOccupied */ + /** Lookup707: polkadot_runtime_parachains::scheduler::pallet::CoreOccupied */ PolkadotRuntimeParachainsSchedulerPalletCoreOccupied: { _enum: { Free: "Null", Paras: "PolkadotRuntimeParachainsSchedulerPalletParasEntry", }, }, - /** Lookup690: polkadot_runtime_parachains::scheduler::pallet::ParasEntry */ + /** Lookup708: polkadot_runtime_parachains::scheduler::pallet::ParasEntry */ PolkadotRuntimeParachainsSchedulerPalletParasEntry: { assignment: "PolkadotRuntimeParachainsSchedulerCommonAssignment", availabilityTimeouts: "u32", ttl: "u32", }, - /** Lookup691: polkadot_runtime_parachains::scheduler::common::Assignment */ + /** Lookup709: polkadot_runtime_parachains::scheduler::common::Assignment */ PolkadotRuntimeParachainsSchedulerCommonAssignment: { _enum: { Pool: { @@ -5741,7 +5977,7 @@ export default { Bulk: "u32", }, }, - /** Lookup696: polkadot_runtime_parachains::paras::PvfCheckActiveVoteState */ + /** Lookup714: polkadot_runtime_parachains::paras::PvfCheckActiveVoteState */ PolkadotRuntimeParachainsParasPvfCheckActiveVoteState: { votesAccept: "BitVec", votesReject: "BitVec", @@ -5749,7 +5985,7 @@ export default { createdAt: "u32", causes: "Vec", }, - /** Lookup698: polkadot_runtime_parachains::paras::PvfCheckCause */ + /** Lookup716: polkadot_runtime_parachains::paras::PvfCheckCause */ PolkadotRuntimeParachainsParasPvfCheckCause: { _enum: { Onboarding: "u32", @@ -5760,11 +5996,11 @@ export default { }, }, }, - /** Lookup699: polkadot_runtime_parachains::paras::UpgradeStrategy */ + /** Lookup717: polkadot_runtime_parachains::paras::UpgradeStrategy */ PolkadotRuntimeParachainsParasUpgradeStrategy: { _enum: ["SetGoAheadSignal", "ApplyAtExpectedBlock"], }, - /** Lookup701: polkadot_runtime_parachains::paras::ParaLifecycle */ + /** Lookup719: polkadot_runtime_parachains::paras::ParaLifecycle */ PolkadotRuntimeParachainsParasParaLifecycle: { _enum: [ "Onboarding", @@ -5776,25 +6012,25 @@ export default { "OffboardingParachain", ], }, - /** Lookup703: polkadot_runtime_parachains::paras::ParaPastCodeMeta */ + /** Lookup721: polkadot_runtime_parachains::paras::ParaPastCodeMeta */ PolkadotRuntimeParachainsParasParaPastCodeMeta: { upgradeTimes: "Vec", lastPruned: "Option", }, - /** Lookup705: polkadot_runtime_parachains::paras::ReplacementTimes */ + /** Lookup723: polkadot_runtime_parachains::paras::ReplacementTimes */ PolkadotRuntimeParachainsParasReplacementTimes: { expectedAt: "u32", activatedAt: "u32", }, - /** Lookup707: polkadot_primitives::v8::UpgradeGoAhead */ + /** Lookup725: polkadot_primitives::v8::UpgradeGoAhead */ PolkadotPrimitivesV8UpgradeGoAhead: { _enum: ["Abort", "GoAhead"], }, - /** Lookup708: polkadot_primitives::v8::UpgradeRestriction */ + /** Lookup726: polkadot_primitives::v8::UpgradeRestriction */ PolkadotPrimitivesV8UpgradeRestriction: { _enum: ["Present"], }, - /** Lookup709: polkadot_runtime_parachains::paras::pallet::Error */ + /** Lookup727: polkadot_runtime_parachains::paras::pallet::Error */ PolkadotRuntimeParachainsParasPalletError: { _enum: [ "NotRegistered", @@ -5812,18 +6048,18 @@ export default { "InvalidCode", ], }, - /** Lookup711: polkadot_runtime_parachains::initializer::BufferedSessionChange */ + /** Lookup729: polkadot_runtime_parachains::initializer::BufferedSessionChange */ PolkadotRuntimeParachainsInitializerBufferedSessionChange: { validators: "Vec", queued: "Vec", sessionIndex: "u32", }, - /** Lookup713: polkadot_core_primitives::InboundDownwardMessage */ + /** Lookup731: polkadot_core_primitives::InboundDownwardMessage */ PolkadotCorePrimitivesInboundDownwardMessage: { sentAt: "u32", msg: "Bytes", }, - /** Lookup714: polkadot_runtime_parachains::hrmp::HrmpOpenChannelRequest */ + /** Lookup732: polkadot_runtime_parachains::hrmp::HrmpOpenChannelRequest */ PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest: { confirmed: "bool", age: "u32", @@ -5832,7 +6068,7 @@ export default { maxCapacity: "u32", maxTotalSize: "u32", }, - /** Lookup716: polkadot_runtime_parachains::hrmp::HrmpChannel */ + /** Lookup734: polkadot_runtime_parachains::hrmp::HrmpChannel */ PolkadotRuntimeParachainsHrmpHrmpChannel: { maxCapacity: "u32", maxTotalSize: "u32", @@ -5843,12 +6079,12 @@ export default { senderDeposit: "u128", recipientDeposit: "u128", }, - /** Lookup718: polkadot_core_primitives::InboundHrmpMessage */ + /** Lookup736: polkadot_core_primitives::InboundHrmpMessage */ PolkadotCorePrimitivesInboundHrmpMessage: { sentAt: "u32", data: "Bytes", }, - /** Lookup721: polkadot_runtime_parachains::hrmp::pallet::Error */ + /** Lookup739: polkadot_runtime_parachains::hrmp::pallet::Error */ PolkadotRuntimeParachainsHrmpPalletError: { _enum: [ "OpenHrmpChannelToSelf", @@ -5873,7 +6109,7 @@ export default { "ChannelCreationNotAuthorized", ], }, - /** Lookup723: polkadot_primitives::v8::SessionInfo */ + /** Lookup741: polkadot_primitives::v8::SessionInfo */ PolkadotPrimitivesV8SessionInfo: { activeValidatorIndices: "Vec", randomSeed: "[u8;32]", @@ -5890,20 +6126,20 @@ export default { neededApprovals: "u32", }, /** - * Lookup724: polkadot_primitives::v8::IndexedVec */ PolkadotPrimitivesV8IndexedVecValidatorIndex: "Vec", - /** Lookup725: polkadot_primitives::v8::IndexedVec */ + /** Lookup743: polkadot_primitives::v8::IndexedVec */ PolkadotPrimitivesV8IndexedVecGroupIndex: "Vec>", - /** Lookup727: polkadot_primitives::v8::DisputeState */ + /** Lookup745: polkadot_primitives::v8::DisputeState */ PolkadotPrimitivesV8DisputeState: { validatorsFor: "BitVec", validatorsAgainst: "BitVec", start: "u32", concludedAt: "Option", }, - /** Lookup729: polkadot_runtime_parachains::disputes::pallet::Error */ + /** Lookup747: polkadot_runtime_parachains::disputes::pallet::Error */ PolkadotRuntimeParachainsDisputesPalletError: { _enum: [ "DuplicateDisputeStatementSets", @@ -5917,7 +6153,7 @@ export default { "UnconfirmedDispute", ], }, - /** Lookup730: polkadot_primitives::v8::slashing::PendingSlashes */ + /** Lookup748: polkadot_primitives::v8::slashing::PendingSlashes */ PolkadotPrimitivesV8SlashingPendingSlashes: { _alias: { keys_: "keys", @@ -5925,7 +6161,7 @@ export default { keys_: "BTreeMap", kind: "PolkadotPrimitivesV8SlashingSlashingOffenceKind", }, - /** Lookup734: polkadot_runtime_parachains::disputes::slashing::pallet::Error */ + /** Lookup752: polkadot_runtime_parachains::disputes::slashing::pallet::Error */ PolkadotRuntimeParachainsDisputesSlashingPalletError: { _enum: [ "InvalidKeyOwnershipProof", @@ -5936,7 +6172,7 @@ export default { "DuplicateSlashingReport", ], }, - /** Lookup735: pallet_message_queue::BookState */ + /** Lookup753: pallet_message_queue::BookState */ PalletMessageQueueBookState: { _alias: { size_: "size", @@ -5948,12 +6184,12 @@ export default { messageCount: "u64", size_: "u64", }, - /** Lookup737: pallet_message_queue::Neighbours */ + /** Lookup755: pallet_message_queue::Neighbours */ PalletMessageQueueNeighbours: { prev: "DancelightRuntimeAggregateMessageOrigin", next: "DancelightRuntimeAggregateMessageOrigin", }, - /** Lookup739: pallet_message_queue::Page */ + /** Lookup757: pallet_message_queue::Page */ PalletMessageQueuePage: { remaining: "u32", remainingSize: "u32", @@ -5962,7 +6198,7 @@ export default { last: "u32", heap: "Bytes", }, - /** Lookup741: pallet_message_queue::pallet::Error */ + /** Lookup759: pallet_message_queue::pallet::Error */ PalletMessageQueueError: { _enum: [ "NotReapable", @@ -5976,38 +6212,38 @@ export default { "RecursiveDisallowed", ], }, - /** Lookup742: polkadot_runtime_parachains::on_demand::types::CoreAffinityCount */ + /** Lookup760: polkadot_runtime_parachains::on_demand::types::CoreAffinityCount */ PolkadotRuntimeParachainsOnDemandTypesCoreAffinityCount: { coreIndex: "u32", count: "u32", }, - /** Lookup743: polkadot_runtime_parachains::on_demand::types::QueueStatusType */ + /** Lookup761: polkadot_runtime_parachains::on_demand::types::QueueStatusType */ PolkadotRuntimeParachainsOnDemandTypesQueueStatusType: { traffic: "u128", nextIndex: "u32", smallestIndex: "u32", freedIndices: "BinaryHeapReverseQueueIndex", }, - /** Lookup745: BinaryHeap */ + /** Lookup763: BinaryHeap */ BinaryHeapReverseQueueIndex: "Vec", - /** Lookup748: BinaryHeap */ + /** Lookup766: BinaryHeap */ BinaryHeapEnqueuedOrder: "Vec", - /** Lookup749: polkadot_runtime_parachains::on_demand::types::EnqueuedOrder */ + /** Lookup767: polkadot_runtime_parachains::on_demand::types::EnqueuedOrder */ PolkadotRuntimeParachainsOnDemandTypesEnqueuedOrder: { paraId: "u32", idx: "u32", }, - /** Lookup753: polkadot_runtime_parachains::on_demand::pallet::Error */ + /** Lookup771: polkadot_runtime_parachains::on_demand::pallet::Error */ PolkadotRuntimeParachainsOnDemandPalletError: { _enum: ["QueueFull", "SpotPriceHigherThanMaxAmount"], }, - /** Lookup754: polkadot_runtime_common::paras_registrar::ParaInfo */ + /** Lookup772: polkadot_runtime_common::paras_registrar::ParaInfo */ PolkadotRuntimeCommonParasRegistrarParaInfo: { manager: "AccountId32", deposit: "u128", locked: "Option", }, - /** Lookup756: polkadot_runtime_common::paras_registrar::pallet::Error */ + /** Lookup774: polkadot_runtime_common::paras_registrar::pallet::Error */ PolkadotRuntimeCommonParasRegistrarPalletError: { _enum: [ "NotRegistered", @@ -6026,12 +6262,12 @@ export default { "CannotSwap", ], }, - /** Lookup757: pallet_utility::pallet::Error */ + /** Lookup775: pallet_utility::pallet::Error */ PalletUtilityError: { _enum: ["TooManyCalls"], }, /** - * Lookup759: pallet_identity::types::Registration> */ PalletIdentityRegistration: { @@ -6039,18 +6275,18 @@ export default { deposit: "u128", info: "PalletIdentityLegacyIdentityInfo", }, - /** Lookup768: pallet_identity::types::RegistrarInfo */ + /** Lookup786: pallet_identity::types::RegistrarInfo */ PalletIdentityRegistrarInfo: { account: "AccountId32", fee: "u128", fields: "u64", }, - /** Lookup770: pallet_identity::types::AuthorityProperties> */ + /** Lookup788: pallet_identity::types::AuthorityProperties> */ PalletIdentityAuthorityProperties: { suffix: "Bytes", allocation: "u32", }, - /** Lookup772: pallet_identity::pallet::Error */ + /** Lookup790: pallet_identity::pallet::Error */ PalletIdentityError: { _enum: [ "TooManySubAccounts", @@ -6082,7 +6318,7 @@ export default { ], }, /** - * Lookup775: pallet_scheduler::Scheduled, * BlockNumber, dancelight_runtime::OriginCaller, sp_core::crypto::AccountId32> */ @@ -6093,29 +6329,29 @@ export default { maybePeriodic: "Option<(u32,u32)>", origin: "DancelightRuntimeOriginCaller", }, - /** Lookup777: pallet_scheduler::RetryConfig */ + /** Lookup795: pallet_scheduler::RetryConfig */ PalletSchedulerRetryConfig: { totalRetries: "u8", remaining: "u8", period: "u32", }, - /** Lookup778: pallet_scheduler::pallet::Error */ + /** Lookup796: pallet_scheduler::pallet::Error */ PalletSchedulerError: { _enum: ["FailedToSchedule", "NotFound", "TargetBlockNumberInPast", "RescheduleNoChange", "Named"], }, - /** Lookup781: pallet_proxy::ProxyDefinition */ + /** Lookup799: pallet_proxy::ProxyDefinition */ PalletProxyProxyDefinition: { delegate: "AccountId32", proxyType: "DancelightRuntimeProxyType", delay: "u32", }, - /** Lookup785: pallet_proxy::Announcement */ + /** Lookup803: pallet_proxy::Announcement */ PalletProxyAnnouncement: { real: "AccountId32", callHash: "H256", height: "u32", }, - /** Lookup787: pallet_proxy::pallet::Error */ + /** Lookup805: pallet_proxy::pallet::Error */ PalletProxyError: { _enum: [ "TooMany", @@ -6128,14 +6364,14 @@ export default { "NoSelfProxy", ], }, - /** Lookup789: pallet_multisig::Multisig */ + /** Lookup807: pallet_multisig::Multisig */ PalletMultisigMultisig: { when: "PalletMultisigTimepoint", deposit: "u128", depositor: "AccountId32", approvals: "Vec", }, - /** Lookup791: pallet_multisig::pallet::Error */ + /** Lookup809: pallet_multisig::pallet::Error */ PalletMultisigError: { _enum: [ "MinimumThreshold", @@ -6154,7 +6390,7 @@ export default { "AlreadyStored", ], }, - /** Lookup792: pallet_preimage::OldRequestStatus */ + /** Lookup810: pallet_preimage::OldRequestStatus */ PalletPreimageOldRequestStatus: { _enum: { Unrequested: { @@ -6169,7 +6405,7 @@ export default { }, }, /** - * Lookup795: pallet_preimage::RequestStatus> */ PalletPreimageRequestStatus: { @@ -6185,7 +6421,7 @@ export default { }, }, }, - /** Lookup800: pallet_preimage::pallet::Error */ + /** Lookup818: pallet_preimage::pallet::Error */ PalletPreimageError: { _enum: [ "TooBig", @@ -6198,11 +6434,11 @@ export default { "TooFew", ], }, - /** Lookup801: pallet_asset_rate::pallet::Error */ + /** Lookup819: pallet_asset_rate::pallet::Error */ PalletAssetRateError: { _enum: ["UnknownAssetKind", "AlreadyExists", "Overflow"], }, - /** Lookup802: pallet_xcm::pallet::QueryStatus */ + /** Lookup820: pallet_xcm::pallet::QueryStatus */ PalletXcmQueryStatus: { _enum: { Pending: { @@ -6221,7 +6457,7 @@ export default { }, }, }, - /** Lookup806: xcm::VersionedResponse */ + /** Lookup824: xcm::VersionedResponse */ XcmVersionedResponse: { _enum: { __Unused0: "Null", @@ -6231,7 +6467,7 @@ export default { V4: "StagingXcmV4Response", }, }, - /** Lookup812: pallet_xcm::pallet::VersionMigrationStage */ + /** Lookup830: pallet_xcm::pallet::VersionMigrationStage */ PalletXcmVersionMigrationStage: { _enum: { MigrateSupportedVersion: "Null", @@ -6240,14 +6476,14 @@ export default { MigrateAndNotifyOldTargets: "Null", }, }, - /** Lookup814: pallet_xcm::pallet::RemoteLockedFungibleRecord */ + /** Lookup832: pallet_xcm::pallet::RemoteLockedFungibleRecord */ PalletXcmRemoteLockedFungibleRecord: { amount: "u128", owner: "XcmVersionedLocation", locker: "XcmVersionedLocation", consumers: "Vec<(Null,u128)>", }, - /** Lookup821: pallet_xcm::pallet::Error */ + /** Lookup839: pallet_xcm::pallet::Error */ PalletXcmError: { _enum: [ "Unreachable", @@ -6277,7 +6513,7 @@ export default { "LocalExecutionIncomplete", ], }, - /** Lookup822: snowbridge_pallet_inbound_queue::pallet::Error */ + /** Lookup840: snowbridge_pallet_inbound_queue::pallet::Error */ SnowbridgePalletInboundQueueError: { _enum: { InvalidGateway: "Null", @@ -6293,11 +6529,11 @@ export default { ConvertMessage: "SnowbridgeRouterPrimitivesInboundConvertMessageError", }, }, - /** Lookup823: snowbridge_core::inbound::VerificationError */ + /** Lookup841: snowbridge_core::inbound::VerificationError */ SnowbridgeCoreInboundVerificationError: { _enum: ["HeaderNotFound", "LogNotFound", "InvalidLog", "InvalidProof", "InvalidExecutionProof"], }, - /** Lookup824: snowbridge_pallet_inbound_queue::pallet::SendError */ + /** Lookup842: snowbridge_pallet_inbound_queue::pallet::SendError */ SnowbridgePalletInboundQueueSendError: { _enum: [ "NotApplicable", @@ -6309,11 +6545,11 @@ export default { "Fees", ], }, - /** Lookup825: snowbridge_router_primitives::inbound::ConvertMessageError */ + /** Lookup843: snowbridge_router_primitives::inbound::ConvertMessageError */ SnowbridgeRouterPrimitivesInboundConvertMessageError: { _enum: ["UnsupportedVersion", "InvalidDestination", "InvalidToken", "UnsupportedFeeAsset", "CannotReanchor"], }, - /** Lookup827: snowbridge_pallet_outbound_queue::types::CommittedMessage */ + /** Lookup845: snowbridge_pallet_outbound_queue::types::CommittedMessage */ SnowbridgePalletOutboundQueueCommittedMessage: { channelId: "SnowbridgeCoreChannelId", nonce: "Compact", @@ -6324,16 +6560,16 @@ export default { reward: "Compact", id: "H256", }, - /** Lookup828: snowbridge_pallet_outbound_queue::pallet::Error */ + /** Lookup846: snowbridge_pallet_outbound_queue::pallet::Error */ SnowbridgePalletOutboundQueueError: { _enum: ["MessageTooLarge", "Halted", "InvalidChannel"], }, - /** Lookup829: snowbridge_core::Channel */ + /** Lookup847: snowbridge_core::Channel */ SnowbridgeCoreChannel: { agentId: "H256", paraId: "u32", }, - /** Lookup830: snowbridge_pallet_system::pallet::Error */ + /** Lookup848: snowbridge_pallet_system::pallet::Error */ SnowbridgePalletSystemError: { _enum: { LocationConversionFailed: "Null", @@ -6349,15 +6585,15 @@ export default { InvalidUpgradeParameters: "Null", }, }, - /** Lookup831: snowbridge_core::outbound::SendError */ + /** Lookup849: snowbridge_core::outbound::SendError */ SnowbridgeCoreOutboundSendError: { _enum: ["MessageTooLarge", "Halted", "InvalidChannel"], }, - /** Lookup832: pallet_migrations::pallet::Error */ + /** Lookup850: pallet_migrations::pallet::Error */ PalletMigrationsError: { _enum: ["PreimageMissing", "WrongUpperBound", "PreimageIsTooBig", "PreimageAlreadyExists"], }, - /** Lookup836: pallet_beefy::pallet::Error */ + /** Lookup854: pallet_beefy::pallet::Error */ PalletBeefyError: { _enum: [ "InvalidKeyOwnershipProof", @@ -6369,43 +6605,43 @@ export default { "InvalidConfiguration", ], }, - /** Lookup837: sp_consensus_beefy::mmr::BeefyAuthoritySet */ + /** Lookup855: sp_consensus_beefy::mmr::BeefyAuthoritySet */ SpConsensusBeefyMmrBeefyAuthoritySet: { id: "u64", len: "u32", keysetCommitment: "H256", }, - /** Lookup838: snowbridge_beacon_primitives::types::CompactBeaconState */ + /** Lookup856: snowbridge_beacon_primitives::types::CompactBeaconState */ SnowbridgeBeaconPrimitivesCompactBeaconState: { slot: "Compact", blockRootsRoot: "H256", }, - /** Lookup839: snowbridge_beacon_primitives::types::SyncCommitteePrepared */ + /** Lookup857: snowbridge_beacon_primitives::types::SyncCommitteePrepared */ SnowbridgeBeaconPrimitivesSyncCommitteePrepared: { root: "H256", - pubkeys: "[Lookup841;512]", + pubkeys: "[Lookup859;512]", aggregatePubkey: "SnowbridgeMilagroBlsKeysPublicKey", }, - /** Lookup841: snowbridge_milagro_bls::keys::PublicKey */ + /** Lookup859: snowbridge_milagro_bls::keys::PublicKey */ SnowbridgeMilagroBlsKeysPublicKey: { point: "SnowbridgeAmclBls381Ecp", }, - /** Lookup842: snowbridge_amcl::bls381::ecp::ECP */ + /** Lookup860: snowbridge_amcl::bls381::ecp::ECP */ SnowbridgeAmclBls381Ecp: { x: "SnowbridgeAmclBls381Fp", y: "SnowbridgeAmclBls381Fp", z: "SnowbridgeAmclBls381Fp", }, - /** Lookup843: snowbridge_amcl::bls381::fp::FP */ + /** Lookup861: snowbridge_amcl::bls381::fp::FP */ SnowbridgeAmclBls381Fp: { x: "SnowbridgeAmclBls381Big", xes: "i32", }, - /** Lookup844: snowbridge_amcl::bls381::big::Big */ + /** Lookup862: snowbridge_amcl::bls381::big::Big */ SnowbridgeAmclBls381Big: { w: "[i32;14]", }, - /** Lookup847: snowbridge_beacon_primitives::types::ForkVersions */ + /** Lookup865: snowbridge_beacon_primitives::types::ForkVersions */ SnowbridgeBeaconPrimitivesForkVersions: { genesis: "SnowbridgeBeaconPrimitivesFork", altair: "SnowbridgeBeaconPrimitivesFork", @@ -6413,12 +6649,12 @@ export default { capella: "SnowbridgeBeaconPrimitivesFork", deneb: "SnowbridgeBeaconPrimitivesFork", }, - /** Lookup848: snowbridge_beacon_primitives::types::Fork */ + /** Lookup866: snowbridge_beacon_primitives::types::Fork */ SnowbridgeBeaconPrimitivesFork: { version: "[u8;4]", epoch: "u64", }, - /** Lookup849: snowbridge_pallet_ethereum_client::pallet::Error */ + /** Lookup867: snowbridge_pallet_ethereum_client::pallet::Error */ SnowbridgePalletEthereumClientError: { _enum: { SkippedSyncCommitteePeriod: "Null", @@ -6448,11 +6684,11 @@ export default { Halted: "Null", }, }, - /** Lookup850: snowbridge_beacon_primitives::bls::BlsError */ + /** Lookup868: snowbridge_beacon_primitives::bls::BlsError */ SnowbridgeBeaconPrimitivesBlsBlsError: { _enum: ["InvalidSignature", "InvalidPublicKey", "InvalidAggregatePublicKeys", "SignatureVerificationFailed"], }, - /** Lookup851: polkadot_runtime_common::paras_sudo_wrapper::pallet::Error */ + /** Lookup869: polkadot_runtime_common::paras_sudo_wrapper::pallet::Error */ PolkadotRuntimeCommonParasSudoWrapperPalletError: { _enum: [ "ParaDoesntExist", @@ -6466,32 +6702,32 @@ export default { "TooManyCores", ], }, - /** Lookup852: pallet_sudo::pallet::Error */ + /** Lookup870: pallet_sudo::pallet::Error */ PalletSudoError: { _enum: ["RequireSudo"], }, - /** Lookup855: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender */ + /** Lookup873: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender */ FrameSystemExtensionsCheckNonZeroSender: "Null", - /** Lookup856: frame_system::extensions::check_spec_version::CheckSpecVersion */ + /** Lookup874: frame_system::extensions::check_spec_version::CheckSpecVersion */ FrameSystemExtensionsCheckSpecVersion: "Null", - /** Lookup857: frame_system::extensions::check_tx_version::CheckTxVersion */ + /** Lookup875: frame_system::extensions::check_tx_version::CheckTxVersion */ FrameSystemExtensionsCheckTxVersion: "Null", - /** Lookup858: frame_system::extensions::check_genesis::CheckGenesis */ + /** Lookup876: frame_system::extensions::check_genesis::CheckGenesis */ FrameSystemExtensionsCheckGenesis: "Null", - /** Lookup861: frame_system::extensions::check_nonce::CheckNonce */ + /** Lookup879: frame_system::extensions::check_nonce::CheckNonce */ FrameSystemExtensionsCheckNonce: "Compact", - /** Lookup862: frame_system::extensions::check_weight::CheckWeight */ + /** Lookup880: frame_system::extensions::check_weight::CheckWeight */ FrameSystemExtensionsCheckWeight: "Null", - /** Lookup863: pallet_transaction_payment::ChargeTransactionPayment */ + /** Lookup881: pallet_transaction_payment::ChargeTransactionPayment */ PalletTransactionPaymentChargeTransactionPayment: "Compact", - /** Lookup864: frame_metadata_hash_extension::CheckMetadataHash */ + /** Lookup882: frame_metadata_hash_extension::CheckMetadataHash */ FrameMetadataHashExtensionCheckMetadataHash: { mode: "FrameMetadataHashExtensionMode", }, - /** Lookup865: frame_metadata_hash_extension::Mode */ + /** Lookup883: frame_metadata_hash_extension::Mode */ FrameMetadataHashExtensionMode: { _enum: ["Disabled", "Enabled"], }, - /** Lookup866: dancelight_runtime::Runtime */ + /** Lookup884: dancelight_runtime::Runtime */ DancelightRuntimeRuntime: "Null", }; diff --git a/typescript-api/src/dancelight/interfaces/registry.ts b/typescript-api/src/dancelight/interfaces/registry.ts index 5b0e81a5f..af1cd63c0 100644 --- a/typescript-api/src/dancelight/interfaces/registry.ts +++ b/typescript-api/src/dancelight/interfaces/registry.ts @@ -161,6 +161,17 @@ import type { PalletOffencesEvent, PalletParametersCall, PalletParametersEvent, + PalletPooledStakingAllTargetPool, + PalletPooledStakingCall, + PalletPooledStakingCandidateEligibleCandidate, + PalletPooledStakingError, + PalletPooledStakingEvent, + PalletPooledStakingHoldReason, + PalletPooledStakingPendingOperationKey, + PalletPooledStakingPendingOperationQuery, + PalletPooledStakingPoolsKey, + PalletPooledStakingSharesOrStake, + PalletPooledStakingTargetPool, PalletPreimageCall, PalletPreimageError, PalletPreimageEvent, @@ -650,6 +661,17 @@ declare module "@polkadot/types/types/registry" { PalletOffencesEvent: PalletOffencesEvent; PalletParametersCall: PalletParametersCall; PalletParametersEvent: PalletParametersEvent; + PalletPooledStakingAllTargetPool: PalletPooledStakingAllTargetPool; + PalletPooledStakingCall: PalletPooledStakingCall; + PalletPooledStakingCandidateEligibleCandidate: PalletPooledStakingCandidateEligibleCandidate; + PalletPooledStakingError: PalletPooledStakingError; + PalletPooledStakingEvent: PalletPooledStakingEvent; + PalletPooledStakingHoldReason: PalletPooledStakingHoldReason; + PalletPooledStakingPendingOperationKey: PalletPooledStakingPendingOperationKey; + PalletPooledStakingPendingOperationQuery: PalletPooledStakingPendingOperationQuery; + PalletPooledStakingPoolsKey: PalletPooledStakingPoolsKey; + PalletPooledStakingSharesOrStake: PalletPooledStakingSharesOrStake; + PalletPooledStakingTargetPool: PalletPooledStakingTargetPool; PalletPreimageCall: PalletPreimageCall; PalletPreimageError: PalletPreimageError; PalletPreimageEvent: PalletPreimageEvent; diff --git a/typescript-api/src/dancelight/interfaces/types-lookup.ts b/typescript-api/src/dancelight/interfaces/types-lookup.ts index 30cba9bfc..240124e2a 100644 --- a/typescript-api/src/dancelight/interfaces/types-lookup.ts +++ b/typescript-api/src/dancelight/interfaces/types-lookup.ts @@ -707,7 +707,139 @@ declare module "@polkadot/types/lookup" { readonly type: "RewardedOrchestrator" | "RewardedContainer"; } - /** @name PalletTreasuryEvent (64) */ + /** @name PalletPooledStakingEvent (64) */ + interface PalletPooledStakingEvent extends Enum { + readonly isUpdatedCandidatePosition: boolean; + readonly asUpdatedCandidatePosition: { + readonly candidate: AccountId32; + readonly stake: u128; + readonly selfDelegation: u128; + readonly before: Option; + readonly after: Option; + } & Struct; + readonly isRequestedDelegate: boolean; + readonly asRequestedDelegate: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly pool: PalletPooledStakingTargetPool; + readonly pending: u128; + } & Struct; + readonly isExecutedDelegate: boolean; + readonly asExecutedDelegate: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly pool: PalletPooledStakingTargetPool; + readonly staked: u128; + readonly released: u128; + } & Struct; + readonly isRequestedUndelegate: boolean; + readonly asRequestedUndelegate: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly from: PalletPooledStakingTargetPool; + readonly pending: u128; + readonly released: u128; + } & Struct; + readonly isExecutedUndelegate: boolean; + readonly asExecutedUndelegate: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly released: u128; + } & Struct; + readonly isIncreasedStake: boolean; + readonly asIncreasedStake: { + readonly candidate: AccountId32; + readonly stakeDiff: u128; + } & Struct; + readonly isDecreasedStake: boolean; + readonly asDecreasedStake: { + readonly candidate: AccountId32; + readonly stakeDiff: u128; + } & Struct; + readonly isStakedAutoCompounding: boolean; + readonly asStakedAutoCompounding: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly shares: u128; + readonly stake: u128; + } & Struct; + readonly isUnstakedAutoCompounding: boolean; + readonly asUnstakedAutoCompounding: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly shares: u128; + readonly stake: u128; + } & Struct; + readonly isStakedManualRewards: boolean; + readonly asStakedManualRewards: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly shares: u128; + readonly stake: u128; + } & Struct; + readonly isUnstakedManualRewards: boolean; + readonly asUnstakedManualRewards: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly shares: u128; + readonly stake: u128; + } & Struct; + readonly isRewardedCollator: boolean; + readonly asRewardedCollator: { + readonly collator: AccountId32; + readonly autoCompoundingRewards: u128; + readonly manualClaimRewards: u128; + } & Struct; + readonly isRewardedDelegators: boolean; + readonly asRewardedDelegators: { + readonly collator: AccountId32; + readonly autoCompoundingRewards: u128; + readonly manualClaimRewards: u128; + } & Struct; + readonly isClaimedManualRewards: boolean; + readonly asClaimedManualRewards: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly rewards: u128; + } & Struct; + readonly isSwappedPool: boolean; + readonly asSwappedPool: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly sourcePool: PalletPooledStakingTargetPool; + readonly sourceShares: u128; + readonly sourceStake: u128; + readonly targetShares: u128; + readonly targetStake: u128; + readonly pendingLeaving: u128; + readonly released: u128; + } & Struct; + readonly type: + | "UpdatedCandidatePosition" + | "RequestedDelegate" + | "ExecutedDelegate" + | "RequestedUndelegate" + | "ExecutedUndelegate" + | "IncreasedStake" + | "DecreasedStake" + | "StakedAutoCompounding" + | "UnstakedAutoCompounding" + | "StakedManualRewards" + | "UnstakedManualRewards" + | "RewardedCollator" + | "RewardedDelegators" + | "ClaimedManualRewards" + | "SwappedPool"; + } + + /** @name PalletPooledStakingTargetPool (66) */ + interface PalletPooledStakingTargetPool extends Enum { + readonly isAutoCompounding: boolean; + readonly isManualRewards: boolean; + readonly type: "AutoCompounding" | "ManualRewards"; + } + + /** @name PalletTreasuryEvent (67) */ interface PalletTreasuryEvent extends Enum { readonly isSpending: boolean; readonly asSpending: { @@ -784,7 +916,7 @@ declare module "@polkadot/types/lookup" { | "SpendProcessed"; } - /** @name PalletConvictionVotingEvent (66) */ + /** @name PalletConvictionVotingEvent (69) */ interface PalletConvictionVotingEvent extends Enum { readonly isDelegated: boolean; readonly asDelegated: ITuple<[AccountId32, AccountId32]>; @@ -803,7 +935,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Delegated" | "Undelegated" | "Voted" | "VoteRemoved"; } - /** @name PalletConvictionVotingVoteAccountVote (67) */ + /** @name PalletConvictionVotingVoteAccountVote (70) */ interface PalletConvictionVotingVoteAccountVote extends Enum { readonly isStandard: boolean; readonly asStandard: { @@ -824,7 +956,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Standard" | "Split" | "SplitAbstain"; } - /** @name PalletReferendaEvent (69) */ + /** @name PalletReferendaEvent (72) */ interface PalletReferendaEvent extends Enum { readonly isSubmitted: boolean; readonly asSubmitted: { @@ -928,7 +1060,7 @@ declare module "@polkadot/types/lookup" { | "MetadataCleared"; } - /** @name FrameSupportPreimagesBounded (71) */ + /** @name FrameSupportPreimagesBounded (74) */ interface FrameSupportPreimagesBounded extends Enum { readonly isLegacy: boolean; readonly asLegacy: { @@ -944,7 +1076,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Legacy" | "Inline" | "Lookup"; } - /** @name FrameSystemCall (73) */ + /** @name FrameSystemCall (76) */ interface FrameSystemCall extends Enum { readonly isRemark: boolean; readonly asRemark: { @@ -1005,7 +1137,7 @@ declare module "@polkadot/types/lookup" { | "ApplyAuthorizedUpgrade"; } - /** @name PalletBabeCall (77) */ + /** @name PalletBabeCall (80) */ interface PalletBabeCall extends Enum { readonly isReportEquivocation: boolean; readonly asReportEquivocation: { @@ -1024,7 +1156,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ReportEquivocation" | "ReportEquivocationUnsigned" | "PlanConfigChange"; } - /** @name SpConsensusSlotsEquivocationProof (78) */ + /** @name SpConsensusSlotsEquivocationProof (81) */ interface SpConsensusSlotsEquivocationProof extends Struct { readonly offender: SpConsensusBabeAppPublic; readonly slot: u64; @@ -1032,7 +1164,7 @@ declare module "@polkadot/types/lookup" { readonly secondHeader: SpRuntimeHeader; } - /** @name SpRuntimeHeader (79) */ + /** @name SpRuntimeHeader (82) */ interface SpRuntimeHeader extends Struct { readonly parentHash: H256; readonly number: Compact; @@ -1041,17 +1173,17 @@ declare module "@polkadot/types/lookup" { readonly digest: SpRuntimeDigest; } - /** @name SpConsensusBabeAppPublic (81) */ + /** @name SpConsensusBabeAppPublic (84) */ interface SpConsensusBabeAppPublic extends U8aFixed {} - /** @name SpSessionMembershipProof (82) */ + /** @name SpSessionMembershipProof (85) */ interface SpSessionMembershipProof extends Struct { readonly session: u32; readonly trieNodes: Vec; readonly validatorCount: u32; } - /** @name SpConsensusBabeDigestsNextConfigDescriptor (83) */ + /** @name SpConsensusBabeDigestsNextConfigDescriptor (86) */ interface SpConsensusBabeDigestsNextConfigDescriptor extends Enum { readonly isV1: boolean; readonly asV1: { @@ -1061,7 +1193,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V1"; } - /** @name SpConsensusBabeAllowedSlots (85) */ + /** @name SpConsensusBabeAllowedSlots (88) */ interface SpConsensusBabeAllowedSlots extends Enum { readonly isPrimarySlots: boolean; readonly isPrimaryAndSecondaryPlainSlots: boolean; @@ -1069,7 +1201,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PrimarySlots" | "PrimaryAndSecondaryPlainSlots" | "PrimaryAndSecondaryVRFSlots"; } - /** @name PalletTimestampCall (86) */ + /** @name PalletTimestampCall (89) */ interface PalletTimestampCall extends Enum { readonly isSet: boolean; readonly asSet: { @@ -1078,7 +1210,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Set"; } - /** @name PalletBalancesCall (87) */ + /** @name PalletBalancesCall (90) */ interface PalletBalancesCall extends Enum { readonly isTransferAllowDeath: boolean; readonly asTransferAllowDeath: { @@ -1137,14 +1269,14 @@ declare module "@polkadot/types/lookup" { | "Burn"; } - /** @name PalletBalancesAdjustmentDirection (93) */ + /** @name PalletBalancesAdjustmentDirection (96) */ interface PalletBalancesAdjustmentDirection extends Enum { readonly isIncrease: boolean; readonly isDecrease: boolean; readonly type: "Increase" | "Decrease"; } - /** @name PalletParametersCall (94) */ + /** @name PalletParametersCall (97) */ interface PalletParametersCall extends Enum { readonly isSetParameter: boolean; readonly asSetParameter: { @@ -1153,14 +1285,14 @@ declare module "@polkadot/types/lookup" { readonly type: "SetParameter"; } - /** @name DancelightRuntimeRuntimeParameters (95) */ + /** @name DancelightRuntimeRuntimeParameters (98) */ interface DancelightRuntimeRuntimeParameters extends Enum { readonly isPreimage: boolean; readonly asPreimage: DancelightRuntimeDynamicParamsPreimageParameters; readonly type: "Preimage"; } - /** @name DancelightRuntimeDynamicParamsPreimageParameters (96) */ + /** @name DancelightRuntimeDynamicParamsPreimageParameters (99) */ interface DancelightRuntimeDynamicParamsPreimageParameters extends Enum { readonly isBaseDeposit: boolean; readonly asBaseDeposit: ITuple<[DancelightRuntimeDynamicParamsPreimageBaseDeposit, Option]>; @@ -1169,7 +1301,7 @@ declare module "@polkadot/types/lookup" { readonly type: "BaseDeposit" | "ByteDeposit"; } - /** @name PalletRegistrarCall (97) */ + /** @name PalletRegistrarCall (100) */ interface PalletRegistrarCall extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -1239,7 +1371,7 @@ declare module "@polkadot/types/lookup" { | "DeregisterWithRelayProof"; } - /** @name DpContainerChainGenesisDataContainerChainGenesisData (98) */ + /** @name DpContainerChainGenesisDataContainerChainGenesisData (101) */ interface DpContainerChainGenesisDataContainerChainGenesisData extends Struct { readonly storage: Vec; readonly name: Bytes; @@ -1249,42 +1381,42 @@ declare module "@polkadot/types/lookup" { readonly properties: DpContainerChainGenesisDataProperties; } - /** @name DpContainerChainGenesisDataContainerChainGenesisDataItem (100) */ + /** @name DpContainerChainGenesisDataContainerChainGenesisDataItem (103) */ interface DpContainerChainGenesisDataContainerChainGenesisDataItem extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name DpContainerChainGenesisDataProperties (102) */ + /** @name DpContainerChainGenesisDataProperties (105) */ interface DpContainerChainGenesisDataProperties extends Struct { readonly tokenMetadata: DpContainerChainGenesisDataTokenMetadata; readonly isEthereum: bool; } - /** @name DpContainerChainGenesisDataTokenMetadata (103) */ + /** @name DpContainerChainGenesisDataTokenMetadata (106) */ interface DpContainerChainGenesisDataTokenMetadata extends Struct { readonly tokenSymbol: Bytes; readonly ss58Format: u32; readonly tokenDecimals: u32; } - /** @name TpTraitsSlotFrequency (107) */ + /** @name TpTraitsSlotFrequency (110) */ interface TpTraitsSlotFrequency extends Struct { readonly min: u32; readonly max: u32; } - /** @name TpTraitsParathreadParams (109) */ + /** @name TpTraitsParathreadParams (112) */ interface TpTraitsParathreadParams extends Struct { readonly slotFrequency: TpTraitsSlotFrequency; } - /** @name SpTrieStorageProof (110) */ + /** @name SpTrieStorageProof (113) */ interface SpTrieStorageProof extends Struct { readonly trieNodes: BTreeSet; } - /** @name SpRuntimeMultiSignature (112) */ + /** @name SpRuntimeMultiSignature (115) */ interface SpRuntimeMultiSignature extends Enum { readonly isEd25519: boolean; readonly asEd25519: U8aFixed; @@ -1295,7 +1427,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ed25519" | "Sr25519" | "Ecdsa"; } - /** @name PalletConfigurationCall (115) */ + /** @name PalletConfigurationCall (118) */ interface PalletConfigurationCall extends Enum { readonly isSetMaxCollators: boolean; readonly asSetMaxCollators: { @@ -1350,7 +1482,7 @@ declare module "@polkadot/types/lookup" { | "SetBypassConsistencyCheck"; } - /** @name PalletInvulnerablesCall (117) */ + /** @name PalletInvulnerablesCall (120) */ interface PalletInvulnerablesCall extends Enum { readonly isAddInvulnerable: boolean; readonly asAddInvulnerable: { @@ -1363,13 +1495,13 @@ declare module "@polkadot/types/lookup" { readonly type: "AddInvulnerable" | "RemoveInvulnerable"; } - /** @name PalletCollatorAssignmentCall (118) */ + /** @name PalletCollatorAssignmentCall (121) */ type PalletCollatorAssignmentCall = Null; - /** @name PalletAuthorityAssignmentCall (119) */ + /** @name PalletAuthorityAssignmentCall (122) */ type PalletAuthorityAssignmentCall = Null; - /** @name PalletAuthorNotingCall (120) */ + /** @name PalletAuthorNotingCall (123) */ interface PalletAuthorNotingCall extends Enum { readonly isSetLatestAuthorData: boolean; readonly asSetLatestAuthorData: { @@ -1389,7 +1521,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SetLatestAuthorData" | "SetAuthor" | "KillAuthorData"; } - /** @name PalletServicesPaymentCall (121) */ + /** @name PalletServicesPaymentCall (124) */ interface PalletServicesPaymentCall extends Enum { readonly isPurchaseCredits: boolean; readonly asPurchaseCredits: { @@ -1436,7 +1568,7 @@ declare module "@polkadot/types/lookup" { | "SetMaxTip"; } - /** @name PalletDataPreserversCall (122) */ + /** @name PalletDataPreserversCall (125) */ interface PalletDataPreserversCall extends Enum { readonly isCreateProfile: boolean; readonly asCreateProfile: { @@ -1494,7 +1626,7 @@ declare module "@polkadot/types/lookup" { | "ForceStartAssignment"; } - /** @name PalletDataPreserversProfile (123) */ + /** @name PalletDataPreserversProfile (126) */ interface PalletDataPreserversProfile extends Struct { readonly url: Bytes; readonly paraIds: PalletDataPreserversParaIdsFilter; @@ -1502,7 +1634,7 @@ declare module "@polkadot/types/lookup" { readonly assignmentRequest: DancelightRuntimePreserversAssignmentPaymentRequest; } - /** @name PalletDataPreserversParaIdsFilter (125) */ + /** @name PalletDataPreserversParaIdsFilter (128) */ interface PalletDataPreserversParaIdsFilter extends Enum { readonly isAnyParaId: boolean; readonly isWhitelist: boolean; @@ -1512,7 +1644,7 @@ declare module "@polkadot/types/lookup" { readonly type: "AnyParaId" | "Whitelist" | "Blacklist"; } - /** @name PalletDataPreserversProfileMode (129) */ + /** @name PalletDataPreserversProfileMode (132) */ interface PalletDataPreserversProfileMode extends Enum { readonly isBootnode: boolean; readonly isRpc: boolean; @@ -1522,25 +1654,25 @@ declare module "@polkadot/types/lookup" { readonly type: "Bootnode" | "Rpc"; } - /** @name DancelightRuntimePreserversAssignmentPaymentRequest (130) */ + /** @name DancelightRuntimePreserversAssignmentPaymentRequest (133) */ interface DancelightRuntimePreserversAssignmentPaymentRequest extends Enum { readonly isFree: boolean; readonly type: "Free"; } - /** @name DancelightRuntimePreserversAssignmentPaymentExtra (131) */ + /** @name DancelightRuntimePreserversAssignmentPaymentExtra (134) */ interface DancelightRuntimePreserversAssignmentPaymentExtra extends Enum { readonly isFree: boolean; readonly type: "Free"; } - /** @name DancelightRuntimePreserversAssignmentPaymentWitness (132) */ + /** @name DancelightRuntimePreserversAssignmentPaymentWitness (135) */ interface DancelightRuntimePreserversAssignmentPaymentWitness extends Enum { readonly isFree: boolean; readonly type: "Free"; } - /** @name PalletExternalValidatorsCall (133) */ + /** @name PalletExternalValidatorsCall (136) */ interface PalletExternalValidatorsCall extends Enum { readonly isSkipExternalValidators: boolean; readonly asSkipExternalValidators: { @@ -1561,7 +1693,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SkipExternalValidators" | "AddWhitelisted" | "RemoveWhitelisted" | "ForceEra"; } - /** @name PalletExternalValidatorSlashesCall (134) */ + /** @name PalletExternalValidatorSlashesCall (137) */ interface PalletExternalValidatorSlashesCall extends Enum { readonly isCancelDeferredSlash: boolean; readonly asCancelDeferredSlash: { @@ -1583,7 +1715,7 @@ declare module "@polkadot/types/lookup" { readonly type: "CancelDeferredSlash" | "ForceInjectSlash" | "RootTestSendMsgToEth"; } - /** @name PalletSessionCall (136) */ + /** @name PalletSessionCall (139) */ interface PalletSessionCall extends Enum { readonly isSetKeys: boolean; readonly asSetKeys: { @@ -1594,7 +1726,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SetKeys" | "PurgeKeys"; } - /** @name DancelightRuntimeSessionKeys (137) */ + /** @name DancelightRuntimeSessionKeys (140) */ interface DancelightRuntimeSessionKeys extends Struct { readonly grandpa: SpConsensusGrandpaAppPublic; readonly babe: SpConsensusBabeAppPublic; @@ -1605,22 +1737,22 @@ declare module "@polkadot/types/lookup" { readonly nimbus: NimbusPrimitivesNimbusCryptoPublic; } - /** @name PolkadotPrimitivesV8ValidatorAppPublic (138) */ + /** @name PolkadotPrimitivesV8ValidatorAppPublic (141) */ interface PolkadotPrimitivesV8ValidatorAppPublic extends U8aFixed {} - /** @name PolkadotPrimitivesV8AssignmentAppPublic (139) */ + /** @name PolkadotPrimitivesV8AssignmentAppPublic (142) */ interface PolkadotPrimitivesV8AssignmentAppPublic extends U8aFixed {} - /** @name SpAuthorityDiscoveryAppPublic (140) */ + /** @name SpAuthorityDiscoveryAppPublic (143) */ interface SpAuthorityDiscoveryAppPublic extends U8aFixed {} - /** @name SpConsensusBeefyEcdsaCryptoPublic (141) */ + /** @name SpConsensusBeefyEcdsaCryptoPublic (144) */ interface SpConsensusBeefyEcdsaCryptoPublic extends U8aFixed {} - /** @name NimbusPrimitivesNimbusCryptoPublic (143) */ + /** @name NimbusPrimitivesNimbusCryptoPublic (146) */ interface NimbusPrimitivesNimbusCryptoPublic extends U8aFixed {} - /** @name PalletGrandpaCall (144) */ + /** @name PalletGrandpaCall (147) */ interface PalletGrandpaCall extends Enum { readonly isReportEquivocation: boolean; readonly asReportEquivocation: { @@ -1640,13 +1772,13 @@ declare module "@polkadot/types/lookup" { readonly type: "ReportEquivocation" | "ReportEquivocationUnsigned" | "NoteStalled"; } - /** @name SpConsensusGrandpaEquivocationProof (145) */ + /** @name SpConsensusGrandpaEquivocationProof (148) */ interface SpConsensusGrandpaEquivocationProof extends Struct { readonly setId: u64; readonly equivocation: SpConsensusGrandpaEquivocation; } - /** @name SpConsensusGrandpaEquivocation (146) */ + /** @name SpConsensusGrandpaEquivocation (149) */ interface SpConsensusGrandpaEquivocation extends Enum { readonly isPrevote: boolean; readonly asPrevote: FinalityGrandpaEquivocationPrevote; @@ -1655,7 +1787,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Prevote" | "Precommit"; } - /** @name FinalityGrandpaEquivocationPrevote (147) */ + /** @name FinalityGrandpaEquivocationPrevote (150) */ interface FinalityGrandpaEquivocationPrevote extends Struct { readonly roundNumber: u64; readonly identity: SpConsensusGrandpaAppPublic; @@ -1663,16 +1795,16 @@ declare module "@polkadot/types/lookup" { readonly second: ITuple<[FinalityGrandpaPrevote, SpConsensusGrandpaAppSignature]>; } - /** @name FinalityGrandpaPrevote (148) */ + /** @name FinalityGrandpaPrevote (151) */ interface FinalityGrandpaPrevote extends Struct { readonly targetHash: H256; readonly targetNumber: u32; } - /** @name SpConsensusGrandpaAppSignature (149) */ + /** @name SpConsensusGrandpaAppSignature (152) */ interface SpConsensusGrandpaAppSignature extends U8aFixed {} - /** @name FinalityGrandpaEquivocationPrecommit (151) */ + /** @name FinalityGrandpaEquivocationPrecommit (154) */ interface FinalityGrandpaEquivocationPrecommit extends Struct { readonly roundNumber: u64; readonly identity: SpConsensusGrandpaAppPublic; @@ -1680,13 +1812,105 @@ declare module "@polkadot/types/lookup" { readonly second: ITuple<[FinalityGrandpaPrecommit, SpConsensusGrandpaAppSignature]>; } - /** @name FinalityGrandpaPrecommit (152) */ + /** @name FinalityGrandpaPrecommit (155) */ interface FinalityGrandpaPrecommit extends Struct { readonly targetHash: H256; readonly targetNumber: u32; } - /** @name PalletTreasuryCall (154) */ + /** @name PalletPooledStakingCall (157) */ + interface PalletPooledStakingCall extends Enum { + readonly isRebalanceHold: boolean; + readonly asRebalanceHold: { + readonly candidate: AccountId32; + readonly delegator: AccountId32; + readonly pool: PalletPooledStakingAllTargetPool; + } & Struct; + readonly isRequestDelegate: boolean; + readonly asRequestDelegate: { + readonly candidate: AccountId32; + readonly pool: PalletPooledStakingTargetPool; + readonly stake: u128; + } & Struct; + readonly isExecutePendingOperations: boolean; + readonly asExecutePendingOperations: { + readonly operations: Vec; + } & Struct; + readonly isRequestUndelegate: boolean; + readonly asRequestUndelegate: { + readonly candidate: AccountId32; + readonly pool: PalletPooledStakingTargetPool; + readonly amount: PalletPooledStakingSharesOrStake; + } & Struct; + readonly isClaimManualRewards: boolean; + readonly asClaimManualRewards: { + readonly pairs: Vec>; + } & Struct; + readonly isUpdateCandidatePosition: boolean; + readonly asUpdateCandidatePosition: { + readonly candidates: Vec; + } & Struct; + readonly isSwapPool: boolean; + readonly asSwapPool: { + readonly candidate: AccountId32; + readonly sourcePool: PalletPooledStakingTargetPool; + readonly amount: PalletPooledStakingSharesOrStake; + } & Struct; + readonly type: + | "RebalanceHold" + | "RequestDelegate" + | "ExecutePendingOperations" + | "RequestUndelegate" + | "ClaimManualRewards" + | "UpdateCandidatePosition" + | "SwapPool"; + } + + /** @name PalletPooledStakingAllTargetPool (158) */ + interface PalletPooledStakingAllTargetPool extends Enum { + readonly isJoining: boolean; + readonly isAutoCompounding: boolean; + readonly isManualRewards: boolean; + readonly isLeaving: boolean; + readonly type: "Joining" | "AutoCompounding" | "ManualRewards" | "Leaving"; + } + + /** @name PalletPooledStakingPendingOperationQuery (160) */ + interface PalletPooledStakingPendingOperationQuery extends Struct { + readonly delegator: AccountId32; + readonly operation: PalletPooledStakingPendingOperationKey; + } + + /** @name PalletPooledStakingPendingOperationKey (161) */ + interface PalletPooledStakingPendingOperationKey extends Enum { + readonly isJoiningAutoCompounding: boolean; + readonly asJoiningAutoCompounding: { + readonly candidate: AccountId32; + readonly at: u32; + } & Struct; + readonly isJoiningManualRewards: boolean; + readonly asJoiningManualRewards: { + readonly candidate: AccountId32; + readonly at: u32; + } & Struct; + readonly isLeaving: boolean; + readonly asLeaving: { + readonly candidate: AccountId32; + readonly at: u32; + } & Struct; + readonly type: "JoiningAutoCompounding" | "JoiningManualRewards" | "Leaving"; + } + + /** @name PalletPooledStakingSharesOrStake (162) */ + interface PalletPooledStakingSharesOrStake extends Enum { + readonly isShares: boolean; + readonly asShares: u128; + readonly isStake: boolean; + readonly asStake: u128; + readonly type: "Shares" | "Stake"; + } + + /** @name PalletTreasuryCall (165) */ interface PalletTreasuryCall extends Enum { readonly isSpendLocal: boolean; readonly asSpendLocal: { @@ -1719,7 +1943,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SpendLocal" | "RemoveApproval" | "Spend" | "Payout" | "CheckStatus" | "VoidSpend"; } - /** @name PalletConvictionVotingCall (156) */ + /** @name PalletConvictionVotingCall (166) */ interface PalletConvictionVotingCall extends Enum { readonly isVote: boolean; readonly asVote: { @@ -1756,7 +1980,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Vote" | "Delegate" | "Undelegate" | "Unlock" | "RemoveVote" | "RemoveOtherVote"; } - /** @name PalletConvictionVotingConviction (157) */ + /** @name PalletConvictionVotingConviction (167) */ interface PalletConvictionVotingConviction extends Enum { readonly isNone: boolean; readonly isLocked1x: boolean; @@ -1768,7 +1992,7 @@ declare module "@polkadot/types/lookup" { readonly type: "None" | "Locked1x" | "Locked2x" | "Locked3x" | "Locked4x" | "Locked5x" | "Locked6x"; } - /** @name PalletReferendaCall (159) */ + /** @name PalletReferendaCall (169) */ interface PalletReferendaCall extends Enum { readonly isSubmit: boolean; readonly asSubmit: { @@ -1821,7 +2045,7 @@ declare module "@polkadot/types/lookup" { | "SetMetadata"; } - /** @name DancelightRuntimeOriginCaller (160) */ + /** @name DancelightRuntimeOriginCaller (170) */ interface DancelightRuntimeOriginCaller extends Enum { readonly isSystem: boolean; readonly asSystem: FrameSupportDispatchRawOrigin; @@ -1835,7 +2059,7 @@ declare module "@polkadot/types/lookup" { readonly type: "System" | "Void" | "Origins" | "ParachainsOrigin" | "XcmPallet"; } - /** @name FrameSupportDispatchRawOrigin (161) */ + /** @name FrameSupportDispatchRawOrigin (171) */ interface FrameSupportDispatchRawOrigin extends Enum { readonly isRoot: boolean; readonly isSigned: boolean; @@ -1844,7 +2068,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Root" | "Signed" | "None"; } - /** @name DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin (162) */ + /** @name DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin (172) */ interface DancelightRuntimeGovernanceOriginsPalletCustomOriginsOrigin extends Enum { readonly isStakingAdmin: boolean; readonly isTreasurer: boolean; @@ -1903,14 +2127,14 @@ declare module "@polkadot/types/lookup" { | "Fellowship9Dan"; } - /** @name PolkadotRuntimeParachainsOriginPalletOrigin (163) */ + /** @name PolkadotRuntimeParachainsOriginPalletOrigin (173) */ interface PolkadotRuntimeParachainsOriginPalletOrigin extends Enum { readonly isParachain: boolean; readonly asParachain: u32; readonly type: "Parachain"; } - /** @name PalletXcmOrigin (164) */ + /** @name PalletXcmOrigin (174) */ interface PalletXcmOrigin extends Enum { readonly isXcm: boolean; readonly asXcm: StagingXcmV4Location; @@ -1919,13 +2143,13 @@ declare module "@polkadot/types/lookup" { readonly type: "Xcm" | "Response"; } - /** @name StagingXcmV4Location (165) */ + /** @name StagingXcmV4Location (175) */ interface StagingXcmV4Location extends Struct { readonly parents: u8; readonly interior: StagingXcmV4Junctions; } - /** @name StagingXcmV4Junctions (166) */ + /** @name StagingXcmV4Junctions (176) */ interface StagingXcmV4Junctions extends Enum { readonly isHere: boolean; readonly isX1: boolean; @@ -1947,7 +2171,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Here" | "X1" | "X2" | "X3" | "X4" | "X5" | "X6" | "X7" | "X8"; } - /** @name StagingXcmV4Junction (168) */ + /** @name StagingXcmV4Junction (178) */ interface StagingXcmV4Junction extends Enum { readonly isParachain: boolean; readonly asParachain: Compact; @@ -1996,7 +2220,7 @@ declare module "@polkadot/types/lookup" { | "GlobalConsensus"; } - /** @name StagingXcmV4JunctionNetworkId (170) */ + /** @name StagingXcmV4JunctionNetworkId (180) */ interface StagingXcmV4JunctionNetworkId extends Enum { readonly isByGenesis: boolean; readonly asByGenesis: U8aFixed; @@ -2031,7 +2255,7 @@ declare module "@polkadot/types/lookup" { | "PolkadotBulletin"; } - /** @name XcmV3JunctionBodyId (171) */ + /** @name XcmV3JunctionBodyId (181) */ interface XcmV3JunctionBodyId extends Enum { readonly isUnit: boolean; readonly isMoniker: boolean; @@ -2058,7 +2282,7 @@ declare module "@polkadot/types/lookup" { | "Treasury"; } - /** @name XcmV3JunctionBodyPart (172) */ + /** @name XcmV3JunctionBodyPart (182) */ interface XcmV3JunctionBodyPart extends Enum { readonly isVoice: boolean; readonly isMembers: boolean; @@ -2083,10 +2307,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Voice" | "Members" | "Fraction" | "AtLeastProportion" | "MoreThanProportion"; } - /** @name SpCoreVoid (180) */ + /** @name SpCoreVoid (190) */ type SpCoreVoid = Null; - /** @name FrameSupportScheduleDispatchTime (181) */ + /** @name FrameSupportScheduleDispatchTime (191) */ interface FrameSupportScheduleDispatchTime extends Enum { readonly isAt: boolean; readonly asAt: u32; @@ -2095,7 +2319,7 @@ declare module "@polkadot/types/lookup" { readonly type: "At" | "After"; } - /** @name PalletRankedCollectiveCall (183) */ + /** @name PalletRankedCollectiveCall (193) */ interface PalletRankedCollectiveCall extends Enum { readonly isAddMember: boolean; readonly asAddMember: { @@ -2139,7 +2363,7 @@ declare module "@polkadot/types/lookup" { | "ExchangeMember"; } - /** @name PalletWhitelistCall (185) */ + /** @name PalletWhitelistCall (195) */ interface PalletWhitelistCall extends Enum { readonly isWhitelistCall: boolean; readonly asWhitelistCall: { @@ -2166,7 +2390,7 @@ declare module "@polkadot/types/lookup" { | "DispatchWhitelistedCallWithPreimage"; } - /** @name PolkadotRuntimeParachainsConfigurationPalletCall (186) */ + /** @name PolkadotRuntimeParachainsConfigurationPalletCall (196) */ interface PolkadotRuntimeParachainsConfigurationPalletCall extends Enum { readonly isSetValidationUpgradeCooldown: boolean; readonly asSetValidationUpgradeCooldown: { @@ -2412,16 +2636,16 @@ declare module "@polkadot/types/lookup" { | "SetSchedulerParams"; } - /** @name PolkadotPrimitivesV8AsyncBackingAsyncBackingParams (187) */ + /** @name PolkadotPrimitivesV8AsyncBackingAsyncBackingParams (197) */ interface PolkadotPrimitivesV8AsyncBackingAsyncBackingParams extends Struct { readonly maxCandidateDepth: u32; readonly allowedAncestryLen: u32; } - /** @name PolkadotPrimitivesV8ExecutorParams (188) */ + /** @name PolkadotPrimitivesV8ExecutorParams (198) */ interface PolkadotPrimitivesV8ExecutorParams extends Vec {} - /** @name PolkadotPrimitivesV8ExecutorParamsExecutorParam (190) */ + /** @name PolkadotPrimitivesV8ExecutorParamsExecutorParam (200) */ interface PolkadotPrimitivesV8ExecutorParamsExecutorParam extends Enum { readonly isMaxMemoryPages: boolean; readonly asMaxMemoryPages: u32; @@ -2446,26 +2670,26 @@ declare module "@polkadot/types/lookup" { | "WasmExtBulkMemory"; } - /** @name PolkadotPrimitivesV8PvfPrepKind (191) */ + /** @name PolkadotPrimitivesV8PvfPrepKind (201) */ interface PolkadotPrimitivesV8PvfPrepKind extends Enum { readonly isPrecheck: boolean; readonly isPrepare: boolean; readonly type: "Precheck" | "Prepare"; } - /** @name PolkadotPrimitivesV8PvfExecKind (192) */ + /** @name PolkadotPrimitivesV8PvfExecKind (202) */ interface PolkadotPrimitivesV8PvfExecKind extends Enum { readonly isBacking: boolean; readonly isApproval: boolean; readonly type: "Backing" | "Approval"; } - /** @name PolkadotPrimitivesV8ApprovalVotingParams (193) */ + /** @name PolkadotPrimitivesV8ApprovalVotingParams (203) */ interface PolkadotPrimitivesV8ApprovalVotingParams extends Struct { readonly maxApprovalCoalesceCount: u32; } - /** @name PolkadotPrimitivesV8SchedulerParams (194) */ + /** @name PolkadotPrimitivesV8SchedulerParams (204) */ interface PolkadotPrimitivesV8SchedulerParams extends Struct { readonly groupRotationFrequency: u32; readonly parasAvailabilityPeriod: u32; @@ -2480,13 +2704,13 @@ declare module "@polkadot/types/lookup" { readonly ttl: u32; } - /** @name PolkadotRuntimeParachainsSharedPalletCall (195) */ + /** @name PolkadotRuntimeParachainsSharedPalletCall (205) */ type PolkadotRuntimeParachainsSharedPalletCall = Null; - /** @name PolkadotRuntimeParachainsInclusionPalletCall (196) */ + /** @name PolkadotRuntimeParachainsInclusionPalletCall (206) */ type PolkadotRuntimeParachainsInclusionPalletCall = Null; - /** @name PolkadotRuntimeParachainsParasInherentPalletCall (197) */ + /** @name PolkadotRuntimeParachainsParasInherentPalletCall (207) */ interface PolkadotRuntimeParachainsParasInherentPalletCall extends Enum { readonly isEnter: boolean; readonly asEnter: { @@ -2495,7 +2719,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Enter"; } - /** @name PolkadotPrimitivesV8InherentData (198) */ + /** @name PolkadotPrimitivesV8InherentData (208) */ interface PolkadotPrimitivesV8InherentData extends Struct { readonly bitfields: Vec; readonly backedCandidates: Vec; @@ -2503,33 +2727,33 @@ declare module "@polkadot/types/lookup" { readonly parentHeader: SpRuntimeHeader; } - /** @name PolkadotPrimitivesV8SignedUncheckedSigned (200) */ + /** @name PolkadotPrimitivesV8SignedUncheckedSigned (210) */ interface PolkadotPrimitivesV8SignedUncheckedSigned extends Struct { readonly payload: BitVec; readonly validatorIndex: u32; readonly signature: PolkadotPrimitivesV8ValidatorAppSignature; } - /** @name BitvecOrderLsb0 (203) */ + /** @name BitvecOrderLsb0 (213) */ type BitvecOrderLsb0 = Null; - /** @name PolkadotPrimitivesV8ValidatorAppSignature (205) */ + /** @name PolkadotPrimitivesV8ValidatorAppSignature (215) */ interface PolkadotPrimitivesV8ValidatorAppSignature extends U8aFixed {} - /** @name PolkadotPrimitivesV8BackedCandidate (207) */ + /** @name PolkadotPrimitivesV8BackedCandidate (217) */ interface PolkadotPrimitivesV8BackedCandidate extends Struct { readonly candidate: PolkadotPrimitivesV8CommittedCandidateReceipt; readonly validityVotes: Vec; readonly validatorIndices: BitVec; } - /** @name PolkadotPrimitivesV8CommittedCandidateReceipt (208) */ + /** @name PolkadotPrimitivesV8CommittedCandidateReceipt (218) */ interface PolkadotPrimitivesV8CommittedCandidateReceipt extends Struct { readonly descriptor: PolkadotPrimitivesV8CandidateDescriptor; readonly commitments: PolkadotPrimitivesV8CandidateCommitments; } - /** @name PolkadotPrimitivesV8CandidateDescriptor (209) */ + /** @name PolkadotPrimitivesV8CandidateDescriptor (219) */ interface PolkadotPrimitivesV8CandidateDescriptor extends Struct { readonly paraId: u32; readonly relayParent: H256; @@ -2542,13 +2766,13 @@ declare module "@polkadot/types/lookup" { readonly validationCodeHash: H256; } - /** @name PolkadotPrimitivesV8CollatorAppPublic (210) */ + /** @name PolkadotPrimitivesV8CollatorAppPublic (220) */ interface PolkadotPrimitivesV8CollatorAppPublic extends U8aFixed {} - /** @name PolkadotPrimitivesV8CollatorAppSignature (211) */ + /** @name PolkadotPrimitivesV8CollatorAppSignature (221) */ interface PolkadotPrimitivesV8CollatorAppSignature extends U8aFixed {} - /** @name PolkadotPrimitivesV8CandidateCommitments (213) */ + /** @name PolkadotPrimitivesV8CandidateCommitments (223) */ interface PolkadotPrimitivesV8CandidateCommitments extends Struct { readonly upwardMessages: Vec; readonly horizontalMessages: Vec; @@ -2558,13 +2782,13 @@ declare module "@polkadot/types/lookup" { readonly hrmpWatermark: u32; } - /** @name PolkadotCorePrimitivesOutboundHrmpMessage (216) */ + /** @name PolkadotCorePrimitivesOutboundHrmpMessage (226) */ interface PolkadotCorePrimitivesOutboundHrmpMessage extends Struct { readonly recipient: u32; readonly data: Bytes; } - /** @name PolkadotPrimitivesV8ValidityAttestation (221) */ + /** @name PolkadotPrimitivesV8ValidityAttestation (231) */ interface PolkadotPrimitivesV8ValidityAttestation extends Enum { readonly isImplicit: boolean; readonly asImplicit: PolkadotPrimitivesV8ValidatorAppSignature; @@ -2573,7 +2797,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Implicit" | "Explicit"; } - /** @name PolkadotPrimitivesV8DisputeStatementSet (223) */ + /** @name PolkadotPrimitivesV8DisputeStatementSet (233) */ interface PolkadotPrimitivesV8DisputeStatementSet extends Struct { readonly candidateHash: H256; readonly session: u32; @@ -2582,7 +2806,7 @@ declare module "@polkadot/types/lookup" { >; } - /** @name PolkadotPrimitivesV8DisputeStatement (227) */ + /** @name PolkadotPrimitivesV8DisputeStatement (237) */ interface PolkadotPrimitivesV8DisputeStatement extends Enum { readonly isValid: boolean; readonly asValid: PolkadotPrimitivesV8ValidDisputeStatementKind; @@ -2591,7 +2815,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Valid" | "Invalid"; } - /** @name PolkadotPrimitivesV8ValidDisputeStatementKind (228) */ + /** @name PolkadotPrimitivesV8ValidDisputeStatementKind (238) */ interface PolkadotPrimitivesV8ValidDisputeStatementKind extends Enum { readonly isExplicit: boolean; readonly isBackingSeconded: boolean; @@ -2609,13 +2833,13 @@ declare module "@polkadot/types/lookup" { | "ApprovalCheckingMultipleCandidates"; } - /** @name PolkadotPrimitivesV8InvalidDisputeStatementKind (230) */ + /** @name PolkadotPrimitivesV8InvalidDisputeStatementKind (240) */ interface PolkadotPrimitivesV8InvalidDisputeStatementKind extends Enum { readonly isExplicit: boolean; readonly type: "Explicit"; } - /** @name PolkadotRuntimeParachainsParasPalletCall (231) */ + /** @name PolkadotRuntimeParachainsParasPalletCall (241) */ interface PolkadotRuntimeParachainsParasPalletCall extends Enum { readonly isForceSetCurrentCode: boolean; readonly asForceSetCurrentCode: { @@ -2672,7 +2896,7 @@ declare module "@polkadot/types/lookup" { | "ForceSetMostRecentContext"; } - /** @name PolkadotPrimitivesV8PvfCheckStatement (232) */ + /** @name PolkadotPrimitivesV8PvfCheckStatement (242) */ interface PolkadotPrimitivesV8PvfCheckStatement extends Struct { readonly accept: bool; readonly subject: H256; @@ -2680,7 +2904,7 @@ declare module "@polkadot/types/lookup" { readonly validatorIndex: u32; } - /** @name PolkadotRuntimeParachainsInitializerPalletCall (233) */ + /** @name PolkadotRuntimeParachainsInitializerPalletCall (243) */ interface PolkadotRuntimeParachainsInitializerPalletCall extends Enum { readonly isForceApprove: boolean; readonly asForceApprove: { @@ -2689,7 +2913,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ForceApprove"; } - /** @name PolkadotRuntimeParachainsHrmpPalletCall (234) */ + /** @name PolkadotRuntimeParachainsHrmpPalletCall (244) */ interface PolkadotRuntimeParachainsHrmpPalletCall extends Enum { readonly isHrmpInitOpenChannel: boolean; readonly asHrmpInitOpenChannel: { @@ -2759,19 +2983,19 @@ declare module "@polkadot/types/lookup" { | "EstablishChannelWithSystem"; } - /** @name PolkadotParachainPrimitivesPrimitivesHrmpChannelId (235) */ + /** @name PolkadotParachainPrimitivesPrimitivesHrmpChannelId (245) */ interface PolkadotParachainPrimitivesPrimitivesHrmpChannelId extends Struct { readonly sender: u32; readonly recipient: u32; } - /** @name PolkadotRuntimeParachainsDisputesPalletCall (236) */ + /** @name PolkadotRuntimeParachainsDisputesPalletCall (246) */ interface PolkadotRuntimeParachainsDisputesPalletCall extends Enum { readonly isForceUnfreeze: boolean; readonly type: "ForceUnfreeze"; } - /** @name PolkadotRuntimeParachainsDisputesSlashingPalletCall (237) */ + /** @name PolkadotRuntimeParachainsDisputesSlashingPalletCall (247) */ interface PolkadotRuntimeParachainsDisputesSlashingPalletCall extends Enum { readonly isReportDisputeLostUnsigned: boolean; readonly asReportDisputeLostUnsigned: { @@ -2781,7 +3005,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ReportDisputeLostUnsigned"; } - /** @name PolkadotPrimitivesV8SlashingDisputeProof (238) */ + /** @name PolkadotPrimitivesV8SlashingDisputeProof (248) */ interface PolkadotPrimitivesV8SlashingDisputeProof extends Struct { readonly timeSlot: PolkadotPrimitivesV8SlashingDisputesTimeSlot; readonly kind: PolkadotPrimitivesV8SlashingSlashingOffenceKind; @@ -2789,20 +3013,20 @@ declare module "@polkadot/types/lookup" { readonly validatorId: PolkadotPrimitivesV8ValidatorAppPublic; } - /** @name PolkadotPrimitivesV8SlashingDisputesTimeSlot (239) */ + /** @name PolkadotPrimitivesV8SlashingDisputesTimeSlot (249) */ interface PolkadotPrimitivesV8SlashingDisputesTimeSlot extends Struct { readonly sessionIndex: u32; readonly candidateHash: H256; } - /** @name PolkadotPrimitivesV8SlashingSlashingOffenceKind (240) */ + /** @name PolkadotPrimitivesV8SlashingSlashingOffenceKind (250) */ interface PolkadotPrimitivesV8SlashingSlashingOffenceKind extends Enum { readonly isForInvalid: boolean; readonly isAgainstValid: boolean; readonly type: "ForInvalid" | "AgainstValid"; } - /** @name PalletMessageQueueCall (241) */ + /** @name PalletMessageQueueCall (251) */ interface PalletMessageQueueCall extends Enum { readonly isReapPage: boolean; readonly asReapPage: { @@ -2819,7 +3043,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ReapPage" | "ExecuteOverweight"; } - /** @name DancelightRuntimeAggregateMessageOrigin (242) */ + /** @name DancelightRuntimeAggregateMessageOrigin (252) */ interface DancelightRuntimeAggregateMessageOrigin extends Enum { readonly isUmp: boolean; readonly asUmp: PolkadotRuntimeParachainsInclusionUmpQueueId; @@ -2830,17 +3054,17 @@ declare module "@polkadot/types/lookup" { readonly type: "Ump" | "Snowbridge" | "SnowbridgeTanssi"; } - /** @name PolkadotRuntimeParachainsInclusionUmpQueueId (243) */ + /** @name PolkadotRuntimeParachainsInclusionUmpQueueId (253) */ interface PolkadotRuntimeParachainsInclusionUmpQueueId extends Enum { readonly isPara: boolean; readonly asPara: u32; readonly type: "Para"; } - /** @name SnowbridgeCoreChannelId (244) */ + /** @name SnowbridgeCoreChannelId (254) */ interface SnowbridgeCoreChannelId extends U8aFixed {} - /** @name PolkadotRuntimeParachainsOnDemandPalletCall (245) */ + /** @name PolkadotRuntimeParachainsOnDemandPalletCall (255) */ interface PolkadotRuntimeParachainsOnDemandPalletCall extends Enum { readonly isPlaceOrderAllowDeath: boolean; readonly asPlaceOrderAllowDeath: { @@ -2855,7 +3079,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PlaceOrderAllowDeath" | "PlaceOrderKeepAlive"; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletCall (246) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletCall (256) */ interface PolkadotRuntimeCommonParasRegistrarPalletCall extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -2911,7 +3135,7 @@ declare module "@polkadot/types/lookup" { | "SetCurrentHead"; } - /** @name PalletUtilityCall (247) */ + /** @name PalletUtilityCall (257) */ interface PalletUtilityCall extends Enum { readonly isBatch: boolean; readonly asBatch: { @@ -2943,7 +3167,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Batch" | "AsDerivative" | "BatchAll" | "DispatchAs" | "ForceBatch" | "WithWeight"; } - /** @name PalletIdentityCall (249) */ + /** @name PalletIdentityCall (259) */ interface PalletIdentityCall extends Enum { readonly isAddRegistrar: boolean; readonly asAddRegistrar: { @@ -3065,7 +3289,7 @@ declare module "@polkadot/types/lookup" { | "RemoveDanglingUsername"; } - /** @name PalletIdentityLegacyIdentityInfo (250) */ + /** @name PalletIdentityLegacyIdentityInfo (260) */ interface PalletIdentityLegacyIdentityInfo extends Struct { readonly additional: Vec>; readonly display: Data; @@ -3078,7 +3302,7 @@ declare module "@polkadot/types/lookup" { readonly twitter: Data; } - /** @name PalletIdentityJudgement (287) */ + /** @name PalletIdentityJudgement (297) */ interface PalletIdentityJudgement extends Enum { readonly isUnknown: boolean; readonly isFeePaid: boolean; @@ -3091,7 +3315,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unknown" | "FeePaid" | "Reasonable" | "KnownGood" | "OutOfDate" | "LowQuality" | "Erroneous"; } - /** @name PalletSchedulerCall (290) */ + /** @name PalletSchedulerCall (300) */ interface PalletSchedulerCall extends Enum { readonly isSchedule: boolean; readonly asSchedule: { @@ -3165,7 +3389,7 @@ declare module "@polkadot/types/lookup" { | "CancelRetryNamed"; } - /** @name PalletProxyCall (293) */ + /** @name PalletProxyCall (303) */ interface PalletProxyCall extends Enum { readonly isProxy: boolean; readonly asProxy: { @@ -3235,7 +3459,7 @@ declare module "@polkadot/types/lookup" { | "ProxyAnnounced"; } - /** @name DancelightRuntimeProxyType (295) */ + /** @name DancelightRuntimeProxyType (305) */ interface DancelightRuntimeProxyType extends Enum { readonly isAny: boolean; readonly isNonTransfer: boolean; @@ -3256,7 +3480,7 @@ declare module "@polkadot/types/lookup" { | "SudoRegistrar"; } - /** @name PalletMultisigCall (296) */ + /** @name PalletMultisigCall (306) */ interface PalletMultisigCall extends Enum { readonly isAsMultiThreshold1: boolean; readonly asAsMultiThreshold1: { @@ -3289,13 +3513,13 @@ declare module "@polkadot/types/lookup" { readonly type: "AsMultiThreshold1" | "AsMulti" | "ApproveAsMulti" | "CancelAsMulti"; } - /** @name PalletMultisigTimepoint (298) */ + /** @name PalletMultisigTimepoint (308) */ interface PalletMultisigTimepoint extends Struct { readonly height: u32; readonly index: u32; } - /** @name PalletPreimageCall (299) */ + /** @name PalletPreimageCall (309) */ interface PalletPreimageCall extends Enum { readonly isNotePreimage: boolean; readonly asNotePreimage: { @@ -3320,7 +3544,7 @@ declare module "@polkadot/types/lookup" { readonly type: "NotePreimage" | "UnnotePreimage" | "RequestPreimage" | "UnrequestPreimage" | "EnsureUpdated"; } - /** @name PalletAssetRateCall (301) */ + /** @name PalletAssetRateCall (311) */ interface PalletAssetRateCall extends Enum { readonly isCreate: boolean; readonly asCreate: { @@ -3339,7 +3563,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Create" | "Update" | "Remove"; } - /** @name PalletXcmCall (303) */ + /** @name PalletXcmCall (313) */ interface PalletXcmCall extends Enum { readonly isSend: boolean; readonly asSend: { @@ -3442,7 +3666,7 @@ declare module "@polkadot/types/lookup" { | "TransferAssetsUsingTypeAndThen"; } - /** @name XcmVersionedLocation (304) */ + /** @name XcmVersionedLocation (314) */ interface XcmVersionedLocation extends Enum { readonly isV2: boolean; readonly asV2: XcmV2MultiLocation; @@ -3453,13 +3677,13 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name XcmV2MultiLocation (305) */ + /** @name XcmV2MultiLocation (315) */ interface XcmV2MultiLocation extends Struct { readonly parents: u8; readonly interior: XcmV2MultilocationJunctions; } - /** @name XcmV2MultilocationJunctions (306) */ + /** @name XcmV2MultilocationJunctions (316) */ interface XcmV2MultilocationJunctions extends Enum { readonly isHere: boolean; readonly isX1: boolean; @@ -3496,7 +3720,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Here" | "X1" | "X2" | "X3" | "X4" | "X5" | "X6" | "X7" | "X8"; } - /** @name XcmV2Junction (307) */ + /** @name XcmV2Junction (317) */ interface XcmV2Junction extends Enum { readonly isParachain: boolean; readonly asParachain: Compact; @@ -3539,7 +3763,7 @@ declare module "@polkadot/types/lookup" { | "Plurality"; } - /** @name XcmV2NetworkId (308) */ + /** @name XcmV2NetworkId (318) */ interface XcmV2NetworkId extends Enum { readonly isAny: boolean; readonly isNamed: boolean; @@ -3549,7 +3773,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Any" | "Named" | "Polkadot" | "Kusama"; } - /** @name XcmV2BodyId (310) */ + /** @name XcmV2BodyId (320) */ interface XcmV2BodyId extends Enum { readonly isUnit: boolean; readonly isNamed: boolean; @@ -3576,7 +3800,7 @@ declare module "@polkadot/types/lookup" { | "Treasury"; } - /** @name XcmV2BodyPart (311) */ + /** @name XcmV2BodyPart (321) */ interface XcmV2BodyPart extends Enum { readonly isVoice: boolean; readonly isMembers: boolean; @@ -3601,13 +3825,13 @@ declare module "@polkadot/types/lookup" { readonly type: "Voice" | "Members" | "Fraction" | "AtLeastProportion" | "MoreThanProportion"; } - /** @name StagingXcmV3MultiLocation (312) */ + /** @name StagingXcmV3MultiLocation (322) */ interface StagingXcmV3MultiLocation extends Struct { readonly parents: u8; readonly interior: XcmV3Junctions; } - /** @name XcmV3Junctions (313) */ + /** @name XcmV3Junctions (323) */ interface XcmV3Junctions extends Enum { readonly isHere: boolean; readonly isX1: boolean; @@ -3644,7 +3868,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Here" | "X1" | "X2" | "X3" | "X4" | "X5" | "X6" | "X7" | "X8"; } - /** @name XcmV3Junction (314) */ + /** @name XcmV3Junction (324) */ interface XcmV3Junction extends Enum { readonly isParachain: boolean; readonly asParachain: Compact; @@ -3693,7 +3917,7 @@ declare module "@polkadot/types/lookup" { | "GlobalConsensus"; } - /** @name XcmV3JunctionNetworkId (316) */ + /** @name XcmV3JunctionNetworkId (326) */ interface XcmV3JunctionNetworkId extends Enum { readonly isByGenesis: boolean; readonly asByGenesis: U8aFixed; @@ -3728,7 +3952,7 @@ declare module "@polkadot/types/lookup" { | "PolkadotBulletin"; } - /** @name XcmVersionedXcm (317) */ + /** @name XcmVersionedXcm (327) */ interface XcmVersionedXcm extends Enum { readonly isV2: boolean; readonly asV2: XcmV2Xcm; @@ -3739,10 +3963,10 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name XcmV2Xcm (318) */ + /** @name XcmV2Xcm (328) */ interface XcmV2Xcm extends Vec {} - /** @name XcmV2Instruction (320) */ + /** @name XcmV2Instruction (330) */ interface XcmV2Instruction extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: XcmV2MultiassetMultiAssets; @@ -3890,16 +4114,16 @@ declare module "@polkadot/types/lookup" { | "UnsubscribeVersion"; } - /** @name XcmV2MultiassetMultiAssets (321) */ + /** @name XcmV2MultiassetMultiAssets (331) */ interface XcmV2MultiassetMultiAssets extends Vec {} - /** @name XcmV2MultiAsset (323) */ + /** @name XcmV2MultiAsset (333) */ interface XcmV2MultiAsset extends Struct { readonly id: XcmV2MultiassetAssetId; readonly fun: XcmV2MultiassetFungibility; } - /** @name XcmV2MultiassetAssetId (324) */ + /** @name XcmV2MultiassetAssetId (334) */ interface XcmV2MultiassetAssetId extends Enum { readonly isConcrete: boolean; readonly asConcrete: XcmV2MultiLocation; @@ -3908,7 +4132,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Concrete" | "Abstract"; } - /** @name XcmV2MultiassetFungibility (325) */ + /** @name XcmV2MultiassetFungibility (335) */ interface XcmV2MultiassetFungibility extends Enum { readonly isFungible: boolean; readonly asFungible: Compact; @@ -3917,7 +4141,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV2MultiassetAssetInstance (326) */ + /** @name XcmV2MultiassetAssetInstance (336) */ interface XcmV2MultiassetAssetInstance extends Enum { readonly isUndefined: boolean; readonly isIndex: boolean; @@ -3935,7 +4159,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Undefined" | "Index" | "Array4" | "Array8" | "Array16" | "Array32" | "Blob"; } - /** @name XcmV2Response (327) */ + /** @name XcmV2Response (337) */ interface XcmV2Response extends Enum { readonly isNull: boolean; readonly isAssets: boolean; @@ -3947,7 +4171,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Null" | "Assets" | "ExecutionResult" | "Version"; } - /** @name XcmV2TraitsError (330) */ + /** @name XcmV2TraitsError (340) */ interface XcmV2TraitsError extends Enum { readonly isOverflow: boolean; readonly isUnimplemented: boolean; @@ -4006,7 +4230,7 @@ declare module "@polkadot/types/lookup" { | "WeightNotComputable"; } - /** @name XcmV2OriginKind (331) */ + /** @name XcmV2OriginKind (341) */ interface XcmV2OriginKind extends Enum { readonly isNative: boolean; readonly isSovereignAccount: boolean; @@ -4015,12 +4239,12 @@ declare module "@polkadot/types/lookup" { readonly type: "Native" | "SovereignAccount" | "Superuser" | "Xcm"; } - /** @name XcmDoubleEncoded (332) */ + /** @name XcmDoubleEncoded (342) */ interface XcmDoubleEncoded extends Struct { readonly encoded: Bytes; } - /** @name XcmV2MultiassetMultiAssetFilter (333) */ + /** @name XcmV2MultiassetMultiAssetFilter (343) */ interface XcmV2MultiassetMultiAssetFilter extends Enum { readonly isDefinite: boolean; readonly asDefinite: XcmV2MultiassetMultiAssets; @@ -4029,7 +4253,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Definite" | "Wild"; } - /** @name XcmV2MultiassetWildMultiAsset (334) */ + /** @name XcmV2MultiassetWildMultiAsset (344) */ interface XcmV2MultiassetWildMultiAsset extends Enum { readonly isAll: boolean; readonly isAllOf: boolean; @@ -4040,14 +4264,14 @@ declare module "@polkadot/types/lookup" { readonly type: "All" | "AllOf"; } - /** @name XcmV2MultiassetWildFungibility (335) */ + /** @name XcmV2MultiassetWildFungibility (345) */ interface XcmV2MultiassetWildFungibility extends Enum { readonly isFungible: boolean; readonly isNonFungible: boolean; readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV2WeightLimit (336) */ + /** @name XcmV2WeightLimit (346) */ interface XcmV2WeightLimit extends Enum { readonly isUnlimited: boolean; readonly isLimited: boolean; @@ -4055,10 +4279,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Unlimited" | "Limited"; } - /** @name XcmV3Xcm (337) */ + /** @name XcmV3Xcm (347) */ interface XcmV3Xcm extends Vec {} - /** @name XcmV3Instruction (339) */ + /** @name XcmV3Instruction (349) */ interface XcmV3Instruction extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: XcmV3MultiassetMultiAssets; @@ -4288,16 +4512,16 @@ declare module "@polkadot/types/lookup" { | "UnpaidExecution"; } - /** @name XcmV3MultiassetMultiAssets (340) */ + /** @name XcmV3MultiassetMultiAssets (350) */ interface XcmV3MultiassetMultiAssets extends Vec {} - /** @name XcmV3MultiAsset (342) */ + /** @name XcmV3MultiAsset (352) */ interface XcmV3MultiAsset extends Struct { readonly id: XcmV3MultiassetAssetId; readonly fun: XcmV3MultiassetFungibility; } - /** @name XcmV3MultiassetAssetId (343) */ + /** @name XcmV3MultiassetAssetId (353) */ interface XcmV3MultiassetAssetId extends Enum { readonly isConcrete: boolean; readonly asConcrete: StagingXcmV3MultiLocation; @@ -4306,7 +4530,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Concrete" | "Abstract"; } - /** @name XcmV3MultiassetFungibility (344) */ + /** @name XcmV3MultiassetFungibility (354) */ interface XcmV3MultiassetFungibility extends Enum { readonly isFungible: boolean; readonly asFungible: Compact; @@ -4315,7 +4539,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV3MultiassetAssetInstance (345) */ + /** @name XcmV3MultiassetAssetInstance (355) */ interface XcmV3MultiassetAssetInstance extends Enum { readonly isUndefined: boolean; readonly isIndex: boolean; @@ -4331,7 +4555,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Undefined" | "Index" | "Array4" | "Array8" | "Array16" | "Array32"; } - /** @name XcmV3Response (346) */ + /** @name XcmV3Response (356) */ interface XcmV3Response extends Enum { readonly isNull: boolean; readonly isAssets: boolean; @@ -4347,7 +4571,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Null" | "Assets" | "ExecutionResult" | "Version" | "PalletsInfo" | "DispatchResult"; } - /** @name XcmV3TraitsError (349) */ + /** @name XcmV3TraitsError (359) */ interface XcmV3TraitsError extends Enum { readonly isOverflow: boolean; readonly isUnimplemented: boolean; @@ -4434,7 +4658,7 @@ declare module "@polkadot/types/lookup" { | "ExceedsStackLimit"; } - /** @name XcmV3PalletInfo (351) */ + /** @name XcmV3PalletInfo (361) */ interface XcmV3PalletInfo extends Struct { readonly index: Compact; readonly name: Bytes; @@ -4444,7 +4668,7 @@ declare module "@polkadot/types/lookup" { readonly patch: Compact; } - /** @name XcmV3MaybeErrorCode (354) */ + /** @name XcmV3MaybeErrorCode (364) */ interface XcmV3MaybeErrorCode extends Enum { readonly isSuccess: boolean; readonly isError: boolean; @@ -4454,7 +4678,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Success" | "Error" | "TruncatedError"; } - /** @name XcmV3OriginKind (357) */ + /** @name XcmV3OriginKind (367) */ interface XcmV3OriginKind extends Enum { readonly isNative: boolean; readonly isSovereignAccount: boolean; @@ -4463,14 +4687,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Native" | "SovereignAccount" | "Superuser" | "Xcm"; } - /** @name XcmV3QueryResponseInfo (358) */ + /** @name XcmV3QueryResponseInfo (368) */ interface XcmV3QueryResponseInfo extends Struct { readonly destination: StagingXcmV3MultiLocation; readonly queryId: Compact; readonly maxWeight: SpWeightsWeightV2Weight; } - /** @name XcmV3MultiassetMultiAssetFilter (359) */ + /** @name XcmV3MultiassetMultiAssetFilter (369) */ interface XcmV3MultiassetMultiAssetFilter extends Enum { readonly isDefinite: boolean; readonly asDefinite: XcmV3MultiassetMultiAssets; @@ -4479,7 +4703,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Definite" | "Wild"; } - /** @name XcmV3MultiassetWildMultiAsset (360) */ + /** @name XcmV3MultiassetWildMultiAsset (370) */ interface XcmV3MultiassetWildMultiAsset extends Enum { readonly isAll: boolean; readonly isAllOf: boolean; @@ -4498,14 +4722,14 @@ declare module "@polkadot/types/lookup" { readonly type: "All" | "AllOf" | "AllCounted" | "AllOfCounted"; } - /** @name XcmV3MultiassetWildFungibility (361) */ + /** @name XcmV3MultiassetWildFungibility (371) */ interface XcmV3MultiassetWildFungibility extends Enum { readonly isFungible: boolean; readonly isNonFungible: boolean; readonly type: "Fungible" | "NonFungible"; } - /** @name XcmV3WeightLimit (362) */ + /** @name XcmV3WeightLimit (372) */ interface XcmV3WeightLimit extends Enum { readonly isUnlimited: boolean; readonly isLimited: boolean; @@ -4513,10 +4737,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Unlimited" | "Limited"; } - /** @name StagingXcmV4Xcm (363) */ + /** @name StagingXcmV4Xcm (373) */ interface StagingXcmV4Xcm extends Vec {} - /** @name StagingXcmV4Instruction (365) */ + /** @name StagingXcmV4Instruction (375) */ interface StagingXcmV4Instruction extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: StagingXcmV4AssetAssets; @@ -4746,19 +4970,19 @@ declare module "@polkadot/types/lookup" { | "UnpaidExecution"; } - /** @name StagingXcmV4AssetAssets (366) */ + /** @name StagingXcmV4AssetAssets (376) */ interface StagingXcmV4AssetAssets extends Vec {} - /** @name StagingXcmV4Asset (368) */ + /** @name StagingXcmV4Asset (378) */ interface StagingXcmV4Asset extends Struct { readonly id: StagingXcmV4AssetAssetId; readonly fun: StagingXcmV4AssetFungibility; } - /** @name StagingXcmV4AssetAssetId (369) */ + /** @name StagingXcmV4AssetAssetId (379) */ interface StagingXcmV4AssetAssetId extends StagingXcmV4Location {} - /** @name StagingXcmV4AssetFungibility (370) */ + /** @name StagingXcmV4AssetFungibility (380) */ interface StagingXcmV4AssetFungibility extends Enum { readonly isFungible: boolean; readonly asFungible: Compact; @@ -4767,7 +4991,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Fungible" | "NonFungible"; } - /** @name StagingXcmV4AssetAssetInstance (371) */ + /** @name StagingXcmV4AssetAssetInstance (381) */ interface StagingXcmV4AssetAssetInstance extends Enum { readonly isUndefined: boolean; readonly isIndex: boolean; @@ -4783,7 +5007,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Undefined" | "Index" | "Array4" | "Array8" | "Array16" | "Array32"; } - /** @name StagingXcmV4Response (372) */ + /** @name StagingXcmV4Response (382) */ interface StagingXcmV4Response extends Enum { readonly isNull: boolean; readonly isAssets: boolean; @@ -4799,7 +5023,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Null" | "Assets" | "ExecutionResult" | "Version" | "PalletsInfo" | "DispatchResult"; } - /** @name StagingXcmV4PalletInfo (374) */ + /** @name StagingXcmV4PalletInfo (384) */ interface StagingXcmV4PalletInfo extends Struct { readonly index: Compact; readonly name: Bytes; @@ -4809,14 +5033,14 @@ declare module "@polkadot/types/lookup" { readonly patch: Compact; } - /** @name StagingXcmV4QueryResponseInfo (378) */ + /** @name StagingXcmV4QueryResponseInfo (388) */ interface StagingXcmV4QueryResponseInfo extends Struct { readonly destination: StagingXcmV4Location; readonly queryId: Compact; readonly maxWeight: SpWeightsWeightV2Weight; } - /** @name StagingXcmV4AssetAssetFilter (379) */ + /** @name StagingXcmV4AssetAssetFilter (389) */ interface StagingXcmV4AssetAssetFilter extends Enum { readonly isDefinite: boolean; readonly asDefinite: StagingXcmV4AssetAssets; @@ -4825,7 +5049,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Definite" | "Wild"; } - /** @name StagingXcmV4AssetWildAsset (380) */ + /** @name StagingXcmV4AssetWildAsset (390) */ interface StagingXcmV4AssetWildAsset extends Enum { readonly isAll: boolean; readonly isAllOf: boolean; @@ -4844,14 +5068,14 @@ declare module "@polkadot/types/lookup" { readonly type: "All" | "AllOf" | "AllCounted" | "AllOfCounted"; } - /** @name StagingXcmV4AssetWildFungibility (381) */ + /** @name StagingXcmV4AssetWildFungibility (391) */ interface StagingXcmV4AssetWildFungibility extends Enum { readonly isFungible: boolean; readonly isNonFungible: boolean; readonly type: "Fungible" | "NonFungible"; } - /** @name XcmVersionedAssets (382) */ + /** @name XcmVersionedAssets (392) */ interface XcmVersionedAssets extends Enum { readonly isV2: boolean; readonly asV2: XcmV2MultiassetMultiAssets; @@ -4862,7 +5086,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name StagingXcmExecutorAssetTransferTransferType (394) */ + /** @name StagingXcmExecutorAssetTransferTransferType (404) */ interface StagingXcmExecutorAssetTransferTransferType extends Enum { readonly isTeleport: boolean; readonly isLocalReserve: boolean; @@ -4872,7 +5096,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Teleport" | "LocalReserve" | "DestinationReserve" | "RemoteReserve"; } - /** @name XcmVersionedAssetId (395) */ + /** @name XcmVersionedAssetId (405) */ interface XcmVersionedAssetId extends Enum { readonly isV3: boolean; readonly asV3: XcmV3MultiassetAssetId; @@ -4881,7 +5105,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V3" | "V4"; } - /** @name SnowbridgePalletInboundQueueCall (396) */ + /** @name SnowbridgePalletInboundQueueCall (406) */ interface SnowbridgePalletInboundQueueCall extends Enum { readonly isSubmit: boolean; readonly asSubmit: { @@ -4894,26 +5118,26 @@ declare module "@polkadot/types/lookup" { readonly type: "Submit" | "SetOperatingMode"; } - /** @name SnowbridgeCoreInboundMessage (397) */ + /** @name SnowbridgeCoreInboundMessage (407) */ interface SnowbridgeCoreInboundMessage extends Struct { readonly eventLog: SnowbridgeCoreInboundLog; readonly proof: SnowbridgeCoreInboundProof; } - /** @name SnowbridgeCoreInboundLog (398) */ + /** @name SnowbridgeCoreInboundLog (408) */ interface SnowbridgeCoreInboundLog extends Struct { readonly address: H160; readonly topics: Vec; readonly data: Bytes; } - /** @name SnowbridgeCoreInboundProof (400) */ + /** @name SnowbridgeCoreInboundProof (410) */ interface SnowbridgeCoreInboundProof extends Struct { readonly receiptProof: ITuple<[Vec, Vec]>; readonly executionProof: SnowbridgeBeaconPrimitivesExecutionProof; } - /** @name SnowbridgeBeaconPrimitivesExecutionProof (402) */ + /** @name SnowbridgeBeaconPrimitivesExecutionProof (412) */ interface SnowbridgeBeaconPrimitivesExecutionProof extends Struct { readonly header: SnowbridgeBeaconPrimitivesBeaconHeader; readonly ancestryProof: Option; @@ -4921,7 +5145,7 @@ declare module "@polkadot/types/lookup" { readonly executionBranch: Vec; } - /** @name SnowbridgeBeaconPrimitivesBeaconHeader (403) */ + /** @name SnowbridgeBeaconPrimitivesBeaconHeader (413) */ interface SnowbridgeBeaconPrimitivesBeaconHeader extends Struct { readonly slot: u64; readonly proposerIndex: u64; @@ -4930,13 +5154,13 @@ declare module "@polkadot/types/lookup" { readonly bodyRoot: H256; } - /** @name SnowbridgeBeaconPrimitivesAncestryProof (405) */ + /** @name SnowbridgeBeaconPrimitivesAncestryProof (415) */ interface SnowbridgeBeaconPrimitivesAncestryProof extends Struct { readonly headerBranch: Vec; readonly finalizedBlockRoot: H256; } - /** @name SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader (406) */ + /** @name SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader (416) */ interface SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader extends Enum { readonly isCapella: boolean; readonly asCapella: SnowbridgeBeaconPrimitivesExecutionPayloadHeader; @@ -4945,7 +5169,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Capella" | "Deneb"; } - /** @name SnowbridgeBeaconPrimitivesExecutionPayloadHeader (407) */ + /** @name SnowbridgeBeaconPrimitivesExecutionPayloadHeader (417) */ interface SnowbridgeBeaconPrimitivesExecutionPayloadHeader extends Struct { readonly parentHash: H256; readonly feeRecipient: H160; @@ -4964,7 +5188,7 @@ declare module "@polkadot/types/lookup" { readonly withdrawalsRoot: H256; } - /** @name SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader (410) */ + /** @name SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader (420) */ interface SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader extends Struct { readonly parentHash: H256; readonly feeRecipient: H160; @@ -4985,14 +5209,14 @@ declare module "@polkadot/types/lookup" { readonly excessBlobGas: u64; } - /** @name SnowbridgeCoreOperatingModeBasicOperatingMode (411) */ + /** @name SnowbridgeCoreOperatingModeBasicOperatingMode (421) */ interface SnowbridgeCoreOperatingModeBasicOperatingMode extends Enum { readonly isNormal: boolean; readonly isHalted: boolean; readonly type: "Normal" | "Halted"; } - /** @name SnowbridgePalletOutboundQueueCall (412) */ + /** @name SnowbridgePalletOutboundQueueCall (422) */ interface SnowbridgePalletOutboundQueueCall extends Enum { readonly isSetOperatingMode: boolean; readonly asSetOperatingMode: { @@ -5001,7 +5225,7 @@ declare module "@polkadot/types/lookup" { readonly type: "SetOperatingMode"; } - /** @name SnowbridgePalletSystemCall (413) */ + /** @name SnowbridgePalletSystemCall (423) */ interface SnowbridgePalletSystemCall extends Enum { readonly isUpgrade: boolean; readonly asUpgrade: { @@ -5067,20 +5291,20 @@ declare module "@polkadot/types/lookup" { | "RegisterToken"; } - /** @name SnowbridgeCoreOutboundV1Initializer (415) */ + /** @name SnowbridgeCoreOutboundV1Initializer (425) */ interface SnowbridgeCoreOutboundV1Initializer extends Struct { readonly params: Bytes; readonly maximumRequiredGas: u64; } - /** @name SnowbridgeCoreOutboundV1OperatingMode (416) */ + /** @name SnowbridgeCoreOutboundV1OperatingMode (426) */ interface SnowbridgeCoreOutboundV1OperatingMode extends Enum { readonly isNormal: boolean; readonly isRejectingOutboundMessages: boolean; readonly type: "Normal" | "RejectingOutboundMessages"; } - /** @name SnowbridgeCorePricingPricingParameters (417) */ + /** @name SnowbridgeCorePricingPricingParameters (427) */ interface SnowbridgeCorePricingPricingParameters extends Struct { readonly exchangeRate: u128; readonly rewards: SnowbridgeCorePricingRewards; @@ -5088,20 +5312,20 @@ declare module "@polkadot/types/lookup" { readonly multiplier: u128; } - /** @name SnowbridgeCorePricingRewards (418) */ + /** @name SnowbridgeCorePricingRewards (428) */ interface SnowbridgeCorePricingRewards extends Struct { readonly local: u128; readonly remote: U256; } - /** @name SnowbridgeCoreAssetMetadata (419) */ + /** @name SnowbridgeCoreAssetMetadata (429) */ interface SnowbridgeCoreAssetMetadata extends Struct { readonly name: Bytes; readonly symbol: Bytes; readonly decimals: u8; } - /** @name PalletMigrationsCall (420) */ + /** @name PalletMigrationsCall (430) */ interface PalletMigrationsCall extends Enum { readonly isForceSetCursor: boolean; readonly asForceSetCursor: { @@ -5121,7 +5345,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ForceSetCursor" | "ForceSetActiveCursor" | "ForceOnboardMbms" | "ClearHistoric"; } - /** @name PalletMigrationsMigrationCursor (422) */ + /** @name PalletMigrationsMigrationCursor (432) */ interface PalletMigrationsMigrationCursor extends Enum { readonly isActive: boolean; readonly asActive: PalletMigrationsActiveCursor; @@ -5129,14 +5353,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Active" | "Stuck"; } - /** @name PalletMigrationsActiveCursor (424) */ + /** @name PalletMigrationsActiveCursor (434) */ interface PalletMigrationsActiveCursor extends Struct { readonly index: u32; readonly innerCursor: Option; readonly startedAt: u32; } - /** @name PalletMigrationsHistoricCleanupSelector (426) */ + /** @name PalletMigrationsHistoricCleanupSelector (436) */ interface PalletMigrationsHistoricCleanupSelector extends Enum { readonly isSpecific: boolean; readonly asSpecific: Vec; @@ -5148,7 +5372,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Specific" | "Wildcard"; } - /** @name PalletBeefyCall (429) */ + /** @name PalletBeefyCall (439) */ interface PalletBeefyCall extends Enum { readonly isReportDoubleVoting: boolean; readonly asReportDoubleVoting: { @@ -5194,40 +5418,40 @@ declare module "@polkadot/types/lookup" { | "ReportFutureBlockVotingUnsigned"; } - /** @name SpConsensusBeefyDoubleVotingProof (430) */ + /** @name SpConsensusBeefyDoubleVotingProof (440) */ interface SpConsensusBeefyDoubleVotingProof extends Struct { readonly first: SpConsensusBeefyVoteMessage; readonly second: SpConsensusBeefyVoteMessage; } - /** @name SpConsensusBeefyEcdsaCryptoSignature (431) */ + /** @name SpConsensusBeefyEcdsaCryptoSignature (441) */ interface SpConsensusBeefyEcdsaCryptoSignature extends U8aFixed {} - /** @name SpConsensusBeefyVoteMessage (432) */ + /** @name SpConsensusBeefyVoteMessage (442) */ interface SpConsensusBeefyVoteMessage extends Struct { readonly commitment: SpConsensusBeefyCommitment; readonly id: SpConsensusBeefyEcdsaCryptoPublic; readonly signature: SpConsensusBeefyEcdsaCryptoSignature; } - /** @name SpConsensusBeefyCommitment (433) */ + /** @name SpConsensusBeefyCommitment (443) */ interface SpConsensusBeefyCommitment extends Struct { readonly payload: SpConsensusBeefyPayload; readonly blockNumber: u32; readonly validatorSetId: u64; } - /** @name SpConsensusBeefyPayload (434) */ + /** @name SpConsensusBeefyPayload (444) */ interface SpConsensusBeefyPayload extends Vec> {} - /** @name SpConsensusBeefyForkVotingProof (437) */ + /** @name SpConsensusBeefyForkVotingProof (447) */ interface SpConsensusBeefyForkVotingProof extends Struct { readonly vote: SpConsensusBeefyVoteMessage; readonly ancestryProof: SpMmrPrimitivesAncestryProof; readonly header: SpRuntimeHeader; } - /** @name SpMmrPrimitivesAncestryProof (438) */ + /** @name SpMmrPrimitivesAncestryProof (448) */ interface SpMmrPrimitivesAncestryProof extends Struct { readonly prevPeaks: Vec; readonly prevLeafCount: u64; @@ -5235,12 +5459,12 @@ declare module "@polkadot/types/lookup" { readonly items: Vec>; } - /** @name SpConsensusBeefyFutureBlockVotingProof (441) */ + /** @name SpConsensusBeefyFutureBlockVotingProof (451) */ interface SpConsensusBeefyFutureBlockVotingProof extends Struct { readonly vote: SpConsensusBeefyVoteMessage; } - /** @name SnowbridgePalletEthereumClientCall (442) */ + /** @name SnowbridgePalletEthereumClientCall (452) */ interface SnowbridgePalletEthereumClientCall extends Enum { readonly isForceCheckpoint: boolean; readonly asForceCheckpoint: { @@ -5257,7 +5481,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ForceCheckpoint" | "Submit" | "SetOperatingMode"; } - /** @name SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate (443) */ + /** @name SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate (453) */ interface SnowbridgeBeaconPrimitivesUpdatesCheckpointUpdate extends Struct { readonly header: SnowbridgeBeaconPrimitivesBeaconHeader; readonly currentSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; @@ -5267,16 +5491,16 @@ declare module "@polkadot/types/lookup" { readonly blockRootsBranch: Vec; } - /** @name SnowbridgeBeaconPrimitivesSyncCommittee (444) */ + /** @name SnowbridgeBeaconPrimitivesSyncCommittee (454) */ interface SnowbridgeBeaconPrimitivesSyncCommittee extends Struct { readonly pubkeys: Vec; readonly aggregatePubkey: SnowbridgeBeaconPrimitivesPublicKey; } - /** @name SnowbridgeBeaconPrimitivesPublicKey (446) */ + /** @name SnowbridgeBeaconPrimitivesPublicKey (456) */ interface SnowbridgeBeaconPrimitivesPublicKey extends U8aFixed {} - /** @name SnowbridgeBeaconPrimitivesUpdatesUpdate (448) */ + /** @name SnowbridgeBeaconPrimitivesUpdatesUpdate (458) */ interface SnowbridgeBeaconPrimitivesUpdatesUpdate extends Struct { readonly attestedHeader: SnowbridgeBeaconPrimitivesBeaconHeader; readonly syncAggregate: SnowbridgeBeaconPrimitivesSyncAggregate; @@ -5288,22 +5512,22 @@ declare module "@polkadot/types/lookup" { readonly blockRootsBranch: Vec; } - /** @name SnowbridgeBeaconPrimitivesSyncAggregate (449) */ + /** @name SnowbridgeBeaconPrimitivesSyncAggregate (459) */ interface SnowbridgeBeaconPrimitivesSyncAggregate extends Struct { readonly syncCommitteeBits: U8aFixed; readonly syncCommitteeSignature: SnowbridgeBeaconPrimitivesSignature; } - /** @name SnowbridgeBeaconPrimitivesSignature (450) */ + /** @name SnowbridgeBeaconPrimitivesSignature (460) */ interface SnowbridgeBeaconPrimitivesSignature extends U8aFixed {} - /** @name SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate (453) */ + /** @name SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate (463) */ interface SnowbridgeBeaconPrimitivesUpdatesNextSyncCommitteeUpdate extends Struct { readonly nextSyncCommittee: SnowbridgeBeaconPrimitivesSyncCommittee; readonly nextSyncCommitteeBranch: Vec; } - /** @name PolkadotRuntimeCommonParasSudoWrapperPalletCall (454) */ + /** @name PolkadotRuntimeCommonParasSudoWrapperPalletCall (464) */ interface PolkadotRuntimeCommonParasSudoWrapperPalletCall extends Enum { readonly isSudoScheduleParaInitialize: boolean; readonly asSudoScheduleParaInitialize: { @@ -5343,14 +5567,14 @@ declare module "@polkadot/types/lookup" { | "SudoEstablishHrmpChannel"; } - /** @name PolkadotRuntimeParachainsParasParaGenesisArgs (455) */ + /** @name PolkadotRuntimeParachainsParasParaGenesisArgs (465) */ interface PolkadotRuntimeParachainsParasParaGenesisArgs extends Struct { readonly genesisHead: Bytes; readonly validationCode: Bytes; readonly paraKind: bool; } - /** @name PalletRootTestingCall (456) */ + /** @name PalletRootTestingCall (466) */ interface PalletRootTestingCall extends Enum { readonly isFillBlock: boolean; readonly asFillBlock: { @@ -5360,7 +5584,7 @@ declare module "@polkadot/types/lookup" { readonly type: "FillBlock" | "TriggerDefensive"; } - /** @name PalletSudoCall (457) */ + /** @name PalletSudoCall (467) */ interface PalletSudoCall extends Enum { readonly isSudo: boolean; readonly asSudo: { @@ -5384,17 +5608,17 @@ declare module "@polkadot/types/lookup" { readonly type: "Sudo" | "SudoUncheckedWeight" | "SetKey" | "SudoAs" | "RemoveKey"; } - /** @name SpRuntimeBlakeTwo256 (458) */ + /** @name SpRuntimeBlakeTwo256 (468) */ type SpRuntimeBlakeTwo256 = Null; - /** @name PalletConvictionVotingTally (460) */ + /** @name PalletConvictionVotingTally (470) */ interface PalletConvictionVotingTally extends Struct { readonly ayes: u128; readonly nays: u128; readonly support: u128; } - /** @name PalletRankedCollectiveEvent (461) */ + /** @name PalletRankedCollectiveEvent (471) */ interface PalletRankedCollectiveEvent extends Enum { readonly isMemberAdded: boolean; readonly asMemberAdded: { @@ -5425,7 +5649,7 @@ declare module "@polkadot/types/lookup" { readonly type: "MemberAdded" | "RankChanged" | "MemberRemoved" | "Voted" | "MemberExchanged"; } - /** @name PalletRankedCollectiveVoteRecord (462) */ + /** @name PalletRankedCollectiveVoteRecord (472) */ interface PalletRankedCollectiveVoteRecord extends Enum { readonly isAye: boolean; readonly asAye: u32; @@ -5434,14 +5658,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Aye" | "Nay"; } - /** @name PalletRankedCollectiveTally (463) */ + /** @name PalletRankedCollectiveTally (473) */ interface PalletRankedCollectiveTally extends Struct { readonly bareAyes: u32; readonly ayes: u32; readonly nays: u32; } - /** @name PalletWhitelistEvent (465) */ + /** @name PalletWhitelistEvent (475) */ interface PalletWhitelistEvent extends Enum { readonly isCallWhitelisted: boolean; readonly asCallWhitelisted: { @@ -5459,19 +5683,19 @@ declare module "@polkadot/types/lookup" { readonly type: "CallWhitelisted" | "WhitelistedCallRemoved" | "WhitelistedCallDispatched"; } - /** @name FrameSupportDispatchPostDispatchInfo (467) */ + /** @name FrameSupportDispatchPostDispatchInfo (477) */ interface FrameSupportDispatchPostDispatchInfo extends Struct { readonly actualWeight: Option; readonly paysFee: FrameSupportDispatchPays; } - /** @name SpRuntimeDispatchErrorWithPostInfo (469) */ + /** @name SpRuntimeDispatchErrorWithPostInfo (479) */ interface SpRuntimeDispatchErrorWithPostInfo extends Struct { readonly postInfo: FrameSupportDispatchPostDispatchInfo; readonly error: SpRuntimeDispatchError; } - /** @name PolkadotRuntimeParachainsInclusionPalletEvent (470) */ + /** @name PolkadotRuntimeParachainsInclusionPalletEvent (480) */ interface PolkadotRuntimeParachainsInclusionPalletEvent extends Enum { readonly isCandidateBacked: boolean; readonly asCandidateBacked: ITuple<[PolkadotPrimitivesV8CandidateReceipt, Bytes, u32, u32]>; @@ -5487,13 +5711,13 @@ declare module "@polkadot/types/lookup" { readonly type: "CandidateBacked" | "CandidateIncluded" | "CandidateTimedOut" | "UpwardMessagesReceived"; } - /** @name PolkadotPrimitivesV8CandidateReceipt (471) */ + /** @name PolkadotPrimitivesV8CandidateReceipt (481) */ interface PolkadotPrimitivesV8CandidateReceipt extends Struct { readonly descriptor: PolkadotPrimitivesV8CandidateDescriptor; readonly commitmentsHash: H256; } - /** @name PolkadotRuntimeParachainsParasPalletEvent (474) */ + /** @name PolkadotRuntimeParachainsParasPalletEvent (484) */ interface PolkadotRuntimeParachainsParasPalletEvent extends Enum { readonly isCurrentCodeUpdated: boolean; readonly asCurrentCodeUpdated: u32; @@ -5522,7 +5746,7 @@ declare module "@polkadot/types/lookup" { | "PvfCheckRejected"; } - /** @name PolkadotRuntimeParachainsHrmpPalletEvent (475) */ + /** @name PolkadotRuntimeParachainsHrmpPalletEvent (485) */ interface PolkadotRuntimeParachainsHrmpPalletEvent extends Enum { readonly isOpenChannelRequested: boolean; readonly asOpenChannelRequested: { @@ -5575,7 +5799,7 @@ declare module "@polkadot/types/lookup" { | "OpenChannelDepositsUpdated"; } - /** @name PolkadotRuntimeParachainsDisputesPalletEvent (476) */ + /** @name PolkadotRuntimeParachainsDisputesPalletEvent (486) */ interface PolkadotRuntimeParachainsDisputesPalletEvent extends Enum { readonly isDisputeInitiated: boolean; readonly asDisputeInitiated: ITuple<[H256, PolkadotRuntimeParachainsDisputesDisputeLocation]>; @@ -5586,21 +5810,21 @@ declare module "@polkadot/types/lookup" { readonly type: "DisputeInitiated" | "DisputeConcluded" | "Revert"; } - /** @name PolkadotRuntimeParachainsDisputesDisputeLocation (477) */ + /** @name PolkadotRuntimeParachainsDisputesDisputeLocation (487) */ interface PolkadotRuntimeParachainsDisputesDisputeLocation extends Enum { readonly isLocal: boolean; readonly isRemote: boolean; readonly type: "Local" | "Remote"; } - /** @name PolkadotRuntimeParachainsDisputesDisputeResult (478) */ + /** @name PolkadotRuntimeParachainsDisputesDisputeResult (488) */ interface PolkadotRuntimeParachainsDisputesDisputeResult extends Enum { readonly isValid: boolean; readonly isInvalid: boolean; readonly type: "Valid" | "Invalid"; } - /** @name PalletMessageQueueEvent (479) */ + /** @name PalletMessageQueueEvent (489) */ interface PalletMessageQueueEvent extends Enum { readonly isProcessingFailed: boolean; readonly asProcessingFailed: { @@ -5630,7 +5854,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ProcessingFailed" | "Processed" | "OverweightEnqueued" | "PageReaped"; } - /** @name FrameSupportMessagesProcessMessageError (480) */ + /** @name FrameSupportMessagesProcessMessageError (490) */ interface FrameSupportMessagesProcessMessageError extends Enum { readonly isBadFormat: boolean; readonly isCorrupt: boolean; @@ -5642,7 +5866,7 @@ declare module "@polkadot/types/lookup" { readonly type: "BadFormat" | "Corrupt" | "Unsupported" | "Overweight" | "Yield" | "StackLimitReached"; } - /** @name PolkadotRuntimeParachainsOnDemandPalletEvent (481) */ + /** @name PolkadotRuntimeParachainsOnDemandPalletEvent (491) */ interface PolkadotRuntimeParachainsOnDemandPalletEvent extends Enum { readonly isOnDemandOrderPlaced: boolean; readonly asOnDemandOrderPlaced: { @@ -5657,7 +5881,7 @@ declare module "@polkadot/types/lookup" { readonly type: "OnDemandOrderPlaced" | "SpotPriceSet"; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletEvent (482) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletEvent (492) */ interface PolkadotRuntimeCommonParasRegistrarPalletEvent extends Enum { readonly isRegistered: boolean; readonly asRegistered: { @@ -5681,7 +5905,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Registered" | "Deregistered" | "Reserved" | "Swapped"; } - /** @name PalletUtilityEvent (483) */ + /** @name PalletUtilityEvent (493) */ interface PalletUtilityEvent extends Enum { readonly isBatchInterrupted: boolean; readonly asBatchInterrupted: { @@ -5708,7 +5932,7 @@ declare module "@polkadot/types/lookup" { | "DispatchedAs"; } - /** @name PalletIdentityEvent (485) */ + /** @name PalletIdentityEvent (495) */ interface PalletIdentityEvent extends Enum { readonly isIdentitySet: boolean; readonly asIdentitySet: { @@ -5814,7 +6038,7 @@ declare module "@polkadot/types/lookup" { | "DanglingUsernameRemoved"; } - /** @name PalletSchedulerEvent (486) */ + /** @name PalletSchedulerEvent (496) */ interface PalletSchedulerEvent extends Enum { readonly isScheduled: boolean; readonly asScheduled: { @@ -5876,7 +6100,7 @@ declare module "@polkadot/types/lookup" { | "PermanentlyOverweight"; } - /** @name PalletProxyEvent (488) */ + /** @name PalletProxyEvent (498) */ interface PalletProxyEvent extends Enum { readonly isProxyExecuted: boolean; readonly asProxyExecuted: { @@ -5912,7 +6136,7 @@ declare module "@polkadot/types/lookup" { readonly type: "ProxyExecuted" | "PureCreated" | "Announced" | "ProxyAdded" | "ProxyRemoved"; } - /** @name PalletMultisigEvent (489) */ + /** @name PalletMultisigEvent (499) */ interface PalletMultisigEvent extends Enum { readonly isNewMultisig: boolean; readonly asNewMultisig: { @@ -5945,7 +6169,7 @@ declare module "@polkadot/types/lookup" { readonly type: "NewMultisig" | "MultisigApproval" | "MultisigExecuted" | "MultisigCancelled"; } - /** @name PalletPreimageEvent (490) */ + /** @name PalletPreimageEvent (500) */ interface PalletPreimageEvent extends Enum { readonly isNoted: boolean; readonly asNoted: { @@ -5962,7 +6186,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Noted" | "Requested" | "Cleared"; } - /** @name PalletAssetRateEvent (491) */ + /** @name PalletAssetRateEvent (501) */ interface PalletAssetRateEvent extends Enum { readonly isAssetRateCreated: boolean; readonly asAssetRateCreated: { @@ -5982,7 +6206,7 @@ declare module "@polkadot/types/lookup" { readonly type: "AssetRateCreated" | "AssetRateRemoved" | "AssetRateUpdated"; } - /** @name PalletXcmEvent (492) */ + /** @name PalletXcmEvent (502) */ interface PalletXcmEvent extends Enum { readonly isAttempted: boolean; readonly asAttempted: { @@ -6147,7 +6371,7 @@ declare module "@polkadot/types/lookup" { | "VersionMigrationFinished"; } - /** @name StagingXcmV4TraitsOutcome (493) */ + /** @name StagingXcmV4TraitsOutcome (503) */ interface StagingXcmV4TraitsOutcome extends Enum { readonly isComplete: boolean; readonly asComplete: { @@ -6165,7 +6389,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Complete" | "Incomplete" | "Error"; } - /** @name SnowbridgePalletInboundQueueEvent (494) */ + /** @name SnowbridgePalletInboundQueueEvent (504) */ interface SnowbridgePalletInboundQueueEvent extends Enum { readonly isMessageReceived: boolean; readonly asMessageReceived: { @@ -6181,7 +6405,7 @@ declare module "@polkadot/types/lookup" { readonly type: "MessageReceived" | "OperatingModeChanged"; } - /** @name SnowbridgePalletOutboundQueueEvent (495) */ + /** @name SnowbridgePalletOutboundQueueEvent (505) */ interface SnowbridgePalletOutboundQueueEvent extends Enum { readonly isMessageQueued: boolean; readonly asMessageQueued: { @@ -6204,7 +6428,7 @@ declare module "@polkadot/types/lookup" { readonly type: "MessageQueued" | "MessageAccepted" | "MessagesCommitted" | "OperatingModeChanged"; } - /** @name SnowbridgePalletSystemEvent (496) */ + /** @name SnowbridgePalletSystemEvent (506) */ interface SnowbridgePalletSystemEvent extends Enum { readonly isUpgrade: boolean; readonly asUpgrade: { @@ -6264,7 +6488,7 @@ declare module "@polkadot/types/lookup" { | "RegisterToken"; } - /** @name PalletMigrationsEvent (497) */ + /** @name PalletMigrationsEvent (507) */ interface PalletMigrationsEvent extends Enum { readonly isRuntimeUpgradeStarted: boolean; readonly isRuntimeUpgradeCompleted: boolean; @@ -6297,7 +6521,7 @@ declare module "@polkadot/types/lookup" { | "FailedToResumeIdleXcmExecution"; } - /** @name SnowbridgePalletEthereumClientEvent (499) */ + /** @name SnowbridgePalletEthereumClientEvent (509) */ interface SnowbridgePalletEthereumClientEvent extends Enum { readonly isBeaconHeaderImported: boolean; readonly asBeaconHeaderImported: { @@ -6315,13 +6539,13 @@ declare module "@polkadot/types/lookup" { readonly type: "BeaconHeaderImported" | "SyncCommitteeUpdated" | "OperatingModeChanged"; } - /** @name PalletRootTestingEvent (500) */ + /** @name PalletRootTestingEvent (510) */ interface PalletRootTestingEvent extends Enum { readonly isDefensiveTestCall: boolean; readonly type: "DefensiveTestCall"; } - /** @name PalletSudoEvent (501) */ + /** @name PalletSudoEvent (511) */ interface PalletSudoEvent extends Enum { readonly isSudid: boolean; readonly asSudid: { @@ -6340,7 +6564,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Sudid" | "KeyChanged" | "KeyRemoved" | "SudoAsDone"; } - /** @name FrameSystemPhase (502) */ + /** @name FrameSystemPhase (512) */ interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -6349,33 +6573,33 @@ declare module "@polkadot/types/lookup" { readonly type: "ApplyExtrinsic" | "Finalization" | "Initialization"; } - /** @name FrameSystemLastRuntimeUpgradeInfo (504) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (514) */ interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemCodeUpgradeAuthorization (506) */ + /** @name FrameSystemCodeUpgradeAuthorization (516) */ interface FrameSystemCodeUpgradeAuthorization extends Struct { readonly codeHash: H256; readonly checkVersion: bool; } - /** @name FrameSystemLimitsBlockWeights (507) */ + /** @name FrameSystemLimitsBlockWeights (517) */ interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: SpWeightsWeightV2Weight; readonly maxBlock: SpWeightsWeightV2Weight; readonly perClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; } - /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (508) */ + /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (518) */ interface FrameSupportDispatchPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (509) */ + /** @name FrameSystemLimitsWeightsPerClass (519) */ interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: SpWeightsWeightV2Weight; readonly maxExtrinsic: Option; @@ -6383,25 +6607,25 @@ declare module "@polkadot/types/lookup" { readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (510) */ + /** @name FrameSystemLimitsBlockLength (520) */ interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportDispatchPerDispatchClassU32; } - /** @name FrameSupportDispatchPerDispatchClassU32 (511) */ + /** @name FrameSupportDispatchPerDispatchClassU32 (521) */ interface FrameSupportDispatchPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name SpWeightsRuntimeDbWeight (512) */ + /** @name SpWeightsRuntimeDbWeight (522) */ interface SpWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (513) */ + /** @name SpVersionRuntimeVersion (523) */ interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -6413,7 +6637,7 @@ declare module "@polkadot/types/lookup" { readonly stateVersion: u8; } - /** @name FrameSystemError (517) */ + /** @name FrameSystemError (527) */ interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -6436,7 +6660,7 @@ declare module "@polkadot/types/lookup" { | "Unauthorized"; } - /** @name SpConsensusBabeDigestsPreDigest (524) */ + /** @name SpConsensusBabeDigestsPreDigest (534) */ interface SpConsensusBabeDigestsPreDigest extends Enum { readonly isPrimary: boolean; readonly asPrimary: SpConsensusBabeDigestsPrimaryPreDigest; @@ -6447,39 +6671,39 @@ declare module "@polkadot/types/lookup" { readonly type: "Primary" | "SecondaryPlain" | "SecondaryVRF"; } - /** @name SpConsensusBabeDigestsPrimaryPreDigest (525) */ + /** @name SpConsensusBabeDigestsPrimaryPreDigest (535) */ interface SpConsensusBabeDigestsPrimaryPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; readonly vrfSignature: SpCoreSr25519VrfVrfSignature; } - /** @name SpCoreSr25519VrfVrfSignature (526) */ + /** @name SpCoreSr25519VrfVrfSignature (536) */ interface SpCoreSr25519VrfVrfSignature extends Struct { readonly preOutput: U8aFixed; readonly proof: U8aFixed; } - /** @name SpConsensusBabeDigestsSecondaryPlainPreDigest (527) */ + /** @name SpConsensusBabeDigestsSecondaryPlainPreDigest (537) */ interface SpConsensusBabeDigestsSecondaryPlainPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; } - /** @name SpConsensusBabeDigestsSecondaryVRFPreDigest (528) */ + /** @name SpConsensusBabeDigestsSecondaryVRFPreDigest (538) */ interface SpConsensusBabeDigestsSecondaryVRFPreDigest extends Struct { readonly authorityIndex: u32; readonly slot: u64; readonly vrfSignature: SpCoreSr25519VrfVrfSignature; } - /** @name SpConsensusBabeBabeEpochConfiguration (529) */ + /** @name SpConsensusBabeBabeEpochConfiguration (539) */ interface SpConsensusBabeBabeEpochConfiguration extends Struct { readonly c: ITuple<[u64, u64]>; readonly allowedSlots: SpConsensusBabeAllowedSlots; } - /** @name PalletBabeError (533) */ + /** @name PalletBabeError (543) */ interface PalletBabeError extends Enum { readonly isInvalidEquivocationProof: boolean; readonly isInvalidKeyOwnershipProof: boolean; @@ -6492,14 +6716,14 @@ declare module "@polkadot/types/lookup" { | "InvalidConfiguration"; } - /** @name PalletBalancesBalanceLock (535) */ + /** @name PalletBalancesBalanceLock (545) */ interface PalletBalancesBalanceLock extends Struct { readonly id: U8aFixed; readonly amount: u128; readonly reasons: PalletBalancesReasons; } - /** @name PalletBalancesReasons (536) */ + /** @name PalletBalancesReasons (546) */ interface PalletBalancesReasons extends Enum { readonly isFee: boolean; readonly isMisc: boolean; @@ -6507,48 +6731,56 @@ declare module "@polkadot/types/lookup" { readonly type: "Fee" | "Misc" | "All"; } - /** @name PalletBalancesReserveData (539) */ + /** @name PalletBalancesReserveData (549) */ interface PalletBalancesReserveData extends Struct { readonly id: U8aFixed; readonly amount: u128; } - /** @name DancelightRuntimeRuntimeHoldReason (543) */ + /** @name DancelightRuntimeRuntimeHoldReason (553) */ interface DancelightRuntimeRuntimeHoldReason extends Enum { readonly isContainerRegistrar: boolean; readonly asContainerRegistrar: PalletRegistrarHoldReason; readonly isDataPreservers: boolean; readonly asDataPreservers: PalletDataPreserversHoldReason; + readonly isPooledStaking: boolean; + readonly asPooledStaking: PalletPooledStakingHoldReason; readonly isPreimage: boolean; readonly asPreimage: PalletPreimageHoldReason; - readonly type: "ContainerRegistrar" | "DataPreservers" | "Preimage"; + readonly type: "ContainerRegistrar" | "DataPreservers" | "PooledStaking" | "Preimage"; } - /** @name PalletRegistrarHoldReason (544) */ + /** @name PalletRegistrarHoldReason (554) */ interface PalletRegistrarHoldReason extends Enum { readonly isRegistrarDeposit: boolean; readonly type: "RegistrarDeposit"; } - /** @name PalletDataPreserversHoldReason (545) */ + /** @name PalletDataPreserversHoldReason (555) */ interface PalletDataPreserversHoldReason extends Enum { readonly isProfileDeposit: boolean; readonly type: "ProfileDeposit"; } - /** @name PalletPreimageHoldReason (546) */ + /** @name PalletPooledStakingHoldReason (556) */ + interface PalletPooledStakingHoldReason extends Enum { + readonly isPooledStake: boolean; + readonly type: "PooledStake"; + } + + /** @name PalletPreimageHoldReason (557) */ interface PalletPreimageHoldReason extends Enum { readonly isPreimage: boolean; readonly type: "Preimage"; } - /** @name FrameSupportTokensMiscIdAmount (549) */ + /** @name FrameSupportTokensMiscIdAmount (560) */ interface FrameSupportTokensMiscIdAmount extends Struct { readonly id: Null; readonly amount: u128; } - /** @name PalletBalancesError (551) */ + /** @name PalletBalancesError (562) */ interface PalletBalancesError extends Enum { readonly isVestingBalance: boolean; readonly isLiquidityRestrictions: boolean; @@ -6577,26 +6809,26 @@ declare module "@polkadot/types/lookup" { | "DeltaZero"; } - /** @name PalletTransactionPaymentReleases (552) */ + /** @name PalletTransactionPaymentReleases (563) */ interface PalletTransactionPaymentReleases extends Enum { readonly isV1Ancient: boolean; readonly isV2: boolean; readonly type: "V1Ancient" | "V2"; } - /** @name SpStakingOffenceOffenceDetails (553) */ + /** @name SpStakingOffenceOffenceDetails (564) */ interface SpStakingOffenceOffenceDetails extends Struct { readonly offender: ITuple<[AccountId32, Null]>; readonly reporters: Vec; } - /** @name PalletRegistrarDepositInfo (565) */ + /** @name PalletRegistrarDepositInfo (576) */ interface PalletRegistrarDepositInfo extends Struct { readonly creator: AccountId32; readonly deposit: u128; } - /** @name PalletRegistrarError (566) */ + /** @name PalletRegistrarError (577) */ interface PalletRegistrarError extends Enum { readonly isParaIdAlreadyRegistered: boolean; readonly isParaIdNotRegistered: boolean; @@ -6635,7 +6867,7 @@ declare module "@polkadot/types/lookup" { | "WasmCodeNecessary"; } - /** @name PalletConfigurationHostConfiguration (567) */ + /** @name PalletConfigurationHostConfiguration (578) */ interface PalletConfigurationHostConfiguration extends Struct { readonly maxCollators: u32; readonly minOrchestratorCollators: u32; @@ -6648,13 +6880,13 @@ declare module "@polkadot/types/lookup" { readonly maxParachainCoresPercentage: Option; } - /** @name PalletConfigurationError (570) */ + /** @name PalletConfigurationError (581) */ interface PalletConfigurationError extends Enum { readonly isInvalidNewValue: boolean; readonly type: "InvalidNewValue"; } - /** @name PalletInvulnerablesError (572) */ + /** @name PalletInvulnerablesError (583) */ interface PalletInvulnerablesError extends Enum { readonly isTooManyInvulnerables: boolean; readonly isAlreadyInvulnerable: boolean; @@ -6669,26 +6901,26 @@ declare module "@polkadot/types/lookup" { | "UnableToDeriveCollatorId"; } - /** @name DpCollatorAssignmentAssignedCollatorsAccountId32 (573) */ + /** @name DpCollatorAssignmentAssignedCollatorsAccountId32 (584) */ interface DpCollatorAssignmentAssignedCollatorsAccountId32 extends Struct { readonly orchestratorChain: Vec; readonly containerChains: BTreeMap>; } - /** @name DpCollatorAssignmentAssignedCollatorsPublic (578) */ + /** @name DpCollatorAssignmentAssignedCollatorsPublic (589) */ interface DpCollatorAssignmentAssignedCollatorsPublic extends Struct { readonly orchestratorChain: Vec; readonly containerChains: BTreeMap>; } - /** @name TpTraitsContainerChainBlockInfo (586) */ + /** @name TpTraitsContainerChainBlockInfo (597) */ interface TpTraitsContainerChainBlockInfo extends Struct { readonly blockNumber: u32; readonly author: AccountId32; readonly latestSlotNumber: u64; } - /** @name PalletAuthorNotingError (587) */ + /** @name PalletAuthorNotingError (598) */ interface PalletAuthorNotingError extends Enum { readonly isFailedReading: boolean; readonly isFailedDecodingHeader: boolean; @@ -6707,7 +6939,7 @@ declare module "@polkadot/types/lookup" { | "NonAuraDigest"; } - /** @name PalletServicesPaymentError (588) */ + /** @name PalletServicesPaymentError (599) */ interface PalletServicesPaymentError extends Enum { readonly isInsufficientFundsToPurchaseCredits: boolean; readonly isInsufficientCredits: boolean; @@ -6715,7 +6947,7 @@ declare module "@polkadot/types/lookup" { readonly type: "InsufficientFundsToPurchaseCredits" | "InsufficientCredits" | "CreditPriceTooExpensive"; } - /** @name PalletDataPreserversRegisteredProfile (589) */ + /** @name PalletDataPreserversRegisteredProfile (600) */ interface PalletDataPreserversRegisteredProfile extends Struct { readonly account: AccountId32; readonly deposit: u128; @@ -6723,7 +6955,7 @@ declare module "@polkadot/types/lookup" { readonly assignment: Option>; } - /** @name PalletDataPreserversError (595) */ + /** @name PalletDataPreserversError (606) */ interface PalletDataPreserversError extends Enum { readonly isNoBootNodes: boolean; readonly isUnknownProfileId: boolean; @@ -6748,13 +6980,13 @@ declare module "@polkadot/types/lookup" { | "CantDeleteAssignedProfile"; } - /** @name TpTraitsActiveEraInfo (598) */ + /** @name TpTraitsActiveEraInfo (609) */ interface TpTraitsActiveEraInfo extends Struct { readonly index: u32; readonly start: Option; } - /** @name PalletExternalValidatorsError (600) */ + /** @name PalletExternalValidatorsError (611) */ interface PalletExternalValidatorsError extends Enum { readonly isTooManyWhitelisted: boolean; readonly isAlreadyWhitelisted: boolean; @@ -6769,7 +7001,7 @@ declare module "@polkadot/types/lookup" { | "UnableToDeriveValidatorId"; } - /** @name PalletExternalValidatorSlashesSlash (603) */ + /** @name PalletExternalValidatorSlashesSlash (614) */ interface PalletExternalValidatorSlashesSlash extends Struct { readonly validator: AccountId32; readonly reporters: Vec; @@ -6778,7 +7010,7 @@ declare module "@polkadot/types/lookup" { readonly confirmed: bool; } - /** @name PalletExternalValidatorSlashesError (604) */ + /** @name PalletExternalValidatorSlashesError (615) */ interface PalletExternalValidatorSlashesError extends Enum { readonly isEmptyTargets: boolean; readonly isInvalidSlashIndex: boolean; @@ -6801,16 +7033,16 @@ declare module "@polkadot/types/lookup" { | "EthereumDeliverFail"; } - /** @name PalletExternalValidatorsRewardsEraRewardPoints (605) */ + /** @name PalletExternalValidatorsRewardsEraRewardPoints (616) */ interface PalletExternalValidatorsRewardsEraRewardPoints extends Struct { readonly total: u32; readonly individual: BTreeMap; } - /** @name SpCoreCryptoKeyTypeId (612) */ + /** @name SpCoreCryptoKeyTypeId (623) */ interface SpCoreCryptoKeyTypeId extends U8aFixed {} - /** @name PalletSessionError (613) */ + /** @name PalletSessionError (624) */ interface PalletSessionError extends Enum { readonly isInvalidProof: boolean; readonly isNoAssociatedValidatorId: boolean; @@ -6820,7 +7052,7 @@ declare module "@polkadot/types/lookup" { readonly type: "InvalidProof" | "NoAssociatedValidatorId" | "DuplicatedKey" | "NoKeys" | "NoAccount"; } - /** @name PalletGrandpaStoredState (614) */ + /** @name PalletGrandpaStoredState (625) */ interface PalletGrandpaStoredState extends Enum { readonly isLive: boolean; readonly isPendingPause: boolean; @@ -6837,7 +7069,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Live" | "PendingPause" | "Paused" | "PendingResume"; } - /** @name PalletGrandpaStoredPendingChange (615) */ + /** @name PalletGrandpaStoredPendingChange (626) */ interface PalletGrandpaStoredPendingChange extends Struct { readonly scheduledAt: u32; readonly delay: u32; @@ -6845,7 +7077,7 @@ declare module "@polkadot/types/lookup" { readonly forced: Option; } - /** @name PalletGrandpaError (617) */ + /** @name PalletGrandpaError (628) */ interface PalletGrandpaError extends Enum { readonly isPauseFailed: boolean; readonly isResumeFailed: boolean; @@ -6864,13 +7096,123 @@ declare module "@polkadot/types/lookup" { | "DuplicateOffenceReport"; } - /** @name PalletInflationRewardsChainsToRewardValue (620) */ + /** @name PalletInflationRewardsChainsToRewardValue (631) */ interface PalletInflationRewardsChainsToRewardValue extends Struct { readonly paraIds: Vec; readonly rewardsPerChain: u128; } - /** @name PalletTreasuryProposal (621) */ + /** @name PalletPooledStakingCandidateEligibleCandidate (633) */ + interface PalletPooledStakingCandidateEligibleCandidate extends Struct { + readonly candidate: AccountId32; + readonly stake: u128; + } + + /** @name PalletPooledStakingPoolsKey (636) */ + interface PalletPooledStakingPoolsKey extends Enum { + readonly isCandidateTotalStake: boolean; + readonly isJoiningShares: boolean; + readonly asJoiningShares: { + readonly delegator: AccountId32; + } & Struct; + readonly isJoiningSharesSupply: boolean; + readonly isJoiningSharesTotalStaked: boolean; + readonly isJoiningSharesHeldStake: boolean; + readonly asJoiningSharesHeldStake: { + readonly delegator: AccountId32; + } & Struct; + readonly isAutoCompoundingShares: boolean; + readonly asAutoCompoundingShares: { + readonly delegator: AccountId32; + } & Struct; + readonly isAutoCompoundingSharesSupply: boolean; + readonly isAutoCompoundingSharesTotalStaked: boolean; + readonly isAutoCompoundingSharesHeldStake: boolean; + readonly asAutoCompoundingSharesHeldStake: { + readonly delegator: AccountId32; + } & Struct; + readonly isManualRewardsShares: boolean; + readonly asManualRewardsShares: { + readonly delegator: AccountId32; + } & Struct; + readonly isManualRewardsSharesSupply: boolean; + readonly isManualRewardsSharesTotalStaked: boolean; + readonly isManualRewardsSharesHeldStake: boolean; + readonly asManualRewardsSharesHeldStake: { + readonly delegator: AccountId32; + } & Struct; + readonly isManualRewardsCounter: boolean; + readonly isManualRewardsCheckpoint: boolean; + readonly asManualRewardsCheckpoint: { + readonly delegator: AccountId32; + } & Struct; + readonly isLeavingShares: boolean; + readonly asLeavingShares: { + readonly delegator: AccountId32; + } & Struct; + readonly isLeavingSharesSupply: boolean; + readonly isLeavingSharesTotalStaked: boolean; + readonly isLeavingSharesHeldStake: boolean; + readonly asLeavingSharesHeldStake: { + readonly delegator: AccountId32; + } & Struct; + readonly type: + | "CandidateTotalStake" + | "JoiningShares" + | "JoiningSharesSupply" + | "JoiningSharesTotalStaked" + | "JoiningSharesHeldStake" + | "AutoCompoundingShares" + | "AutoCompoundingSharesSupply" + | "AutoCompoundingSharesTotalStaked" + | "AutoCompoundingSharesHeldStake" + | "ManualRewardsShares" + | "ManualRewardsSharesSupply" + | "ManualRewardsSharesTotalStaked" + | "ManualRewardsSharesHeldStake" + | "ManualRewardsCounter" + | "ManualRewardsCheckpoint" + | "LeavingShares" + | "LeavingSharesSupply" + | "LeavingSharesTotalStaked" + | "LeavingSharesHeldStake"; + } + + /** @name PalletPooledStakingError (638) */ + interface PalletPooledStakingError extends Enum { + readonly isInvalidPalletSetting: boolean; + readonly isDisabledFeature: boolean; + readonly isNoOneIsStaking: boolean; + readonly isStakeMustBeNonZero: boolean; + readonly isRewardsMustBeNonZero: boolean; + readonly isMathUnderflow: boolean; + readonly isMathOverflow: boolean; + readonly isNotEnoughShares: boolean; + readonly isTryingToLeaveTooSoon: boolean; + readonly isInconsistentState: boolean; + readonly isUnsufficientSharesForTransfer: boolean; + readonly isCandidateTransferingOwnSharesForbidden: boolean; + readonly isRequestCannotBeExecuted: boolean; + readonly asRequestCannotBeExecuted: u16; + readonly isSwapResultsInZeroShares: boolean; + readonly type: + | "InvalidPalletSetting" + | "DisabledFeature" + | "NoOneIsStaking" + | "StakeMustBeNonZero" + | "RewardsMustBeNonZero" + | "MathUnderflow" + | "MathOverflow" + | "NotEnoughShares" + | "TryingToLeaveTooSoon" + | "InconsistentState" + | "UnsufficientSharesForTransfer" + | "CandidateTransferingOwnSharesForbidden" + | "RequestCannotBeExecuted" + | "SwapResultsInZeroShares"; + } + + /** @name PalletTreasuryProposal (639) */ interface PalletTreasuryProposal extends Struct { readonly proposer: AccountId32; readonly value: u128; @@ -6878,7 +7220,7 @@ declare module "@polkadot/types/lookup" { readonly bond: u128; } - /** @name PalletTreasurySpendStatus (623) */ + /** @name PalletTreasurySpendStatus (641) */ interface PalletTreasurySpendStatus extends Struct { readonly assetKind: Null; readonly amount: u128; @@ -6888,7 +7230,7 @@ declare module "@polkadot/types/lookup" { readonly status: PalletTreasuryPaymentState; } - /** @name PalletTreasuryPaymentState (624) */ + /** @name PalletTreasuryPaymentState (642) */ interface PalletTreasuryPaymentState extends Enum { readonly isPending: boolean; readonly isAttempted: boolean; @@ -6899,10 +7241,10 @@ declare module "@polkadot/types/lookup" { readonly type: "Pending" | "Attempted" | "Failed"; } - /** @name FrameSupportPalletId (626) */ + /** @name FrameSupportPalletId (644) */ interface FrameSupportPalletId extends U8aFixed {} - /** @name PalletTreasuryError (627) */ + /** @name PalletTreasuryError (645) */ interface PalletTreasuryError extends Enum { readonly isInvalidIndex: boolean; readonly isTooManyApprovals: boolean; @@ -6929,7 +7271,7 @@ declare module "@polkadot/types/lookup" { | "Inconclusive"; } - /** @name PalletConvictionVotingVoteVoting (629) */ + /** @name PalletConvictionVotingVoteVoting (647) */ interface PalletConvictionVotingVoteVoting extends Enum { readonly isCasting: boolean; readonly asCasting: PalletConvictionVotingVoteCasting; @@ -6938,23 +7280,23 @@ declare module "@polkadot/types/lookup" { readonly type: "Casting" | "Delegating"; } - /** @name PalletConvictionVotingVoteCasting (630) */ + /** @name PalletConvictionVotingVoteCasting (648) */ interface PalletConvictionVotingVoteCasting extends Struct { readonly votes: Vec>; readonly delegations: PalletConvictionVotingDelegations; readonly prior: PalletConvictionVotingVotePriorLock; } - /** @name PalletConvictionVotingDelegations (634) */ + /** @name PalletConvictionVotingDelegations (652) */ interface PalletConvictionVotingDelegations extends Struct { readonly votes: u128; readonly capital: u128; } - /** @name PalletConvictionVotingVotePriorLock (635) */ + /** @name PalletConvictionVotingVotePriorLock (653) */ interface PalletConvictionVotingVotePriorLock extends ITuple<[u32, u128]> {} - /** @name PalletConvictionVotingVoteDelegating (636) */ + /** @name PalletConvictionVotingVoteDelegating (654) */ interface PalletConvictionVotingVoteDelegating extends Struct { readonly balance: u128; readonly target: AccountId32; @@ -6963,7 +7305,7 @@ declare module "@polkadot/types/lookup" { readonly prior: PalletConvictionVotingVotePriorLock; } - /** @name PalletConvictionVotingError (640) */ + /** @name PalletConvictionVotingError (658) */ interface PalletConvictionVotingError extends Enum { readonly isNotOngoing: boolean; readonly isNotVoter: boolean; @@ -6992,7 +7334,7 @@ declare module "@polkadot/types/lookup" { | "BadClass"; } - /** @name PalletReferendaReferendumInfoConvictionVotingTally (641) */ + /** @name PalletReferendaReferendumInfoConvictionVotingTally (659) */ interface PalletReferendaReferendumInfoConvictionVotingTally extends Enum { readonly isOngoing: boolean; readonly asOngoing: PalletReferendaReferendumStatusConvictionVotingTally; @@ -7009,7 +7351,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ongoing" | "Approved" | "Rejected" | "Cancelled" | "TimedOut" | "Killed"; } - /** @name PalletReferendaReferendumStatusConvictionVotingTally (642) */ + /** @name PalletReferendaReferendumStatusConvictionVotingTally (660) */ interface PalletReferendaReferendumStatusConvictionVotingTally extends Struct { readonly track: u16; readonly origin: DancelightRuntimeOriginCaller; @@ -7024,19 +7366,19 @@ declare module "@polkadot/types/lookup" { readonly alarm: Option]>>; } - /** @name PalletReferendaDeposit (643) */ + /** @name PalletReferendaDeposit (661) */ interface PalletReferendaDeposit extends Struct { readonly who: AccountId32; readonly amount: u128; } - /** @name PalletReferendaDecidingStatus (646) */ + /** @name PalletReferendaDecidingStatus (664) */ interface PalletReferendaDecidingStatus extends Struct { readonly since: u32; readonly confirming: Option; } - /** @name PalletReferendaTrackInfo (654) */ + /** @name PalletReferendaTrackInfo (672) */ interface PalletReferendaTrackInfo extends Struct { readonly name: Text; readonly maxDeciding: u32; @@ -7049,7 +7391,7 @@ declare module "@polkadot/types/lookup" { readonly minSupport: PalletReferendaCurve; } - /** @name PalletReferendaCurve (655) */ + /** @name PalletReferendaCurve (673) */ interface PalletReferendaCurve extends Enum { readonly isLinearDecreasing: boolean; readonly asLinearDecreasing: { @@ -7073,7 +7415,7 @@ declare module "@polkadot/types/lookup" { readonly type: "LinearDecreasing" | "SteppedDecreasing" | "Reciprocal"; } - /** @name PalletReferendaError (658) */ + /** @name PalletReferendaError (676) */ interface PalletReferendaError extends Enum { readonly isNotOngoing: boolean; readonly isHasDeposit: boolean; @@ -7106,12 +7448,12 @@ declare module "@polkadot/types/lookup" { | "PreimageStoredWithDifferentLength"; } - /** @name PalletRankedCollectiveMemberRecord (659) */ + /** @name PalletRankedCollectiveMemberRecord (677) */ interface PalletRankedCollectiveMemberRecord extends Struct { readonly rank: u16; } - /** @name PalletRankedCollectiveError (663) */ + /** @name PalletRankedCollectiveError (681) */ interface PalletRankedCollectiveError extends Enum { readonly isAlreadyMember: boolean; readonly isNotMember: boolean; @@ -7138,7 +7480,7 @@ declare module "@polkadot/types/lookup" { | "TooManyMembers"; } - /** @name PalletReferendaReferendumInfoRankedCollectiveTally (664) */ + /** @name PalletReferendaReferendumInfoRankedCollectiveTally (682) */ interface PalletReferendaReferendumInfoRankedCollectiveTally extends Enum { readonly isOngoing: boolean; readonly asOngoing: PalletReferendaReferendumStatusRankedCollectiveTally; @@ -7155,7 +7497,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Ongoing" | "Approved" | "Rejected" | "Cancelled" | "TimedOut" | "Killed"; } - /** @name PalletReferendaReferendumStatusRankedCollectiveTally (665) */ + /** @name PalletReferendaReferendumStatusRankedCollectiveTally (683) */ interface PalletReferendaReferendumStatusRankedCollectiveTally extends Struct { readonly track: u16; readonly origin: DancelightRuntimeOriginCaller; @@ -7170,7 +7512,7 @@ declare module "@polkadot/types/lookup" { readonly alarm: Option]>>; } - /** @name PalletWhitelistError (668) */ + /** @name PalletWhitelistError (686) */ interface PalletWhitelistError extends Enum { readonly isUnavailablePreImage: boolean; readonly isUndecodableCall: boolean; @@ -7185,7 +7527,7 @@ declare module "@polkadot/types/lookup" { | "CallAlreadyWhitelisted"; } - /** @name PolkadotRuntimeParachainsConfigurationHostConfiguration (669) */ + /** @name PolkadotRuntimeParachainsConfigurationHostConfiguration (687) */ interface PolkadotRuntimeParachainsConfigurationHostConfiguration extends Struct { readonly maxCodeSize: u32; readonly maxHeadDataSize: u32; @@ -7224,19 +7566,19 @@ declare module "@polkadot/types/lookup" { readonly schedulerParams: PolkadotPrimitivesV8SchedulerParams; } - /** @name PolkadotRuntimeParachainsConfigurationPalletError (672) */ + /** @name PolkadotRuntimeParachainsConfigurationPalletError (690) */ interface PolkadotRuntimeParachainsConfigurationPalletError extends Enum { readonly isInvalidNewValue: boolean; readonly type: "InvalidNewValue"; } - /** @name PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker (675) */ + /** @name PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker (693) */ interface PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker extends Struct { readonly buffer: Vec>; readonly latestNumber: u32; } - /** @name PolkadotRuntimeParachainsInclusionCandidatePendingAvailability (679) */ + /** @name PolkadotRuntimeParachainsInclusionCandidatePendingAvailability (697) */ interface PolkadotRuntimeParachainsInclusionCandidatePendingAvailability extends Struct { readonly core: u32; readonly hash_: H256; @@ -7249,7 +7591,7 @@ declare module "@polkadot/types/lookup" { readonly backingGroup: u32; } - /** @name PolkadotRuntimeParachainsInclusionPalletError (680) */ + /** @name PolkadotRuntimeParachainsInclusionPalletError (698) */ interface PolkadotRuntimeParachainsInclusionPalletError extends Enum { readonly isValidatorIndexOutOfBounds: boolean; readonly isUnscheduledCandidate: boolean; @@ -7288,7 +7630,7 @@ declare module "@polkadot/types/lookup" { | "ParaHeadMismatch"; } - /** @name PolkadotPrimitivesV8ScrapedOnChainVotes (681) */ + /** @name PolkadotPrimitivesV8ScrapedOnChainVotes (699) */ interface PolkadotPrimitivesV8ScrapedOnChainVotes extends Struct { readonly session: u32; readonly backingValidatorsPerCandidate: Vec< @@ -7297,7 +7639,7 @@ declare module "@polkadot/types/lookup" { readonly disputes: Vec; } - /** @name PolkadotRuntimeParachainsParasInherentPalletError (686) */ + /** @name PolkadotRuntimeParachainsParasInherentPalletError (704) */ interface PolkadotRuntimeParachainsParasInherentPalletError extends Enum { readonly isTooManyInclusionInherents: boolean; readonly isInvalidParentHeader: boolean; @@ -7312,7 +7654,7 @@ declare module "@polkadot/types/lookup" { | "UnscheduledCandidate"; } - /** @name PolkadotRuntimeParachainsSchedulerPalletCoreOccupied (689) */ + /** @name PolkadotRuntimeParachainsSchedulerPalletCoreOccupied (707) */ interface PolkadotRuntimeParachainsSchedulerPalletCoreOccupied extends Enum { readonly isFree: boolean; readonly isParas: boolean; @@ -7320,14 +7662,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Free" | "Paras"; } - /** @name PolkadotRuntimeParachainsSchedulerPalletParasEntry (690) */ + /** @name PolkadotRuntimeParachainsSchedulerPalletParasEntry (708) */ interface PolkadotRuntimeParachainsSchedulerPalletParasEntry extends Struct { readonly assignment: PolkadotRuntimeParachainsSchedulerCommonAssignment; readonly availabilityTimeouts: u32; readonly ttl: u32; } - /** @name PolkadotRuntimeParachainsSchedulerCommonAssignment (691) */ + /** @name PolkadotRuntimeParachainsSchedulerCommonAssignment (709) */ interface PolkadotRuntimeParachainsSchedulerCommonAssignment extends Enum { readonly isPool: boolean; readonly asPool: { @@ -7339,7 +7681,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Pool" | "Bulk"; } - /** @name PolkadotRuntimeParachainsParasPvfCheckActiveVoteState (696) */ + /** @name PolkadotRuntimeParachainsParasPvfCheckActiveVoteState (714) */ interface PolkadotRuntimeParachainsParasPvfCheckActiveVoteState extends Struct { readonly votesAccept: BitVec; readonly votesReject: BitVec; @@ -7348,7 +7690,7 @@ declare module "@polkadot/types/lookup" { readonly causes: Vec; } - /** @name PolkadotRuntimeParachainsParasPvfCheckCause (698) */ + /** @name PolkadotRuntimeParachainsParasPvfCheckCause (716) */ interface PolkadotRuntimeParachainsParasPvfCheckCause extends Enum { readonly isOnboarding: boolean; readonly asOnboarding: u32; @@ -7361,14 +7703,14 @@ declare module "@polkadot/types/lookup" { readonly type: "Onboarding" | "Upgrade"; } - /** @name PolkadotRuntimeParachainsParasUpgradeStrategy (699) */ + /** @name PolkadotRuntimeParachainsParasUpgradeStrategy (717) */ interface PolkadotRuntimeParachainsParasUpgradeStrategy extends Enum { readonly isSetGoAheadSignal: boolean; readonly isApplyAtExpectedBlock: boolean; readonly type: "SetGoAheadSignal" | "ApplyAtExpectedBlock"; } - /** @name PolkadotRuntimeParachainsParasParaLifecycle (701) */ + /** @name PolkadotRuntimeParachainsParasParaLifecycle (719) */ interface PolkadotRuntimeParachainsParasParaLifecycle extends Enum { readonly isOnboarding: boolean; readonly isParathread: boolean; @@ -7387,32 +7729,32 @@ declare module "@polkadot/types/lookup" { | "OffboardingParachain"; } - /** @name PolkadotRuntimeParachainsParasParaPastCodeMeta (703) */ + /** @name PolkadotRuntimeParachainsParasParaPastCodeMeta (721) */ interface PolkadotRuntimeParachainsParasParaPastCodeMeta extends Struct { readonly upgradeTimes: Vec; readonly lastPruned: Option; } - /** @name PolkadotRuntimeParachainsParasReplacementTimes (705) */ + /** @name PolkadotRuntimeParachainsParasReplacementTimes (723) */ interface PolkadotRuntimeParachainsParasReplacementTimes extends Struct { readonly expectedAt: u32; readonly activatedAt: u32; } - /** @name PolkadotPrimitivesV8UpgradeGoAhead (707) */ + /** @name PolkadotPrimitivesV8UpgradeGoAhead (725) */ interface PolkadotPrimitivesV8UpgradeGoAhead extends Enum { readonly isAbort: boolean; readonly isGoAhead: boolean; readonly type: "Abort" | "GoAhead"; } - /** @name PolkadotPrimitivesV8UpgradeRestriction (708) */ + /** @name PolkadotPrimitivesV8UpgradeRestriction (726) */ interface PolkadotPrimitivesV8UpgradeRestriction extends Enum { readonly isPresent: boolean; readonly type: "Present"; } - /** @name PolkadotRuntimeParachainsParasPalletError (709) */ + /** @name PolkadotRuntimeParachainsParasPalletError (727) */ interface PolkadotRuntimeParachainsParasPalletError extends Enum { readonly isNotRegistered: boolean; readonly isCannotOnboard: boolean; @@ -7443,20 +7785,20 @@ declare module "@polkadot/types/lookup" { | "InvalidCode"; } - /** @name PolkadotRuntimeParachainsInitializerBufferedSessionChange (711) */ + /** @name PolkadotRuntimeParachainsInitializerBufferedSessionChange (729) */ interface PolkadotRuntimeParachainsInitializerBufferedSessionChange extends Struct { readonly validators: Vec; readonly queued: Vec; readonly sessionIndex: u32; } - /** @name PolkadotCorePrimitivesInboundDownwardMessage (713) */ + /** @name PolkadotCorePrimitivesInboundDownwardMessage (731) */ interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct { readonly sentAt: u32; readonly msg: Bytes; } - /** @name PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest (714) */ + /** @name PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest (732) */ interface PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest extends Struct { readonly confirmed: bool; readonly age: u32; @@ -7466,7 +7808,7 @@ declare module "@polkadot/types/lookup" { readonly maxTotalSize: u32; } - /** @name PolkadotRuntimeParachainsHrmpHrmpChannel (716) */ + /** @name PolkadotRuntimeParachainsHrmpHrmpChannel (734) */ interface PolkadotRuntimeParachainsHrmpHrmpChannel extends Struct { readonly maxCapacity: u32; readonly maxTotalSize: u32; @@ -7478,13 +7820,13 @@ declare module "@polkadot/types/lookup" { readonly recipientDeposit: u128; } - /** @name PolkadotCorePrimitivesInboundHrmpMessage (718) */ + /** @name PolkadotCorePrimitivesInboundHrmpMessage (736) */ interface PolkadotCorePrimitivesInboundHrmpMessage extends Struct { readonly sentAt: u32; readonly data: Bytes; } - /** @name PolkadotRuntimeParachainsHrmpPalletError (721) */ + /** @name PolkadotRuntimeParachainsHrmpPalletError (739) */ interface PolkadotRuntimeParachainsHrmpPalletError extends Enum { readonly isOpenHrmpChannelToSelf: boolean; readonly isOpenHrmpChannelInvalidRecipient: boolean; @@ -7529,7 +7871,7 @@ declare module "@polkadot/types/lookup" { | "ChannelCreationNotAuthorized"; } - /** @name PolkadotPrimitivesV8SessionInfo (723) */ + /** @name PolkadotPrimitivesV8SessionInfo (741) */ interface PolkadotPrimitivesV8SessionInfo extends Struct { readonly activeValidatorIndices: Vec; readonly randomSeed: U8aFixed; @@ -7546,13 +7888,13 @@ declare module "@polkadot/types/lookup" { readonly neededApprovals: u32; } - /** @name PolkadotPrimitivesV8IndexedVecValidatorIndex (724) */ + /** @name PolkadotPrimitivesV8IndexedVecValidatorIndex (742) */ interface PolkadotPrimitivesV8IndexedVecValidatorIndex extends Vec {} - /** @name PolkadotPrimitivesV8IndexedVecGroupIndex (725) */ + /** @name PolkadotPrimitivesV8IndexedVecGroupIndex (743) */ interface PolkadotPrimitivesV8IndexedVecGroupIndex extends Vec> {} - /** @name PolkadotPrimitivesV8DisputeState (727) */ + /** @name PolkadotPrimitivesV8DisputeState (745) */ interface PolkadotPrimitivesV8DisputeState extends Struct { readonly validatorsFor: BitVec; readonly validatorsAgainst: BitVec; @@ -7560,7 +7902,7 @@ declare module "@polkadot/types/lookup" { readonly concludedAt: Option; } - /** @name PolkadotRuntimeParachainsDisputesPalletError (729) */ + /** @name PolkadotRuntimeParachainsDisputesPalletError (747) */ interface PolkadotRuntimeParachainsDisputesPalletError extends Enum { readonly isDuplicateDisputeStatementSets: boolean; readonly isAncientDisputeStatement: boolean; @@ -7583,13 +7925,13 @@ declare module "@polkadot/types/lookup" { | "UnconfirmedDispute"; } - /** @name PolkadotPrimitivesV8SlashingPendingSlashes (730) */ + /** @name PolkadotPrimitivesV8SlashingPendingSlashes (748) */ interface PolkadotPrimitivesV8SlashingPendingSlashes extends Struct { readonly keys_: BTreeMap; readonly kind: PolkadotPrimitivesV8SlashingSlashingOffenceKind; } - /** @name PolkadotRuntimeParachainsDisputesSlashingPalletError (734) */ + /** @name PolkadotRuntimeParachainsDisputesSlashingPalletError (752) */ interface PolkadotRuntimeParachainsDisputesSlashingPalletError extends Enum { readonly isInvalidKeyOwnershipProof: boolean; readonly isInvalidSessionIndex: boolean; @@ -7606,7 +7948,7 @@ declare module "@polkadot/types/lookup" { | "DuplicateSlashingReport"; } - /** @name PalletMessageQueueBookState (735) */ + /** @name PalletMessageQueueBookState (753) */ interface PalletMessageQueueBookState extends Struct { readonly begin: u32; readonly end: u32; @@ -7616,13 +7958,13 @@ declare module "@polkadot/types/lookup" { readonly size_: u64; } - /** @name PalletMessageQueueNeighbours (737) */ + /** @name PalletMessageQueueNeighbours (755) */ interface PalletMessageQueueNeighbours extends Struct { readonly prev: DancelightRuntimeAggregateMessageOrigin; readonly next: DancelightRuntimeAggregateMessageOrigin; } - /** @name PalletMessageQueuePage (739) */ + /** @name PalletMessageQueuePage (757) */ interface PalletMessageQueuePage extends Struct { readonly remaining: u32; readonly remainingSize: u32; @@ -7632,7 +7974,7 @@ declare module "@polkadot/types/lookup" { readonly heap: Bytes; } - /** @name PalletMessageQueueError (741) */ + /** @name PalletMessageQueueError (759) */ interface PalletMessageQueueError extends Enum { readonly isNotReapable: boolean; readonly isNoPage: boolean; @@ -7655,13 +7997,13 @@ declare module "@polkadot/types/lookup" { | "RecursiveDisallowed"; } - /** @name PolkadotRuntimeParachainsOnDemandTypesCoreAffinityCount (742) */ + /** @name PolkadotRuntimeParachainsOnDemandTypesCoreAffinityCount (760) */ interface PolkadotRuntimeParachainsOnDemandTypesCoreAffinityCount extends Struct { readonly coreIndex: u32; readonly count: u32; } - /** @name PolkadotRuntimeParachainsOnDemandTypesQueueStatusType (743) */ + /** @name PolkadotRuntimeParachainsOnDemandTypesQueueStatusType (761) */ interface PolkadotRuntimeParachainsOnDemandTypesQueueStatusType extends Struct { readonly traffic: u128; readonly nextIndex: u32; @@ -7669,33 +8011,33 @@ declare module "@polkadot/types/lookup" { readonly freedIndices: BinaryHeapReverseQueueIndex; } - /** @name BinaryHeapReverseQueueIndex (745) */ + /** @name BinaryHeapReverseQueueIndex (763) */ interface BinaryHeapReverseQueueIndex extends Vec {} - /** @name BinaryHeapEnqueuedOrder (748) */ + /** @name BinaryHeapEnqueuedOrder (766) */ interface BinaryHeapEnqueuedOrder extends Vec {} - /** @name PolkadotRuntimeParachainsOnDemandTypesEnqueuedOrder (749) */ + /** @name PolkadotRuntimeParachainsOnDemandTypesEnqueuedOrder (767) */ interface PolkadotRuntimeParachainsOnDemandTypesEnqueuedOrder extends Struct { readonly paraId: u32; readonly idx: u32; } - /** @name PolkadotRuntimeParachainsOnDemandPalletError (753) */ + /** @name PolkadotRuntimeParachainsOnDemandPalletError (771) */ interface PolkadotRuntimeParachainsOnDemandPalletError extends Enum { readonly isQueueFull: boolean; readonly isSpotPriceHigherThanMaxAmount: boolean; readonly type: "QueueFull" | "SpotPriceHigherThanMaxAmount"; } - /** @name PolkadotRuntimeCommonParasRegistrarParaInfo (754) */ + /** @name PolkadotRuntimeCommonParasRegistrarParaInfo (772) */ interface PolkadotRuntimeCommonParasRegistrarParaInfo extends Struct { readonly manager: AccountId32; readonly deposit: u128; readonly locked: Option; } - /** @name PolkadotRuntimeCommonParasRegistrarPalletError (756) */ + /** @name PolkadotRuntimeCommonParasRegistrarPalletError (774) */ interface PolkadotRuntimeCommonParasRegistrarPalletError extends Enum { readonly isNotRegistered: boolean; readonly isAlreadyRegistered: boolean; @@ -7728,33 +8070,33 @@ declare module "@polkadot/types/lookup" { | "CannotSwap"; } - /** @name PalletUtilityError (757) */ + /** @name PalletUtilityError (775) */ interface PalletUtilityError extends Enum { readonly isTooManyCalls: boolean; readonly type: "TooManyCalls"; } - /** @name PalletIdentityRegistration (759) */ + /** @name PalletIdentityRegistration (777) */ interface PalletIdentityRegistration extends Struct { readonly judgements: Vec>; readonly deposit: u128; readonly info: PalletIdentityLegacyIdentityInfo; } - /** @name PalletIdentityRegistrarInfo (768) */ + /** @name PalletIdentityRegistrarInfo (786) */ interface PalletIdentityRegistrarInfo extends Struct { readonly account: AccountId32; readonly fee: u128; readonly fields: u64; } - /** @name PalletIdentityAuthorityProperties (770) */ + /** @name PalletIdentityAuthorityProperties (788) */ interface PalletIdentityAuthorityProperties extends Struct { readonly suffix: Bytes; readonly allocation: u32; } - /** @name PalletIdentityError (772) */ + /** @name PalletIdentityError (790) */ interface PalletIdentityError extends Enum { readonly isTooManySubAccounts: boolean; readonly isNotFound: boolean; @@ -7811,7 +8153,7 @@ declare module "@polkadot/types/lookup" { | "NotExpired"; } - /** @name PalletSchedulerScheduled (775) */ + /** @name PalletSchedulerScheduled (793) */ interface PalletSchedulerScheduled extends Struct { readonly maybeId: Option; readonly priority: u8; @@ -7820,14 +8162,14 @@ declare module "@polkadot/types/lookup" { readonly origin: DancelightRuntimeOriginCaller; } - /** @name PalletSchedulerRetryConfig (777) */ + /** @name PalletSchedulerRetryConfig (795) */ interface PalletSchedulerRetryConfig extends Struct { readonly totalRetries: u8; readonly remaining: u8; readonly period: u32; } - /** @name PalletSchedulerError (778) */ + /** @name PalletSchedulerError (796) */ interface PalletSchedulerError extends Enum { readonly isFailedToSchedule: boolean; readonly isNotFound: boolean; @@ -7837,21 +8179,21 @@ declare module "@polkadot/types/lookup" { readonly type: "FailedToSchedule" | "NotFound" | "TargetBlockNumberInPast" | "RescheduleNoChange" | "Named"; } - /** @name PalletProxyProxyDefinition (781) */ + /** @name PalletProxyProxyDefinition (799) */ interface PalletProxyProxyDefinition extends Struct { readonly delegate: AccountId32; readonly proxyType: DancelightRuntimeProxyType; readonly delay: u32; } - /** @name PalletProxyAnnouncement (785) */ + /** @name PalletProxyAnnouncement (803) */ interface PalletProxyAnnouncement extends Struct { readonly real: AccountId32; readonly callHash: H256; readonly height: u32; } - /** @name PalletProxyError (787) */ + /** @name PalletProxyError (805) */ interface PalletProxyError extends Enum { readonly isTooMany: boolean; readonly isNotFound: boolean; @@ -7872,7 +8214,7 @@ declare module "@polkadot/types/lookup" { | "NoSelfProxy"; } - /** @name PalletMultisigMultisig (789) */ + /** @name PalletMultisigMultisig (807) */ interface PalletMultisigMultisig extends Struct { readonly when: PalletMultisigTimepoint; readonly deposit: u128; @@ -7880,7 +8222,7 @@ declare module "@polkadot/types/lookup" { readonly approvals: Vec; } - /** @name PalletMultisigError (791) */ + /** @name PalletMultisigError (809) */ interface PalletMultisigError extends Enum { readonly isMinimumThreshold: boolean; readonly isAlreadyApproved: boolean; @@ -7913,7 +8255,7 @@ declare module "@polkadot/types/lookup" { | "AlreadyStored"; } - /** @name PalletPreimageOldRequestStatus (792) */ + /** @name PalletPreimageOldRequestStatus (810) */ interface PalletPreimageOldRequestStatus extends Enum { readonly isUnrequested: boolean; readonly asUnrequested: { @@ -7929,7 +8271,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unrequested" | "Requested"; } - /** @name PalletPreimageRequestStatus (795) */ + /** @name PalletPreimageRequestStatus (813) */ interface PalletPreimageRequestStatus extends Enum { readonly isUnrequested: boolean; readonly asUnrequested: { @@ -7945,7 +8287,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Unrequested" | "Requested"; } - /** @name PalletPreimageError (800) */ + /** @name PalletPreimageError (818) */ interface PalletPreimageError extends Enum { readonly isTooBig: boolean; readonly isAlreadyNoted: boolean; @@ -7966,7 +8308,7 @@ declare module "@polkadot/types/lookup" { | "TooFew"; } - /** @name PalletAssetRateError (801) */ + /** @name PalletAssetRateError (819) */ interface PalletAssetRateError extends Enum { readonly isUnknownAssetKind: boolean; readonly isAlreadyExists: boolean; @@ -7974,7 +8316,7 @@ declare module "@polkadot/types/lookup" { readonly type: "UnknownAssetKind" | "AlreadyExists" | "Overflow"; } - /** @name PalletXcmQueryStatus (802) */ + /** @name PalletXcmQueryStatus (820) */ interface PalletXcmQueryStatus extends Enum { readonly isPending: boolean; readonly asPending: { @@ -7996,7 +8338,7 @@ declare module "@polkadot/types/lookup" { readonly type: "Pending" | "VersionNotifier" | "Ready"; } - /** @name XcmVersionedResponse (806) */ + /** @name XcmVersionedResponse (824) */ interface XcmVersionedResponse extends Enum { readonly isV2: boolean; readonly asV2: XcmV2Response; @@ -8007,7 +8349,7 @@ declare module "@polkadot/types/lookup" { readonly type: "V2" | "V3" | "V4"; } - /** @name PalletXcmVersionMigrationStage (812) */ + /** @name PalletXcmVersionMigrationStage (830) */ interface PalletXcmVersionMigrationStage extends Enum { readonly isMigrateSupportedVersion: boolean; readonly isMigrateVersionNotifiers: boolean; @@ -8021,7 +8363,7 @@ declare module "@polkadot/types/lookup" { | "MigrateAndNotifyOldTargets"; } - /** @name PalletXcmRemoteLockedFungibleRecord (814) */ + /** @name PalletXcmRemoteLockedFungibleRecord (832) */ interface PalletXcmRemoteLockedFungibleRecord extends Struct { readonly amount: u128; readonly owner: XcmVersionedLocation; @@ -8029,7 +8371,7 @@ declare module "@polkadot/types/lookup" { readonly consumers: Vec>; } - /** @name PalletXcmError (821) */ + /** @name PalletXcmError (839) */ interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -8082,7 +8424,7 @@ declare module "@polkadot/types/lookup" { | "LocalExecutionIncomplete"; } - /** @name SnowbridgePalletInboundQueueError (822) */ + /** @name SnowbridgePalletInboundQueueError (840) */ interface SnowbridgePalletInboundQueueError extends Enum { readonly isInvalidGateway: boolean; readonly isInvalidEnvelope: boolean; @@ -8112,7 +8454,7 @@ declare module "@polkadot/types/lookup" { | "ConvertMessage"; } - /** @name SnowbridgeCoreInboundVerificationError (823) */ + /** @name SnowbridgeCoreInboundVerificationError (841) */ interface SnowbridgeCoreInboundVerificationError extends Enum { readonly isHeaderNotFound: boolean; readonly isLogNotFound: boolean; @@ -8122,7 +8464,7 @@ declare module "@polkadot/types/lookup" { readonly type: "HeaderNotFound" | "LogNotFound" | "InvalidLog" | "InvalidProof" | "InvalidExecutionProof"; } - /** @name SnowbridgePalletInboundQueueSendError (824) */ + /** @name SnowbridgePalletInboundQueueSendError (842) */ interface SnowbridgePalletInboundQueueSendError extends Enum { readonly isNotApplicable: boolean; readonly isNotRoutable: boolean; @@ -8141,7 +8483,7 @@ declare module "@polkadot/types/lookup" { | "Fees"; } - /** @name SnowbridgeRouterPrimitivesInboundConvertMessageError (825) */ + /** @name SnowbridgeRouterPrimitivesInboundConvertMessageError (843) */ interface SnowbridgeRouterPrimitivesInboundConvertMessageError extends Enum { readonly isUnsupportedVersion: boolean; readonly isInvalidDestination: boolean; @@ -8156,7 +8498,7 @@ declare module "@polkadot/types/lookup" { | "CannotReanchor"; } - /** @name SnowbridgePalletOutboundQueueCommittedMessage (827) */ + /** @name SnowbridgePalletOutboundQueueCommittedMessage (845) */ interface SnowbridgePalletOutboundQueueCommittedMessage extends Struct { readonly channelId: SnowbridgeCoreChannelId; readonly nonce: Compact; @@ -8168,7 +8510,7 @@ declare module "@polkadot/types/lookup" { readonly id: H256; } - /** @name SnowbridgePalletOutboundQueueError (828) */ + /** @name SnowbridgePalletOutboundQueueError (846) */ interface SnowbridgePalletOutboundQueueError extends Enum { readonly isMessageTooLarge: boolean; readonly isHalted: boolean; @@ -8176,13 +8518,13 @@ declare module "@polkadot/types/lookup" { readonly type: "MessageTooLarge" | "Halted" | "InvalidChannel"; } - /** @name SnowbridgeCoreChannel (829) */ + /** @name SnowbridgeCoreChannel (847) */ interface SnowbridgeCoreChannel extends Struct { readonly agentId: H256; readonly paraId: u32; } - /** @name SnowbridgePalletSystemError (830) */ + /** @name SnowbridgePalletSystemError (848) */ interface SnowbridgePalletSystemError extends Enum { readonly isLocationConversionFailed: boolean; readonly isAgentAlreadyCreated: boolean; @@ -8210,7 +8552,7 @@ declare module "@polkadot/types/lookup" { | "InvalidUpgradeParameters"; } - /** @name SnowbridgeCoreOutboundSendError (831) */ + /** @name SnowbridgeCoreOutboundSendError (849) */ interface SnowbridgeCoreOutboundSendError extends Enum { readonly isMessageTooLarge: boolean; readonly isHalted: boolean; @@ -8218,7 +8560,7 @@ declare module "@polkadot/types/lookup" { readonly type: "MessageTooLarge" | "Halted" | "InvalidChannel"; } - /** @name PalletMigrationsError (832) */ + /** @name PalletMigrationsError (850) */ interface PalletMigrationsError extends Enum { readonly isPreimageMissing: boolean; readonly isWrongUpperBound: boolean; @@ -8227,7 +8569,7 @@ declare module "@polkadot/types/lookup" { readonly type: "PreimageMissing" | "WrongUpperBound" | "PreimageIsTooBig" | "PreimageAlreadyExists"; } - /** @name PalletBeefyError (836) */ + /** @name PalletBeefyError (854) */ interface PalletBeefyError extends Enum { readonly isInvalidKeyOwnershipProof: boolean; readonly isInvalidDoubleVotingProof: boolean; @@ -8246,50 +8588,50 @@ declare module "@polkadot/types/lookup" { | "InvalidConfiguration"; } - /** @name SpConsensusBeefyMmrBeefyAuthoritySet (837) */ + /** @name SpConsensusBeefyMmrBeefyAuthoritySet (855) */ interface SpConsensusBeefyMmrBeefyAuthoritySet extends Struct { readonly id: u64; readonly len: u32; readonly keysetCommitment: H256; } - /** @name SnowbridgeBeaconPrimitivesCompactBeaconState (838) */ + /** @name SnowbridgeBeaconPrimitivesCompactBeaconState (856) */ interface SnowbridgeBeaconPrimitivesCompactBeaconState extends Struct { readonly slot: Compact; readonly blockRootsRoot: H256; } - /** @name SnowbridgeBeaconPrimitivesSyncCommitteePrepared (839) */ + /** @name SnowbridgeBeaconPrimitivesSyncCommitteePrepared (857) */ interface SnowbridgeBeaconPrimitivesSyncCommitteePrepared extends Struct { readonly root: H256; readonly pubkeys: Vec; readonly aggregatePubkey: SnowbridgeMilagroBlsKeysPublicKey; } - /** @name SnowbridgeMilagroBlsKeysPublicKey (841) */ + /** @name SnowbridgeMilagroBlsKeysPublicKey (859) */ interface SnowbridgeMilagroBlsKeysPublicKey extends Struct { readonly point: SnowbridgeAmclBls381Ecp; } - /** @name SnowbridgeAmclBls381Ecp (842) */ + /** @name SnowbridgeAmclBls381Ecp (860) */ interface SnowbridgeAmclBls381Ecp extends Struct { readonly x: SnowbridgeAmclBls381Fp; readonly y: SnowbridgeAmclBls381Fp; readonly z: SnowbridgeAmclBls381Fp; } - /** @name SnowbridgeAmclBls381Fp (843) */ + /** @name SnowbridgeAmclBls381Fp (861) */ interface SnowbridgeAmclBls381Fp extends Struct { readonly x: SnowbridgeAmclBls381Big; readonly xes: i32; } - /** @name SnowbridgeAmclBls381Big (844) */ + /** @name SnowbridgeAmclBls381Big (862) */ interface SnowbridgeAmclBls381Big extends Struct { readonly w: Vec; } - /** @name SnowbridgeBeaconPrimitivesForkVersions (847) */ + /** @name SnowbridgeBeaconPrimitivesForkVersions (865) */ interface SnowbridgeBeaconPrimitivesForkVersions extends Struct { readonly genesis: SnowbridgeBeaconPrimitivesFork; readonly altair: SnowbridgeBeaconPrimitivesFork; @@ -8298,13 +8640,13 @@ declare module "@polkadot/types/lookup" { readonly deneb: SnowbridgeBeaconPrimitivesFork; } - /** @name SnowbridgeBeaconPrimitivesFork (848) */ + /** @name SnowbridgeBeaconPrimitivesFork (866) */ interface SnowbridgeBeaconPrimitivesFork extends Struct { readonly version: U8aFixed; readonly epoch: u64; } - /** @name SnowbridgePalletEthereumClientError (849) */ + /** @name SnowbridgePalletEthereumClientError (867) */ interface SnowbridgePalletEthereumClientError extends Enum { readonly isSkippedSyncCommitteePeriod: boolean; readonly isSyncCommitteeUpdateRequired: boolean; @@ -8360,7 +8702,7 @@ declare module "@polkadot/types/lookup" { | "Halted"; } - /** @name SnowbridgeBeaconPrimitivesBlsBlsError (850) */ + /** @name SnowbridgeBeaconPrimitivesBlsBlsError (868) */ interface SnowbridgeBeaconPrimitivesBlsBlsError extends Enum { readonly isInvalidSignature: boolean; readonly isInvalidPublicKey: boolean; @@ -8373,7 +8715,7 @@ declare module "@polkadot/types/lookup" { | "SignatureVerificationFailed"; } - /** @name PolkadotRuntimeCommonParasSudoWrapperPalletError (851) */ + /** @name PolkadotRuntimeCommonParasSudoWrapperPalletError (869) */ interface PolkadotRuntimeCommonParasSudoWrapperPalletError extends Enum { readonly isParaDoesntExist: boolean; readonly isParaAlreadyExists: boolean; @@ -8396,45 +8738,45 @@ declare module "@polkadot/types/lookup" { | "TooManyCores"; } - /** @name PalletSudoError (852) */ + /** @name PalletSudoError (870) */ interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: "RequireSudo"; } - /** @name FrameSystemExtensionsCheckNonZeroSender (855) */ + /** @name FrameSystemExtensionsCheckNonZeroSender (873) */ type FrameSystemExtensionsCheckNonZeroSender = Null; - /** @name FrameSystemExtensionsCheckSpecVersion (856) */ + /** @name FrameSystemExtensionsCheckSpecVersion (874) */ type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckTxVersion (857) */ + /** @name FrameSystemExtensionsCheckTxVersion (875) */ type FrameSystemExtensionsCheckTxVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (858) */ + /** @name FrameSystemExtensionsCheckGenesis (876) */ type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (861) */ + /** @name FrameSystemExtensionsCheckNonce (879) */ interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (862) */ + /** @name FrameSystemExtensionsCheckWeight (880) */ type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTransactionPaymentChargeTransactionPayment (863) */ + /** @name PalletTransactionPaymentChargeTransactionPayment (881) */ interface PalletTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name FrameMetadataHashExtensionCheckMetadataHash (864) */ + /** @name FrameMetadataHashExtensionCheckMetadataHash (882) */ interface FrameMetadataHashExtensionCheckMetadataHash extends Struct { readonly mode: FrameMetadataHashExtensionMode; } - /** @name FrameMetadataHashExtensionMode (865) */ + /** @name FrameMetadataHashExtensionMode (883) */ interface FrameMetadataHashExtensionMode extends Enum { readonly isDisabled: boolean; readonly isEnabled: boolean; readonly type: "Disabled" | "Enabled"; } - /** @name DancelightRuntimeRuntime (866) */ + /** @name DancelightRuntimeRuntime (884) */ type DancelightRuntimeRuntime = Null; } // declare module From 57704bf0cff1229a2c88aed1652b27d482f666c1 Mon Sep 17 00:00:00 2001 From: tmpolaczyk <44604217+tmpolaczyk@users.noreply.github.com> Date: Fri, 13 Dec 2024 13:39:02 +0100 Subject: [PATCH 3/6] Update moonwall to 5.9.1 and add --bail=1 (#779) * Update moonwall to 5.9.1 * Add --bail=1 to zombienet tests Make test failures faster --- pnpm-lock.yaml | 1974 +++++++++++++++++++++++++++++++------ test/moonwall.config.json | 54 + test/package.json | 7 +- 3 files changed, 1709 insertions(+), 326 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 64f93a6ca..923a17245 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -25,11 +25,11 @@ importers: specifier: 0.3200.3 version: 0.3200.3 '@moonwall/cli': - specifier: 5.6.0 - version: 5.6.0(@types/node@22.9.0)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3))(typescript@5.6.3)(zod@3.23.8) + specifier: 5.9.1 + version: 5.9.1(@types/node@22.9.0)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3))(tsx@4.19.2)(typescript@5.6.3)(zod@3.23.8) '@moonwall/util': - specifier: 5.6.0 - version: 5.6.0(@types/node@22.9.0)(@vitest/ui@2.1.5(vitest@2.1.5))(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(typescript@5.6.3)(zod@3.23.8) + specifier: 5.9.1 + version: 5.9.1(@types/node@22.9.0)(@vitest/ui@2.1.5)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5)(zod@3.23.8) '@polkadot/api': specifier: 14.3.1 version: 14.3.1 @@ -211,13 +211,30 @@ packages: '@adraffy/ens-normalize@1.11.0': resolution: {integrity: sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==} + '@alcalzone/ansi-tokenize@0.1.3': + resolution: {integrity: sha512-3yWxPTq3UQ/FY9p1ErPxIyfT64elWaMvM9lIHnaqpyft63tkxodF5aUElYHrdisWve5cETkh1+KBw1yJuW0aRw==} + engines: {node: '>=14.13.1'} + '@asamuzakjp/dom-selector@2.0.2': resolution: {integrity: sha512-x1KXOatwofR6ZAYzXRBL5wrdV0vwNxlTCK9NCuLqAzQYARqGcvFwiJA6A1ERuh+dgeA4Dxm3JBYictIes+SqUQ==} + '@babel/code-frame@7.26.2': + resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==} + engines: {node: '>=6.9.0'} + + '@babel/helper-validator-identifier@7.25.9': + resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==} + engines: {node: '>=6.9.0'} + '@colors/colors@1.5.0': resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==} engines: {node: '>=0.1.90'} + '@commander-js/extra-typings@12.1.0': + resolution: {integrity: sha512-wf/lwQvWAA0goIghcb91dQYpkLBcyhOhQNqG/VgWhnKzgt+UOMvra7EX/2fv70arm5RW+PUHoQHHDa6/p77Eqg==} + peerDependencies: + commander: ~12.1.0 + '@cspotcode/source-map-support@0.8.1': resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} engines: {node: '>=12'} @@ -234,6 +251,12 @@ packages: cpu: [ppc64] os: [aix] + '@esbuild/aix-ppc64@0.24.0': + resolution: {integrity: sha512-WtKdFM7ls47zkKHFVzMz8opM7LkcsIp9amDUBIAWirg70RM71WRSjdILPsY5Uv1D42ZpUfaPILDlfactHgsRkw==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + '@esbuild/android-arm64@0.21.5': resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==} engines: {node: '>=12'} @@ -246,6 +269,12 @@ packages: cpu: [arm64] os: [android] + '@esbuild/android-arm64@0.24.0': + resolution: {integrity: sha512-Vsm497xFM7tTIPYK9bNTYJyF/lsP590Qc1WxJdlB6ljCbdZKU9SY8i7+Iin4kyhV/KV5J2rOKsBQbB77Ab7L/w==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + '@esbuild/android-arm@0.21.5': resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==} engines: {node: '>=12'} @@ -258,6 +287,12 @@ packages: cpu: [arm] os: [android] + '@esbuild/android-arm@0.24.0': + resolution: {integrity: sha512-arAtTPo76fJ/ICkXWetLCc9EwEHKaeya4vMrReVlEIUCAUncH7M4bhMQ+M9Vf+FFOZJdTNMXNBrWwW+OXWpSew==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + '@esbuild/android-x64@0.21.5': resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==} engines: {node: '>=12'} @@ -270,6 +305,12 @@ packages: cpu: [x64] os: [android] + '@esbuild/android-x64@0.24.0': + resolution: {integrity: sha512-t8GrvnFkiIY7pa7mMgJd7p8p8qqYIz1NYiAoKc75Zyv73L3DZW++oYMSHPRarcotTKuSs6m3hTOa5CKHaS02TQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + '@esbuild/darwin-arm64@0.21.5': resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==} engines: {node: '>=12'} @@ -282,6 +323,12 @@ packages: cpu: [arm64] os: [darwin] + '@esbuild/darwin-arm64@0.24.0': + resolution: {integrity: sha512-CKyDpRbK1hXwv79soeTJNHb5EiG6ct3efd/FTPdzOWdbZZfGhpbcqIpiD0+vwmpu0wTIL97ZRPZu8vUt46nBSw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + '@esbuild/darwin-x64@0.21.5': resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==} engines: {node: '>=12'} @@ -294,6 +341,12 @@ packages: cpu: [x64] os: [darwin] + '@esbuild/darwin-x64@0.24.0': + resolution: {integrity: sha512-rgtz6flkVkh58od4PwTRqxbKH9cOjaXCMZgWD905JOzjFKW+7EiUObfd/Kav+A6Gyud6WZk9w+xu6QLytdi2OA==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + '@esbuild/freebsd-arm64@0.21.5': resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==} engines: {node: '>=12'} @@ -306,6 +359,12 @@ packages: cpu: [arm64] os: [freebsd] + '@esbuild/freebsd-arm64@0.24.0': + resolution: {integrity: sha512-6Mtdq5nHggwfDNLAHkPlyLBpE5L6hwsuXZX8XNmHno9JuL2+bg2BX5tRkwjyfn6sKbxZTq68suOjgWqCicvPXA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + '@esbuild/freebsd-x64@0.21.5': resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==} engines: {node: '>=12'} @@ -318,6 +377,12 @@ packages: cpu: [x64] os: [freebsd] + '@esbuild/freebsd-x64@0.24.0': + resolution: {integrity: sha512-D3H+xh3/zphoX8ck4S2RxKR6gHlHDXXzOf6f/9dbFt/NRBDIE33+cVa49Kil4WUjxMGW0ZIYBYtaGCa2+OsQwQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + '@esbuild/linux-arm64@0.21.5': resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==} engines: {node: '>=12'} @@ -330,6 +395,12 @@ packages: cpu: [arm64] os: [linux] + '@esbuild/linux-arm64@0.24.0': + resolution: {integrity: sha512-TDijPXTOeE3eaMkRYpcy3LarIg13dS9wWHRdwYRnzlwlA370rNdZqbcp0WTyyV/k2zSxfko52+C7jU5F9Tfj1g==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + '@esbuild/linux-arm@0.21.5': resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==} engines: {node: '>=12'} @@ -342,6 +413,12 @@ packages: cpu: [arm] os: [linux] + '@esbuild/linux-arm@0.24.0': + resolution: {integrity: sha512-gJKIi2IjRo5G6Glxb8d3DzYXlxdEj2NlkixPsqePSZMhLudqPhtZ4BUrpIuTjJYXxvF9njql+vRjB2oaC9XpBw==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + '@esbuild/linux-ia32@0.21.5': resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==} engines: {node: '>=12'} @@ -354,6 +431,12 @@ packages: cpu: [ia32] os: [linux] + '@esbuild/linux-ia32@0.24.0': + resolution: {integrity: sha512-K40ip1LAcA0byL05TbCQ4yJ4swvnbzHscRmUilrmP9Am7//0UjPreh4lpYzvThT2Quw66MhjG//20mrufm40mA==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + '@esbuild/linux-loong64@0.21.5': resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==} engines: {node: '>=12'} @@ -366,6 +449,12 @@ packages: cpu: [loong64] os: [linux] + '@esbuild/linux-loong64@0.24.0': + resolution: {integrity: sha512-0mswrYP/9ai+CU0BzBfPMZ8RVm3RGAN/lmOMgW4aFUSOQBjA31UP8Mr6DDhWSuMwj7jaWOT0p0WoZ6jeHhrD7g==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + '@esbuild/linux-mips64el@0.21.5': resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==} engines: {node: '>=12'} @@ -378,6 +467,12 @@ packages: cpu: [mips64el] os: [linux] + '@esbuild/linux-mips64el@0.24.0': + resolution: {integrity: sha512-hIKvXm0/3w/5+RDtCJeXqMZGkI2s4oMUGj3/jM0QzhgIASWrGO5/RlzAzm5nNh/awHE0A19h/CvHQe6FaBNrRA==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + '@esbuild/linux-ppc64@0.21.5': resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==} engines: {node: '>=12'} @@ -390,6 +485,12 @@ packages: cpu: [ppc64] os: [linux] + '@esbuild/linux-ppc64@0.24.0': + resolution: {integrity: sha512-HcZh5BNq0aC52UoocJxaKORfFODWXZxtBaaZNuN3PUX3MoDsChsZqopzi5UupRhPHSEHotoiptqikjN/B77mYQ==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + '@esbuild/linux-riscv64@0.21.5': resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==} engines: {node: '>=12'} @@ -402,6 +503,12 @@ packages: cpu: [riscv64] os: [linux] + '@esbuild/linux-riscv64@0.24.0': + resolution: {integrity: sha512-bEh7dMn/h3QxeR2KTy1DUszQjUrIHPZKyO6aN1X4BCnhfYhuQqedHaa5MxSQA/06j3GpiIlFGSsy1c7Gf9padw==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + '@esbuild/linux-s390x@0.21.5': resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==} engines: {node: '>=12'} @@ -414,6 +521,12 @@ packages: cpu: [s390x] os: [linux] + '@esbuild/linux-s390x@0.24.0': + resolution: {integrity: sha512-ZcQ6+qRkw1UcZGPyrCiHHkmBaj9SiCD8Oqd556HldP+QlpUIe2Wgn3ehQGVoPOvZvtHm8HPx+bH20c9pvbkX3g==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + '@esbuild/linux-x64@0.21.5': resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==} engines: {node: '>=12'} @@ -426,6 +539,12 @@ packages: cpu: [x64] os: [linux] + '@esbuild/linux-x64@0.24.0': + resolution: {integrity: sha512-vbutsFqQ+foy3wSSbmjBXXIJ6PL3scghJoM8zCL142cGaZKAdCZHyf+Bpu/MmX9zT9Q0zFBVKb36Ma5Fzfa8xA==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + '@esbuild/netbsd-x64@0.21.5': resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==} engines: {node: '>=12'} @@ -438,12 +557,24 @@ packages: cpu: [x64] os: [netbsd] + '@esbuild/netbsd-x64@0.24.0': + resolution: {integrity: sha512-hjQ0R/ulkO8fCYFsG0FZoH+pWgTTDreqpqY7UnQntnaKv95uP5iW3+dChxnx7C3trQQU40S+OgWhUVwCjVFLvg==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + '@esbuild/openbsd-arm64@0.23.1': resolution: {integrity: sha512-3x37szhLexNA4bXhLrCC/LImN/YtWis6WXr1VESlfVtVeoFJBRINPJ3f0a/6LV8zpikqoUg4hyXw0sFBt5Cr+Q==} engines: {node: '>=18'} cpu: [arm64] os: [openbsd] + '@esbuild/openbsd-arm64@0.24.0': + resolution: {integrity: sha512-MD9uzzkPQbYehwcN583yx3Tu5M8EIoTD+tUgKF982WYL9Pf5rKy9ltgD0eUgs8pvKnmizxjXZyLt0z6DC3rRXg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + '@esbuild/openbsd-x64@0.21.5': resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==} engines: {node: '>=12'} @@ -456,6 +587,12 @@ packages: cpu: [x64] os: [openbsd] + '@esbuild/openbsd-x64@0.24.0': + resolution: {integrity: sha512-4ir0aY1NGUhIC1hdoCzr1+5b43mw99uNwVzhIq1OY3QcEwPDO3B7WNXBzaKY5Nsf1+N11i1eOfFcq+D/gOS15Q==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + '@esbuild/sunos-x64@0.21.5': resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==} engines: {node: '>=12'} @@ -468,6 +605,12 @@ packages: cpu: [x64] os: [sunos] + '@esbuild/sunos-x64@0.24.0': + resolution: {integrity: sha512-jVzdzsbM5xrotH+W5f1s+JtUy1UWgjU0Cf4wMvffTB8m6wP5/kx0KiaLHlbJO+dMgtxKV8RQ/JvtlFcdZ1zCPA==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + '@esbuild/win32-arm64@0.21.5': resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==} engines: {node: '>=12'} @@ -480,6 +623,12 @@ packages: cpu: [arm64] os: [win32] + '@esbuild/win32-arm64@0.24.0': + resolution: {integrity: sha512-iKc8GAslzRpBytO2/aN3d2yb2z8XTVfNV0PjGlCxKo5SgWmNXx82I/Q3aG1tFfS+A2igVCY97TJ8tnYwpUWLCA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + '@esbuild/win32-ia32@0.21.5': resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==} engines: {node: '>=12'} @@ -492,6 +641,12 @@ packages: cpu: [ia32] os: [win32] + '@esbuild/win32-ia32@0.24.0': + resolution: {integrity: sha512-vQW36KZolfIudCcTnaTpmLQ24Ha1RjygBo39/aLkM2kmjkWmZGEJ5Gn9l5/7tzXA42QGIoWbICfg6KLLkIw6yw==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + '@esbuild/win32-x64@0.21.5': resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==} engines: {node: '>=12'} @@ -504,6 +659,12 @@ packages: cpu: [x64] os: [win32] + '@esbuild/win32-x64@0.24.0': + resolution: {integrity: sha512-7IAFPrjSQIJrGsK6flwg7NFmwBoSTyF3rl7If0hNUFQU4ilTsEPL6GuMuU9BfIWVVGuRnuIidkSMC+c0Otu8IA==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + '@eslint-community/eslint-utils@4.4.1': resolution: {integrity: sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -548,17 +709,108 @@ packages: resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} deprecated: Use @eslint/object-schema instead + '@inquirer/checkbox@4.0.3': + resolution: {integrity: sha512-CEt9B4e8zFOGtc/LYeQx5m8nfqQeG/4oNNv0PUvXGG0mys+wR/WbJ3B4KfSQ4Fcr3AQfpiuFOi3fVvmPfvNbxw==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/confirm@5.1.0': + resolution: {integrity: sha512-osaBbIMEqVFjTX5exoqPXs6PilWQdjaLhGtMDXMXg/yxkHXNq43GlxGyTA35lK2HpzUgDN+Cjh/2AmqCN0QJpw==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/core@10.1.1': + resolution: {integrity: sha512-rmZVXy9iZvO3ZStEe/ayuuwIJ23LSF13aPMlLMTQARX6lGUBDHGV8UB5i9MRrfy0+mZwt5/9bdy8llszSD3NQA==} + engines: {node: '>=18'} + + '@inquirer/editor@4.2.0': + resolution: {integrity: sha512-Z3LeGsD3WlItDqLxTPciZDbGtm0wrz7iJGS/uUxSiQxef33ZrBq7LhsXg30P7xrWz1kZX4iGzxxj5SKZmJ8W+w==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/expand@4.0.3': + resolution: {integrity: sha512-MDszqW4HYBpVMmAoy/FA9laLrgo899UAga0itEjsYrBthKieDZNc0e16gdn7N3cQ0DSf/6zsTBZMuDYDQU4ktg==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/figures@1.0.8': + resolution: {integrity: sha512-tKd+jsmhq21AP1LhexC0pPwsCxEhGgAkg28byjJAd+xhmIs8LUX8JbUc3vBf3PhLxWiB5EvyBE5X7JSPAqMAqg==} + engines: {node: '>=18'} + + '@inquirer/input@4.1.0': + resolution: {integrity: sha512-16B8A9hY741yGXzd8UJ9R8su/fuuyO2e+idd7oVLYjP23wKJ6ILRIIHcnXe8/6AoYgwRS2zp4PNsW/u/iZ24yg==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/number@3.0.3': + resolution: {integrity: sha512-HA/W4YV+5deKCehIutfGBzNxWH1nhvUC67O4fC9ufSijn72yrYnRmzvC61dwFvlXIG1fQaYWi+cqNE9PaB9n6Q==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/password@4.0.3': + resolution: {integrity: sha512-3qWjk6hS0iabG9xx0U1plwQLDBc/HA/hWzLFFatADpR6XfE62LqPr9GpFXBkLU0KQUaIXZ996bNG+2yUvocH8w==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/prompts@7.2.0': + resolution: {integrity: sha512-ZXYZ5oGVrb+hCzcglPeVerJ5SFwennmDOPfXq1WyeZIrPGySLbl4W6GaSsBFvu3WII36AOK5yB8RMIEEkBjf8w==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/rawlist@4.0.3': + resolution: {integrity: sha512-5MhinSzfmOiZlRoPezfbJdfVCZikZs38ja3IOoWe7H1dxL0l3Z2jAUgbBldeyhhOkELdGvPlBfQaNbeLslib1w==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/search@3.0.3': + resolution: {integrity: sha512-mQTCbdNolTGvGGVCJSI6afDwiSGTV+fMLPEIMDJgIV6L/s3+RYRpxt6t0DYnqMQmemnZ/Zq0vTIRwoHT1RgcTg==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/select@4.0.3': + resolution: {integrity: sha512-OZfKDtDE8+J54JYAFTUGZwvKNfC7W/gFCjDkcsO7HnTH/wljsZo9y/FJquOxMy++DY0+9l9o/MOZ8s5s1j5wmw==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + + '@inquirer/type@3.0.1': + resolution: {integrity: sha512-+ksJMIy92sOAiAccGpcKZUc3bYO07cADnscIxHBknEm3uNts3movSmBofc1908BNy5edKscxYeAdaX1NXkHS6A==} + engines: {node: '>=18'} + peerDependencies: + '@types/node': '>=18' + '@isaacs/cliui@8.0.2': resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} engines: {node: '>=12'} + '@jridgewell/gen-mapping@0.3.5': + resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} + engines: {node: '>=6.0.0'} + '@jridgewell/resolve-uri@3.1.2': resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} engines: {node: '>=6.0.0'} + '@jridgewell/set-array@1.2.1': + resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} + engines: {node: '>=6.0.0'} + '@jridgewell/sourcemap-codec@1.5.0': resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} + '@jridgewell/trace-mapping@0.3.25': + resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + '@jridgewell/trace-mapping@0.3.9': resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} @@ -570,17 +822,17 @@ packages: resolution: {integrity: sha512-YXOPW30HTuLf2BUbfgDzlj6rEqXH789FPp4FxiB0EAEHBAK2ijfQpAe3qtdTWXXxdnt9rVdiwlUf2wJQWC4O/Q==} engines: {node: '>=20.0.0'} - '@moonwall/cli@5.6.0': - resolution: {integrity: sha512-iymDiZ+Hstj34ZYg+0c+X2WKNFVwzX1XM6rM0XM/4NDc8eHK9XPh0ZvJOlAeYS52PRbMk0xMzShTecpoxkE5kA==} + '@moonwall/cli@5.9.1': + resolution: {integrity: sha512-DjnHB61lr8qkIm+BqhBhGGyHdFrlKlntxOAvJCmoDfNlsMmXHvsaeU9E7KNYRHnXbklrHKMhQhXQ8LdFIfqDXA==} engines: {node: '>=20', pnpm: '>=7'} hasBin: true - '@moonwall/types@5.6.0': - resolution: {integrity: sha512-r1bM/uVgmQBIxIZnLnVub/OklNYn7zVfsKapREqKkK0rQgFZPXSnCISXx8dN6Nkmxc3lNKrD45/xGwgzz+DUEw==} + '@moonwall/types@5.9.1': + resolution: {integrity: sha512-1q72msaH3SbKcM0pdcqxnSEJVrrK7WO9lUsBObjuOu/an4zIzluELw65Hu3J6lfCvKg13ypUnJic7McX3mHdKw==} engines: {node: '>=20', pnpm: '>=7'} - '@moonwall/util@5.6.0': - resolution: {integrity: sha512-xGrkpEIWTrHvSOcABaw9Rcb1zs1TZmmvrO0mZIvjs6iky/fX8vd8f8ybYbTNYvzN+HAI6uKnK5ryyOhY3u4UAw==} + '@moonwall/util@5.9.1': + resolution: {integrity: sha512-UlbwiX5ibywxLaCVwgNIcHOXoHh/nSHg+crtl+0f7suANJpCuQwm1WSUUMstaEliJ7FvNiGlwjozpU/NpBXWJA==} engines: {node: '>=20', pnpm: '>=7'} '@noble/curves@1.2.0': @@ -702,30 +954,102 @@ packages: '@polka/url@1.0.0-next.28': resolution: {integrity: sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==} + '@polkadot-api/cli@0.9.21': + resolution: {integrity: sha512-ZvuYRn9f2F8vrm0lPJP8NjbrVLkGpsiWbq0MFlUXhwfTUvkKWPu48rSPiN2SAYAD0p1rOevLus1FdGZL0J/fRw==} + hasBin: true + + '@polkadot-api/codegen@0.12.9': + resolution: {integrity: sha512-lxwKRJqKKmR0Fm9g2KU4KgMB5NeKvc1505iGY0nd/PistTzVIk4zsX3Ja9dPFSB4wMMZ9ykMbbamc3+t6jbkaw==} + + '@polkadot-api/ink-contracts@0.2.2': + resolution: {integrity: sha512-jbkrbZo8Yfe9UupmPuWIUdQz0a/Oxi6m1qPGEfXSmwML27FgWEmb+8IG9chLzJ59/z1oMWxgKHkK8BLLWnSLGg==} + '@polkadot-api/json-rpc-provider-proxy@0.1.0': resolution: {integrity: sha512-8GSFE5+EF73MCuLQm8tjrbCqlgclcHBSRaswvXziJ0ZW7iw3UEMsKkkKvELayWyBuOPa2T5i1nj6gFOeIsqvrg==} + '@polkadot-api/json-rpc-provider-proxy@0.2.4': + resolution: {integrity: sha512-nuGoY9QpBAiRU7xmXN3nugFvPcnSu3IxTLm1OWcNTGlZ1LW5bvdQHz3JLk56+Jlyb3GJ971hqdg2DJsMXkKCOg==} + '@polkadot-api/json-rpc-provider@0.0.1': resolution: {integrity: sha512-/SMC/l7foRjpykLTUTacIH05H3mr9ip8b5xxfwXlVezXrNVLp3Cv0GX6uItkKd+ZjzVPf3PFrDF2B2/HLSNESA==} + '@polkadot-api/json-rpc-provider@0.0.4': + resolution: {integrity: sha512-9cDijLIxzHOBuq6yHqpqjJ9jBmXrctjc1OFqU+tQrS96adQze3mTIH6DTgfb/0LMrqxzxffz1HQGrIlEH00WrA==} + + '@polkadot-api/known-chains@0.5.8': + resolution: {integrity: sha512-4UoxnqPeJ2viRykArIhUmYsgo2fc84mqC8o/qvmJ0w3r7qwO2/7NS2zpwMuricGtNvdNKyJRMGHAeJdrIfCB3A==} + + '@polkadot-api/logs-provider@0.0.6': + resolution: {integrity: sha512-4WgHlvy+xee1ADaaVf6+MlK/+jGMtsMgAzvbQOJZnP4PfQuagoTqaeayk8HYKxXGphogLlPbD06tANxcb+nvAg==} + '@polkadot-api/metadata-builders@0.3.2': resolution: {integrity: sha512-TKpfoT6vTb+513KDzMBTfCb/ORdgRnsS3TDFpOhAhZ08ikvK+hjHMt5plPiAX/OWkm1Wc9I3+K6W0hX5Ab7MVg==} + '@polkadot-api/metadata-builders@0.9.2': + resolution: {integrity: sha512-2vxtjMC5PvN+sTM6DPMopznNfTUJEe6G6CzMhtK19CASb2OeN9NoRpnxmpEagjndO98YPkyQtDv25sKGUVhgAA==} + + '@polkadot-api/metadata-compatibility@0.1.12': + resolution: {integrity: sha512-zhRhsuzHb6klnRW/pMXb5YLKRtvmGw4sicV6jxKDIclpuOZ+QxMWFmqTGM1Vsea5qNX/Z9HrWvXOYxMlkcW7Pg==} + '@polkadot-api/observable-client@0.3.2': resolution: {integrity: sha512-HGgqWgEutVyOBXoGOPp4+IAq6CNdK/3MfQJmhCJb8YaJiaK4W6aRGrdQuQSTPHfERHCARt9BrOmEvTXAT257Ug==} peerDependencies: '@polkadot-api/substrate-client': 0.1.4 rxjs: '>=7.8.0' + '@polkadot-api/observable-client@0.6.3': + resolution: {integrity: sha512-DNau9rUmEMEnfDKxfoZrtL2oPCXdXuV6c0AvG8kNGviuknk5y7HzlU21rI3O486zqmLQE2ntPxQmT+yeYxW8DA==} + peerDependencies: + '@polkadot-api/substrate-client': 0.3.0 + rxjs: '>=7.8.0' + + '@polkadot-api/pjs-signer@0.6.1': + resolution: {integrity: sha512-0GYUS0rVxB/Vju4YqX1/9CM1bVmscCSTgI2le5eeYFmz+MHMMPuLTXQyRSCa6nNH/0/L03xL9gmSzwwAVGDpKw==} + + '@polkadot-api/polkadot-sdk-compat@2.3.1': + resolution: {integrity: sha512-rb8IWmPRhKWD9NG4zh2n4q0HlEAvq+Cv1CbD+8YxH0XAqIIiFA+ch5JeDCIxQYngkn/43B0Gs7Gtzh18yv2yoA==} + + '@polkadot-api/polkadot-signer@0.1.6': + resolution: {integrity: sha512-X7ghAa4r7doETtjAPTb50IpfGtrBmy3BJM5WCfNKa1saK04VFY9w+vDn+hwEcM4p0PcDHt66Ts74hzvHq54d9A==} + + '@polkadot-api/signer@0.1.11': + resolution: {integrity: sha512-DVNB5fdB5vGjSgBbSqzZtaZ15pW/KJG5FARI9h1KgyDWdXhJo5pkGID/LuY5dQbdlnPbTkLhtDhZ2+4G2NWrzg==} + + '@polkadot-api/signers-common@0.1.2': + resolution: {integrity: sha512-JtJmU7v4/80mu05qI3F/BP44nT43VfmyLsr7NO4n5+txZ9sFMDXQQELtis/fQnZgzkps8wPOwagjkSdutTow5A==} + + '@polkadot-api/sm-provider@0.1.7': + resolution: {integrity: sha512-BhNKVeIFZdawpPVadXszLl8IP4EDjcLHe/GchfRRFkvoNFuwS2nNv/npYIqCviXV+dd2R8VnEELxwScsf380Og==} + peerDependencies: + '@polkadot-api/smoldot': '>=0.3' + + '@polkadot-api/smoldot@0.3.7': + resolution: {integrity: sha512-Fnrz0Xt8fli7LhHSOWbNraiXpLJWCwOglI+BgBWnYpsdHXSMU5TsYEw5oo9rkfI9zDeZsbtXvMTW3MqTeCLtQg==} + '@polkadot-api/substrate-bindings@0.6.0': resolution: {integrity: sha512-lGuhE74NA1/PqdN7fKFdE5C1gNYX357j1tWzdlPXI0kQ7h3kN0zfxNOpPUN7dIrPcOFZ6C0tRRVrBylXkI6xPw==} + '@polkadot-api/substrate-bindings@0.9.4': + resolution: {integrity: sha512-SUyetILwgUsodSk1qhNu0HflRBdq2VBCbqAqCBNaoCauE3/Q/G6k7xS+1nE6MTcpjZQex+TriJdDz/trLSvwsA==} + '@polkadot-api/substrate-client@0.1.4': resolution: {integrity: sha512-MljrPobN0ZWTpn++da9vOvt+Ex+NlqTlr/XT7zi9sqPtDJiQcYl+d29hFAgpaeTqbeQKZwz3WDE9xcEfLE8c5A==} + '@polkadot-api/substrate-client@0.3.0': + resolution: {integrity: sha512-0hEvQLKH2zhaFzE8DPkWehvJilec8u2O2wbIEUStm0OJ8jIFtJ40MFjXQfB01dXBWUz1KaVBqS6xd3sZA90Dpw==} + '@polkadot-api/utils@0.1.0': resolution: {integrity: sha512-MXzWZeuGxKizPx2Xf/47wx9sr/uxKw39bVJUptTJdsaQn/TGq+z310mHzf1RCGvC1diHM8f593KrnDgc9oNbJA==} + '@polkadot-api/utils@0.1.2': + resolution: {integrity: sha512-yhs5k2a8N1SBJcz7EthZoazzLQUkZxbf+0271Xzu42C5AEM9K9uFLbsB+ojzHEM72O5X8lPtSwGKNmS7WQyDyg==} + + '@polkadot-api/wasm-executor@0.1.2': + resolution: {integrity: sha512-a5wGenltB3EFPdf72u8ewi6HsUg2qubUAf3ekJprZf24lTK3+w8a/GUF/y6r08LJF35MALZ32SAtLqtVTIOGnQ==} + + '@polkadot-api/ws-provider@0.3.6': + resolution: {integrity: sha512-D2+rvcDc9smt24qUKqFoCuKKNhyBVDQEtnsqHiUN/Ym8UGP+Acegac3b9VOig70EpCcRBoYeXY2gEog2ybx1Kg==} + '@polkadot/api-augment@14.0.1': resolution: {integrity: sha512-+ZHq3JaQZ/3Q45r6/YQBeLfoP8S5ibgkOvLKnKA9cJeF7oP5Qgi6pAEnGW0accfnT9PyCEco9fD/ZOLR9Yka7w==} engines: {node: '>=18'} @@ -1066,6 +1390,13 @@ packages: '@scure/bip39@1.4.0': resolution: {integrity: sha512-BEEm6p8IueV/ZTfQLp/0vhw4NPnT9oWf5+28nvmeUICjP99f4vr2d+qc7AVGDDtwRep6ifR43Yed9ERVmiITzw==} + '@sec-ant/readable-stream@0.4.1': + resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==} + + '@sindresorhus/merge-streams@4.0.0': + resolution: {integrity: sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==} + engines: {node: '>=18'} + '@sqltools/formatter@1.2.5': resolution: {integrity: sha512-Uy0+khmZqUrUGm5dmMqVlnvufZRSK0FbYzVgp0UMstm+F5+W2/jnEEQyc9vo1ZR/E5ZI/B1WjjoTqBqwJL6Krw==} @@ -1077,6 +1408,7 @@ packages: '@substrate/connect@0.8.11': resolution: {integrity: sha512-ofLs1PAO9AtDdPbdyTYj217Pe+lBfTLltdHDs3ds8no0BseoLeAGxpz1mHfi7zB4IxI3YyAiLjH6U8cw4pj4Nw==} + deprecated: versions below 1.x are no longer maintained '@substrate/light-client-extension-helpers@1.0.0': resolution: {integrity: sha512-TdKlni1mBBZptOaeVrKnusMg/UBpWUORNDv5fdCaJklP4RJiFOzBCrzC+CyVI5kQzsXBisZ+2pXm+rIjS38kHg==} @@ -1126,6 +1458,9 @@ packages: '@types/ms@0.7.34': resolution: {integrity: sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==} + '@types/node@22.10.1': + resolution: {integrity: sha512-qKgsUwfHZV2WCWLAnVP1JqnpE6Im6h3Y0+fYgMTasNQ7V++CBX5OT1as0g0f+OyubbFqhf6XVNIsmN4IIhEgGQ==} + '@types/node@22.5.0': resolution: {integrity: sha512-DkFrJOe+rfdHTqqMg0bSNlGlQ85hSoh2TPzZyhHsXnMtligRWpxUySiyw8FY14ITt24HVCiQPWxS3KO/QlGmWg==} @@ -1135,9 +1470,21 @@ packages: '@types/node@22.9.0': resolution: {integrity: sha512-vuyHg81vvWA1Z1ELfvLko2c8f34gyA0zaic0+Rllc5lbCnbSyuvb2Oxpm6TAUAC/2xZN3QGqxBNggD1nNR2AfQ==} + '@types/normalize-package-data@2.4.4': + resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==} + + '@types/prop-types@15.7.14': + resolution: {integrity: sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==} + + '@types/react@18.3.14': + resolution: {integrity: sha512-NzahNKvjNhVjuPBQ+2G7WlxstQ+47kXZNHlUvFakDViuIEfGY926GqhMueQFZ7woG+sPiQKlF36XfrIUVSUfFg==} + '@types/semver@7.5.8': resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} + '@types/tmp@0.2.6': + resolution: {integrity: sha512-chhaNf2oKHlRkDGt+tiKE2Z5aJ6qalm7Z9rlLdBwmOiAAf09YQvvoLXjWK4HWPF1xU/fqvMgfNfpVoBscA/tKA==} + '@types/unist@2.0.11': resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==} @@ -1333,6 +1680,10 @@ packages: resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} engines: {node: '>=8'} + ansi-escapes@7.0.0: + resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==} + engines: {node: '>=18'} + ansi-regex@5.0.1: resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} engines: {node: '>=8'} @@ -1374,10 +1725,6 @@ packages: argparse@2.0.1: resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} - array-buffer-byte-length@1.0.1: - resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==} - engines: {node: '>= 0.4'} - array-union@2.1.0: resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} engines: {node: '>=8'} @@ -1399,6 +1746,10 @@ packages: resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==} engines: {node: '>=8.0.0'} + auto-bind@5.0.1: + resolution: {integrity: sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + available-typed-arrays@1.0.7: resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} engines: {node: '>= 0.4'} @@ -1434,9 +1785,6 @@ packages: bl@4.1.0: resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} - bl@5.1.0: - resolution: {integrity: sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ==} - bn.js@5.2.1: resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==} @@ -1466,6 +1814,12 @@ packages: buffer@6.0.3: resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} + bundle-require@5.0.0: + resolution: {integrity: sha512-GuziW3fSSmopcx4KRymQEJVbZUfqlCqcq7dvs6TYwKRZiegK/2buMxQTPs6MGlNv50wms1699qYO54R8XfRX4w==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + peerDependencies: + esbuild: '>=0.18' + cac@6.7.14: resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} engines: {node: '>=8'} @@ -1528,6 +1882,10 @@ packages: resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} engines: {node: '>= 8.10.0'} + chokidar@4.0.1: + resolution: {integrity: sha512-n8enUVCED/KVRQlab1hr3MVpcVMvxtZjmEa956u+4YijlmQED223XMSYj2tLuKvr4jcCTzNNMpQDUer72MMmzA==} + engines: {node: '>= 14.16.0'} + chownr@1.1.4: resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} @@ -1545,6 +1903,10 @@ packages: clear@0.1.0: resolution: {integrity: sha512-qMjRnoL+JDPJHeLePZJuao6+8orzHMGP04A8CdwCNsKhRbOnKRjefxONR7bwILT3MHecxKBjHkKL/tkZ8r4Uzw==} + cli-boxes@3.0.0: + resolution: {integrity: sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==} + engines: {node: '>=10'} + cli-cursor@3.1.0: resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} engines: {node: '>=8'} @@ -1553,6 +1915,10 @@ packages: resolution: {integrity: sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + cli-cursor@5.0.0: + resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==} + engines: {node: '>=18'} + cli-highlight@2.1.11: resolution: {integrity: sha512-9KDcoEVwyUXrjcJNvHD0NFc/hiwe/WPVYIleQh2O1N2Zro5gWJZ/K+3DGn8w8P/F6FxOgzyC5bxDyHIgCSPhGg==} engines: {node: '>=8.0.0', npm: '>=5.0.0'} @@ -1570,6 +1936,10 @@ packages: resolution: {integrity: sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==} engines: {node: 10.* || >= 12.*} + cli-truncate@4.0.0: + resolution: {integrity: sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==} + engines: {node: '>=18'} + cli-width@4.1.0: resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==} engines: {node: '>= 12'} @@ -1585,6 +1955,10 @@ packages: resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} engines: {node: '>=0.8'} + code-excerpt@4.0.0: + resolution: {integrity: sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + color-convert@2.0.1: resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} engines: {node: '>=7.0.0'} @@ -1613,6 +1987,14 @@ packages: command-exists@1.2.9: resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==} + commander@12.1.0: + resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==} + engines: {node: '>=18'} + + commander@4.1.1: + resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==} + engines: {node: '>= 6'} + commander@5.1.0: resolution: {integrity: sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==} engines: {node: '>= 6'} @@ -1634,9 +2016,17 @@ packages: connected-domain@1.0.0: resolution: {integrity: sha512-lHlohUiJxlpunvDag2Y0pO20bnvarMjnrdciZeuJUqRwrf/5JHNhdpiPIr5GQ8IkqrFj5TDMQwcCjblGo1oeuA==} + consola@3.2.3: + resolution: {integrity: sha512-I5qxpzLv+sJhTVEoLYNcTW+bThDCPsit0vLNKShZx6rLtpilNpmmeTPaeqJb9ZE9dV3DGaeby6Vuhrw38WjeyQ==} + engines: {node: ^14.18.0 || >=16.10.0} + console-control-strings@1.1.0: resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==} + convert-to-spaces@2.0.1: + resolution: {integrity: sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + crc-32@1.2.2: resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} engines: {node: '>=0.8'} @@ -1660,6 +2050,9 @@ packages: resolution: {integrity: sha512-h66W1URKpBS5YMI/V8PyXvTMFT8SupJ1IzoIV8IeBC/ji8WVmrO8dGlTi+2dh6whmdk6BiKJLD/ZBkhWbcg6nA==} engines: {node: '>=18'} + csstype@3.1.3: + resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==} + data-uri-to-buffer@4.0.1: resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==} engines: {node: '>= 12'} @@ -1705,10 +2098,6 @@ packages: resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} engines: {node: '>=6'} - deep-equal@2.2.3: - resolution: {integrity: sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA==} - engines: {node: '>= 0.4'} - deep-extend@0.6.0: resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} engines: {node: '>=4.0.0'} @@ -1716,6 +2105,10 @@ packages: deep-is@0.1.4: resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + deepmerge-ts@7.1.3: + resolution: {integrity: sha512-qCSH6I0INPxd9Y1VtAiLpnYvz5O//6rCfJXKk0z66Up9/VOSr+1yS8XSKA5IWRxjocFGlzPyaZYe+jxq7OOLtQ==} + engines: {node: '>=16.0.0'} + defaults@1.0.4: resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==} @@ -1742,6 +2135,10 @@ packages: resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} engines: {node: '>=6'} + detect-indent@7.0.1: + resolution: {integrity: sha512-Mc7QhQ8s+cLrnUfU/Ji94vG/r8M26m8f++vyres4ZoojaRDpZ1eSIh/EpzLNwlWuvzSZ3UbDFspjFvTDXe6e/g==} + engines: {node: '>=12.20'} + detect-libc@2.0.3: resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} engines: {node: '>=8'} @@ -1778,6 +2175,9 @@ packages: eastasianwidth@0.2.0: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} + emoji-regex@10.4.0: + resolution: {integrity: sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==} + emoji-regex@8.0.0: resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} @@ -1798,6 +2198,10 @@ packages: resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} engines: {node: '>=6'} + environment@1.1.0: + resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==} + engines: {node: '>=18'} + err-code@2.0.3: resolution: {integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==} @@ -1812,12 +2216,12 @@ packages: resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} engines: {node: '>= 0.4'} - es-get-iterator@1.1.3: - resolution: {integrity: sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==} - es-module-lexer@1.5.4: resolution: {integrity: sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw==} + es-toolkit@1.29.0: + resolution: {integrity: sha512-GjTll+E6APcfAQA09D89HdT8Qn2Yb+TeDSDBTMcxAo+V+w1amAtCI15LJu4YPH/UCPoSo/F47Gr1LIM0TE0lZA==} + es6-error@4.1.1: resolution: {integrity: sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==} @@ -1831,6 +2235,11 @@ packages: engines: {node: '>=18'} hasBin: true + esbuild@0.24.0: + resolution: {integrity: sha512-FuLPevChGDshgSicjisSooU0cemp/sGXR841D5LHMB7mTVOmsEHcAxaH3irL53+8YDIeVNQEySh4DaYU/iuPqQ==} + engines: {node: '>=18'} + hasBin: true + escalade@3.2.0: resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} engines: {node: '>=6'} @@ -1839,6 +2248,10 @@ packages: resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} engines: {node: '>=0.8.0'} + escape-string-regexp@2.0.0: + resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} + engines: {node: '>=8'} + escape-string-regexp@4.0.0: resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} engines: {node: '>=10'} @@ -1902,6 +2315,10 @@ packages: resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} engines: {node: '>=10'} + execa@9.5.2: + resolution: {integrity: sha512-EHlpxMCpHWSAh1dgS6bVeoLAXGnJNdR93aabr4QCGbzOM73o5XmRfM/e5FUqsw3aagP8S8XEWUWFAxnRBnAF0Q==} + engines: {node: ^18.19.0 || >=20.5.0} + expand-template@2.0.3: resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} engines: {node: '>=6'} @@ -1959,6 +2376,10 @@ packages: resolution: {integrity: sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==} engines: {node: '>=8'} + figures@6.1.0: + resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==} + engines: {node: '>=18'} + file-entry-cache@6.0.1: resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} engines: {node: ^10.12.0 || >=12.0.0} @@ -2020,6 +2441,9 @@ packages: resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==} engines: {node: '>= 8'} + fs.promises.exists@1.1.4: + resolution: {integrity: sha512-lJzUGWbZn8vhGWBedA+RYjB/BeJ+3458ljUfmplqhIeb6ewzTFWNPCR1HCiYCkXV9zxcHz9zXkJzMsEgDLzh3Q==} + fs.realpath@1.0.0: resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} @@ -2031,9 +2455,6 @@ packages: function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - functions-have-names@1.2.3: - resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} - gauge@4.0.4: resolution: {integrity: sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==} engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0} @@ -2043,6 +2464,10 @@ packages: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} + get-east-asian-width@1.3.0: + resolution: {integrity: sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==} + engines: {node: '>=18'} + get-func-name@2.0.2: resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} @@ -2058,6 +2483,10 @@ packages: resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} engines: {node: '>=10'} + get-stream@9.0.1: + resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==} + engines: {node: '>=18'} + get-tsconfig@4.8.1: resolution: {integrity: sha512-k9PN+cFBmaLWtVz29SkUoqU5O0slLuHJXt/2P+tMVFT+phsSGXGkp9t3rQIqdz0e+06EHNGs3oM6ZX1s2zHxRg==} @@ -2123,9 +2552,6 @@ packages: engines: {node: '>=0.4.7'} hasBin: true - has-bigints@1.0.2: - resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} - has-flag@4.0.0: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} @@ -2162,6 +2588,10 @@ packages: highlight.js@10.7.3: resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} + hosted-git-info@7.0.2: + resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==} + engines: {node: ^16.14.0 || >=18.0.0} + html-encoding-sniffer@4.0.0: resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==} engines: {node: '>=18'} @@ -2189,6 +2619,10 @@ packages: resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} engines: {node: '>=10.17.0'} + human-signals@8.0.0: + resolution: {integrity: sha512-/1/GPCpDUCCYwlERiYjxoczfP0zfvZMU/OWgQPMya9AbAE24vseigFdhAMObpc8Q4lc/kjutPfUddDYyAmejnA==} + engines: {node: '>=18.18.0'} + humanize-ms@1.2.1: resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} @@ -2222,6 +2656,14 @@ packages: resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} engines: {node: '>=8'} + indent-string@5.0.0: + resolution: {integrity: sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==} + engines: {node: '>=12'} + + index-to-position@0.1.2: + resolution: {integrity: sha512-MWDKS3AS1bGCHLBA2VLImJz42f7bJh8wQsTGCzI3j519/CASStoDONUBVz2I/VID0MpiX3SGSnbOD2xUalbE5g==} + engines: {node: '>=18'} + infer-owner@1.0.4: resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==} @@ -2235,19 +2677,23 @@ packages: ini@1.3.8: resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} - inquirer-press-to-continue@1.2.0: - resolution: {integrity: sha512-HdKOgEAydYhI3OKLy5S4LMi7a/AHJjPzF06mHqbdVxlTmHOaytQVBaVbQcSytukD70K9FYLhYicNOPuNjFiWVQ==} + ink@5.1.0: + resolution: {integrity: sha512-3vIO+CU4uSg167/dZrg4wHy75llUINYXxN4OsdaCkE40q4zyOTPwNc2VEpLnnWsIvIQeo6x6lilAhuaSt+rIsA==} + engines: {node: '>=18'} peerDependencies: - inquirer: '>=8.0.0 <10.0.0' + '@types/react': '>=18.0.0' + react: '>=18.0.0' + react-devtools-core: ^4.19.1 + peerDependenciesMeta: + '@types/react': + optional: true + react-devtools-core: + optional: true inquirer@9.2.16: resolution: {integrity: sha512-qzgbB+yNjgSzk2omeqMDtO9IgJet/UL67luT1MaaggRpGK73DBQct5Q4pipwFQcIKK1GbMODYd4UfsRCkSP1DA==} engines: {node: '>=18'} - internal-slot@1.0.7: - resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==} - engines: {node: '>= 0.4'} - ip-address@9.0.5: resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==} engines: {node: '>= 12'} @@ -2260,21 +2706,10 @@ packages: resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==} engines: {node: '>= 0.4'} - is-array-buffer@3.0.4: - resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==} - engines: {node: '>= 0.4'} - - is-bigint@1.0.4: - resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} - is-binary-path@2.1.0: resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} engines: {node: '>=8'} - is-boolean-object@1.1.2: - resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} - engines: {node: '>= 0.4'} - is-buffer@1.1.6: resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} @@ -2286,10 +2721,6 @@ packages: resolution: {integrity: sha512-bc4NlCDiCr28U4aEsQ3Qs2491gVq4V8G7MQyws968ImqjKuYtTJXrl7Vq7jsN7Ly/C3xj5KWFrY7sHNeDkAzXw==} engines: {node: '>= 0.4'} - is-date-object@1.0.5: - resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} - engines: {node: '>= 0.4'} - is-descriptor@1.0.3: resolution: {integrity: sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==} engines: {node: '>= 0.4'} @@ -2302,6 +2733,14 @@ packages: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} engines: {node: '>=8'} + is-fullwidth-code-point@4.0.0: + resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==} + engines: {node: '>=12'} + + is-fullwidth-code-point@5.0.0: + resolution: {integrity: sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==} + engines: {node: '>=18'} + is-generator-function@1.0.10: resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==} engines: {node: '>= 0.4'} @@ -2310,6 +2749,11 @@ packages: resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} engines: {node: '>=0.10.0'} + is-in-ci@1.0.0: + resolution: {integrity: sha512-eUuAjybVTHMYWm/U+vBO1sY/JOCgoPCXRxzdju0K+K0BiGW0SChEL1MLC0PoCIR1OlPo5YAp8HuQoUlsWEICwg==} + engines: {node: '>=18'} + hasBin: true + is-interactive@1.0.0: resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} engines: {node: '>=8'} @@ -2321,14 +2765,6 @@ packages: is-lambda@1.0.1: resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==} - is-map@2.0.3: - resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==} - engines: {node: '>= 0.4'} - - is-number-object@1.0.7: - resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} - engines: {node: '>= 0.4'} - is-number@3.0.0: resolution: {integrity: sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg==} engines: {node: '>=0.10.0'} @@ -2345,32 +2781,20 @@ packages: resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==} engines: {node: '>=8'} + is-plain-obj@4.1.0: + resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==} + engines: {node: '>=12'} + is-potential-custom-element-name@1.0.1: resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==} - is-regex@1.1.4: - resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} - engines: {node: '>= 0.4'} - - is-set@2.0.3: - resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==} - engines: {node: '>= 0.4'} - - is-shared-array-buffer@1.0.3: - resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==} - engines: {node: '>= 0.4'} - is-stream@2.0.1: resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} engines: {node: '>=8'} - is-string@1.0.7: - resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} - engines: {node: '>= 0.4'} - - is-symbol@1.0.4: - resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} - engines: {node: '>= 0.4'} + is-stream@4.0.1: + resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==} + engines: {node: '>=18'} is-typed-array@1.1.13: resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} @@ -2384,16 +2808,9 @@ packages: resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==} engines: {node: '>=12'} - is-weakmap@2.0.2: - resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==} - engines: {node: '>= 0.4'} - - is-weakset@2.0.3: - resolution: {integrity: sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==} - engines: {node: '>= 0.4'} - - isarray@2.0.5: - resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} + is-unicode-supported@2.1.0: + resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==} + engines: {node: '>=18'} isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} @@ -2426,6 +2843,9 @@ packages: js-sha3@0.8.0: resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} + js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + js-yaml@4.1.0: resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} hasBin: true @@ -2492,6 +2912,17 @@ packages: resolution: {integrity: sha512-EXFrhSpiHtJ+/L8xXDvQNK5VjUMG51u878jzZcaT5XhuN/zFg6PWJFnl/qB2Y2j7eMWnvCRP7Kp+ua2H36cG4g==} engines: {node: '>=12.0.0'} + lilconfig@3.1.3: + resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==} + engines: {node: '>=14'} + + lines-and-columns@1.2.4: + resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + + load-tsconfig@0.2.5: + resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + locate-path@6.0.0: resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} engines: {node: '>=10'} @@ -2499,6 +2930,9 @@ packages: lodash.merge@4.6.2: resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + lodash.sortby@4.7.0: + resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==} + lodash@4.17.21: resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} @@ -2506,13 +2940,17 @@ packages: resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} engines: {node: '>=10'} - log-symbols@5.1.0: - resolution: {integrity: sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA==} - engines: {node: '>=12'} + log-symbols@6.0.0: + resolution: {integrity: sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==} + engines: {node: '>=18'} long@4.0.0: resolution: {integrity: sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==} + loose-envify@1.4.0: + resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} + hasBin: true + loupe@2.3.7: resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} @@ -2712,6 +3150,10 @@ packages: resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} engines: {node: '>=6'} + mimic-function@5.0.1: + resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==} + engines: {node: '>=18'} + mimic-response@3.1.0: resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} engines: {node: '>=10'} @@ -2815,6 +3257,10 @@ packages: resolution: {integrity: sha512-avsJQhyd+680gKXyG/sQc0nXaC6rBkPOfyHYcFb9+hdkqQkR9bdnkJ0AMZhke0oesPqIO+mFFJ+IdBc7mst4IA==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + mute-stream@2.0.0: + resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==} + engines: {node: ^18.17.0 || >=20.5.0} + mz@2.7.0: resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} @@ -2906,6 +3352,10 @@ packages: engines: {node: '>=6'} hasBin: true + normalize-package-data@6.0.2: + resolution: {integrity: sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==} + engines: {node: ^16.14.0 || >=18.0.0} + normalize-path@3.0.0: resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} engines: {node: '>=0.10.0'} @@ -2914,6 +3364,10 @@ packages: resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==} engines: {node: '>=8'} + npm-run-path@6.0.0: + resolution: {integrity: sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==} + engines: {node: '>=18'} + npmlog@6.0.2: resolution: {integrity: sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==} engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0} @@ -2933,22 +3387,10 @@ packages: resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} engines: {node: '>=0.10.0'} - object-inspect@1.13.3: - resolution: {integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==} - engines: {node: '>= 0.4'} - - object-is@1.1.6: - resolution: {integrity: sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==} - engines: {node: '>= 0.4'} - object-keys@1.1.1: resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} engines: {node: '>= 0.4'} - object.assign@4.1.5: - resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} - engines: {node: '>= 0.4'} - on-exit-leak-free@2.1.2: resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==} engines: {node: '>=14.0.0'} @@ -2960,6 +3402,10 @@ packages: resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} engines: {node: '>=6'} + onetime@7.0.0: + resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==} + engines: {node: '>=18'} + optionator@0.9.4: resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} engines: {node: '>= 0.8.0'} @@ -2968,9 +3414,9 @@ packages: resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} engines: {node: '>=10'} - ora@6.3.1: - resolution: {integrity: sha512-ERAyNnZOfqM+Ao3RAvIXkYh5joP220yf59gVe2X/cI6SiCxIdi4c9HZKZD8R6q/RDXEje1THBju6iExiSsgJaQ==} - engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + ora@8.1.1: + resolution: {integrity: sha512-YWielGi1XzG1UTvOaCFaNgEnuhZVMSHYkW/FQ7UX8O26PtlpdM84c0f7wLPlkvx2RfiQmnzd61d/MGxmpQeJPw==} + engines: {node: '>=18'} os-tmpdir@1.0.2: resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} @@ -3006,6 +3452,14 @@ packages: resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} engines: {node: '>=6'} + parse-json@8.1.0: + resolution: {integrity: sha512-rum1bPifK5SSar35Z6EKZuYPJx85pkNaFrxBK3mwdfSJ1/WKbYrjoW/zTPSjRRamfmVX1ACBIdFAO0VRErW/EA==} + engines: {node: '>=18'} + + parse-ms@4.0.0: + resolution: {integrity: sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==} + engines: {node: '>=18'} + parse5-htmlparser2-tree-adapter@6.0.1: resolution: {integrity: sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==} @@ -3018,6 +3472,10 @@ packages: parse5@7.2.1: resolution: {integrity: sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==} + patch-console@2.0.0: + resolution: {integrity: sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} @@ -3030,6 +3488,10 @@ packages: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} + path-key@4.0.0: + resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==} + engines: {node: '>=12'} + path-scurry@1.11.1: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} @@ -3081,15 +3543,43 @@ packages: resolution: {integrity: sha512-xSEmD4pLnV54t0NOUN16yCl7RIB1c5UUOse5HSyEXtBp+FgFQyPeDutc+Q2ZO7/22vImV7VfEjH/1zV2QuqvYw==} hasBin: true + pirates@4.0.6: + resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==} + engines: {node: '>= 6'} + pnpm@9.13.0: resolution: {integrity: sha512-vrniqAPbM2wQya9oK1itcYHKD70NQRnysz1fJYLpbWwNk8hbI4aSlbdlFw+9qpKJDA2mraRXQVA5dp7fPJWe/g==} engines: {node: '>=18.12'} hasBin: true + polkadot-api@1.7.7: + resolution: {integrity: sha512-W6YmA4LhPVv2xhp5dKHM/lZp0fclpaKvspR0h+TBANNdUpBp5aAxq6qdkPAZ4sWTC6Rfi+j5PZZP88oQweOHWg==} + hasBin: true + peerDependencies: + rxjs: '>=7.8.0' + possible-typed-array-names@1.0.0: resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==} engines: {node: '>= 0.4'} + postcss-load-config@6.0.1: + resolution: {integrity: sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==} + engines: {node: '>= 18'} + peerDependencies: + jiti: '>=1.21.0' + postcss: '>=8.0.9' + tsx: ^4.8.1 + yaml: ^2.4.2 + peerDependenciesMeta: + jiti: + optional: true + postcss: + optional: true + tsx: + optional: true + yaml: + optional: true + postcss@8.4.49: resolution: {integrity: sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==} engines: {node: ^10 || ^12 || >=14} @@ -3125,6 +3615,10 @@ packages: engines: {node: '>=14'} hasBin: true + pretty-ms@9.2.0: + resolution: {integrity: sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==} + engines: {node: '>=18'} + process-warning@4.0.0: resolution: {integrity: sha512-/MyYDxttz7DfGMMHiysAsFE4qF+pQYAA8ziO/3NcRVrQ5fSk+Mns4QZA/oRPFzvcqNoVJXQNWNAsdwBXLUkQKw==} @@ -3187,6 +3681,20 @@ packages: resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true + react-reconciler@0.29.2: + resolution: {integrity: sha512-zZQqIiYgDCTP/f1N/mAR10nJGrPD2ZR+jDSEsKWJHYC7Cm2wodlwbR3upZRdC3cjIjSlTLNVyO7Iu0Yy7t2AYg==} + engines: {node: '>=0.10.0'} + peerDependencies: + react: ^18.3.1 + + react@18.3.1: + resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} + engines: {node: '>=0.10.0'} + + read-pkg@9.0.1: + resolution: {integrity: sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==} + engines: {node: '>=18'} + readable-stream@3.6.2: resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} engines: {node: '>= 6'} @@ -3199,6 +3707,10 @@ packages: resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} engines: {node: '>=8.10.0'} + readdirp@4.0.2: + resolution: {integrity: sha512-yDMz9g+VaZkqBYS/ozoBJwaBhTbZo3UNYQHNRw1D3UFQB8oHB4uS/tAODO+ZLjGWmUbKnIlOWO+aaIiAxrUWHA==} + engines: {node: '>= 14.16.0'} + real-require@0.2.0: resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==} engines: {node: '>= 12.13.0'} @@ -3206,10 +3718,6 @@ packages: reflect-metadata@0.2.2: resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==} - regexp.prototype.flags@1.5.3: - resolution: {integrity: sha512-vqlC04+RQoFalODCbCumG2xIOvapzVMHwsyIGM/SIE8fRhFFsXeH8/QQ+s0T0kDAhKc4k30s73/0ydkHQz6HlQ==} - engines: {node: '>= 0.4'} - require-directory@2.1.1: resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} engines: {node: '>=0.10.0'} @@ -3225,6 +3733,10 @@ packages: resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} engines: {node: '>=4'} + resolve-from@5.0.0: + resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} + engines: {node: '>=8'} + resolve-pkg-maps@1.0.0: resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} @@ -3236,6 +3748,10 @@ packages: resolution: {integrity: sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + restore-cursor@5.1.0: + resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==} + engines: {node: '>=18'} + retry@0.12.0: resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} engines: {node: '>= 4'} @@ -3301,8 +3817,11 @@ packages: resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==} engines: {node: '>=v12.22.7'} - scale-ts@1.6.0: - resolution: {integrity: sha512-Ja5VCjNZR8TGKhUumy9clVVxcDpM+YFjAnkMuwQy68Hixio3VRRvWdE3g8T/yC+HXA0ZDQl2TGyUmtmbcVl40Q==} + scale-ts@1.6.1: + resolution: {integrity: sha512-PBMc2AWc6wSEqJYBDPcyCLUj9/tMKnLX70jLOSndMtcUoLQucP/DM0vnQo1wJAYjTrQiq8iG9rD0q6wFzgjH7g==} + + scheduler@0.23.2: + resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} secure-json-parse@2.7.0: resolution: {integrity: sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==} @@ -3333,10 +3852,6 @@ packages: resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} engines: {node: '>= 0.4'} - set-function-name@2.0.2: - resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} - engines: {node: '>= 0.4'} - setimmediate@1.0.5: resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==} @@ -3352,10 +3867,6 @@ packages: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} - side-channel@1.0.6: - resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} - engines: {node: '>= 0.4'} - siginfo@2.0.0: resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} @@ -3380,6 +3891,14 @@ packages: resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} engines: {node: '>=8'} + slice-ansi@5.0.0: + resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==} + engines: {node: '>=12'} + + slice-ansi@7.1.0: + resolution: {integrity: sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==} + engines: {node: '>=18'} + smart-buffer@4.2.0: resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==} engines: {node: '>= 6.0.0', npm: '>= 3.0.0'} @@ -3387,6 +3906,9 @@ packages: smoldot@2.0.26: resolution: {integrity: sha512-F+qYmH4z2s2FK+CxGj8moYcd1ekSIKH8ywkdqlOz88Dat35iB1DIYL11aILN46YSGMzQW/lbJNS307zBSDN5Ig==} + smoldot@2.0.33: + resolution: {integrity: sha512-EnGqFb2oJSYjR04WsvL4tZNPrkdSiScBk3yQUhvWwJqpJ2bBu8Sq/hQgyVB20J1NxJ6FL0cgldjnGJmH1iQCTg==} + socks-proxy-agent@6.2.1: resolution: {integrity: sha512-a6KW9G+6B3nWZ1yB8G7pJwL3ggLy1uTzKAgCb7ttblwqdz9fMGJUuTy3uFzEP48FAs9FLILlmzDlE2JJhVQaXQ==} engines: {node: '>= 10'} @@ -3403,6 +3925,10 @@ packages: sonic-boom@4.2.0: resolution: {integrity: sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==} + sort-keys@5.1.0: + resolution: {integrity: sha512-aSbHV0DaBcr7u0PVHXzM6NbZNAtrr9sF6+Qfs9UUVG7Ll3jQ6hHi8F/xqIIcn2rvIVbr0v/2zyjSdwSV47AgLQ==} + engines: {node: '>=12'} + source-map-js@1.2.1: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} @@ -3411,6 +3937,22 @@ packages: resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} engines: {node: '>=0.10.0'} + source-map@0.8.0-beta.0: + resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} + engines: {node: '>= 8'} + + spdx-correct@3.2.0: + resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==} + + spdx-exceptions@2.5.0: + resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==} + + spdx-expression-parse@3.0.1: + resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==} + + spdx-license-ids@3.0.20: + resolution: {integrity: sha512-jg25NiDV/1fLtSgEgyvVyDunvaNHbuwF9lfNV17gSmPFAlYzdfNBlLtLzXTevwkPj7DhGbmN9VnmJIgLnhvaBw==} + split2@4.2.0: resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==} engines: {node: '>= 10.x'} @@ -3425,19 +3967,19 @@ packages: resolution: {integrity: sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==} engines: {node: '>= 8'} + stack-utils@2.0.6: + resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==} + engines: {node: '>=10'} + stackback@0.0.2: resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} std-env@3.8.0: resolution: {integrity: sha512-Bc3YwwCB+OzldMxOXJIIvC6cPRWr/LxOp48CdQTOkPyk/t4JWWJbrilwBd7RJzKV8QW7tJkcgAmeuLLJugl5/w==} - stdin-discarder@0.1.0: - resolution: {integrity: sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ==} - engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} - - stop-iteration-iterator@1.0.0: - resolution: {integrity: sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==} - engines: {node: '>= 0.4'} + stdin-discarder@0.2.2: + resolution: {integrity: sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==} + engines: {node: '>=18'} string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} @@ -3447,6 +3989,10 @@ packages: resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==} engines: {node: '>=12'} + string-width@7.2.0: + resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==} + engines: {node: '>=18'} + string_decoder@1.3.0: resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} @@ -3462,6 +4008,10 @@ packages: resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==} engines: {node: '>=6'} + strip-final-newline@4.0.0: + resolution: {integrity: sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==} + engines: {node: '>=18'} + strip-json-comments@2.0.1: resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} engines: {node: '>=0.10.0'} @@ -3470,6 +4020,11 @@ packages: resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} engines: {node: '>=8'} + sucrase@3.35.0: + resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} + engines: {node: '>=16 || 14 >=14.17'} + hasBin: true + supports-color@7.2.0: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} @@ -3565,16 +4120,26 @@ packages: tr46@0.0.3: resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + tr46@1.0.1: + resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} + tr46@5.0.0: resolution: {integrity: sha512-tk2G5R2KRwBd+ZN0zaEXpmzdKyOYksXwywulIX95MBODjSzMIuQnQ3m8JxgbhnL1LeVo7lqQKsYa1O3Htl7K5g==} engines: {node: '>=18'} + tree-kill@1.2.2: + resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} + hasBin: true + ts-api-utils@1.4.0: resolution: {integrity: sha512-032cPxaEKwM+GT3vA5JXNzIaizx388rhsSW79vGRNGXfRRAdEAn2mvk36PvK5HnOchyWZ7afLEXqYCvPCrzuzQ==} engines: {node: '>=16'} peerDependencies: typescript: '>=4.2.0' + ts-interface-checker@0.1.13: + resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==} + ts-node@10.9.2: resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} hasBin: true @@ -3586,14 +4151,39 @@ packages: peerDependenciesMeta: '@swc/core': optional: true - '@swc/wasm': + '@swc/wasm': + optional: true + + tsc-prog@2.3.0: + resolution: {integrity: sha512-ycET2d75EgcX7y8EmG4KiZkLAwUzbY4xRhA6NU0uVbHkY4ZjrAAuzTMxXI85kOwATqPnBI5C/7y7rlpY0xdqHA==} + engines: {node: '>=12'} + peerDependencies: + typescript: '>=4' + + tslib@2.7.0: + resolution: {integrity: sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==} + + tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + + tsup@8.3.5: + resolution: {integrity: sha512-Tunf6r6m6tnZsG9GYWndg0z8dEV7fD733VBFzFJ5Vcm1FtlXB8xBD/rtrBi2a3YKEV7hHtxiZtW5EAVADoe1pA==} + engines: {node: '>=18'} + hasBin: true + peerDependencies: + '@microsoft/api-extractor': ^7.36.0 + '@swc/core': ^1 + postcss: ^8.4.12 + typescript: '>=4.5.0' + peerDependenciesMeta: + '@microsoft/api-extractor': + optional: true + '@swc/core': + optional: true + postcss: + optional: true + typescript: optional: true - - tslib@2.7.0: - resolution: {integrity: sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==} - - tslib@2.8.1: - resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} tsx@4.19.2: resolution: {integrity: sha512-pOUl6Vo2LUq/bSa8S5q7b91cgNSjctn9ugq/+Mvow99qW6x/UZYwzxy/3NmqoT66eHYfCVvFvACC58UBPFf28g==} @@ -3623,6 +4213,10 @@ packages: resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} engines: {node: '>=10'} + type-fest@4.30.0: + resolution: {integrity: sha512-G6zXWS1dLj6eagy6sVhOMQiLtJdxQBHIA9Z6HFUNLOlr6MFOgzV8wvmidtPONfPtEUv0uZsy77XJNzTAfwPDaA==} + engines: {node: '>=16'} + typeorm@0.3.20: resolution: {integrity: sha512-sJ0T08dV5eoZroaq9uPKBoNcGslHBR4E4y+EBHs//SiGbblGe7IeduP/IH4ddCcj0qp3PHwDwGnuvqEAnKlq/Q==} engines: {node: '>=16.13.0'} @@ -3697,6 +4291,17 @@ packages: undici-types@6.19.8: resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} + undici-types@6.20.0: + resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==} + + unicorn-magic@0.1.0: + resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==} + engines: {node: '>=18'} + + unicorn-magic@0.3.0: + resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==} + engines: {node: '>=18'} + unique-filename@1.1.1: resolution: {integrity: sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==} @@ -3744,6 +4349,9 @@ packages: v8-compile-cache-lib@3.0.1: resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} + validate-npm-package-license@3.0.4: + resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==} + viem@2.21.45: resolution: {integrity: sha512-I+On/IiaObQdhDKWU5Rurh6nf3G7reVkAODG5ECIfjsrGQ3EPJnxirUPT4FNV6bWER5iphoG62/TidwuTSOA1A==} peerDependencies: @@ -3906,6 +4514,9 @@ packages: webidl-conversions@3.0.1: resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + webidl-conversions@4.0.2: + resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} + webidl-conversions@7.0.0: resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==} engines: {node: '>=12'} @@ -3925,12 +4536,8 @@ packages: whatwg-url@5.0.0: resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} - which-boxed-primitive@1.0.2: - resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} - - which-collection@1.0.2: - resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==} - engines: {node: '>= 0.4'} + whatwg-url@7.1.0: + resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==} which-typed-array@1.1.15: resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} @@ -3949,6 +4556,10 @@ packages: wide-align@1.1.5: resolution: {integrity: sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==} + widest-line@5.0.0: + resolution: {integrity: sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==} + engines: {node: '>=18'} + window-size@1.1.1: resolution: {integrity: sha512-5D/9vujkmVQ7pSmc0SCBmHXbkv6eaHwXEx65MywhmUMsI8sGqJ972APq1lotfcwMKPFLuCFfL8xGHLIp7jaBmA==} engines: {node: '>= 0.10.0'} @@ -3976,9 +4587,25 @@ packages: resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==} engines: {node: '>=12'} + wrap-ansi@9.0.0: + resolution: {integrity: sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==} + engines: {node: '>=18'} + wrappy@1.0.2: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + write-file-atomic@5.0.1: + resolution: {integrity: sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + + write-json-file@6.0.0: + resolution: {integrity: sha512-MNHcU3f9WxnNyR6MxsYSj64Jz0+dwIpisWKWq9gqLj/GwmA9INg3BZ3vt70/HB3GEwrnDQWr4RPrywnhNzmUFA==} + engines: {node: '>=18'} + + write-package@7.1.0: + resolution: {integrity: sha512-DqUx8GI3r9BFWwU2DPKddL1E7xWfbFED82mLVhGXKlFEPe8IkBftzO7WfNwHtk7oGDHDeuH/o8VMpzzfMwmLUA==} + engines: {node: '>=18'} + ws@8.17.1: resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==} engines: {node: '>=10.0.0'} @@ -4055,6 +4682,17 @@ packages: resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} engines: {node: '>=10'} + yoctocolors-cjs@2.1.2: + resolution: {integrity: sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA==} + engines: {node: '>=18'} + + yoctocolors@2.1.1: + resolution: {integrity: sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==} + engines: {node: '>=18'} + + yoga-wasm-web@0.3.3: + resolution: {integrity: sha512-N+d4UJSJbt/R3wqY7Coqs5pcV0aUj2j9IaQ3rNj9bVCLld8tTGKRa2USARjnvZJWVx1NDmQev8EknoczaOQDOA==} + zod@3.23.8: resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==} @@ -4164,15 +4802,32 @@ snapshots: '@adraffy/ens-normalize@1.11.0': {} + '@alcalzone/ansi-tokenize@0.1.3': + dependencies: + ansi-styles: 6.2.1 + is-fullwidth-code-point: 4.0.0 + '@asamuzakjp/dom-selector@2.0.2': dependencies: bidi-js: 1.0.3 css-tree: 2.3.1 is-potential-custom-element-name: 1.0.1 + '@babel/code-frame@7.26.2': + dependencies: + '@babel/helper-validator-identifier': 7.25.9 + js-tokens: 4.0.0 + picocolors: 1.1.1 + + '@babel/helper-validator-identifier@7.25.9': {} + '@colors/colors@1.5.0': optional: true + '@commander-js/extra-typings@12.1.0(commander@12.1.0)': + dependencies: + commander: 12.1.0 + '@cspotcode/source-map-support@0.8.1': dependencies: '@jridgewell/trace-mapping': 0.3.9 @@ -4183,141 +4838,213 @@ snapshots: '@esbuild/aix-ppc64@0.23.1': optional: true + '@esbuild/aix-ppc64@0.24.0': + optional: true + '@esbuild/android-arm64@0.21.5': optional: true '@esbuild/android-arm64@0.23.1': optional: true + '@esbuild/android-arm64@0.24.0': + optional: true + '@esbuild/android-arm@0.21.5': optional: true '@esbuild/android-arm@0.23.1': optional: true + '@esbuild/android-arm@0.24.0': + optional: true + '@esbuild/android-x64@0.21.5': optional: true '@esbuild/android-x64@0.23.1': optional: true + '@esbuild/android-x64@0.24.0': + optional: true + '@esbuild/darwin-arm64@0.21.5': optional: true '@esbuild/darwin-arm64@0.23.1': optional: true + '@esbuild/darwin-arm64@0.24.0': + optional: true + '@esbuild/darwin-x64@0.21.5': optional: true '@esbuild/darwin-x64@0.23.1': optional: true + '@esbuild/darwin-x64@0.24.0': + optional: true + '@esbuild/freebsd-arm64@0.21.5': optional: true '@esbuild/freebsd-arm64@0.23.1': optional: true + '@esbuild/freebsd-arm64@0.24.0': + optional: true + '@esbuild/freebsd-x64@0.21.5': optional: true '@esbuild/freebsd-x64@0.23.1': optional: true + '@esbuild/freebsd-x64@0.24.0': + optional: true + '@esbuild/linux-arm64@0.21.5': optional: true '@esbuild/linux-arm64@0.23.1': optional: true + '@esbuild/linux-arm64@0.24.0': + optional: true + '@esbuild/linux-arm@0.21.5': optional: true '@esbuild/linux-arm@0.23.1': optional: true + '@esbuild/linux-arm@0.24.0': + optional: true + '@esbuild/linux-ia32@0.21.5': optional: true '@esbuild/linux-ia32@0.23.1': optional: true + '@esbuild/linux-ia32@0.24.0': + optional: true + '@esbuild/linux-loong64@0.21.5': optional: true '@esbuild/linux-loong64@0.23.1': optional: true + '@esbuild/linux-loong64@0.24.0': + optional: true + '@esbuild/linux-mips64el@0.21.5': optional: true '@esbuild/linux-mips64el@0.23.1': optional: true + '@esbuild/linux-mips64el@0.24.0': + optional: true + '@esbuild/linux-ppc64@0.21.5': optional: true '@esbuild/linux-ppc64@0.23.1': optional: true + '@esbuild/linux-ppc64@0.24.0': + optional: true + '@esbuild/linux-riscv64@0.21.5': optional: true '@esbuild/linux-riscv64@0.23.1': optional: true + '@esbuild/linux-riscv64@0.24.0': + optional: true + '@esbuild/linux-s390x@0.21.5': optional: true '@esbuild/linux-s390x@0.23.1': optional: true + '@esbuild/linux-s390x@0.24.0': + optional: true + '@esbuild/linux-x64@0.21.5': optional: true '@esbuild/linux-x64@0.23.1': optional: true + '@esbuild/linux-x64@0.24.0': + optional: true + '@esbuild/netbsd-x64@0.21.5': optional: true '@esbuild/netbsd-x64@0.23.1': optional: true + '@esbuild/netbsd-x64@0.24.0': + optional: true + '@esbuild/openbsd-arm64@0.23.1': optional: true + '@esbuild/openbsd-arm64@0.24.0': + optional: true + '@esbuild/openbsd-x64@0.21.5': optional: true '@esbuild/openbsd-x64@0.23.1': optional: true + '@esbuild/openbsd-x64@0.24.0': + optional: true + '@esbuild/sunos-x64@0.21.5': optional: true '@esbuild/sunos-x64@0.23.1': optional: true + '@esbuild/sunos-x64@0.24.0': + optional: true + '@esbuild/win32-arm64@0.21.5': optional: true '@esbuild/win32-arm64@0.23.1': optional: true + '@esbuild/win32-arm64@0.24.0': + optional: true + '@esbuild/win32-ia32@0.21.5': optional: true '@esbuild/win32-ia32@0.23.1': optional: true + '@esbuild/win32-ia32@0.24.0': + optional: true + '@esbuild/win32-x64@0.21.5': optional: true '@esbuild/win32-x64@0.23.1': optional: true + '@esbuild/win32-x64@0.24.0': + optional: true + '@eslint-community/eslint-utils@4.4.1(eslint@8.56.0)': dependencies: eslint: 8.56.0 @@ -4360,6 +5087,112 @@ snapshots: '@humanwhocodes/object-schema@2.0.3': {} + '@inquirer/checkbox@4.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/figures': 1.0.8 + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + ansi-escapes: 4.3.2 + yoctocolors-cjs: 2.1.2 + + '@inquirer/confirm@5.1.0(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + + '@inquirer/core@10.1.1(@types/node@22.9.0)': + dependencies: + '@inquirer/figures': 1.0.8 + '@inquirer/type': 3.0.1(@types/node@22.9.0) + ansi-escapes: 4.3.2 + cli-width: 4.1.0 + mute-stream: 2.0.0 + signal-exit: 4.1.0 + strip-ansi: 6.0.1 + wrap-ansi: 6.2.0 + yoctocolors-cjs: 2.1.2 + transitivePeerDependencies: + - '@types/node' + + '@inquirer/editor@4.2.0(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + external-editor: 3.1.0 + + '@inquirer/expand@4.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + yoctocolors-cjs: 2.1.2 + + '@inquirer/figures@1.0.8': {} + + '@inquirer/input@4.1.0(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + + '@inquirer/number@3.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + + '@inquirer/password@4.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + ansi-escapes: 4.3.2 + + '@inquirer/prompts@7.2.0(@types/node@22.9.0)': + dependencies: + '@inquirer/checkbox': 4.0.3(@types/node@22.9.0) + '@inquirer/confirm': 5.1.0(@types/node@22.9.0) + '@inquirer/editor': 4.2.0(@types/node@22.9.0) + '@inquirer/expand': 4.0.3(@types/node@22.9.0) + '@inquirer/input': 4.1.0(@types/node@22.9.0) + '@inquirer/number': 3.0.3(@types/node@22.9.0) + '@inquirer/password': 4.0.3(@types/node@22.9.0) + '@inquirer/rawlist': 4.0.3(@types/node@22.9.0) + '@inquirer/search': 3.0.3(@types/node@22.9.0) + '@inquirer/select': 4.0.3(@types/node@22.9.0) + '@types/node': 22.9.0 + + '@inquirer/rawlist@4.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + yoctocolors-cjs: 2.1.2 + + '@inquirer/search@3.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/figures': 1.0.8 + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + yoctocolors-cjs: 2.1.2 + + '@inquirer/select@4.0.3(@types/node@22.9.0)': + dependencies: + '@inquirer/core': 10.1.1(@types/node@22.9.0) + '@inquirer/figures': 1.0.8 + '@inquirer/type': 3.0.1(@types/node@22.9.0) + '@types/node': 22.9.0 + ansi-escapes: 4.3.2 + yoctocolors-cjs: 2.1.2 + + '@inquirer/type@3.0.1(@types/node@22.9.0)': + dependencies: + '@types/node': 22.9.0 + '@isaacs/cliui@8.0.2': dependencies: string-width: 5.1.2 @@ -4369,10 +5202,23 @@ snapshots: wrap-ansi: 8.1.0 wrap-ansi-cjs: wrap-ansi@7.0.0 + '@jridgewell/gen-mapping@0.3.5': + dependencies: + '@jridgewell/set-array': 1.2.1 + '@jridgewell/sourcemap-codec': 1.5.0 + '@jridgewell/trace-mapping': 0.3.25 + '@jridgewell/resolve-uri@3.1.2': {} + '@jridgewell/set-array@1.2.1': {} + '@jridgewell/sourcemap-codec@1.5.0': {} + '@jridgewell/trace-mapping@0.3.25': + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.0 + '@jridgewell/trace-mapping@0.3.9': dependencies: '@jridgewell/resolve-uri': 3.1.2 @@ -4400,12 +5246,13 @@ snapshots: - supports-color - utf-8-validate - '@moonwall/cli@5.6.0(@types/node@22.9.0)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3))(typescript@5.6.3)(zod@3.23.8)': + '@moonwall/cli@5.9.1(@types/node@22.9.0)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3))(tsx@4.19.2)(typescript@5.6.3)(zod@3.23.8)': dependencies: '@acala-network/chopsticks': 1.0.1(debug@4.3.7)(ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3)) + '@inquirer/prompts': 7.2.0(@types/node@22.9.0) '@moonbeam-network/api-augment': 0.3200.3 - '@moonwall/types': 5.6.0(chokidar@3.6.0)(encoding@0.1.13)(typescript@5.6.3)(zod@3.23.8) - '@moonwall/util': 5.6.0(@types/node@22.9.0)(@vitest/ui@2.1.5(vitest@2.1.5))(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(typescript@5.6.3)(zod@3.23.8) + '@moonwall/types': 5.9.1(@vitest/ui@2.1.5)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5)(zod@3.23.8) + '@moonwall/util': 5.9.1(@types/node@22.9.0)(@vitest/ui@2.1.5)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5)(zod@3.23.8) '@octokit/rest': 21.0.2 '@polkadot/api': 14.3.1 '@polkadot/api-derive': 14.3.1 @@ -4414,6 +5261,8 @@ snapshots: '@polkadot/types-codec': 14.3.1 '@polkadot/util': 13.2.3 '@polkadot/util-crypto': 13.2.3(@polkadot/util@13.2.3) + '@types/react': 18.3.14 + '@types/tmp': 0.2.6 '@vitest/ui': 2.1.5(vitest@2.1.5) '@zombienet/orchestrator': 0.0.97(@polkadot/util@13.2.3)(@types/node@22.9.0)(chokidar@3.6.0) '@zombienet/utils': 0.0.25(@types/node@22.9.0)(chokidar@3.6.0)(typescript@5.6.3) @@ -4427,12 +5276,14 @@ snapshots: dotenv: 16.4.5 ethers: 6.13.4 get-port: 7.1.0 - inquirer: 9.2.16 - inquirer-press-to-continue: 1.2.0(inquirer@9.2.16) + ink: 5.1.0(@types/react@18.3.14)(react@18.3.1) jsonc-parser: 3.3.1 minimatch: 9.0.5 + polkadot-api: 1.7.7(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(yaml@2.4.5) + react: 18.3.1 semver: 7.6.3 tiny-invariant: 1.3.3 + tmp: 0.2.3 viem: 2.21.45(typescript@5.6.3)(zod@3.23.8) vitest: 2.1.5(@types/node@22.9.0)(@vitest/ui@2.1.5)(jsdom@23.2.0) web3: 4.15.0(encoding@0.1.13)(typescript@5.6.3)(zod@3.23.8) @@ -4443,6 +5294,7 @@ snapshots: transitivePeerDependencies: - '@edge-runtime/vm' - '@google-cloud/spanner' + - '@microsoft/api-extractor' - '@sap/hana-client' - '@swc/core' - '@swc/wasm' @@ -4457,6 +5309,7 @@ snapshots: - happy-dom - hdb-pool - ioredis + - jiti - jsdom - less - lightningcss @@ -4468,7 +5321,10 @@ snapshots: - pg - pg-native - pg-query-stream + - postcss + - react-devtools-core - redis + - rxjs - sass - sass-embedded - sql.js @@ -4477,12 +5333,13 @@ snapshots: - supports-color - terser - ts-node + - tsx - typeorm-aurora-data-api-driver - typescript - utf-8-validate - zod - '@moonwall/types@5.6.0(chokidar@3.6.0)(encoding@0.1.13)(typescript@5.6.3)(zod@3.23.8)': + '@moonwall/types@5.9.1(@vitest/ui@2.1.5)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5)(zod@3.23.8)': dependencies: '@polkadot/api': 14.3.1 '@polkadot/api-base': 14.3.1 @@ -4495,23 +5352,45 @@ snapshots: bottleneck: 2.19.5 debug: 4.3.7(supports-color@8.1.1) ethers: 6.13.4 + polkadot-api: 1.7.7(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(yaml@2.4.5) viem: 2.21.45(typescript@5.6.3)(zod@3.23.8) + vitest: 2.1.5(@types/node@22.9.0)(@vitest/ui@2.1.5)(jsdom@23.2.0) web3: 4.15.0(encoding@0.1.13)(typescript@5.6.3)(zod@3.23.8) transitivePeerDependencies: + - '@edge-runtime/vm' + - '@microsoft/api-extractor' - '@swc/core' - '@swc/wasm' + - '@vitest/browser' + - '@vitest/ui' - bufferutil - chokidar - encoding + - happy-dom + - jiti + - jsdom + - less + - lightningcss + - msw + - postcss + - rxjs + - sass + - sass-embedded + - stylus + - sugarss - supports-color + - terser + - tsx - typescript - utf-8-validate + - yaml - zod - '@moonwall/util@5.6.0(@types/node@22.9.0)(@vitest/ui@2.1.5(vitest@2.1.5))(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(typescript@5.6.3)(zod@3.23.8)': + '@moonwall/util@5.9.1(@types/node@22.9.0)(@vitest/ui@2.1.5)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5)(zod@3.23.8)': dependencies: + '@inquirer/prompts': 7.2.0(@types/node@22.9.0) '@moonbeam-network/api-augment': 0.3200.3 - '@moonwall/types': 5.6.0(chokidar@3.6.0)(encoding@0.1.13)(typescript@5.6.3)(zod@3.23.8) + '@moonwall/types': 5.9.1(@vitest/ui@2.1.5)(chokidar@3.6.0)(encoding@0.1.13)(jsdom@23.2.0)(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5)(zod@3.23.8) '@polkadot/api': 14.3.1 '@polkadot/api-derive': 14.3.1 '@polkadot/keyring': 13.2.3(@polkadot/util-crypto@13.2.3(@polkadot/util@13.2.3))(@polkadot/util@13.2.3) @@ -4528,8 +5407,6 @@ snapshots: debug: 4.3.7(supports-color@8.1.1) dotenv: 16.4.5 ethers: 6.13.4 - inquirer: 9.2.16 - inquirer-press-to-continue: 1.2.0(inquirer@9.2.16) rlp: 3.0.0 semver: 7.6.3 viem: 2.21.45(typescript@5.6.3)(zod@3.23.8) @@ -4539,6 +5416,7 @@ snapshots: yargs: 17.7.2 transitivePeerDependencies: - '@edge-runtime/vm' + - '@microsoft/api-extractor' - '@swc/core' - '@swc/wasm' - '@types/node' @@ -4548,18 +5426,23 @@ snapshots: - chokidar - encoding - happy-dom + - jiti - jsdom - less - lightningcss - msw + - postcss + - rxjs - sass - sass-embedded - stylus - sugarss - supports-color - terser + - tsx - typescript - utf-8-validate + - yaml - zod '@noble/curves@1.2.0': @@ -4686,18 +5569,92 @@ snapshots: '@polka/url@1.0.0-next.28': {} + '@polkadot-api/cli@0.9.21(postcss@8.4.49)(tsx@4.19.2)(yaml@2.4.5)': + dependencies: + '@commander-js/extra-typings': 12.1.0(commander@12.1.0) + '@polkadot-api/codegen': 0.12.9 + '@polkadot-api/ink-contracts': 0.2.2 + '@polkadot-api/json-rpc-provider': 0.0.4 + '@polkadot-api/known-chains': 0.5.8 + '@polkadot-api/metadata-compatibility': 0.1.12 + '@polkadot-api/observable-client': 0.6.3(@polkadot-api/substrate-client@0.3.0)(rxjs@7.8.1) + '@polkadot-api/polkadot-sdk-compat': 2.3.1 + '@polkadot-api/sm-provider': 0.1.7(@polkadot-api/smoldot@0.3.7) + '@polkadot-api/smoldot': 0.3.7 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/substrate-client': 0.3.0 + '@polkadot-api/utils': 0.1.2 + '@polkadot-api/wasm-executor': 0.1.2 + '@polkadot-api/ws-provider': 0.3.6 + '@types/node': 22.10.1 + commander: 12.1.0 + execa: 9.5.2 + fs.promises.exists: 1.1.4 + ora: 8.1.1 + read-pkg: 9.0.1 + rxjs: 7.8.1 + tsc-prog: 2.3.0(typescript@5.6.3) + tsup: 8.3.5(postcss@8.4.49)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5) + typescript: 5.6.3 + write-package: 7.1.0 + transitivePeerDependencies: + - '@microsoft/api-extractor' + - '@swc/core' + - bufferutil + - jiti + - postcss + - supports-color + - tsx + - utf-8-validate + - yaml + + '@polkadot-api/codegen@0.12.9': + dependencies: + '@polkadot-api/ink-contracts': 0.2.2 + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/metadata-compatibility': 0.1.12 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/utils': 0.1.2 + + '@polkadot-api/ink-contracts@0.2.2': + dependencies: + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/utils': 0.1.2 + scale-ts: 1.6.1 + '@polkadot-api/json-rpc-provider-proxy@0.1.0': optional: true + '@polkadot-api/json-rpc-provider-proxy@0.2.4': {} + '@polkadot-api/json-rpc-provider@0.0.1': optional: true + '@polkadot-api/json-rpc-provider@0.0.4': {} + + '@polkadot-api/known-chains@0.5.8': {} + + '@polkadot-api/logs-provider@0.0.6': + dependencies: + '@polkadot-api/json-rpc-provider': 0.0.4 + '@polkadot-api/metadata-builders@0.3.2': dependencies: '@polkadot-api/substrate-bindings': 0.6.0 '@polkadot-api/utils': 0.1.0 optional: true + '@polkadot-api/metadata-builders@0.9.2': + dependencies: + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/utils': 0.1.2 + + '@polkadot-api/metadata-compatibility@0.1.12': + dependencies: + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/observable-client@0.3.2(@polkadot-api/substrate-client@0.1.4)(rxjs@7.8.1)': dependencies: '@polkadot-api/metadata-builders': 0.3.2 @@ -4707,23 +5664,99 @@ snapshots: rxjs: 7.8.1 optional: true + '@polkadot-api/observable-client@0.6.3(@polkadot-api/substrate-client@0.3.0)(rxjs@7.8.1)': + dependencies: + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/substrate-client': 0.3.0 + '@polkadot-api/utils': 0.1.2 + rxjs: 7.8.1 + + '@polkadot-api/pjs-signer@0.6.1': + dependencies: + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/polkadot-signer': 0.1.6 + '@polkadot-api/signers-common': 0.1.2 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/utils': 0.1.2 + + '@polkadot-api/polkadot-sdk-compat@2.3.1': + dependencies: + '@polkadot-api/json-rpc-provider': 0.0.4 + + '@polkadot-api/polkadot-signer@0.1.6': {} + + '@polkadot-api/signer@0.1.11': + dependencies: + '@noble/hashes': 1.5.0 + '@polkadot-api/polkadot-signer': 0.1.6 + '@polkadot-api/signers-common': 0.1.2 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/utils': 0.1.2 + + '@polkadot-api/signers-common@0.1.2': + dependencies: + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/polkadot-signer': 0.1.6 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/utils': 0.1.2 + + '@polkadot-api/sm-provider@0.1.7(@polkadot-api/smoldot@0.3.7)': + dependencies: + '@polkadot-api/json-rpc-provider': 0.0.4 + '@polkadot-api/json-rpc-provider-proxy': 0.2.4 + '@polkadot-api/smoldot': 0.3.7 + + '@polkadot-api/smoldot@0.3.7': + dependencies: + '@types/node': 22.9.0 + smoldot: 2.0.33 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + '@polkadot-api/substrate-bindings@0.6.0': dependencies: '@noble/hashes': 1.5.0 '@polkadot-api/utils': 0.1.0 '@scure/base': 1.1.9 - scale-ts: 1.6.0 + scale-ts: 1.6.1 optional: true + '@polkadot-api/substrate-bindings@0.9.4': + dependencies: + '@noble/hashes': 1.5.0 + '@polkadot-api/utils': 0.1.2 + '@scure/base': 1.1.9 + scale-ts: 1.6.1 + '@polkadot-api/substrate-client@0.1.4': dependencies: '@polkadot-api/json-rpc-provider': 0.0.1 '@polkadot-api/utils': 0.1.0 optional: true + '@polkadot-api/substrate-client@0.3.0': + dependencies: + '@polkadot-api/json-rpc-provider': 0.0.4 + '@polkadot-api/utils': 0.1.2 + '@polkadot-api/utils@0.1.0': optional: true + '@polkadot-api/utils@0.1.2': {} + + '@polkadot-api/wasm-executor@0.1.2': {} + + '@polkadot-api/ws-provider@0.3.6': + dependencies: + '@polkadot-api/json-rpc-provider': 0.0.4 + '@polkadot-api/json-rpc-provider-proxy': 0.2.4 + ws: 8.18.0 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + '@polkadot/api-augment@14.0.1': dependencies: '@polkadot/api-base': 14.0.1 @@ -5303,6 +6336,10 @@ snapshots: '@noble/hashes': 1.5.0 '@scure/base': 1.1.9 + '@sec-ant/readable-stream@0.4.1': {} + + '@sindresorhus/merge-streams@4.0.0': {} + '@sqltools/formatter@1.2.5': {} '@substrate/connect-extension-protocol@2.1.0': @@ -5371,6 +6408,10 @@ snapshots: '@types/ms@0.7.34': {} + '@types/node@22.10.1': + dependencies: + undici-types: 6.20.0 + '@types/node@22.5.0': dependencies: undici-types: 6.19.8 @@ -5383,8 +6424,19 @@ snapshots: dependencies: undici-types: 6.19.8 + '@types/normalize-package-data@2.4.4': {} + + '@types/prop-types@15.7.14': {} + + '@types/react@18.3.14': + dependencies: + '@types/prop-types': 15.7.14 + csstype: 3.1.3 + '@types/semver@7.5.8': {} + '@types/tmp@0.2.6': {} + '@types/unist@2.0.11': {} '@types/unist@3.0.3': {} @@ -5655,6 +6707,10 @@ snapshots: dependencies: type-fest: 0.21.3 + ansi-escapes@7.0.0: + dependencies: + environment: 1.1.0 + ansi-regex@5.0.1: {} ansi-regex@6.1.0: {} @@ -5687,11 +6743,6 @@ snapshots: argparse@2.0.1: {} - array-buffer-byte-length@1.0.1: - dependencies: - call-bind: 1.0.7 - is-array-buffer: 3.0.4 - array-union@2.1.0: {} asap@2.0.6: {} @@ -5704,6 +6755,8 @@ snapshots: atomic-sleep@1.0.0: {} + auto-bind@5.0.1: {} + available-typed-arrays@1.0.7: dependencies: possible-typed-array-names: 1.0.0 @@ -5742,12 +6795,6 @@ snapshots: inherits: 2.0.4 readable-stream: 3.6.2 - bl@5.1.0: - dependencies: - buffer: 6.0.3 - inherits: 2.0.4 - readable-stream: 3.6.2 - bn.js@5.2.1: {} boolean@3.2.0: {} @@ -5779,6 +6826,11 @@ snapshots: base64-js: 1.5.1 ieee754: 1.2.1 + bundle-require@5.0.0(esbuild@0.24.0): + dependencies: + esbuild: 0.24.0 + load-tsconfig: 0.2.5 + cac@6.7.14: {} cacache@15.3.0: @@ -5874,6 +6926,10 @@ snapshots: optionalDependencies: fsevents: 2.3.3 + chokidar@4.0.1: + dependencies: + readdirp: 4.0.2 + chownr@1.1.4: {} chownr@2.0.0: {} @@ -5885,6 +6941,8 @@ snapshots: clear@0.1.0: {} + cli-boxes@3.0.0: {} + cli-cursor@3.1.0: dependencies: restore-cursor: 3.1.0 @@ -5893,6 +6951,10 @@ snapshots: dependencies: restore-cursor: 4.0.0 + cli-cursor@5.0.0: + dependencies: + restore-cursor: 5.1.0 + cli-highlight@2.1.11: dependencies: chalk: 4.1.2 @@ -5914,6 +6976,11 @@ snapshots: optionalDependencies: '@colors/colors': 1.5.0 + cli-truncate@4.0.0: + dependencies: + slice-ansi: 5.0.0 + string-width: 7.2.0 + cli-width@4.1.0: {} cliui@7.0.4: @@ -5930,6 +6997,10 @@ snapshots: clone@1.0.4: {} + code-excerpt@4.0.0: + dependencies: + convert-to-spaces: 2.0.1 + color-convert@2.0.1: dependencies: color-name: 1.1.4 @@ -5951,6 +7022,10 @@ snapshots: command-exists@1.2.9: {} + commander@12.1.0: {} + + commander@4.1.1: {} + commander@5.1.0: {} commander@8.3.0: {} @@ -5966,9 +7041,13 @@ snapshots: connected-domain@1.0.0: {} + consola@3.2.3: {} + console-control-strings@1.1.0: optional: true + convert-to-spaces@2.0.1: {} + crc-32@1.2.2: {} create-require@1.1.1: {} @@ -5994,6 +7073,8 @@ snapshots: dependencies: rrweb-cssom: 0.7.1 + csstype@3.1.3: {} + data-uri-to-buffer@4.0.1: {} data-urls@5.0.0: @@ -6029,31 +7110,12 @@ snapshots: deep-eql@5.0.2: {} - deep-equal@2.2.3: - dependencies: - array-buffer-byte-length: 1.0.1 - call-bind: 1.0.7 - es-get-iterator: 1.1.3 - get-intrinsic: 1.2.4 - is-arguments: 1.1.1 - is-array-buffer: 3.0.4 - is-date-object: 1.0.5 - is-regex: 1.1.4 - is-shared-array-buffer: 1.0.3 - isarray: 2.0.5 - object-is: 1.1.6 - object-keys: 1.1.1 - object.assign: 4.1.5 - regexp.prototype.flags: 1.5.3 - side-channel: 1.0.6 - which-boxed-primitive: 1.0.2 - which-collection: 1.0.2 - which-typed-array: 1.1.15 - deep-extend@0.6.0: {} deep-is@0.1.4: {} + deepmerge-ts@7.1.3: {} + defaults@1.0.4: dependencies: clone: 1.0.4 @@ -6081,6 +7143,8 @@ snapshots: dequal@2.0.3: {} + detect-indent@7.0.1: {} + detect-libc@2.0.3: {} detect-node@2.1.0: {} @@ -6107,6 +7171,8 @@ snapshots: eastasianwidth@0.2.0: {} + emoji-regex@10.4.0: {} + emoji-regex@8.0.0: {} emoji-regex@9.2.2: {} @@ -6125,6 +7191,8 @@ snapshots: env-paths@2.2.1: optional: true + environment@1.1.0: {} + err-code@2.0.3: optional: true @@ -6136,20 +7204,10 @@ snapshots: es-errors@1.3.0: {} - es-get-iterator@1.1.3: - dependencies: - call-bind: 1.0.7 - get-intrinsic: 1.2.4 - has-symbols: 1.0.3 - is-arguments: 1.1.1 - is-map: 2.0.3 - is-set: 2.0.3 - is-string: 1.0.7 - isarray: 2.0.5 - stop-iteration-iterator: 1.0.0 - es-module-lexer@1.5.4: {} + es-toolkit@1.29.0: {} + es6-error@4.1.1: {} esbuild@0.21.5: @@ -6205,10 +7263,39 @@ snapshots: '@esbuild/win32-ia32': 0.23.1 '@esbuild/win32-x64': 0.23.1 + esbuild@0.24.0: + optionalDependencies: + '@esbuild/aix-ppc64': 0.24.0 + '@esbuild/android-arm': 0.24.0 + '@esbuild/android-arm64': 0.24.0 + '@esbuild/android-x64': 0.24.0 + '@esbuild/darwin-arm64': 0.24.0 + '@esbuild/darwin-x64': 0.24.0 + '@esbuild/freebsd-arm64': 0.24.0 + '@esbuild/freebsd-x64': 0.24.0 + '@esbuild/linux-arm': 0.24.0 + '@esbuild/linux-arm64': 0.24.0 + '@esbuild/linux-ia32': 0.24.0 + '@esbuild/linux-loong64': 0.24.0 + '@esbuild/linux-mips64el': 0.24.0 + '@esbuild/linux-ppc64': 0.24.0 + '@esbuild/linux-riscv64': 0.24.0 + '@esbuild/linux-s390x': 0.24.0 + '@esbuild/linux-x64': 0.24.0 + '@esbuild/netbsd-x64': 0.24.0 + '@esbuild/openbsd-arm64': 0.24.0 + '@esbuild/openbsd-x64': 0.24.0 + '@esbuild/sunos-x64': 0.24.0 + '@esbuild/win32-arm64': 0.24.0 + '@esbuild/win32-ia32': 0.24.0 + '@esbuild/win32-x64': 0.24.0 + escalade@3.2.0: {} escape-string-regexp@1.0.5: {} + escape-string-regexp@2.0.0: {} + escape-string-regexp@4.0.0: {} eslint-scope@7.2.2: @@ -6321,6 +7408,21 @@ snapshots: signal-exit: 3.0.7 strip-final-newline: 2.0.0 + execa@9.5.2: + dependencies: + '@sindresorhus/merge-streams': 4.0.0 + cross-spawn: 7.0.5 + figures: 6.1.0 + get-stream: 9.0.1 + human-signals: 8.0.0 + is-plain-obj: 4.1.0 + is-stream: 4.0.1 + npm-run-path: 6.0.0 + pretty-ms: 9.2.0 + signal-exit: 4.1.0 + strip-final-newline: 4.0.0 + yoctocolors: 2.1.1 + expand-template@2.0.3: {} expect-type@1.1.0: {} @@ -6370,6 +7472,10 @@ snapshots: dependencies: escape-string-regexp: 1.0.5 + figures@6.1.0: + dependencies: + is-unicode-supported: 2.1.0 + file-entry-cache@6.0.1: dependencies: flat-cache: 3.2.0 @@ -6430,6 +7536,8 @@ snapshots: dependencies: minipass: 3.3.6 + fs.promises.exists@1.1.4: {} + fs.realpath@1.0.0: {} fsevents@2.3.3: @@ -6437,8 +7545,6 @@ snapshots: function-bind@1.1.2: {} - functions-have-names@1.2.3: {} - gauge@4.0.4: dependencies: aproba: 2.0.0 @@ -6453,6 +7559,8 @@ snapshots: get-caller-file@2.0.5: {} + get-east-asian-width@1.3.0: {} + get-func-name@2.0.2: {} get-intrinsic@1.2.4: @@ -6467,6 +7575,11 @@ snapshots: get-stream@6.0.1: {} + get-stream@9.0.1: + dependencies: + '@sec-ant/readable-stream': 0.4.1 + is-stream: 4.0.1 + get-tsconfig@4.8.1: dependencies: resolve-pkg-maps: 1.0.0 @@ -6562,8 +7675,6 @@ snapshots: optionalDependencies: uglify-js: 3.19.3 - has-bigints@1.0.2: {} - has-flag@4.0.0: {} has-property-descriptors@1.0.2: @@ -6591,6 +7702,10 @@ snapshots: highlight.js@10.7.3: {} + hosted-git-info@7.0.2: + dependencies: + lru-cache: 10.4.3 + html-encoding-sniffer@4.0.0: dependencies: whatwg-encoding: 3.1.1 @@ -6631,6 +7746,8 @@ snapshots: human-signals@2.1.0: {} + human-signals@8.0.0: {} + humanize-ms@1.2.1: dependencies: ms: 2.1.3 @@ -6660,6 +7777,10 @@ snapshots: indent-string@4.0.0: optional: true + indent-string@5.0.0: {} + + index-to-position@0.1.2: {} + infer-owner@1.0.4: optional: true @@ -6672,11 +7793,38 @@ snapshots: ini@1.3.8: {} - inquirer-press-to-continue@1.2.0(inquirer@9.2.16): + ink@5.1.0(@types/react@18.3.14)(react@18.3.1): dependencies: - deep-equal: 2.2.3 - inquirer: 9.2.16 - ora: 6.3.1 + '@alcalzone/ansi-tokenize': 0.1.3 + ansi-escapes: 7.0.0 + ansi-styles: 6.2.1 + auto-bind: 5.0.1 + chalk: 5.3.0 + cli-boxes: 3.0.0 + cli-cursor: 4.0.0 + cli-truncate: 4.0.0 + code-excerpt: 4.0.0 + es-toolkit: 1.29.0 + indent-string: 5.0.0 + is-in-ci: 1.0.0 + patch-console: 2.0.0 + react: 18.3.1 + react-reconciler: 0.29.2(react@18.3.1) + scheduler: 0.23.2 + signal-exit: 3.0.7 + slice-ansi: 7.1.0 + stack-utils: 2.0.6 + string-width: 7.2.0 + type-fest: 4.30.0 + widest-line: 5.0.0 + wrap-ansi: 9.0.0 + ws: 8.18.0 + yoga-wasm-web: 0.3.3 + optionalDependencies: + '@types/react': 18.3.14 + transitivePeerDependencies: + - bufferutil + - utf-8-validate inquirer@9.2.16: dependencies: @@ -6696,12 +7844,6 @@ snapshots: strip-ansi: 6.0.1 wrap-ansi: 6.2.0 - internal-slot@1.0.7: - dependencies: - es-errors: 1.3.0 - hasown: 2.0.2 - side-channel: 1.0.6 - ip-address@9.0.5: dependencies: jsbn: 1.1.0 @@ -6717,24 +7859,10 @@ snapshots: call-bind: 1.0.7 has-tostringtag: 1.0.2 - is-array-buffer@3.0.4: - dependencies: - call-bind: 1.0.7 - get-intrinsic: 1.2.4 - - is-bigint@1.0.4: - dependencies: - has-bigints: 1.0.2 - is-binary-path@2.1.0: dependencies: binary-extensions: 2.3.0 - is-boolean-object@1.1.2: - dependencies: - call-bind: 1.0.7 - has-tostringtag: 1.0.2 - is-buffer@1.1.6: {} is-callable@1.2.7: {} @@ -6743,10 +7871,6 @@ snapshots: dependencies: hasown: 2.0.2 - is-date-object@1.0.5: - dependencies: - has-tostringtag: 1.0.2 - is-descriptor@1.0.3: dependencies: is-accessor-descriptor: 1.0.1 @@ -6756,6 +7880,12 @@ snapshots: is-fullwidth-code-point@3.0.0: {} + is-fullwidth-code-point@4.0.0: {} + + is-fullwidth-code-point@5.0.0: + dependencies: + get-east-asian-width: 1.3.0 + is-generator-function@1.0.10: dependencies: has-tostringtag: 1.0.2 @@ -6764,6 +7894,8 @@ snapshots: dependencies: is-extglob: 2.1.1 + is-in-ci@1.0.0: {} + is-interactive@1.0.0: {} is-interactive@2.0.0: {} @@ -6771,12 +7903,6 @@ snapshots: is-lambda@1.0.1: optional: true - is-map@2.0.3: {} - - is-number-object@1.0.7: - dependencies: - has-tostringtag: 1.0.2 - is-number@3.0.0: dependencies: kind-of: 3.2.2 @@ -6787,28 +7913,13 @@ snapshots: is-plain-obj@2.1.0: {} - is-potential-custom-element-name@1.0.1: {} - - is-regex@1.1.4: - dependencies: - call-bind: 1.0.7 - has-tostringtag: 1.0.2 - - is-set@2.0.3: {} + is-plain-obj@4.1.0: {} - is-shared-array-buffer@1.0.3: - dependencies: - call-bind: 1.0.7 + is-potential-custom-element-name@1.0.1: {} is-stream@2.0.1: {} - is-string@1.0.7: - dependencies: - has-tostringtag: 1.0.2 - - is-symbol@1.0.4: - dependencies: - has-symbols: 1.0.3 + is-stream@4.0.1: {} is-typed-array@1.1.13: dependencies: @@ -6818,14 +7929,7 @@ snapshots: is-unicode-supported@1.3.0: {} - is-weakmap@2.0.2: {} - - is-weakset@2.0.3: - dependencies: - call-bind: 1.0.7 - get-intrinsic: 1.2.4 - - isarray@2.0.5: {} + is-unicode-supported@2.1.0: {} isexe@2.0.0: {} @@ -6858,6 +7962,8 @@ snapshots: js-sha3@0.8.0: {} + js-tokens@4.0.0: {} + js-yaml@4.1.0: dependencies: argparse: 2.0.1 @@ -6946,12 +8052,20 @@ snapshots: protobufjs: 6.11.4 uint8arrays: 3.1.1 + lilconfig@3.1.3: {} + + lines-and-columns@1.2.4: {} + + load-tsconfig@0.2.5: {} + locate-path@6.0.0: dependencies: p-locate: 5.0.0 lodash.merge@4.6.2: {} + lodash.sortby@4.7.0: {} + lodash@4.17.21: {} log-symbols@4.1.0: @@ -6959,13 +8073,17 @@ snapshots: chalk: 4.1.2 is-unicode-supported: 0.1.0 - log-symbols@5.1.0: + log-symbols@6.0.0: dependencies: chalk: 5.3.0 is-unicode-supported: 1.3.0 long@4.0.0: {} + loose-envify@1.4.0: + dependencies: + js-tokens: 4.0.0 + loupe@2.3.7: dependencies: get-func-name: 2.0.2 @@ -7343,6 +8461,8 @@ snapshots: mimic-fn@2.1.0: {} + mimic-function@5.0.1: {} + mimic-response@3.1.0: {} minimatch@10.0.1: @@ -7469,6 +8589,8 @@ snapshots: mute-stream@1.0.0: {} + mute-stream@2.0.0: {} + mz@2.7.0: dependencies: any-promise: 1.3.0 @@ -7557,12 +8679,23 @@ snapshots: abbrev: 1.1.1 optional: true + normalize-package-data@6.0.2: + dependencies: + hosted-git-info: 7.0.2 + semver: 7.6.3 + validate-npm-package-license: 3.0.4 + normalize-path@3.0.0: {} npm-run-path@4.0.1: dependencies: path-key: 3.1.1 + npm-run-path@6.0.0: + dependencies: + path-key: 4.0.0 + unicorn-magic: 0.3.0 + npmlog@6.0.2: dependencies: are-we-there-yet: 3.0.1 @@ -7581,22 +8714,8 @@ snapshots: object-assign@4.1.1: {} - object-inspect@1.13.3: {} - - object-is@1.1.6: - dependencies: - call-bind: 1.0.7 - define-properties: 1.2.1 - object-keys@1.1.1: {} - object.assign@4.1.5: - dependencies: - call-bind: 1.0.7 - define-properties: 1.2.1 - has-symbols: 1.0.3 - object-keys: 1.1.1 - on-exit-leak-free@2.1.2: {} once@1.4.0: @@ -7607,6 +8726,10 @@ snapshots: dependencies: mimic-fn: 2.1.0 + onetime@7.0.0: + dependencies: + mimic-function: 5.0.1 + optionator@0.9.4: dependencies: deep-is: 0.1.4 @@ -7628,17 +8751,17 @@ snapshots: strip-ansi: 6.0.1 wcwidth: 1.0.1 - ora@6.3.1: + ora@8.1.1: dependencies: chalk: 5.3.0 - cli-cursor: 4.0.0 + cli-cursor: 5.0.0 cli-spinners: 2.9.2 is-interactive: 2.0.0 - is-unicode-supported: 1.3.0 - log-symbols: 5.1.0 - stdin-discarder: 0.1.0 + is-unicode-supported: 2.1.0 + log-symbols: 6.0.0 + stdin-discarder: 0.2.2 + string-width: 7.2.0 strip-ansi: 7.1.0 - wcwidth: 1.0.1 os-tmpdir@1.0.2: {} @@ -7677,6 +8800,14 @@ snapshots: dependencies: callsites: 3.1.0 + parse-json@8.1.0: + dependencies: + '@babel/code-frame': 7.26.2 + index-to-position: 0.1.2 + type-fest: 4.30.0 + + parse-ms@4.0.0: {} + parse5-htmlparser2-tree-adapter@6.0.1: dependencies: parse5: 6.0.1 @@ -7689,12 +8820,16 @@ snapshots: dependencies: entities: 4.5.0 + patch-console@2.0.0: {} + path-exists@4.0.0: {} path-is-absolute@1.0.1: {} path-key@3.1.1: {} + path-key@4.0.0: {} + path-scurry@1.11.1: dependencies: lru-cache: 10.4.3 @@ -7764,10 +8899,52 @@ snapshots: sonic-boom: 4.2.0 thread-stream: 3.1.0 + pirates@4.0.6: {} + pnpm@9.13.0: {} + polkadot-api@1.7.7(postcss@8.4.49)(rxjs@7.8.1)(tsx@4.19.2)(yaml@2.4.5): + dependencies: + '@polkadot-api/cli': 0.9.21(postcss@8.4.49)(tsx@4.19.2)(yaml@2.4.5) + '@polkadot-api/ink-contracts': 0.2.2 + '@polkadot-api/json-rpc-provider': 0.0.4 + '@polkadot-api/known-chains': 0.5.8 + '@polkadot-api/logs-provider': 0.0.6 + '@polkadot-api/metadata-builders': 0.9.2 + '@polkadot-api/metadata-compatibility': 0.1.12 + '@polkadot-api/observable-client': 0.6.3(@polkadot-api/substrate-client@0.3.0)(rxjs@7.8.1) + '@polkadot-api/pjs-signer': 0.6.1 + '@polkadot-api/polkadot-sdk-compat': 2.3.1 + '@polkadot-api/polkadot-signer': 0.1.6 + '@polkadot-api/signer': 0.1.11 + '@polkadot-api/sm-provider': 0.1.7(@polkadot-api/smoldot@0.3.7) + '@polkadot-api/smoldot': 0.3.7 + '@polkadot-api/substrate-bindings': 0.9.4 + '@polkadot-api/substrate-client': 0.3.0 + '@polkadot-api/utils': 0.1.2 + '@polkadot-api/ws-provider': 0.3.6 + rxjs: 7.8.1 + transitivePeerDependencies: + - '@microsoft/api-extractor' + - '@swc/core' + - bufferutil + - jiti + - postcss + - supports-color + - tsx + - utf-8-validate + - yaml + possible-typed-array-names@1.0.0: {} + postcss-load-config@6.0.1(postcss@8.4.49)(tsx@4.19.2)(yaml@2.4.5): + dependencies: + lilconfig: 3.1.3 + optionalDependencies: + postcss: 8.4.49 + tsx: 4.19.2 + yaml: 2.4.5 + postcss@8.4.49: dependencies: nanoid: 3.3.7 @@ -7813,6 +8990,10 @@ snapshots: prettier@3.3.3: {} + pretty-ms@9.2.0: + dependencies: + parse-ms: 4.0.0 + process-warning@4.0.0: {} process@0.11.10: {} @@ -7880,6 +9061,24 @@ snapshots: minimist: 1.2.8 strip-json-comments: 2.0.1 + react-reconciler@0.29.2(react@18.3.1): + dependencies: + loose-envify: 1.4.0 + react: 18.3.1 + scheduler: 0.23.2 + + react@18.3.1: + dependencies: + loose-envify: 1.4.0 + + read-pkg@9.0.1: + dependencies: + '@types/normalize-package-data': 2.4.4 + normalize-package-data: 6.0.2 + parse-json: 8.1.0 + type-fest: 4.30.0 + unicorn-magic: 0.1.0 + readable-stream@3.6.2: dependencies: inherits: 2.0.4 @@ -7898,17 +9097,12 @@ snapshots: dependencies: picomatch: 2.3.1 + readdirp@4.0.2: {} + real-require@0.2.0: {} reflect-metadata@0.2.2: {} - regexp.prototype.flags@1.5.3: - dependencies: - call-bind: 1.0.7 - define-properties: 1.2.1 - es-errors: 1.3.0 - set-function-name: 2.0.2 - require-directory@2.1.1: {} require-from-string@2.0.2: {} @@ -7917,6 +9111,8 @@ snapshots: resolve-from@4.0.0: {} + resolve-from@5.0.0: {} + resolve-pkg-maps@1.0.0: {} restore-cursor@3.1.0: @@ -7929,6 +9125,11 @@ snapshots: onetime: 5.1.2 signal-exit: 3.0.7 + restore-cursor@5.1.0: + dependencies: + onetime: 7.0.0 + signal-exit: 4.1.0 + retry@0.12.0: optional: true @@ -8006,8 +9207,11 @@ snapshots: dependencies: xmlchars: 2.2.0 - scale-ts@1.6.0: - optional: true + scale-ts@1.6.1: {} + + scheduler@0.23.2: + dependencies: + loose-envify: 1.4.0 secure-json-parse@2.7.0: {} @@ -8037,13 +9241,6 @@ snapshots: gopd: 1.0.1 has-property-descriptors: 1.0.2 - set-function-name@2.0.2: - dependencies: - define-data-property: 1.1.4 - es-errors: 1.3.0 - functions-have-names: 1.2.3 - has-property-descriptors: 1.0.2 - setimmediate@1.0.5: {} sha.js@2.4.11: @@ -8057,13 +9254,6 @@ snapshots: shebang-regex@3.0.0: {} - side-channel@1.0.6: - dependencies: - call-bind: 1.0.7 - es-errors: 1.3.0 - get-intrinsic: 1.2.4 - object-inspect: 1.13.3 - siginfo@2.0.0: {} signal-exit@3.0.7: {} @@ -8086,6 +9276,16 @@ snapshots: slash@3.0.0: {} + slice-ansi@5.0.0: + dependencies: + ansi-styles: 6.2.1 + is-fullwidth-code-point: 4.0.0 + + slice-ansi@7.1.0: + dependencies: + ansi-styles: 6.2.1 + is-fullwidth-code-point: 5.0.0 + smart-buffer@4.2.0: optional: true @@ -8097,6 +9297,13 @@ snapshots: - utf-8-validate optional: true + smoldot@2.0.33: + dependencies: + ws: 8.18.0 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + socks-proxy-agent@6.2.1: dependencies: agent-base: 6.0.2 @@ -8128,10 +9335,32 @@ snapshots: dependencies: atomic-sleep: 1.0.0 + sort-keys@5.1.0: + dependencies: + is-plain-obj: 4.1.0 + source-map-js@1.2.1: {} source-map@0.6.1: {} + source-map@0.8.0-beta.0: + dependencies: + whatwg-url: 7.1.0 + + spdx-correct@3.2.0: + dependencies: + spdx-expression-parse: 3.0.1 + spdx-license-ids: 3.0.20 + + spdx-exceptions@2.5.0: {} + + spdx-expression-parse@3.0.1: + dependencies: + spdx-exceptions: 2.5.0 + spdx-license-ids: 3.0.20 + + spdx-license-ids@3.0.20: {} + split2@4.2.0: {} sprintf-js@1.1.3: {} @@ -8153,17 +9382,15 @@ snapshots: minipass: 3.3.6 optional: true + stack-utils@2.0.6: + dependencies: + escape-string-regexp: 2.0.0 + stackback@0.0.2: {} std-env@3.8.0: {} - stdin-discarder@0.1.0: - dependencies: - bl: 5.1.0 - - stop-iteration-iterator@1.0.0: - dependencies: - internal-slot: 1.0.7 + stdin-discarder@0.2.2: {} string-width@4.2.3: dependencies: @@ -8177,6 +9404,12 @@ snapshots: emoji-regex: 9.2.2 strip-ansi: 7.1.0 + string-width@7.2.0: + dependencies: + emoji-regex: 10.4.0 + get-east-asian-width: 1.3.0 + strip-ansi: 7.1.0 + string_decoder@1.3.0: dependencies: safe-buffer: 5.2.1 @@ -8191,10 +9424,22 @@ snapshots: strip-final-newline@2.0.0: {} + strip-final-newline@4.0.0: {} + strip-json-comments@2.0.1: {} strip-json-comments@3.1.1: {} + sucrase@3.35.0: + dependencies: + '@jridgewell/gen-mapping': 0.3.5 + commander: 4.1.1 + glob: 10.4.5 + lines-and-columns: 1.2.4 + mz: 2.7.0 + pirates: 4.0.6 + ts-interface-checker: 0.1.13 + supports-color@7.2.0: dependencies: has-flag: 4.0.0 @@ -8293,14 +9538,22 @@ snapshots: tr46@0.0.3: {} + tr46@1.0.1: + dependencies: + punycode: 2.3.1 + tr46@5.0.0: dependencies: punycode: 2.3.1 + tree-kill@1.2.2: {} + ts-api-utils@1.4.0(typescript@5.6.3): dependencies: typescript: 5.6.3 + ts-interface-checker@0.1.13: {} + ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3): dependencies: '@cspotcode/source-map-support': 0.8.1 @@ -8319,10 +9572,41 @@ snapshots: v8-compile-cache-lib: 3.0.1 yn: 3.1.1 + tsc-prog@2.3.0(typescript@5.6.3): + dependencies: + typescript: 5.6.3 + tslib@2.7.0: {} tslib@2.8.1: {} + tsup@8.3.5(postcss@8.4.49)(tsx@4.19.2)(typescript@5.6.3)(yaml@2.4.5): + dependencies: + bundle-require: 5.0.0(esbuild@0.24.0) + cac: 6.7.14 + chokidar: 4.0.1 + consola: 3.2.3 + debug: 4.3.7(supports-color@8.1.1) + esbuild: 0.24.0 + joycon: 3.1.1 + picocolors: 1.1.1 + postcss-load-config: 6.0.1(postcss@8.4.49)(tsx@4.19.2)(yaml@2.4.5) + resolve-from: 5.0.0 + rollup: 4.26.0 + source-map: 0.8.0-beta.0 + sucrase: 3.35.0 + tinyexec: 0.3.1 + tinyglobby: 0.2.10 + tree-kill: 1.2.2 + optionalDependencies: + postcss: 8.4.49 + typescript: 5.6.3 + transitivePeerDependencies: + - jiti + - supports-color + - tsx + - yaml + tsx@4.19.2: dependencies: esbuild: 0.23.1 @@ -8346,6 +9630,8 @@ snapshots: type-fest@0.21.3: {} + type-fest@4.30.0: {} + typeorm@0.3.20(sqlite3@5.1.7)(ts-node@10.9.2(@types/node@22.9.0)(typescript@5.6.3)): dependencies: '@sqltools/formatter': 1.2.5 @@ -8380,6 +9666,12 @@ snapshots: undici-types@6.19.8: {} + undici-types@6.20.0: {} + + unicorn-magic@0.1.0: {} + + unicorn-magic@0.3.0: {} + unique-filename@1.1.1: dependencies: unique-slug: 2.0.2 @@ -8434,6 +9726,11 @@ snapshots: v8-compile-cache-lib@3.0.1: {} + validate-npm-package-license@3.0.4: + dependencies: + spdx-correct: 3.2.0 + spdx-expression-parse: 3.0.1 + viem@2.21.45(typescript@5.6.3)(zod@3.23.8): dependencies: '@noble/curves': 1.6.0 @@ -8758,6 +10055,8 @@ snapshots: webidl-conversions@3.0.1: {} + webidl-conversions@4.0.2: {} + webidl-conversions@7.0.0: {} whatwg-encoding@3.1.1: @@ -8776,20 +10075,11 @@ snapshots: tr46: 0.0.3 webidl-conversions: 3.0.1 - which-boxed-primitive@1.0.2: - dependencies: - is-bigint: 1.0.4 - is-boolean-object: 1.1.2 - is-number-object: 1.0.7 - is-string: 1.0.7 - is-symbol: 1.0.4 - - which-collection@1.0.2: + whatwg-url@7.1.0: dependencies: - is-map: 2.0.3 - is-set: 2.0.3 - is-weakmap: 2.0.2 - is-weakset: 2.0.3 + lodash.sortby: 4.7.0 + tr46: 1.0.1 + webidl-conversions: 4.0.2 which-typed-array@1.1.15: dependencies: @@ -8813,6 +10103,10 @@ snapshots: string-width: 4.2.3 optional: true + widest-line@5.0.0: + dependencies: + string-width: 7.2.0 + window-size@1.1.1: dependencies: define-property: 1.0.0 @@ -8842,8 +10136,34 @@ snapshots: string-width: 5.1.2 strip-ansi: 7.1.0 + wrap-ansi@9.0.0: + dependencies: + ansi-styles: 6.2.1 + string-width: 7.2.0 + strip-ansi: 7.1.0 + wrappy@1.0.2: {} + write-file-atomic@5.0.1: + dependencies: + imurmurhash: 0.1.4 + signal-exit: 4.1.0 + + write-json-file@6.0.0: + dependencies: + detect-indent: 7.0.1 + is-plain-obj: 4.1.0 + sort-keys: 5.1.0 + write-file-atomic: 5.0.1 + + write-package@7.1.0: + dependencies: + deepmerge-ts: 7.1.3 + read-pkg: 9.0.1 + sort-keys: 5.1.0 + type-fest: 4.30.0 + write-json-file: 6.0.0 + ws@8.17.1: {} ws@8.18.0: {} @@ -8895,4 +10215,10 @@ snapshots: yocto-queue@0.1.0: {} + yoctocolors-cjs@2.1.2: {} + + yoctocolors@2.1.1: {} + + yoga-wasm-web@0.3.3: {} + zod@3.23.8: {} diff --git a/test/moonwall.config.json b/test/moonwall.config.json index 965eb7d2c..c446a77ba 100644 --- a/test/moonwall.config.json +++ b/test/moonwall.config.json @@ -204,6 +204,9 @@ "skipBlockCheck": ["Container2002"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -260,6 +263,9 @@ "skipBlockCheck": ["Container2002"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -314,6 +320,9 @@ "configPath": "./configs/zombie_tanssi_keep_db.json" } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -348,6 +357,9 @@ "configPath": "./configs/zombie_tanssi_metrics.json" } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -382,6 +394,9 @@ "skipBlockCheck": ["Container2000", "Container2001"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -413,6 +428,9 @@ "skipBlockCheck": ["Container2000", "Container2001"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -463,6 +481,9 @@ "configPath": "./configs/zombie_tanssi_rotation.json" } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -512,6 +533,9 @@ "configPath": "./configs/zombie_tanssi_warp_sync.json" } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -563,6 +587,9 @@ "disableDefaultEthProviders": true } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -594,6 +621,9 @@ "disableDefaultEthProviders": true } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "parachain", @@ -622,6 +652,9 @@ "disableDefaultEthProviders": true } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -655,6 +688,9 @@ "disableDefaultEthProviders": true } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Tanssi-relay", @@ -687,6 +723,9 @@ "disableDefaultEthProviders": true } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -725,6 +764,9 @@ "disableDefaultEthProviders": true } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -760,6 +802,9 @@ "skipBlockCheck": ["Container2002"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Tanssi-relay", @@ -806,6 +851,9 @@ "skipBlockCheck": ["Tanssi-relay"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Tanssi-relay", @@ -832,6 +880,9 @@ "skipBlockCheck": ["DataPreserver-2000", "DataPreserver-2001"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Relay", @@ -1094,6 +1145,9 @@ "skipBlockCheck": ["Container2002"] } }, + "vitestArgs": { + "bail": 1 + }, "connections": [ { "name": "Tanssi-relay", diff --git a/test/package.json b/test/package.json index 5cbb186b6..c15067789 100644 --- a/test/package.json +++ b/test/package.json @@ -26,8 +26,8 @@ "devDependencies": { "@acala-network/chopsticks": "1.0.1", "@moonbeam-network/api-augment": "0.3200.3", - "@moonwall/cli": "5.6.0", - "@moonwall/util": "5.6.0", + "@moonwall/cli": "5.9.1", + "@moonwall/util": "5.9.1", "@polkadot/api": "14.3.1", "@polkadot/api-augment": "14.3.1", "@polkadot/keyring": "13.2.3", @@ -69,5 +69,8 @@ "overrides": { "inquirer": "9.2.16" } + }, + "volta": { + "node": "22.12.0" } } From 6a69c783b5354908e1e51ade0809bc30e1654fef Mon Sep 17 00:00:00 2001 From: nanocryk <6422796+nanocryk@users.noreply.github.com> Date: Mon, 16 Dec 2024 17:05:58 +0100 Subject: [PATCH 4/6] Benchmark for on_container_author_noted only (#767) * bench on_container_author_noted * wip fix bench * fix bench * fmt * bench pallet for dancebox * fix bench + update all runtimes/pallet weights * rollback set_latest_author_data weights until real bench run * remove tmp file --- pallets/author-noting/src/benchmarks.rs | 29 ++- pallets/author-noting/src/weights.rs | 202 ++++++++++++------ pallets/inflation-rewards/src/lib.rs | 19 ++ pallets/services-payment/src/lib.rs | 15 ++ pallets/xcm-core-buyer/src/lib.rs | 11 + primitives/traits/src/lib.rs | 8 + runtime/dancebox/src/lib.rs | 4 - .../src/weights/pallet_author_noting.rs | 37 +++- runtime/flashbox/src/lib.rs | 4 - .../src/weights/pallet_author_noting.rs | 33 ++- solo-chains/runtime/dancelight/src/lib.rs | 4 - .../src/weights/pallet_author_noting.rs | 33 ++- 12 files changed, 294 insertions(+), 105 deletions(-) diff --git a/pallets/author-noting/src/benchmarks.rs b/pallets/author-noting/src/benchmarks.rs index 2eb81f418..b4d352c47 100644 --- a/pallets/author-noting/src/benchmarks.rs +++ b/pallets/author-noting/src/benchmarks.rs @@ -25,7 +25,7 @@ use { frame_system::RawOrigin, parity_scale_codec::Encode, sp_std::{boxed::Box, vec}, - tp_traits::{GetContainerChainAuthor, GetCurrentContainerChains}, + tp_traits::{AuthorNotingHook, GetContainerChainAuthor, GetCurrentContainerChains}, }; mod test_sproof { @@ -60,11 +60,11 @@ benchmarks! { let mut container_chains = vec![]; let data = if TypeId::of::<<::RelayOrPara as RelayOrPara>::InherentArg>() == TypeId::of::() { - - + // RELAY MODE let mut sproof_builder = test_sproof::ParaHeaderSproofBuilder::default(); - for para_id in 1..x { + // Must start at 0 in Relay mode (why?) + for para_id in 0..x { let para_id = para_id.into(); container_chains.push(para_id); // Mock assigned authors for this para id @@ -73,8 +73,8 @@ benchmarks! { let num_each_container_chain = 2; T::ContainerChainAuthor::set_authors_for_para_id(para_id, vec![author; num_each_container_chain]); sproof_builder.num_items += 1; - } + } let (root, proof) = sproof_builder.into_state_root_and_proof(); T::RelayOrPara::set_current_relay_chain_state(cumulus_pallet_parachain_system::RelayChainState { state_root: root, @@ -85,9 +85,18 @@ benchmarks! { relay_storage_proof: proof, }; + for para_id in 0..x { + let para_id = para_id.into(); + let author: T::AccountId = account("account id", 0u32, 0u32); + + T::AuthorNotingHook::prepare_worst_case_for_bench(&author, 1, para_id); + } + *(Box::new(arg) as Box).downcast().unwrap() } else if TypeId::of::<<::RelayOrPara as RelayOrPara>::InherentArg>() == TypeId::of::<()>() { + // PARA MODE + // Must start at 1 in Para mode (why?) for para_id in 1..x { let slot: crate::InherentType = 13u64.into(); let header = sp_runtime::generic::Header:: { @@ -113,6 +122,8 @@ benchmarks! { let head_data = HeadData(header.encode()); frame_support::storage::unhashed::put(&key, &head_data); + + T::AuthorNotingHook::prepare_worst_case_for_bench(&author, 1, para_id); } let arg = (); *(Box::new(arg) as Box).downcast().unwrap() @@ -137,6 +148,14 @@ benchmarks! { assert_ok!(Pallet::::set_author(RawOrigin::Root.into(), para_id, block_number, author, u64::from(block_number).into())); }: _(RawOrigin::Root, para_id) + on_container_author_noted { + let para_id = 1000.into(); + let block_number = 1; + let author: T::AccountId = account("account id", 0u32, 0u32); + + T::AuthorNotingHook::prepare_worst_case_for_bench(&author, block_number, para_id); + }: { T::AuthorNotingHook::on_container_author_noted(&author, block_number, para_id )} + impl_benchmark_test_suite!( Pallet, crate::mock::new_test_ext(), diff --git a/pallets/author-noting/src/weights.rs b/pallets/author-noting/src/weights.rs index ea0c99249..622e79b16 100644 --- a/pallets/author-noting/src/weights.rs +++ b/pallets/author-noting/src/weights.rs @@ -17,11 +17,11 @@ //! Autogenerated weights for pallet_author_noting //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-09, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 43.0.0 +//! DATE: 2024-12-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `tomasz-XPS-15-9520`, CPU: `12th Gen Intel(R) Core(TM) i7-12700H` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024 +//! HOSTNAME: `pop-os`, CPU: `12th Gen Intel(R) Core(TM) i7-1260P` +//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 // Executed Command: // ./target/release/tanssi-node @@ -33,15 +33,16 @@ // pallet_author_noting // --extrinsic // * +// --chain=dev // --steps // 50 // --repeat // 20 -// --template=./benchmarking/frame-weight-template.hbs +// --template=./benchmarking/frame-weight-pallet-template.hbs // --json-file // raw.json // --output -// weights.rs +// tmp/dancebox_weights/pallet_author_noting.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,101 +56,174 @@ pub trait WeightInfo { fn set_latest_author_data(x: u32, ) -> Weight; fn set_author() -> Weight; fn kill_author_data() -> Weight; + fn on_container_author_noted() -> Weight; } /// Weights for pallet_author_noting using the Substrate node and recommended hardware. pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { - /// Storage: AuthorNoting DidSetContainerAuthorData (r:1 w:1) - /// Proof: AuthorNoting DidSetContainerAuthorData (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) - /// Storage: Registrar RegisteredParaIds (r:1 w:0) - /// Proof Skipped: Registrar RegisteredParaIds (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainSystem ValidationData (r:1 w:0) - /// Proof Skipped: ParachainSystem ValidationData (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: CollatorAssignment CollatorContainerChain (r:1 w:0) - /// Proof Skipped: CollatorAssignment CollatorContainerChain (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: AuthorNoting LatestAuthor (r:0 w:100) - /// Proof: AuthorNoting LatestAuthor (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen) - /// The range of component `x` is `[0, 100]`. + /// Storage: `AuthorNoting::DidSetContainerAuthorData` (r:1 w:1) + /// Proof: `AuthorNoting::DidSetContainerAuthorData` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `Registrar::RegisteredParaIds` (r:1 w:0) + /// Proof: `Registrar::RegisteredParaIds` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) + /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) + /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Digest` (r:1 w:0) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `CollatorAssignment::CollatorContainerChain` (r:1 w:0) + /// Proof: `CollatorAssignment::CollatorContainerChain` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `AuthorNoting::LatestAuthor` (r:100 w:100) + /// Proof: `AuthorNoting::LatestAuthor` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`) + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(418), added: 913, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:100 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:103 w:102) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Invulnerables::Invulnerables` (r:1 w:0) + /// Proof: `Invulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::Pools` (r:2 w:0) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `XcmCoreBuyer::PendingBlocks` (r:0 w:100) + /// Proof: `XcmCoreBuyer::PendingBlocks` (`max_values`: None, `max_size`: Some(20), added: 2495, mode: `MaxEncodedLen`) + /// The range of component `x` is `[1, 100]`. fn set_latest_author_data(x: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `427 + x * (73 ±0)` - // Estimated: `1912 + x * (73 ±0)` - // Minimum execution time: 7_767_000 picoseconds. - Weight::from_parts(7_985_000, 1912) - // Standard Error: 125_649 - .saturating_add(Weight::from_parts(19_274_325, 0).saturating_mul(x.into())) - .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(1_u64)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) - .saturating_add(Weight::from_parts(0, 73).saturating_mul(x.into())) + // Measured: `1015 + x * (208 ±0)` + // Estimated: `8799 + x * (2603 ±0)` + // Minimum execution time: 122_225_000 picoseconds. + Weight::from_parts(123_639_000, 8799) + // Standard Error: 128_105 + .saturating_add(Weight::from_parts(36_913_982, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(12_u64)) + .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(x.into()))) + .saturating_add(Weight::from_parts(0, 2603).saturating_mul(x.into())) } - /// Storage: AuthorNoting LatestAuthor (r:0 w:1) - /// Proof: AuthorNoting LatestAuthor (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen) + /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) + /// Proof: `AuthorNoting::LatestAuthor` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`) fn set_author() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_877_000 picoseconds. - Weight::from_parts(8_127_000, 0) + // Minimum execution time: 5_776_000 picoseconds. + Weight::from_parts(6_057_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } - /// Storage: AuthorNoting LatestAuthor (r:0 w:1) - /// Proof: AuthorNoting LatestAuthor (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen) + /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) + /// Proof: `AuthorNoting::LatestAuthor` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`) fn kill_author_data() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_190_000 picoseconds. - Weight::from_parts(7_520_000, 0) + // Minimum execution time: 5_542_000 picoseconds. + Weight::from_parts(5_844_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(418), added: 913, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:4 w:3) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Invulnerables::Invulnerables` (r:1 w:0) + /// Proof: `Invulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::Pools` (r:2 w:0) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:1 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + /// Storage: `XcmCoreBuyer::PendingBlocks` (r:0 w:1) + /// Proof: `XcmCoreBuyer::PendingBlocks` (`max_values`: None, `max_size`: Some(20), added: 2495, mode: `MaxEncodedLen`) + fn on_container_author_noted() -> Weight { + // Proof Size summary in bytes: + // Measured: `881` + // Estimated: `11402` + // Minimum execution time: 92_792_000 picoseconds. + Weight::from_parts(99_983_000, 11402) + .saturating_add(T::DbWeight::get().reads(9_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) + } } // For backwards compatibility and tests impl WeightInfo for () { - /// Storage: AuthorNoting DidSetContainerAuthorData (r:1 w:1) - /// Proof: AuthorNoting DidSetContainerAuthorData (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) - /// Storage: Registrar RegisteredParaIds (r:1 w:0) - /// Proof Skipped: Registrar RegisteredParaIds (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainSystem ValidationData (r:1 w:0) - /// Proof Skipped: ParachainSystem ValidationData (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: CollatorAssignment CollatorContainerChain (r:1 w:0) - /// Proof Skipped: CollatorAssignment CollatorContainerChain (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: AuthorNoting LatestAuthor (r:0 w:100) - /// Proof: AuthorNoting LatestAuthor (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen) - /// The range of component `x` is `[0, 100]`. + /// Storage: `AuthorNoting::DidSetContainerAuthorData` (r:1 w:1) + /// Proof: `AuthorNoting::DidSetContainerAuthorData` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `Registrar::RegisteredParaIds` (r:1 w:0) + /// Proof: `Registrar::RegisteredParaIds` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) + /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) + /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Digest` (r:1 w:0) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `CollatorAssignment::CollatorContainerChain` (r:1 w:0) + /// Proof: `CollatorAssignment::CollatorContainerChain` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `AuthorNoting::LatestAuthor` (r:100 w:100) + /// Proof: `AuthorNoting::LatestAuthor` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`) + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(418), added: 913, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:100 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:103 w:102) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Invulnerables::Invulnerables` (r:1 w:0) + /// Proof: `Invulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::Pools` (r:2 w:0) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `XcmCoreBuyer::PendingBlocks` (r:0 w:100) + /// Proof: `XcmCoreBuyer::PendingBlocks` (`max_values`: None, `max_size`: Some(20), added: 2495, mode: `MaxEncodedLen`) + /// The range of component `x` is `[1, 100]`. fn set_latest_author_data(x: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `427 + x * (73 ±0)` - // Estimated: `1912 + x * (73 ±0)` - // Minimum execution time: 7_767_000 picoseconds. - Weight::from_parts(7_985_000, 1912) - // Standard Error: 125_649 - .saturating_add(Weight::from_parts(19_274_325, 0).saturating_mul(x.into())) - .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) - .saturating_add(Weight::from_parts(0, 73).saturating_mul(x.into())) + // Measured: `1015 + x * (208 ±0)` + // Estimated: `8799 + x * (2603 ±0)` + // Minimum execution time: 122_225_000 picoseconds. + Weight::from_parts(123_639_000, 8799) + // Standard Error: 128_105 + .saturating_add(Weight::from_parts(36_913_982, 0).saturating_mul(x.into())) + .saturating_add(RocksDbWeight::get().reads(12_u64)) + .saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(x.into()))) + .saturating_add(RocksDbWeight::get().writes(4_u64)) + .saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(x.into()))) + .saturating_add(Weight::from_parts(0, 2603).saturating_mul(x.into())) } - /// Storage: AuthorNoting LatestAuthor (r:0 w:1) - /// Proof: AuthorNoting LatestAuthor (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen) + /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) + /// Proof: `AuthorNoting::LatestAuthor` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`) fn set_author() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_877_000 picoseconds. - Weight::from_parts(8_127_000, 0) + // Minimum execution time: 5_776_000 picoseconds. + Weight::from_parts(6_057_000, 0) .saturating_add(RocksDbWeight::get().writes(1_u64)) } - /// Storage: AuthorNoting LatestAuthor (r:0 w:1) - /// Proof: AuthorNoting LatestAuthor (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen) + /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) + /// Proof: `AuthorNoting::LatestAuthor` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`) fn kill_author_data() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_190_000 picoseconds. - Weight::from_parts(7_520_000, 0) + // Minimum execution time: 5_542_000 picoseconds. + Weight::from_parts(5_844_000, 0) .saturating_add(RocksDbWeight::get().writes(1_u64)) } + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(418), added: 913, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:4 w:3) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Invulnerables::Invulnerables` (r:1 w:0) + /// Proof: `Invulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::Pools` (r:2 w:0) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:1 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + /// Storage: `XcmCoreBuyer::PendingBlocks` (r:0 w:1) + /// Proof: `XcmCoreBuyer::PendingBlocks` (`max_values`: None, `max_size`: Some(20), added: 2495, mode: `MaxEncodedLen`) + fn on_container_author_noted() -> Weight { + // Proof Size summary in bytes: + // Measured: `881` + // Estimated: `11402` + // Minimum execution time: 92_792_000 picoseconds. + Weight::from_parts(99_983_000, 11402) + .saturating_add(RocksDbWeight::get().reads(9_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) + } } diff --git a/pallets/inflation-rewards/src/lib.rs b/pallets/inflation-rewards/src/lib.rs index 8bc2f08e0..ca90e7a97 100644 --- a/pallets/inflation-rewards/src/lib.rs +++ b/pallets/inflation-rewards/src/lib.rs @@ -298,4 +298,23 @@ impl AuthorNotingHook for Pallet { } total_weight } + + #[cfg(feature = "runtime-benchmarks")] + fn prepare_worst_case_for_bench(_a: &T::AccountId, _b: BlockNumber, para_id: ParaId) { + // arbitrary amount to perform rewarding + // we mint twice as much to the rewards account to make it possible + let reward_amount = 1_000_000_000u32; + let mint = reward_amount * 2; + + T::Currency::resolve( + &T::PendingRewardsAccount::get(), + T::Currency::issue(BalanceOf::::from(mint)), + ) + .expect("to mint tokens"); + + ChainsToReward::::put(ChainsToRewardValue { + para_ids: sp_std::vec![para_id].try_into().expect("to be in bound"), + rewards_per_chain: BalanceOf::::from(reward_amount), + }); + } } diff --git a/pallets/services-payment/src/lib.rs b/pallets/services-payment/src/lib.rs index 65da9e6c7..315f81cd6 100644 --- a/pallets/services-payment/src/lib.rs +++ b/pallets/services-payment/src/lib.rs @@ -547,6 +547,7 @@ impl AuthorNotingHook for Pallet { ) -> Weight { if Pallet::::burn_block_production_free_credit_for_para(¶_id).is_err() { let (amount_to_charge, _weight) = T::ProvideBlockProductionCost::block_cost(¶_id); + match T::Currency::withdraw( &Self::parachain_tank(para_id), amount_to_charge, @@ -566,6 +567,20 @@ impl AuthorNotingHook for Pallet { T::WeightInfo::on_container_author_noted() } + + #[cfg(feature = "runtime-benchmarks")] + fn prepare_worst_case_for_bench( + _author: &T::AccountId, + _block_number: BlockNumber, + para_id: ParaId, + ) { + let (amount_to_charge, _weight) = T::ProvideBlockProductionCost::block_cost(¶_id); + // mint large amount (bigger than ED) to ensure withdraw will not fail. + let mint = BalanceOf::::from(2_000_000_000u32) + amount_to_charge; + + // mint twice more to not have ED issues + T::Currency::resolve_creating(&Self::parachain_tank(para_id), T::Currency::issue(mint)); + } } impl CollatorAssignmentHook> for Pallet { diff --git a/pallets/xcm-core-buyer/src/lib.rs b/pallets/xcm-core-buyer/src/lib.rs index 9bc12ca92..221a29b8c 100644 --- a/pallets/xcm-core-buyer/src/lib.rs +++ b/pallets/xcm-core-buyer/src/lib.rs @@ -125,6 +125,17 @@ impl AuthorNotingHook for Pallet { T::DbWeight::get().writes(1) } + + #[cfg(feature = "runtime-benchmarks")] + fn prepare_worst_case_for_bench( + _author: &T::AccountId, + _block_number: BlockNumber, + para_id: ParaId, + ) { + // We insert the some data in the storage being removed. + // Not sure if this is necessary. + PendingBlocks::::insert(para_id, BlockNumberFor::::from(42u32)); + } } #[frame_support::pallet] diff --git a/primitives/traits/src/lib.rs b/primitives/traits/src/lib.rs index d7c1269d0..3be563c6d 100644 --- a/primitives/traits/src/lib.rs +++ b/primitives/traits/src/lib.rs @@ -99,6 +99,9 @@ pub trait AuthorNotingHook { block_number: BlockNumber, para_id: ParaId, ) -> Weight; + + #[cfg(feature = "runtime-benchmarks")] + fn prepare_worst_case_for_bench(author: &AccountId, block_number: BlockNumber, para_id: ParaId); } #[impl_trait_for_tuples::impl_for_tuples(5)] @@ -108,6 +111,11 @@ impl AuthorNotingHook for Tuple { for_tuples!( #( weight.saturating_accrue(Tuple::on_container_author_noted(a, b, p)); )* ); weight } + + #[cfg(feature = "runtime-benchmarks")] + fn prepare_worst_case_for_bench(a: &AccountId, b: BlockNumber, p: ParaId) { + for_tuples!( #( Tuple::prepare_worst_case_for_bench(a, b, p); )* ); + } } pub trait DistributeRewards { diff --git a/runtime/dancebox/src/lib.rs b/runtime/dancebox/src/lib.rs index 195698190..80217ec8c 100644 --- a/runtime/dancebox/src/lib.rs +++ b/runtime/dancebox/src/lib.rs @@ -1172,10 +1172,6 @@ impl pallet_author_noting::Config for Runtime { type ContainerChains = Registrar; type SlotBeacon = dp_consensus::AuraDigestSlotBeacon; type ContainerChainAuthor = CollatorAssignment; - // We benchmark each hook individually, so for runtime-benchmarks this should be empty - #[cfg(feature = "runtime-benchmarks")] - type AuthorNotingHook = (); - #[cfg(not(feature = "runtime-benchmarks"))] type AuthorNotingHook = (XcmCoreBuyer, InflationRewards, ServicesPayment); type RelayOrPara = pallet_author_noting::ParaMode< cumulus_pallet_parachain_system::RelaychainDataProvider, diff --git a/runtime/dancebox/src/weights/pallet_author_noting.rs b/runtime/dancebox/src/weights/pallet_author_noting.rs index fb549c7bf..35139e94e 100644 --- a/runtime/dancebox/src/weights/pallet_author_noting.rs +++ b/runtime/dancebox/src/weights/pallet_author_noting.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for pallet_author_noting //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-08-05, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 43.0.0 +//! DATE: 2024-12-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `benchmark-1`, CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` +//! HOSTNAME: `pop-os`, CPU: `12th Gen Intel(R) Core(TM) i7-1260P` //! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 // Executed Command: @@ -38,7 +38,7 @@ // 50 // --repeat // 20 -// --template=benchmarking/frame-weight-runtime-template.hbs +// --template=./benchmarking/frame-weight-pallet-template.hbs // --json-file // raw.json // --output @@ -87,8 +87,8 @@ impl pallet_author_noting::WeightInfo for SubstrateWeig // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_640_000 picoseconds. - Weight::from_parts(7_878_000, 0) + // Minimum execution time: 5_776_000 picoseconds. + Weight::from_parts(6_057_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) @@ -97,8 +97,29 @@ impl pallet_author_noting::WeightInfo for SubstrateWeig // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_364_000 picoseconds. - Weight::from_parts(7_656_000, 0) + // Minimum execution time: 5_542_000 picoseconds. + Weight::from_parts(5_844_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(418), added: 913, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:4 w:3) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Invulnerables::Invulnerables` (r:1 w:0) + /// Proof: `Invulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `PooledStaking::Pools` (r:2 w:0) + /// Proof: `PooledStaking::Pools` (`max_values`: None, `max_size`: Some(113), added: 2588, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:1 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + /// Storage: `XcmCoreBuyer::PendingBlocks` (r:0 w:1) + /// Proof: `XcmCoreBuyer::PendingBlocks` (`max_values`: None, `max_size`: Some(20), added: 2495, mode: `MaxEncodedLen`) + fn on_container_author_noted() -> Weight { + // Proof Size summary in bytes: + // Measured: `881` + // Estimated: `11402` + // Minimum execution time: 92_792_000 picoseconds. + Weight::from_parts(99_983_000, 11402) + .saturating_add(T::DbWeight::get().reads(9_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) + } } \ No newline at end of file diff --git a/runtime/flashbox/src/lib.rs b/runtime/flashbox/src/lib.rs index 1c3be8bc9..17678bd29 100644 --- a/runtime/flashbox/src/lib.rs +++ b/runtime/flashbox/src/lib.rs @@ -1020,10 +1020,6 @@ impl pallet_author_noting::Config for Runtime { type ContainerChains = Registrar; type SlotBeacon = dp_consensus::AuraDigestSlotBeacon; type ContainerChainAuthor = CollatorAssignment; - // We benchmark each hook individually, so for runtime-benchmarks this should be empty - #[cfg(feature = "runtime-benchmarks")] - type AuthorNotingHook = (); - #[cfg(not(feature = "runtime-benchmarks"))] type AuthorNotingHook = (InflationRewards, ServicesPayment); type RelayOrPara = pallet_author_noting::ParaMode< cumulus_pallet_parachain_system::RelaychainDataProvider, diff --git a/runtime/flashbox/src/weights/pallet_author_noting.rs b/runtime/flashbox/src/weights/pallet_author_noting.rs index 6990ab2dc..61906f349 100644 --- a/runtime/flashbox/src/weights/pallet_author_noting.rs +++ b/runtime/flashbox/src/weights/pallet_author_noting.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for pallet_author_noting //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-08-05, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 43.0.0 +//! DATE: 2024-12-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `benchmark-1`, CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` +//! HOSTNAME: `pop-os`, CPU: `12th Gen Intel(R) Core(TM) i7-1260P` //! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("flashbox_dev"), DB CACHE: 1024 // Executed Command: @@ -38,7 +38,7 @@ // 50 // --repeat // 20 -// --template=benchmarking/frame-weight-runtime-template.hbs +// --template=./benchmarking/frame-weight-pallet-template.hbs // --json-file // raw.json // --output @@ -87,8 +87,8 @@ impl pallet_author_noting::WeightInfo for SubstrateWeig // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_380_000 picoseconds. - Weight::from_parts(7_628_000, 0) + // Minimum execution time: 6_026_000 picoseconds. + Weight::from_parts(6_250_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) @@ -97,8 +97,25 @@ impl pallet_author_noting::WeightInfo for SubstrateWeig // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_055_000 picoseconds. - Weight::from_parts(7_251_000, 0) + // Minimum execution time: 5_454_000 picoseconds. + Weight::from_parts(5_660_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(818), added: 1313, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Invulnerables::Invulnerables` (r:1 w:0) + /// Proof: `Invulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(6402), added: 6897, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:1 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + fn on_container_author_noted() -> Weight { + // Proof Size summary in bytes: + // Measured: `647` + // Estimated: `7887` + // Minimum execution time: 51_807_000 picoseconds. + Weight::from_parts(53_926_000, 7887) + .saturating_add(T::DbWeight::get().reads(5_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) + } } \ No newline at end of file diff --git a/solo-chains/runtime/dancelight/src/lib.rs b/solo-chains/runtime/dancelight/src/lib.rs index 4107d791f..98b2255b7 100644 --- a/solo-chains/runtime/dancelight/src/lib.rs +++ b/solo-chains/runtime/dancelight/src/lib.rs @@ -2145,10 +2145,6 @@ impl pallet_author_noting::Config for Runtime { type ContainerChains = ContainerRegistrar; type SlotBeacon = BabeSlotBeacon; type ContainerChainAuthor = TanssiCollatorAssignment; - // We benchmark each hook individually, so for runtime-benchmarks this should be empty - #[cfg(feature = "runtime-benchmarks")] - type AuthorNotingHook = (); - #[cfg(not(feature = "runtime-benchmarks"))] type AuthorNotingHook = (InflationRewards, ServicesPayment); type RelayOrPara = pallet_author_noting::RelayMode; type WeightInfo = weights::pallet_author_noting::SubstrateWeight; diff --git a/solo-chains/runtime/dancelight/src/weights/pallet_author_noting.rs b/solo-chains/runtime/dancelight/src/weights/pallet_author_noting.rs index d0fdda9ed..c632200f2 100644 --- a/solo-chains/runtime/dancelight/src/weights/pallet_author_noting.rs +++ b/solo-chains/runtime/dancelight/src/weights/pallet_author_noting.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for pallet_author_noting //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 42.0.0 -//! DATE: 2024-09-30, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 43.0.0 +//! DATE: 2024-12-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `benchmark-1`, CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` +//! HOSTNAME: `pop-os`, CPU: `12th Gen Intel(R) Core(TM) i7-1260P` //! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("dancelight-dev"), DB CACHE: 1024 // Executed Command: @@ -42,7 +42,7 @@ // --json-file // raw.json // --output -// tmp/starlight_weights/pallet_author_noting.rs +// tmp/dancelight_weights/pallet_author_noting.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -86,8 +86,8 @@ impl pallet_author_noting::WeightInfo for SubstrateWeig // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_461_000 picoseconds. - Weight::from_parts(8_735_000, 0) + // Minimum execution time: 5_830_000 picoseconds. + Weight::from_parts(6_151_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `AuthorNoting::LatestAuthor` (r:0 w:1) @@ -96,8 +96,25 @@ impl pallet_author_noting::WeightInfo for SubstrateWeig // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_919_000 picoseconds. - Weight::from_parts(8_059_000, 0) + // Minimum execution time: 5_559_000 picoseconds. + Weight::from_parts(5_882_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } + /// Storage: `InflationRewards::ChainsToReward` (r:1 w:1) + /// Proof: `InflationRewards::ChainsToReward` (`max_values`: Some(1), `max_size`: Some(418), added: 913, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `TanssiInvulnerables::Invulnerables` (r:1 w:0) + /// Proof: `TanssiInvulnerables::Invulnerables` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `ServicesPayment::BlockProductionCredits` (r:1 w:0) + /// Proof: `ServicesPayment::BlockProductionCredits` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`) + fn on_container_author_noted() -> Weight { + // Proof Size summary in bytes: + // Measured: `599` + // Estimated: `6196` + // Minimum execution time: 50_807_000 picoseconds. + Weight::from_parts(51_723_000, 6196) + .saturating_add(T::DbWeight::get().reads(5_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) + } } \ No newline at end of file From 14d61574a80bfa52975007b79cd6e7d393b6e996 Mon Sep 17 00:00:00 2001 From: Diego Date: Tue, 17 Dec 2024 07:14:31 -0300 Subject: [PATCH 5/6] Revisit xcm config for dancelight (#773) * Accept tokens from other parachains * Block receive teleporter assets * Remove waived locations * xcm tests constants for dancelight * Configure dancelight xcm mocknets * Dancelight xcm test working * toml maid * bump tanssi polkadot * Extract Parse and its impl for location * Rust fmt * Toml fmt * Remove unnecesary into * Add missing copyright * Extract NativeAssetReserve from xcm config to commons * Toml fmt * Replace our assert_expected_events for the one in xcm_emulator * fmt * Remove unnecesary LocationToAccountId --- Cargo.lock | 668 +++++++++--------- Cargo.toml | 1 + primitives/xcm-commons/Cargo.toml | 26 + primitives/xcm-commons/src/lib.rs | 59 ++ runtime/dancebox/Cargo.toml | 2 + .../src/tests/common/xcm/core_buyer.rs | 13 +- .../src/tests/common/xcm/core_buyer_common.rs | 3 +- .../src/tests/common/xcm/delivery_fees.rs | 19 +- .../common/xcm/expected_event_checker.rs | 103 --- .../src/tests/common/xcm/force_core_buyer.rs | 13 +- .../xcm/foreign_signed_based_sovereign.rs | 3 +- .../tests/common/xcm/foreign_sovereigns.rs | 18 +- runtime/dancebox/src/tests/common/xcm/mod.rs | 3 - .../xcm/reserver_transfers_polkadot_xcm.rs | 19 +- ...derivative_reception_container_dancebox.rs | 16 +- ...e_reception_dancebox_frontier_container.rs | 15 +- ...ive_reception_dancebox_simple_container.rs | 16 +- ...ken_derivative_reception_relay_dancebox.rs | 15 +- ...tive_reception_relay_frontier_container.rs | 16 +- ...vative_reception_relay_simple_container.rs | 15 +- .../dancebox/src/tests/common/xcm/transact.rs | 13 +- runtime/dancebox/src/tests/common/xcm/trap.rs | 9 +- runtime/dancebox/src/xcm_config.rs | 58 +- solo-chains/runtime/dancelight/Cargo.toml | 25 + .../dancelight/src/tests/common/mod.rs | 23 + .../src/tests/common/xcm/constants.rs | 415 +++++++++++ .../src/tests/common/xcm/mocknets.rs | 128 ++++ .../dancelight/src/tests/common/xcm/mod.rs | 20 + .../xcm/reserver_transfers_polkadot_xcm.rs | 153 ++++ .../runtime/dancelight/src/xcm_config.rs | 19 +- 30 files changed, 1281 insertions(+), 625 deletions(-) create mode 100644 primitives/xcm-commons/Cargo.toml create mode 100644 primitives/xcm-commons/src/lib.rs delete mode 100644 runtime/dancebox/src/tests/common/xcm/expected_event_checker.rs create mode 100644 solo-chains/runtime/dancelight/src/tests/common/xcm/constants.rs create mode 100644 solo-chains/runtime/dancelight/src/tests/common/xcm/mocknets.rs create mode 100644 solo-chains/runtime/dancelight/src/tests/common/xcm/mod.rs create mode 100644 solo-chains/runtime/dancelight/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs diff --git a/Cargo.lock b/Cargo.lock index 0b11d9005..5ea406367 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -576,7 +576,7 @@ checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9" [[package]] name = "asset-test-utils" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-pallet-parachain-system", "cumulus-pallet-xcmp-queue", @@ -605,7 +605,7 @@ dependencies = [ [[package]] name = "assets-common" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "frame-support", @@ -933,7 +933,7 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" [[package]] name = "binary-merkle-tree" version = "15.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "hash-db", "log", @@ -1176,7 +1176,7 @@ dependencies = [ [[package]] name = "bp-header-chain" version = "0.18.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-runtime", "finality-grandpa", @@ -1193,7 +1193,7 @@ dependencies = [ [[package]] name = "bp-messages" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-runtime", @@ -1209,7 +1209,7 @@ dependencies = [ [[package]] name = "bp-parachains" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-polkadot-core", @@ -1226,7 +1226,7 @@ dependencies = [ [[package]] name = "bp-polkadot-core" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-messages", "bp-runtime", @@ -1244,7 +1244,7 @@ dependencies = [ [[package]] name = "bp-relayers" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-messages", @@ -1262,7 +1262,7 @@ dependencies = [ [[package]] name = "bp-runtime" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -1285,7 +1285,7 @@ dependencies = [ [[package]] name = "bp-test-utils" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-parachains", @@ -1305,7 +1305,7 @@ dependencies = [ [[package]] name = "bp-xcm-bridge-hub" version = "0.4.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-messages", "bp-runtime", @@ -1322,7 +1322,7 @@ dependencies = [ [[package]] name = "bp-xcm-bridge-hub-router" version = "0.14.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -1334,7 +1334,7 @@ dependencies = [ [[package]] name = "bridge-hub-common" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "frame-support", @@ -1351,7 +1351,7 @@ dependencies = [ [[package]] name = "bridge-runtime-common" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-messages", @@ -2585,7 +2585,7 @@ dependencies = [ [[package]] name = "cumulus-client-cli" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "clap 4.5.13", "parity-scale-codec", @@ -2602,7 +2602,7 @@ dependencies = [ [[package]] name = "cumulus-client-collator" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-client-consensus-common", "cumulus-client-network", @@ -2625,7 +2625,7 @@ dependencies = [ [[package]] name = "cumulus-client-consensus-aura" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-client-collator", @@ -2670,7 +2670,7 @@ dependencies = [ [[package]] name = "cumulus-client-consensus-common" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-client-pov-recovery", @@ -2700,7 +2700,7 @@ dependencies = [ [[package]] name = "cumulus-client-consensus-proposer" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "anyhow", "async-trait", @@ -2715,7 +2715,7 @@ dependencies = [ [[package]] name = "cumulus-client-network" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-relay-chain-interface", @@ -2741,7 +2741,7 @@ dependencies = [ [[package]] name = "cumulus-client-parachain-inherent" version = "0.12.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-primitives-core", @@ -2763,7 +2763,7 @@ dependencies = [ [[package]] name = "cumulus-client-pov-recovery" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-primitives-core", @@ -2789,7 +2789,7 @@ dependencies = [ [[package]] name = "cumulus-client-service" version = "0.19.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-client-cli", "cumulus-client-collator", @@ -2826,7 +2826,7 @@ dependencies = [ [[package]] name = "cumulus-pallet-parachain-system" version = "0.17.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bytes", "cumulus-pallet-parachain-system-proc-macro", @@ -2862,7 +2862,7 @@ dependencies = [ [[package]] name = "cumulus-pallet-parachain-system-proc-macro" version = "0.6.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -2873,7 +2873,7 @@ dependencies = [ [[package]] name = "cumulus-pallet-session-benchmarking" version = "19.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -2886,7 +2886,7 @@ dependencies = [ [[package]] name = "cumulus-pallet-xcm" version = "0.17.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "frame-support", @@ -2901,7 +2901,7 @@ dependencies = [ [[package]] name = "cumulus-pallet-xcmp-queue" version = "0.17.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bounded-collections 0.2.0", "bp-xcm-bridge-hub-router", @@ -2926,7 +2926,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-aura" version = "0.15.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "sp-api", "sp-consensus-aura", @@ -2935,7 +2935,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-core" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "polkadot-core-primitives", @@ -2951,7 +2951,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-parachain-inherent" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-primitives-core", @@ -2965,7 +2965,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-proof-size-hostfunction" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "sp-externalities", "sp-runtime-interface", @@ -2975,7 +2975,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-storage-weight-reclaim" version = "8.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "cumulus-primitives-proof-size-hostfunction", @@ -2991,7 +2991,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-timestamp" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "sp-inherents", @@ -3001,7 +3001,7 @@ dependencies = [ [[package]] name = "cumulus-primitives-utility" version = "0.17.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "frame-support", @@ -3018,7 +3018,7 @@ dependencies = [ [[package]] name = "cumulus-relay-chain-inprocess-interface" version = "0.19.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-primitives-core", @@ -3042,7 +3042,7 @@ dependencies = [ [[package]] name = "cumulus-relay-chain-interface" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-primitives-core", @@ -3061,7 +3061,7 @@ dependencies = [ [[package]] name = "cumulus-relay-chain-minimal-node" version = "0.19.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "async-trait", @@ -3096,7 +3096,7 @@ dependencies = [ [[package]] name = "cumulus-relay-chain-rpc-interface" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "cumulus-primitives-core", @@ -3135,7 +3135,7 @@ dependencies = [ [[package]] name = "cumulus-test-relay-sproof-builder" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "parity-scale-codec", @@ -3351,6 +3351,7 @@ dependencies = [ "test-relay-sproof-builder", "tp-author-noting-inherent", "tp-traits", + "tp-xcm-commons", "tp-xcm-core-buyer", "westend-runtime", "westend-runtime-constants", @@ -3366,11 +3367,14 @@ dependencies = [ "alloy-sol-types", "binary-merkle-tree", "bitvec", + "container-chain-template-frontier-runtime", + "container-chain-template-simple-runtime", "cumulus-pallet-parachain-system", "cumulus-primitives-core", "dancelight-runtime-constants", "dp-consensus", "dp-container-chain-genesis-data", + "emulated-integration-tests-common", "finality-grandpa", "frame-benchmarking", "frame-executive", @@ -3448,6 +3452,9 @@ dependencies = [ "polkadot-runtime-common", "polkadot-runtime-parachains", "rand", + "rococo-runtime", + "rococo-runtime-constants", + "sc-consensus-grandpa", "scale-info", "separator", "serde", @@ -3502,6 +3509,10 @@ dependencies = [ "tp-author-noting-inherent", "tp-bridge", "tp-traits", + "tp-xcm-commons", + "westend-runtime", + "westend-runtime-constants", + "xcm-emulator", "xcm-runtime-apis", ] @@ -4048,7 +4059,7 @@ dependencies = [ [[package]] name = "emulated-integration-tests-common" version = "14.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "asset-test-utils", "bp-messages", @@ -4925,7 +4936,7 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" [[package]] name = "fork-tree" version = "13.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", ] @@ -5052,7 +5063,7 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa" [[package]] name = "frame-benchmarking" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-support-procedural", @@ -5076,7 +5087,7 @@ dependencies = [ [[package]] name = "frame-benchmarking-cli" version = "43.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "Inflector", "array-bytes", @@ -5126,7 +5137,7 @@ dependencies = [ [[package]] name = "frame-election-provider-solution-type" version = "14.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -5137,7 +5148,7 @@ dependencies = [ [[package]] name = "frame-election-provider-support" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-election-provider-solution-type", "frame-support", @@ -5153,7 +5164,7 @@ dependencies = [ [[package]] name = "frame-executive" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "aquamarine", "frame-support", @@ -5183,7 +5194,7 @@ dependencies = [ [[package]] name = "frame-metadata-hash-extension" version = "0.6.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "docify", @@ -5198,7 +5209,7 @@ dependencies = [ [[package]] name = "frame-remote-externalities" version = "0.46.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "indicatif", @@ -5220,7 +5231,7 @@ dependencies = [ [[package]] name = "frame-support" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "aquamarine", "array-bytes", @@ -5261,7 +5272,7 @@ dependencies = [ [[package]] name = "frame-support-procedural" version = "30.0.3" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "Inflector", "cfg-expr", @@ -5281,7 +5292,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools" version = "13.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support-procedural-tools-derive", "proc-macro-crate 3.1.0", @@ -5293,7 +5304,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools-derive" version = "12.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro2", "quote", @@ -5303,7 +5314,7 @@ dependencies = [ [[package]] name = "frame-system" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cfg-if", "docify", @@ -5323,7 +5334,7 @@ dependencies = [ [[package]] name = "frame-system-benchmarking" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -5337,7 +5348,7 @@ dependencies = [ [[package]] name = "frame-system-rpc-runtime-api" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "parity-scale-codec", @@ -5347,7 +5358,7 @@ dependencies = [ [[package]] name = "frame-try-runtime" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "parity-scale-codec", @@ -7719,7 +7730,7 @@ dependencies = [ [[package]] name = "mmr-gadget" version = "40.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "log", @@ -7738,7 +7749,7 @@ dependencies = [ [[package]] name = "mmr-rpc" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -8607,7 +8618,7 @@ checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f" [[package]] name = "pallet-asset-conversion" version = "20.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -8625,7 +8636,7 @@ dependencies = [ [[package]] name = "pallet-asset-rate" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -8639,7 +8650,7 @@ dependencies = [ [[package]] name = "pallet-asset-tx-payment" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -8656,7 +8667,7 @@ dependencies = [ [[package]] name = "pallet-assets" version = "40.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -8772,7 +8783,7 @@ dependencies = [ [[package]] name = "pallet-authority-discovery" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -8801,7 +8812,7 @@ dependencies = [ [[package]] name = "pallet-authorship" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -8814,7 +8825,7 @@ dependencies = [ [[package]] name = "pallet-babe" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -8837,7 +8848,7 @@ dependencies = [ [[package]] name = "pallet-bags-list" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "aquamarine", "docify", @@ -8858,7 +8869,7 @@ dependencies = [ [[package]] name = "pallet-balances" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -8887,7 +8898,7 @@ dependencies = [ [[package]] name = "pallet-beefy" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -8906,7 +8917,7 @@ dependencies = [ [[package]] name = "pallet-beefy-mmr" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "binary-merkle-tree", @@ -8931,7 +8942,7 @@ dependencies = [ [[package]] name = "pallet-bounties" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -8948,7 +8959,7 @@ dependencies = [ [[package]] name = "pallet-bridge-grandpa" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-runtime", @@ -8967,7 +8978,7 @@ dependencies = [ [[package]] name = "pallet-bridge-messages" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-messages", @@ -8986,7 +8997,7 @@ dependencies = [ [[package]] name = "pallet-bridge-parachains" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-parachains", @@ -9006,7 +9017,7 @@ dependencies = [ [[package]] name = "pallet-bridge-relayers" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-header-chain", "bp-messages", @@ -9030,7 +9041,7 @@ dependencies = [ [[package]] name = "pallet-broker" version = "0.17.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "frame-benchmarking", @@ -9077,7 +9088,7 @@ dependencies = [ [[package]] name = "pallet-child-bounties" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9127,7 +9138,7 @@ dependencies = [ [[package]] name = "pallet-collator-selection" version = "19.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9146,7 +9157,7 @@ dependencies = [ [[package]] name = "pallet-collective" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9180,7 +9191,7 @@ dependencies = [ [[package]] name = "pallet-conviction-voting" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "assert_matches", "frame-benchmarking", @@ -9231,7 +9242,7 @@ dependencies = [ [[package]] name = "pallet-delegated-staking" version = "5.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -9246,7 +9257,7 @@ dependencies = [ [[package]] name = "pallet-democracy" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9263,7 +9274,7 @@ dependencies = [ [[package]] name = "pallet-election-provider-multi-phase" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -9285,7 +9296,7 @@ dependencies = [ [[package]] name = "pallet-election-provider-support-benchmarking" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -9298,7 +9309,7 @@ dependencies = [ [[package]] name = "pallet-elections-phragmen" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9639,7 +9650,7 @@ dependencies = [ [[package]] name = "pallet-fast-unstake" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -9676,7 +9687,7 @@ dependencies = [ [[package]] name = "pallet-grandpa" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9698,7 +9709,7 @@ dependencies = [ [[package]] name = "pallet-identity" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "enumflags2", "frame-benchmarking", @@ -9714,7 +9725,7 @@ dependencies = [ [[package]] name = "pallet-im-online" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9733,7 +9744,7 @@ dependencies = [ [[package]] name = "pallet-indices" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9824,7 +9835,7 @@ dependencies = [ [[package]] name = "pallet-membership" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9840,7 +9851,7 @@ dependencies = [ [[package]] name = "pallet-message-queue" version = "41.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "environmental", "frame-benchmarking", @@ -9878,7 +9889,7 @@ dependencies = [ [[package]] name = "pallet-migrations" version = "8.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -9895,7 +9906,7 @@ dependencies = [ [[package]] name = "pallet-mmr" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9912,7 +9923,7 @@ dependencies = [ [[package]] name = "pallet-multisig" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9927,7 +9938,7 @@ dependencies = [ [[package]] name = "pallet-nis" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -9942,7 +9953,7 @@ dependencies = [ [[package]] name = "pallet-nomination-pools" version = "35.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -9960,7 +9971,7 @@ dependencies = [ [[package]] name = "pallet-nomination-pools-benchmarking" version = "36.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -9980,7 +9991,7 @@ dependencies = [ [[package]] name = "pallet-nomination-pools-runtime-api" version = "33.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "pallet-nomination-pools", "parity-scale-codec", @@ -10005,7 +10016,7 @@ dependencies = [ [[package]] name = "pallet-offences" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -10021,7 +10032,7 @@ dependencies = [ [[package]] name = "pallet-offences-benchmarking" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -10044,7 +10055,7 @@ dependencies = [ [[package]] name = "pallet-parameters" version = "0.9.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -10084,7 +10095,7 @@ dependencies = [ [[package]] name = "pallet-preimage" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10100,7 +10111,7 @@ dependencies = [ [[package]] name = "pallet-proxy" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10114,7 +10125,7 @@ dependencies = [ [[package]] name = "pallet-ranked-collective" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10132,7 +10143,7 @@ dependencies = [ [[package]] name = "pallet-recovery" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10146,7 +10157,7 @@ dependencies = [ [[package]] name = "pallet-referenda" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "assert_matches", "frame-benchmarking", @@ -10226,7 +10237,7 @@ dependencies = [ [[package]] name = "pallet-root-testing" version = "14.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -10240,7 +10251,7 @@ dependencies = [ [[package]] name = "pallet-scheduler" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -10285,7 +10296,7 @@ dependencies = [ [[package]] name = "pallet-session" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -10306,7 +10317,7 @@ dependencies = [ [[package]] name = "pallet-session-benchmarking" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10322,7 +10333,7 @@ dependencies = [ [[package]] name = "pallet-society" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10339,7 +10350,7 @@ dependencies = [ [[package]] name = "pallet-staking" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -10361,7 +10372,7 @@ dependencies = [ [[package]] name = "pallet-staking-reward-curve" version = "12.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -10372,7 +10383,7 @@ dependencies = [ [[package]] name = "pallet-staking-reward-fn" version = "22.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "sp-arithmetic", @@ -10381,7 +10392,7 @@ dependencies = [ [[package]] name = "pallet-staking-runtime-api" version = "24.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "sp-api", @@ -10391,7 +10402,7 @@ dependencies = [ [[package]] name = "pallet-state-trie-migration" version = "40.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10442,7 +10453,7 @@ dependencies = [ [[package]] name = "pallet-sudo" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -10457,7 +10468,7 @@ dependencies = [ [[package]] name = "pallet-timestamp" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -10476,7 +10487,7 @@ dependencies = [ [[package]] name = "pallet-tips" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10494,7 +10505,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -10509,7 +10520,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc" version = "41.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "jsonrpsee", "pallet-transaction-payment-rpc-runtime-api", @@ -10525,7 +10536,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc-runtime-api" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "pallet-transaction-payment", "parity-scale-codec", @@ -10537,7 +10548,7 @@ dependencies = [ [[package]] name = "pallet-treasury" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -10555,7 +10566,7 @@ dependencies = [ [[package]] name = "pallet-tx-pause" version = "19.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-benchmarking", @@ -10572,7 +10583,7 @@ dependencies = [ [[package]] name = "pallet-utility" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10587,7 +10598,7 @@ dependencies = [ [[package]] name = "pallet-vesting" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10601,7 +10612,7 @@ dependencies = [ [[package]] name = "pallet-whitelist" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10615,7 +10626,7 @@ dependencies = [ [[package]] name = "pallet-xcm" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bounded-collections 0.2.0", "frame-benchmarking", @@ -10639,7 +10650,7 @@ dependencies = [ [[package]] name = "pallet-xcm-benchmarks" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -10657,7 +10668,7 @@ dependencies = [ [[package]] name = "pallet-xcm-bridge-hub" version = "0.13.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-messages", "bp-runtime", @@ -10679,7 +10690,7 @@ dependencies = [ [[package]] name = "pallet-xcm-bridge-hub-router" version = "0.15.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bp-xcm-bridge-hub-router", "frame-benchmarking", @@ -10764,7 +10775,7 @@ dependencies = [ [[package]] name = "parachains-common" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "cumulus-primitives-utility", @@ -10794,7 +10805,7 @@ dependencies = [ [[package]] name = "parachains-runtimes-test-utils" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-pallet-parachain-system", "cumulus-pallet-xcmp-queue", @@ -11148,7 +11159,7 @@ checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" [[package]] name = "polkadot-approval-distribution" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "futures 0.3.30", @@ -11168,7 +11179,7 @@ dependencies = [ [[package]] name = "polkadot-availability-bitfield-distribution" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "always-assert", "futures 0.3.30", @@ -11184,7 +11195,7 @@ dependencies = [ [[package]] name = "polkadot-availability-distribution" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "derive_more", "fatality", @@ -11208,7 +11219,7 @@ dependencies = [ [[package]] name = "polkadot-availability-recovery" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "fatality", @@ -11241,7 +11252,7 @@ dependencies = [ [[package]] name = "polkadot-cli" version = "19.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cfg-if", "clap 4.5.13", @@ -11269,7 +11280,7 @@ dependencies = [ [[package]] name = "polkadot-collator-protocol" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "fatality", @@ -11292,7 +11303,7 @@ dependencies = [ [[package]] name = "polkadot-core-primitives" version = "15.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -11303,7 +11314,7 @@ dependencies = [ [[package]] name = "polkadot-dispute-distribution" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "derive_more", "fatality", @@ -11328,7 +11339,7 @@ dependencies = [ [[package]] name = "polkadot-erasure-coding" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "polkadot-node-primitives", @@ -11342,7 +11353,7 @@ dependencies = [ [[package]] name = "polkadot-gossip-support" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "futures-timer", @@ -11364,7 +11375,7 @@ dependencies = [ [[package]] name = "polkadot-network-bridge" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "always-assert", "async-trait", @@ -11387,7 +11398,7 @@ dependencies = [ [[package]] name = "polkadot-node-collation-generation" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "parity-scale-codec", @@ -11405,7 +11416,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-approval-voting" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "derive_more", @@ -11438,7 +11449,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-av-store" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "futures 0.3.30", @@ -11460,7 +11471,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-backing" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "fatality", @@ -11480,7 +11491,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-bitfield-signing" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "polkadot-node-subsystem", @@ -11495,7 +11506,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-candidate-validation" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -11517,7 +11528,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-chain-api" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "polkadot-node-metrics", @@ -11531,7 +11542,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-chain-selection" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "futures-timer", @@ -11548,7 +11559,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-dispute-coordinator" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "fatality", "futures 0.3.30", @@ -11567,7 +11578,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-parachains-inherent" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -11584,7 +11595,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-prospective-parachains" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "fatality", "futures 0.3.30", @@ -11598,7 +11609,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-provisioner" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "fatality", @@ -11616,7 +11627,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-pvf" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "always-assert", "array-bytes", @@ -11645,7 +11656,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-pvf-checker" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "polkadot-node-primitives", @@ -11661,7 +11672,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-pvf-common" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cpu-time", "futures 0.3.30", @@ -11687,7 +11698,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-pvf-execute-worker" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cfg-if", "cpu-time", @@ -11705,7 +11716,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-pvf-prepare-worker" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "blake3", "cfg-if", @@ -11728,7 +11739,7 @@ dependencies = [ [[package]] name = "polkadot-node-core-runtime-api" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "polkadot-node-metrics", @@ -11743,7 +11754,7 @@ dependencies = [ [[package]] name = "polkadot-node-jaeger" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "lazy_static", "log", @@ -11762,7 +11773,7 @@ dependencies = [ [[package]] name = "polkadot-node-metrics" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bs58 0.5.1", "futures 0.3.30", @@ -11781,7 +11792,7 @@ dependencies = [ [[package]] name = "polkadot-node-network-protocol" version = "18.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-channel 1.9.0", "async-trait", @@ -11807,7 +11818,7 @@ dependencies = [ [[package]] name = "polkadot-node-primitives" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "bounded-vec", @@ -11833,7 +11844,7 @@ dependencies = [ [[package]] name = "polkadot-node-subsystem" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "polkadot-node-jaeger", "polkadot-node-subsystem-types", @@ -11843,7 +11854,7 @@ dependencies = [ [[package]] name = "polkadot-node-subsystem-test-helpers" version = "1.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -11865,7 +11876,7 @@ dependencies = [ [[package]] name = "polkadot-node-subsystem-types" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "bitvec", @@ -11895,7 +11906,7 @@ dependencies = [ [[package]] name = "polkadot-node-subsystem-util" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "derive_more", @@ -11931,7 +11942,7 @@ dependencies = [ [[package]] name = "polkadot-overseer" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -11953,7 +11964,7 @@ dependencies = [ [[package]] name = "polkadot-parachain-primitives" version = "14.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bounded-collections 0.2.0", "derive_more", @@ -11969,7 +11980,7 @@ dependencies = [ [[package]] name = "polkadot-primitives" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "hex-literal 0.4.1", @@ -11995,7 +12006,7 @@ dependencies = [ [[package]] name = "polkadot-primitives-test-helpers" version = "0.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "polkadot-primitives", "rand", @@ -12008,7 +12019,7 @@ dependencies = [ [[package]] name = "polkadot-rpc" version = "19.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "jsonrpsee", "mmr-rpc", @@ -12043,7 +12054,7 @@ dependencies = [ [[package]] name = "polkadot-runtime-common" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitvec", "frame-benchmarking", @@ -12093,7 +12104,7 @@ dependencies = [ [[package]] name = "polkadot-runtime-metrics" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bs58 0.5.1", "frame-benchmarking", @@ -12105,7 +12116,7 @@ dependencies = [ [[package]] name = "polkadot-runtime-parachains" version = "17.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bitflags 1.3.2", "bitvec", @@ -12155,7 +12166,7 @@ dependencies = [ [[package]] name = "polkadot-service" version = "19.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "frame-benchmarking", @@ -12262,7 +12273,7 @@ dependencies = [ [[package]] name = "polkadot-statement-distribution" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "arrayvec 0.7.4", "bitvec", @@ -12285,7 +12296,7 @@ dependencies = [ [[package]] name = "polkadot-statement-table" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "polkadot-primitives", @@ -12296,7 +12307,7 @@ dependencies = [ [[package]] name = "polkadot-test-client" version = "1.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "parity-scale-codec", @@ -12324,7 +12335,7 @@ dependencies = [ [[package]] name = "polkadot-test-runtime" version = "1.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-election-provider-support", "frame-executive", @@ -12380,7 +12391,7 @@ dependencies = [ [[package]] name = "polkadot-test-service" version = "1.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-system", "futures 0.3.30", @@ -13538,7 +13549,7 @@ dependencies = [ [[package]] name = "rococo-runtime" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "binary-merkle-tree", "bitvec", @@ -13638,7 +13649,7 @@ dependencies = [ [[package]] name = "rococo-runtime-constants" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "polkadot-primitives", @@ -14018,7 +14029,7 @@ dependencies = [ [[package]] name = "sc-allocator" version = "29.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "sp-core", @@ -14029,7 +14040,7 @@ dependencies = [ [[package]] name = "sc-authority-discovery" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -14059,7 +14070,7 @@ dependencies = [ [[package]] name = "sc-basic-authorship" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "futures-timer", @@ -14081,7 +14092,7 @@ dependencies = [ [[package]] name = "sc-block-builder" version = "0.42.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "sp-api", @@ -14096,7 +14107,7 @@ dependencies = [ [[package]] name = "sc-chain-spec" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "docify", @@ -14123,7 +14134,7 @@ dependencies = [ [[package]] name = "sc-chain-spec-derive" version = "12.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -14134,7 +14145,7 @@ dependencies = [ [[package]] name = "sc-cli" version = "0.47.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "chrono", @@ -14179,7 +14190,7 @@ dependencies = [ [[package]] name = "sc-client-api" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "fnv", "futures 0.3.30", @@ -14206,7 +14217,7 @@ dependencies = [ [[package]] name = "sc-client-db" version = "0.44.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "hash-db", "kvdb", @@ -14232,7 +14243,7 @@ dependencies = [ [[package]] name = "sc-consensus" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -14256,7 +14267,7 @@ dependencies = [ [[package]] name = "sc-consensus-aura" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -14285,7 +14296,7 @@ dependencies = [ [[package]] name = "sc-consensus-babe" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "fork-tree", @@ -14321,7 +14332,7 @@ dependencies = [ [[package]] name = "sc-consensus-babe-rpc" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "jsonrpsee", @@ -14343,7 +14354,7 @@ dependencies = [ [[package]] name = "sc-consensus-beefy" version = "24.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "async-channel 1.9.0", @@ -14379,7 +14390,7 @@ dependencies = [ [[package]] name = "sc-consensus-beefy-rpc" version = "24.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "jsonrpsee", @@ -14399,7 +14410,7 @@ dependencies = [ [[package]] name = "sc-consensus-epochs" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "fork-tree", "parity-scale-codec", @@ -14412,7 +14423,7 @@ dependencies = [ [[package]] name = "sc-consensus-grandpa" version = "0.30.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "ahash 0.8.8", "array-bytes", @@ -14456,7 +14467,7 @@ dependencies = [ [[package]] name = "sc-consensus-grandpa-rpc" version = "0.30.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "finality-grandpa", "futures 0.3.30", @@ -14476,7 +14487,7 @@ dependencies = [ [[package]] name = "sc-consensus-manual-seal" version = "0.46.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "assert_matches", "async-trait", @@ -14511,7 +14522,7 @@ dependencies = [ [[package]] name = "sc-consensus-slots" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -14534,7 +14545,7 @@ dependencies = [ [[package]] name = "sc-executor" version = "0.40.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "parity-scale-codec", @@ -14558,7 +14569,7 @@ dependencies = [ [[package]] name = "sc-executor-common" version = "0.35.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "polkavm", @@ -14572,7 +14583,7 @@ dependencies = [ [[package]] name = "sc-executor-polkavm" version = "0.32.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "polkavm", @@ -14583,7 +14594,7 @@ dependencies = [ [[package]] name = "sc-executor-wasmtime" version = "0.35.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "anyhow", "cfg-if", @@ -14602,7 +14613,7 @@ dependencies = [ [[package]] name = "sc-informant" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "console", "futures 0.3.30", @@ -14619,7 +14630,7 @@ dependencies = [ [[package]] name = "sc-keystore" version = "33.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "parking_lot 0.12.3", @@ -14633,7 +14644,7 @@ dependencies = [ [[package]] name = "sc-mixnet" version = "0.15.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "arrayvec 0.7.4", @@ -14662,7 +14673,7 @@ dependencies = [ [[package]] name = "sc-network" version = "0.45.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "async-channel 1.9.0", @@ -14713,7 +14724,7 @@ dependencies = [ [[package]] name = "sc-network-common" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "bitflags 1.3.2", @@ -14731,7 +14742,7 @@ dependencies = [ [[package]] name = "sc-network-gossip" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "ahash 0.8.8", "futures 0.3.30", @@ -14750,7 +14761,7 @@ dependencies = [ [[package]] name = "sc-network-light" version = "0.44.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "async-channel 1.9.0", @@ -14771,7 +14782,7 @@ dependencies = [ [[package]] name = "sc-network-sync" version = "0.44.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "async-channel 1.9.0", @@ -14808,7 +14819,7 @@ dependencies = [ [[package]] name = "sc-network-test" version = "0.8.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -14840,7 +14851,7 @@ dependencies = [ [[package]] name = "sc-network-transactions" version = "0.44.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "futures 0.3.30", @@ -14859,7 +14870,7 @@ dependencies = [ [[package]] name = "sc-network-types" version = "0.12.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bs58 0.5.1", "ed25519-dalek", @@ -14876,7 +14887,7 @@ dependencies = [ [[package]] name = "sc-offchain" version = "40.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "bytes", @@ -14910,7 +14921,7 @@ dependencies = [ [[package]] name = "sc-proposer-metrics" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "substrate-prometheus-endpoint", @@ -14919,7 +14930,7 @@ dependencies = [ [[package]] name = "sc-rpc" version = "40.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "jsonrpsee", @@ -14951,7 +14962,7 @@ dependencies = [ [[package]] name = "sc-rpc-api" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -14971,7 +14982,7 @@ dependencies = [ [[package]] name = "sc-rpc-server" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "dyn-clone", "forwarded-header-value", @@ -14995,7 +15006,7 @@ dependencies = [ [[package]] name = "sc-rpc-spec-v2" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "futures 0.3.30", @@ -15027,7 +15038,7 @@ dependencies = [ [[package]] name = "sc-service" version = "0.46.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "directories", @@ -15091,7 +15102,7 @@ dependencies = [ [[package]] name = "sc-state-db" version = "0.36.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "parity-scale-codec", @@ -15102,7 +15113,7 @@ dependencies = [ [[package]] name = "sc-storage-monitor" version = "0.22.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "clap 4.5.13", "fs4", @@ -15115,7 +15126,7 @@ dependencies = [ [[package]] name = "sc-sync-state-rpc" version = "0.45.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -15134,7 +15145,7 @@ dependencies = [ [[package]] name = "sc-sysinfo" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "derive_more", "futures 0.3.30", @@ -15155,7 +15166,7 @@ dependencies = [ [[package]] name = "sc-telemetry" version = "25.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "chrono", "futures 0.3.30", @@ -15175,7 +15186,7 @@ dependencies = [ [[package]] name = "sc-tracing" version = "37.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "chrono", "console", @@ -15204,7 +15215,7 @@ dependencies = [ [[package]] name = "sc-tracing-proc-macro" version = "11.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -15215,7 +15226,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -15246,7 +15257,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool-api" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -15262,7 +15273,7 @@ dependencies = [ [[package]] name = "sc-utils" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-channel 1.9.0", "futures 0.3.30", @@ -15866,7 +15877,7 @@ dependencies = [ [[package]] name = "slot-range-helper" version = "15.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "enumn", "parity-scale-codec", @@ -16032,7 +16043,7 @@ dependencies = [ [[package]] name = "snowbridge-beacon-primitives" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "byte-slice-cast", "frame-support", @@ -16054,7 +16065,7 @@ dependencies = [ [[package]] name = "snowbridge-core" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "ethabi-decode", "frame-support", @@ -16077,7 +16088,7 @@ dependencies = [ [[package]] name = "snowbridge-ethereum" version = "0.9.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "ethabi-decode", "ethbloom", @@ -16112,7 +16123,7 @@ dependencies = [ [[package]] name = "snowbridge-outbound-queue-merkle-tree" version = "0.9.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16123,7 +16134,7 @@ dependencies = [ [[package]] name = "snowbridge-pallet-ethereum-client" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -16149,7 +16160,7 @@ dependencies = [ [[package]] name = "snowbridge-pallet-ethereum-client-fixtures" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "hex-literal 0.4.1", "snowbridge-beacon-primitives", @@ -16161,7 +16172,7 @@ dependencies = [ [[package]] name = "snowbridge-pallet-inbound-queue" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "alloy-primitives", "alloy-sol-types", @@ -16189,7 +16200,7 @@ dependencies = [ [[package]] name = "snowbridge-pallet-inbound-queue-fixtures" version = "0.18.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "hex-literal 0.4.1", "snowbridge-beacon-primitives", @@ -16201,7 +16212,7 @@ dependencies = [ [[package]] name = "snowbridge-pallet-outbound-queue" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bridge-hub-common", "ethabi-decode", @@ -16223,7 +16234,7 @@ dependencies = [ [[package]] name = "snowbridge-pallet-system" version = "0.10.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-benchmarking", "frame-support", @@ -16243,7 +16254,7 @@ dependencies = [ [[package]] name = "snowbridge-router-primitives" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "alloy-primitives", "alloy-sol-types", @@ -16316,7 +16327,7 @@ dependencies = [ [[package]] name = "sp-api" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "hash-db", @@ -16338,7 +16349,7 @@ dependencies = [ [[package]] name = "sp-api-proc-macro" version = "20.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "Inflector", "blake2 0.10.6", @@ -16352,7 +16363,7 @@ dependencies = [ [[package]] name = "sp-application-crypto" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16364,7 +16375,7 @@ dependencies = [ [[package]] name = "sp-arithmetic" version = "26.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "integer-sqrt", @@ -16378,7 +16389,7 @@ dependencies = [ [[package]] name = "sp-authority-discovery" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16390,7 +16401,7 @@ dependencies = [ [[package]] name = "sp-block-builder" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "sp-api", "sp-inherents", @@ -16400,7 +16411,7 @@ dependencies = [ [[package]] name = "sp-blockchain" version = "37.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "parity-scale-codec", @@ -16419,7 +16430,7 @@ dependencies = [ [[package]] name = "sp-consensus" version = "0.40.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "futures 0.3.30", @@ -16434,7 +16445,7 @@ dependencies = [ [[package]] name = "sp-consensus-aura" version = "0.40.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "parity-scale-codec", @@ -16450,7 +16461,7 @@ dependencies = [ [[package]] name = "sp-consensus-babe" version = "0.40.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "parity-scale-codec", @@ -16468,7 +16479,7 @@ dependencies = [ [[package]] name = "sp-consensus-beefy" version = "22.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "lazy_static", "parity-scale-codec", @@ -16489,7 +16500,7 @@ dependencies = [ [[package]] name = "sp-consensus-grandpa" version = "21.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "finality-grandpa", "log", @@ -16506,7 +16517,7 @@ dependencies = [ [[package]] name = "sp-consensus-slots" version = "0.40.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16517,7 +16528,7 @@ dependencies = [ [[package]] name = "sp-core" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "bitflags 1.3.2", @@ -16563,7 +16574,7 @@ dependencies = [ [[package]] name = "sp-crypto-hashing" version = "0.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "blake2b_simd", "byteorder", @@ -16576,7 +16587,7 @@ dependencies = [ [[package]] name = "sp-crypto-hashing-proc-macro" version = "0.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "quote", "sp-crypto-hashing", @@ -16586,7 +16597,7 @@ dependencies = [ [[package]] name = "sp-database" version = "10.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "kvdb", "parking_lot 0.12.3", @@ -16595,7 +16606,7 @@ dependencies = [ [[package]] name = "sp-debug-derive" version = "14.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "proc-macro2", "quote", @@ -16605,7 +16616,7 @@ dependencies = [ [[package]] name = "sp-externalities" version = "0.29.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "environmental", "parity-scale-codec", @@ -16615,7 +16626,7 @@ dependencies = [ [[package]] name = "sp-genesis-builder" version = "0.15.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16627,7 +16638,7 @@ dependencies = [ [[package]] name = "sp-inherents" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "impl-trait-for-tuples", @@ -16640,7 +16651,7 @@ dependencies = [ [[package]] name = "sp-io" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bytes", "docify", @@ -16666,7 +16677,7 @@ dependencies = [ [[package]] name = "sp-keyring" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "sp-core", "sp-runtime", @@ -16676,7 +16687,7 @@ dependencies = [ [[package]] name = "sp-keystore" version = "0.40.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "parking_lot 0.12.3", @@ -16687,7 +16698,7 @@ dependencies = [ [[package]] name = "sp-maybe-compressed-blob" version = "11.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "thiserror", "zstd 0.12.4", @@ -16696,7 +16707,7 @@ dependencies = [ [[package]] name = "sp-metadata-ir" version = "0.7.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-metadata", "parity-scale-codec", @@ -16706,7 +16717,7 @@ dependencies = [ [[package]] name = "sp-mixnet" version = "0.12.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16717,7 +16728,7 @@ dependencies = [ [[package]] name = "sp-mmr-primitives" version = "34.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "log", "parity-scale-codec", @@ -16734,7 +16745,7 @@ dependencies = [ [[package]] name = "sp-npos-elections" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16747,7 +16758,7 @@ dependencies = [ [[package]] name = "sp-offchain" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "sp-api", "sp-core", @@ -16757,7 +16768,7 @@ dependencies = [ [[package]] name = "sp-panic-handler" version = "13.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "backtrace", "lazy_static", @@ -16767,7 +16778,7 @@ dependencies = [ [[package]] name = "sp-rpc" version = "32.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "rustc-hash 1.1.0", "serde", @@ -16777,7 +16788,7 @@ dependencies = [ [[package]] name = "sp-runtime" version = "39.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "either", @@ -16803,7 +16814,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface" version = "28.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bytes", "impl-trait-for-tuples", @@ -16822,7 +16833,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface-proc-macro" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "Inflector", "expander", @@ -16835,7 +16846,7 @@ dependencies = [ [[package]] name = "sp-session" version = "36.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "scale-info", @@ -16849,7 +16860,7 @@ dependencies = [ [[package]] name = "sp-staking" version = "36.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "impl-trait-for-tuples", "parity-scale-codec", @@ -16862,7 +16873,7 @@ dependencies = [ [[package]] name = "sp-state-machine" version = "0.43.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "hash-db", "log", @@ -16882,7 +16893,7 @@ dependencies = [ [[package]] name = "sp-statement-store" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "aes-gcm", "curve25519-dalek", @@ -16906,12 +16917,12 @@ dependencies = [ [[package]] name = "sp-std" version = "14.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" [[package]] name = "sp-storage" version = "21.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "impl-serde", "parity-scale-codec", @@ -16923,7 +16934,7 @@ dependencies = [ [[package]] name = "sp-timestamp" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "parity-scale-codec", @@ -16935,7 +16946,7 @@ dependencies = [ [[package]] name = "sp-tracing" version = "17.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "tracing", @@ -16946,7 +16957,7 @@ dependencies = [ [[package]] name = "sp-transaction-pool" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "sp-api", "sp-runtime", @@ -16955,7 +16966,7 @@ dependencies = [ [[package]] name = "sp-transaction-storage-proof" version = "34.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "parity-scale-codec", @@ -16969,7 +16980,7 @@ dependencies = [ [[package]] name = "sp-trie" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "ahash 0.8.8", "hash-db", @@ -16992,7 +17003,7 @@ dependencies = [ [[package]] name = "sp-version" version = "37.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "impl-serde", "parity-scale-codec", @@ -17009,7 +17020,7 @@ dependencies = [ [[package]] name = "sp-version-proc-macro" version = "14.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "parity-scale-codec", "proc-macro2", @@ -17020,7 +17031,7 @@ dependencies = [ [[package]] name = "sp-wasm-interface" version = "21.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "anyhow", "impl-trait-for-tuples", @@ -17032,7 +17043,7 @@ dependencies = [ [[package]] name = "sp-weights" version = "31.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "bounded-collections 0.2.0", "parity-scale-codec", @@ -17256,7 +17267,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "staging-parachain-info" version = "0.17.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "cumulus-primitives-core", "frame-support", @@ -17269,12 +17280,12 @@ dependencies = [ [[package]] name = "staging-tracking-allocator" version = "2.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" [[package]] name = "staging-xcm" version = "14.2.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "bounded-collections 0.2.0", @@ -17293,7 +17304,7 @@ dependencies = [ [[package]] name = "staging-xcm-builder" version = "17.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "frame-system", @@ -17315,7 +17326,7 @@ dependencies = [ [[package]] name = "staging-xcm-executor" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "environmental", "frame-benchmarking", @@ -17477,7 +17488,7 @@ dependencies = [ [[package]] name = "substrate-bip39" version = "0.6.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "hmac 0.12.1", "pbkdf2", @@ -17489,12 +17500,12 @@ dependencies = [ [[package]] name = "substrate-build-script-utils" version = "11.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" [[package]] name = "substrate-frame-rpc-system" version = "39.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "docify", "frame-system-rpc-runtime-api", @@ -17514,7 +17525,7 @@ dependencies = [ [[package]] name = "substrate-prometheus-endpoint" version = "0.17.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "http-body-util", "hyper 1.4.1", @@ -17528,7 +17539,7 @@ dependencies = [ [[package]] name = "substrate-rpc-client" version = "0.44.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "async-trait", "jsonrpsee", @@ -17541,7 +17552,7 @@ dependencies = [ [[package]] name = "substrate-state-trie-migration-rpc" version = "38.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -17558,7 +17569,7 @@ dependencies = [ [[package]] name = "substrate-test-client" version = "2.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "async-trait", @@ -17585,7 +17596,7 @@ dependencies = [ [[package]] name = "substrate-test-runtime" version = "2.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "frame-executive", @@ -17629,7 +17640,7 @@ dependencies = [ [[package]] name = "substrate-test-runtime-client" version = "2.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "futures 0.3.30", "sc-block-builder", @@ -17647,7 +17658,7 @@ dependencies = [ [[package]] name = "substrate-wasm-builder" version = "24.0.1" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "build-helper", @@ -18370,7 +18381,7 @@ dependencies = [ [[package]] name = "test-runtime-constants" version = "1.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "polkadot-primitives", @@ -18838,6 +18849,15 @@ dependencies = [ "sp-std", ] +[[package]] +name = "tp-xcm-commons" +version = "0.1.0" +dependencies = [ + "frame-support", + "log", + "staging-xcm", +] + [[package]] name = "tp-xcm-core-buyer" version = "0.1.0" @@ -18897,7 +18917,7 @@ dependencies = [ [[package]] name = "tracing-gum" version = "16.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "coarsetime", "polkadot-primitives", @@ -18908,7 +18928,7 @@ dependencies = [ [[package]] name = "tracing-gum-proc-macro" version = "5.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "expander", "proc-macro-crate 3.1.0", @@ -19755,7 +19775,7 @@ dependencies = [ [[package]] name = "westend-runtime" version = "18.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "binary-merkle-tree", "bitvec", @@ -19863,7 +19883,7 @@ dependencies = [ [[package]] name = "westend-runtime-constants" version = "17.0.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "polkadot-primitives", @@ -20262,7 +20282,7 @@ dependencies = [ [[package]] name = "xcm-emulator" version = "0.16.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "array-bytes", "cumulus-pallet-parachain-system", @@ -20315,7 +20335,7 @@ dependencies = [ [[package]] name = "xcm-procedural" version = "10.1.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "Inflector", "proc-macro2", @@ -20326,7 +20346,7 @@ dependencies = [ [[package]] name = "xcm-runtime-apis" version = "0.4.0" -source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#f3d164a5c20fba26d080731643b6d1a8380fbdf7" +source = "git+https://github.com/moondance-labs/polkadot-sdk?branch=tanssi-polkadot-stable2409#772548ddb49afaccf7bcf192a9b0780d00dfad3f" dependencies = [ "frame-support", "parity-scale-codec", diff --git a/Cargo.toml b/Cargo.toml index c62dc5ee4..8624cbd7e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -102,6 +102,7 @@ tp-author-noting-inherent = { path = "primitives/author-noting-inherent", defaul tp-bridge = { path = "primitives/bridge", default-features = false } tp-maths = { path = "primitives/maths", default-features = false } tp-traits = { path = "primitives/traits", default-features = false } +tp-xcm-commons = { path = "primitives/xcm-commons", default-features = false } tp-xcm-core-buyer = { path = "primitives/xcm-core-buyer", default-features = false } # Dancekit (wasm) diff --git a/primitives/xcm-commons/Cargo.toml b/primitives/xcm-commons/Cargo.toml new file mode 100644 index 000000000..20e983340 --- /dev/null +++ b/primitives/xcm-commons/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "tp-xcm-commons" +edition = "2021" +version = "0.1.0" +[package.authors] +workspace = true +[package.repository] +workspace = true + +[lints] +workspace = true + +[dependencies] +frame-support = { workspace = true } +log = { workspace = true } +staging-xcm = { workspace = true } + +[features] +default = [ + "std", +] +std = [ + "frame-support/std", + "log/std", + "staging-xcm/std", +] diff --git a/primitives/xcm-commons/src/lib.rs b/primitives/xcm-commons/src/lib.rs new file mode 100644 index 000000000..5f7d76119 --- /dev/null +++ b/primitives/xcm-commons/src/lib.rs @@ -0,0 +1,59 @@ +// 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_attr(not(feature = "std"), no_std)] + +use staging_xcm::latest::prelude::*; +trait Parse { + /// Returns the "chain" location part. It could be parent, sibling + /// parachain, or child parachain. + fn chain_part(&self) -> Option; +} + +impl Parse for Location { + fn chain_part(&self) -> Option { + match (self.parents, self.first_interior()) { + // sibling parachain + (1, Some(Parachain(id))) => Some(Location::new(1, [Parachain(*id)])), + // parent + (1, _) => Some(Location::parent()), + // children parachain + (0, Some(Parachain(id))) => Some(Location::new(0, [Parachain(*id)])), + _ => None, + } + } +} + +pub struct NativeAssetReserve; +impl frame_support::traits::ContainsPair for NativeAssetReserve { + fn contains(asset: &Asset, origin: &Location) -> bool { + log::trace!(target: "xcm::contains", "NativeAssetReserve asset: {:?}, origin: {:?}", asset, origin); + let reserve = if asset.id.0.parents == 0 + && !matches!(asset.id.0.first_interior(), Some(Parachain(_))) + { + Some(Location::here()) + } else { + asset.id.0.chain_part() + }; + + if let Some(ref reserve) = reserve { + if reserve == origin { + return true; + } + } + false + } +} diff --git a/runtime/dancebox/Cargo.toml b/runtime/dancebox/Cargo.toml index d93db612c..6fcd53a5d 100644 --- a/runtime/dancebox/Cargo.toml +++ b/runtime/dancebox/Cargo.toml @@ -48,6 +48,7 @@ pallet-xcm-core-buyer = { workspace = true } pallet-xcm-core-buyer-runtime-api = { workspace = true } tanssi-relay-encoder = { workspace = true } tanssi-runtime-common = { workspace = true } +tp-xcm-commons = { workspace = true } tp-xcm-core-buyer = { workspace = true } # Moonkit @@ -271,6 +272,7 @@ std = [ "test-relay-sproof-builder/std", "tp-author-noting-inherent/std", "tp-traits/std", + "tp-xcm-commons/std", "tp-xcm-core-buyer/std", "westend-runtime-constants/std", "westend-runtime/std", diff --git a/runtime/dancebox/src/tests/common/xcm/core_buyer.rs b/runtime/dancebox/src/tests/common/xcm/core_buyer.rs index 1cdb011c7..f0c9dbee0 100644 --- a/runtime/dancebox/src/tests/common/xcm/core_buyer.rs +++ b/runtime/dancebox/src/tests/common/xcm/core_buyer.rs @@ -15,18 +15,15 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - core_buyer_common::*, - mocknets::{DanceboxRococoPara as Dancebox, RococoRelay as Rococo, RococoRelayPallet}, - *, - }, + crate::tests::common::xcm::{ + core_buyer_common::*, + mocknets::{DanceboxRococoPara as Dancebox, RococoRelay as Rococo, RococoRelayPallet}, + *, }, polkadot_runtime_parachains::on_demand as parachains_assigner_on_demand, staging_xcm::latest::{MaybeErrorCode, Response}, tp_traits::ParaId, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; const PARATHREAD_ID: u32 = 3333; diff --git a/runtime/dancebox/src/tests/common/xcm/core_buyer_common.rs b/runtime/dancebox/src/tests/common/xcm/core_buyer_common.rs index 8562b5784..ccd622861 100644 --- a/runtime/dancebox/src/tests/common/xcm/core_buyer_common.rs +++ b/runtime/dancebox/src/tests/common/xcm/core_buyer_common.rs @@ -16,7 +16,6 @@ use { crate::{ - assert_expected_events, tests::common::{ empty_genesis_data, run_to_session, set_dummy_boot_node, start_block, xcm::{ @@ -42,7 +41,7 @@ use { staging_xcm::v3::QueryId, staging_xcm_executor::traits::ConvertLocation, tp_traits::{ParaId, SlotFrequency}, - xcm_emulator::{Chain, RelayChain}, + xcm_emulator::{assert_expected_events, Chain, RelayChain}, }; pub const PARATHREAD_ID: u32 = 3333; diff --git a/runtime/dancebox/src/tests/common/xcm/delivery_fees.rs b/runtime/dancebox/src/tests/common/xcm/delivery_fees.rs index e4688730f..bbed23d2d 100644 --- a/runtime/dancebox/src/tests/common/xcm/delivery_fees.rs +++ b/runtime/dancebox/src/tests/common/xcm/delivery_fees.rs @@ -15,17 +15,14 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, - EthereumSender as FrontierTemplateSender, FrontierTemplatePara as FrontierTemplate, - FrontierTemplateParaPallet, SimpleTemplatePara as SimpleTemplate, - SimpleTemplateParaPallet, SimpleTemplateSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, + EthereumSender as FrontierTemplateSender, FrontierTemplatePara as FrontierTemplate, + FrontierTemplateParaPallet, SimpleTemplatePara as SimpleTemplate, + SimpleTemplateParaPallet, SimpleTemplateSender, }, + *, }, frame_support::{assert_ok, traits::EnsureOrigin}, paste::paste, @@ -33,7 +30,7 @@ use { latest::prelude::{Junctions::X1, *}, VersionedLocation, VersionedXcm, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[test] diff --git a/runtime/dancebox/src/tests/common/xcm/expected_event_checker.rs b/runtime/dancebox/src/tests/common/xcm/expected_event_checker.rs deleted file mode 100644 index 8d387aef7..000000000 --- a/runtime/dancebox/src/tests/common/xcm/expected_event_checker.rs +++ /dev/null @@ -1,103 +0,0 @@ -// 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 - -#[macro_export] -macro_rules! assert_expected_events { - ( $chain:ident, vec![$( $event_pat:pat => { $($attr:ident : $condition:expr, )* }, )*] ) => { - let mut message: Vec = Vec::new(); - let mut events = <$chain as xcm_emulator::Chain>::events(); - - $( - let mut event_received = false; - let mut meet_conditions = true; - let mut index_match = 0; - let mut event_message: Vec = Vec::new(); - - for (index, event) in events.iter().enumerate() { - // Variable to record current event's meet conditions - #[allow(unused_mut)] // To suppress warning in case no conditions are declared - let mut current_event_meet_conditions = true; - match event { - $event_pat => { - event_received = true; - - #[allow(unused_mut)] // To suppress warning in case no conditions are declared - let mut conditions_message: Vec = Vec::new(); - - $( - // We only want to record condition error messages in case it did not happened before - // Only the first partial match is recorded - if !$condition && event_message.is_empty() { - conditions_message.push( - format!( - " - The attribute {:?} = {:?} did not met the condition {:?}\n", - stringify!($attr), - $attr, - stringify!($condition) - ) - ); - } - current_event_meet_conditions &= $condition; - )* - - // Set the variable to latest matched event's condition evaluation result - meet_conditions = current_event_meet_conditions; - - // Set the index where we found a perfect match - if event_received && meet_conditions { - index_match = index; - break; - } else { - event_message.extend(conditions_message); - } - }, - _ => {} - } - } - - if event_received && !meet_conditions { - message.push( - format!( - "\n\n{}::\x1b[31m{}\x1b[0m was received but some of its attributes did not meet the conditions:\n{}", - stringify!($chain), - stringify!($event_pat), - event_message.concat() - ) - ); - } else if !event_received { - message.push( - format!( - "\n\n{}::\x1b[31m{}\x1b[0m was never received. All events:\n{:#?}", - stringify!($chain), - stringify!($event_pat), - <$chain as xcm_emulator::Chain>::events(), - ) - ); - } else { - // If we find a perfect match we remove the event to avoid being potentially assessed multiple times - events.remove(index_match); - } - )* - - if !message.is_empty() { - // Log events as they will not be logged after the panic - <$chain as xcm_emulator::Chain>::events().iter().for_each(|event| { - log::debug!(target: concat!("events::", stringify!($chain)), "{:?}", event); - }); - panic!("{}", message.concat()) - } - } -} diff --git a/runtime/dancebox/src/tests/common/xcm/force_core_buyer.rs b/runtime/dancebox/src/tests/common/xcm/force_core_buyer.rs index e0c10e39f..c7b8a880e 100644 --- a/runtime/dancebox/src/tests/common/xcm/force_core_buyer.rs +++ b/runtime/dancebox/src/tests/common/xcm/force_core_buyer.rs @@ -15,18 +15,15 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - core_buyer_common::*, - mocknets::{DanceboxRococoPara as Dancebox, RococoRelay as Rococo, RococoRelayPallet}, - *, - }, + crate::tests::common::xcm::{ + core_buyer_common::*, + mocknets::{DanceboxRococoPara as Dancebox, RococoRelay as Rococo, RococoRelayPallet}, + *, }, polkadot_runtime_parachains::on_demand as parachains_assigner_on_demand, staging_xcm::latest::{MaybeErrorCode, Response}, tp_traits::ParaId, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[test] diff --git a/runtime/dancebox/src/tests/common/xcm/foreign_signed_based_sovereign.rs b/runtime/dancebox/src/tests/common/xcm/foreign_signed_based_sovereign.rs index 05f4252d0..f5f90053f 100644 --- a/runtime/dancebox/src/tests/common/xcm/foreign_signed_based_sovereign.rs +++ b/runtime/dancebox/src/tests/common/xcm/foreign_signed_based_sovereign.rs @@ -16,7 +16,6 @@ use { crate::{ - assert_expected_events, tests::common::xcm::{ mocknets::{ DanceboxEmptyReceiver, DanceboxPara as Dancebox, DanceboxParaPallet, @@ -38,7 +37,7 @@ use { VersionedLocation, VersionedXcm, }, staging_xcm_executor::traits::ConvertLocation, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[test] diff --git a/runtime/dancebox/src/tests/common/xcm/foreign_sovereigns.rs b/runtime/dancebox/src/tests/common/xcm/foreign_sovereigns.rs index 5fd08df6f..b374970c8 100644 --- a/runtime/dancebox/src/tests/common/xcm/foreign_sovereigns.rs +++ b/runtime/dancebox/src/tests/common/xcm/foreign_sovereigns.rs @@ -15,17 +15,13 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, EthereumEmptyReceiver, - EthereumSender, FrontierTemplatePara as FrontierTemplate, - FrontierTemplateParaPallet, WestendEmptyReceiver, WestendRelay as Westend, - WestendRelayPallet, WestendSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, EthereumEmptyReceiver, EthereumSender, + FrontierTemplatePara as FrontierTemplate, FrontierTemplateParaPallet, + WestendEmptyReceiver, WestendRelay as Westend, WestendRelayPallet, WestendSender, }, + *, }, container_chain_template_frontier_runtime::currency::UNIT as FRONTIER_DEV, frame_support::{ @@ -38,7 +34,7 @@ use { }, staging_xcm_executor::traits::ConvertLocation, westend_runtime_constants::currency::UNITS as WND, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[test] diff --git a/runtime/dancebox/src/tests/common/xcm/mod.rs b/runtime/dancebox/src/tests/common/xcm/mod.rs index f83881475..d105c8d76 100644 --- a/runtime/dancebox/src/tests/common/xcm/mod.rs +++ b/runtime/dancebox/src/tests/common/xcm/mod.rs @@ -32,9 +32,6 @@ mod token_derivative_reception_relay_simple_container; mod transact; mod trap; -#[macro_use] -mod expected_event_checker; - pub use { paste, xcm_emulator::{bx, Parachain as Para, RelayChain as Relay, TestExt}, diff --git a/runtime/dancebox/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs b/runtime/dancebox/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs index 7a8fac12d..0391513ed 100644 --- a/runtime/dancebox/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs +++ b/runtime/dancebox/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs @@ -15,17 +15,14 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, - SimpleTemplateEmptyReceiver, SimpleTemplatePara as SimpleTemplate, - SimpleTemplateParaPallet, SimpleTemplateSender, WestendRelay as Westend, - WestendRelayPallet, WestendSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, + SimpleTemplateEmptyReceiver, SimpleTemplatePara as SimpleTemplate, + SimpleTemplateParaPallet, SimpleTemplateSender, WestendRelay as Westend, + WestendRelayPallet, WestendSender, }, + *, }, frame_support::{ assert_noop, assert_ok, @@ -37,7 +34,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_container_dancebox.rs b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_container_dancebox.rs index 00f7506b2..ac9b288d9 100644 --- a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_container_dancebox.rs +++ b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_container_dancebox.rs @@ -15,16 +15,12 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxReceiver, - SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, - SimpleTemplateSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxReceiver, + SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, SimpleTemplateSender, }, + *, }, frame_support::{ assert_ok, @@ -36,7 +32,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_frontier_container.rs b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_frontier_container.rs index 11db2ac5a..356a4fcf3 100644 --- a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_frontier_container.rs +++ b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_frontier_container.rs @@ -15,15 +15,12 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, EthereumReceiver, - FrontierTemplatePara as FrontierTemplate, FrontierTemplateParaPallet, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, EthereumReceiver, + FrontierTemplatePara as FrontierTemplate, FrontierTemplateParaPallet, }, + *, }, frame_support::{ assert_ok, @@ -35,7 +32,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_simple_container.rs b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_simple_container.rs index ee78f1344..923a574fe 100644 --- a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_simple_container.rs +++ b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_dancebox_simple_container.rs @@ -15,16 +15,12 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, - SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, - SimpleTemplateReceiver, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxSender, + SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, SimpleTemplateReceiver, }, + *, }, frame_support::{ assert_ok, @@ -36,7 +32,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_dancebox.rs b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_dancebox.rs index ff6e7a9b5..0c103bd99 100644 --- a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_dancebox.rs +++ b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_dancebox.rs @@ -15,15 +15,12 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxReceiver, - WestendRelay as Westend, WestendRelayPallet, WestendSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + DanceboxPara as Dancebox, DanceboxParaPallet, DanceboxReceiver, + WestendRelay as Westend, WestendRelayPallet, WestendSender, }, + *, }, frame_support::{ assert_ok, @@ -34,7 +31,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_frontier_container.rs b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_frontier_container.rs index 4ddc7b1f9..9da49a176 100644 --- a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_frontier_container.rs +++ b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_frontier_container.rs @@ -15,16 +15,12 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - EthereumReceiver, FrontierTemplatePara as FrontierTemplate, - FrontierTemplateParaPallet, WestendRelay as Westend, WestendRelayPallet, - WestendSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + EthereumReceiver, FrontierTemplatePara as FrontierTemplate, FrontierTemplateParaPallet, + WestendRelay as Westend, WestendRelayPallet, WestendSender, }, + *, }, frame_support::{ assert_ok, @@ -36,7 +32,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_simple_container.rs b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_simple_container.rs index 53e61ed38..b11dacb8f 100644 --- a/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_simple_container.rs +++ b/runtime/dancebox/src/tests/common/xcm/token_derivative_reception_relay_simple_container.rs @@ -15,15 +15,12 @@ // along with Tanssi. If not, see use { - crate::{ - assert_expected_events, - tests::common::xcm::{ - mocknets::{ - SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, - SimpleTemplateReceiver, WestendRelay as Westend, WestendRelayPallet, WestendSender, - }, - *, + crate::tests::common::xcm::{ + mocknets::{ + SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, SimpleTemplateReceiver, + WestendRelay as Westend, WestendRelayPallet, WestendSender, }, + *, }, frame_support::{ assert_ok, @@ -34,7 +31,7 @@ use { latest::prelude::{Junctions::*, *}, VersionedLocation, }, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[allow(unused_assignments)] diff --git a/runtime/dancebox/src/tests/common/xcm/transact.rs b/runtime/dancebox/src/tests/common/xcm/transact.rs index 2f86f17e5..df2f1e12a 100644 --- a/runtime/dancebox/src/tests/common/xcm/transact.rs +++ b/runtime/dancebox/src/tests/common/xcm/transact.rs @@ -17,13 +17,10 @@ use crate::tests::common::xcm::*; use { - crate::{ - assert_expected_events, - tests::common::xcm::mocknets::{ - DanceboxPara as Dancebox, FrontierTemplatePara as FrontierTemplate, - FrontierTemplateParaPallet, SimpleTemplatePara as SimpleTemplate, - SimpleTemplateParaPallet, WestendRelay as Westend, WestendRelayPallet, - }, + crate::tests::common::xcm::mocknets::{ + DanceboxPara as Dancebox, FrontierTemplatePara as FrontierTemplate, + FrontierTemplateParaPallet, SimpleTemplatePara as SimpleTemplate, SimpleTemplateParaPallet, + WestendRelay as Westend, WestendRelayPallet, }, frame_support::{ assert_ok, @@ -36,7 +33,7 @@ use { }, staging_xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia}, staging_xcm_executor::traits::ConvertLocation, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[test] diff --git a/runtime/dancebox/src/tests/common/xcm/trap.rs b/runtime/dancebox/src/tests/common/xcm/trap.rs index dbee80210..01fc7ea6e 100644 --- a/runtime/dancebox/src/tests/common/xcm/trap.rs +++ b/runtime/dancebox/src/tests/common/xcm/trap.rs @@ -17,18 +17,15 @@ use crate::tests::common::xcm::*; use { - crate::{ - assert_expected_events, - tests::common::xcm::mocknets::{ - DanceboxPara as Dancebox, WestendRelay as Westend, WestendRelayPallet, - }, + crate::tests::common::xcm::mocknets::{ + DanceboxPara as Dancebox, WestendRelay as Westend, WestendRelayPallet, }, frame_support::{ assert_ok, weights::{Weight, WeightToFee}, }, staging_xcm::{latest::prelude::*, VersionedLocation, VersionedXcm}, - xcm_emulator::Chain, + xcm_emulator::{assert_expected_events, Chain}, }; #[test] diff --git a/runtime/dancebox/src/xcm_config.rs b/runtime/dancebox/src/xcm_config.rs index 3b2eb66fe..8be85851d 100644 --- a/runtime/dancebox/src/xcm_config.rs +++ b/runtime/dancebox/src/xcm_config.rs @@ -63,6 +63,7 @@ use { }, staging_xcm_executor::{traits::JustTry, XcmExecutor}, tp_traits::ParathreadParams, + tp_xcm_commons::NativeAssetReserve, }; parameter_types! { @@ -391,63 +392,6 @@ pub type AssetRateAsMultiplier = ForeignAssetsInstance, >; -// TODO: this should probably move to somewhere in the polkadot-sdk repo -pub struct NativeAssetReserve; -impl frame_support::traits::ContainsPair for NativeAssetReserve { - fn contains(asset: &Asset, origin: &Location) -> bool { - log::trace!(target: "xcm::contains", "NativeAssetReserve asset: {:?}, origin: {:?}", asset, origin); - let reserve = if asset.id.0.parents == 0 - && !matches!(asset.id.0.first_interior(), Some(Parachain(_))) - { - Some(Location::here()) - } else { - asset.id.0.chain_part() - }; - - if let Some(ref reserve) = reserve { - if reserve == origin { - return true; - } - } - false - } -} - -pub trait Parse { - /// Returns the "chain" location part. It could be parent, sibling - /// parachain, or child parachain. - fn chain_part(&self) -> Option; - /// Returns "non-chain" location part. - fn non_chain_part(&self) -> Option; -} - -impl Parse for Location { - fn chain_part(&self) -> Option { - match (self.parents, self.first_interior()) { - // sibling parachain - (1, Some(Parachain(id))) => Some(Location::new(1, [Parachain(*id)])), - // parent - (1, _) => Some(Location::parent()), - // children parachain - (0, Some(Parachain(id))) => Some(Location::new(0, [Parachain(*id)])), - _ => None, - } - } - - fn non_chain_part(&self) -> Option { - let mut junctions = self.interior().clone(); - while matches!(junctions.first(), Some(Parachain(_))) { - let _ = junctions.take_first(); - } - - if junctions != Here { - Some(Location::new(0, junctions)) - } else { - None - } - } -} - parameter_types! { pub MessageQueueServiceWeight: Weight = Perbill::from_percent(25) * RuntimeBlockWeights::get().max_block; } diff --git a/solo-chains/runtime/dancelight/Cargo.toml b/solo-chains/runtime/dancelight/Cargo.toml index 80b2df3ee..99f67ff8b 100644 --- a/solo-chains/runtime/dancelight/Cargo.toml +++ b/solo-chains/runtime/dancelight/Cargo.toml @@ -129,6 +129,7 @@ dp-consensus = { workspace = true } dp-container-chain-genesis-data = { workspace = true } tp-author-noting-inherent = { workspace = true } tp-traits = { workspace = true } +tp-xcm-commons = { workspace = true } pallet-author-noting = { workspace = true } pallet-author-noting-runtime-api = { workspace = true } @@ -158,11 +159,17 @@ tp-bridge = { workspace = true } [dev-dependencies] alloy-sol-types = { workspace = true, default-features = true } +container-chain-template-frontier-runtime = { workspace = true, features = [ "std" ] } +container-chain-template-simple-runtime = { workspace = true, features = [ "std" ] } +emulated-integration-tests-common = { workspace = true } finality-grandpa = { workspace = true, default-features = true, features = [ "derive-codec" ] } keyring = { workspace = true } milagro-bls = { workspace = true, features = [ "std" ] } rand = { workspace = true, features = [ "std", "std_rng" ] } remote-externalities = { workspace = true } +rococo-runtime = { workspace = true } +rococo-runtime-constants = { workspace = true } +sc-consensus-grandpa = { workspace = true } separator = { workspace = true } serde_json = { workspace = true } sp-tracing = { workspace = true } @@ -170,6 +177,9 @@ sp-trie = { workspace = true } test-relay-sproof-builder = { workspace = true } tiny-keccak = { workspace = true } tokio = { workspace = true, features = [ "macros" ] } +westend-runtime = { workspace = true } +westend-runtime-constants = { workspace = true } +xcm-emulator = { workspace = true } [build-dependencies] substrate-wasm-builder = { workspace = true, optional = true } @@ -183,6 +193,8 @@ std = [ "binary-merkle-tree/std", "bitvec/std", "block-builder-api/std", + "container-chain-template-frontier-runtime/std", + "container-chain-template-simple-runtime/std", "cumulus-pallet-parachain-system/std", "cumulus-primitives-core/std", "dancelight-runtime-constants/std", @@ -265,6 +277,8 @@ std = [ "polkadot-parachain-primitives/std", "primitives/std", "rand/std", + "rococo-runtime-constants/std", + "rococo-runtime/std", "runtime-common/std", "runtime-parachains/std", "scale-info/std", @@ -304,7 +318,10 @@ std = [ "tp-author-noting-inherent/std", "tp-bridge/std", "tp-traits/std", + "tp-xcm-commons/std", "tx-pool-api/std", + "westend-runtime-constants/std", + "westend-runtime/std", "xcm-builder/std", "xcm-executor/std", "xcm-runtime-apis/std", @@ -313,6 +330,8 @@ std = [ no_std = [] runtime-benchmarks = [ + "container-chain-template-frontier-runtime/runtime-benchmarks", + "container-chain-template-simple-runtime/runtime-benchmarks", "cumulus-pallet-parachain-system/runtime-benchmarks", "cumulus-primitives-core/runtime-benchmarks", "dp-consensus/runtime-benchmarks", @@ -368,6 +387,7 @@ runtime-benchmarks = [ "pallet-xcm/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", "primitives/runtime-benchmarks", + "rococo-runtime/runtime-benchmarks", "runtime-common/runtime-benchmarks", "runtime-parachains/runtime-benchmarks", "snowbridge-core/runtime-benchmarks", @@ -383,11 +403,14 @@ runtime-benchmarks = [ "tanssi-runtime-common/runtime-benchmarks", "tp-bridge/runtime-benchmarks", "tp-traits/runtime-benchmarks", + "westend-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ + "container-chain-template-frontier-runtime/try-runtime", + "container-chain-template-simple-runtime/try-runtime", "cumulus-pallet-parachain-system/try-runtime", "frame-executive/try-runtime", "frame-support/try-runtime", @@ -447,6 +470,7 @@ try-runtime = [ "pallet-utility/try-runtime", "pallet-whitelist/try-runtime", "pallet-xcm/try-runtime", + "rococo-runtime/try-runtime", "runtime-common/try-runtime", "runtime-parachains/try-runtime", "snowbridge-pallet-ethereum-client/try-runtime", @@ -455,6 +479,7 @@ try-runtime = [ "snowbridge-pallet-system/try-runtime", "sp-runtime/try-runtime", "tanssi-runtime-common/try-runtime", + "westend-runtime/try-runtime", ] # Set timing constants (e.g. session period) to faster versions to speed up testing. diff --git a/solo-chains/runtime/dancelight/src/tests/common/mod.rs b/solo-chains/runtime/dancelight/src/tests/common/mod.rs index fbb9d068b..c29deae89 100644 --- a/solo-chains/runtime/dancelight/src/tests/common/mod.rs +++ b/solo-chains/runtime/dancelight/src/tests/common/mod.rs @@ -57,6 +57,8 @@ use { test_relay_sproof_builder::ParaHeaderSproofBuilder, }; +mod xcm; + pub use crate::{ genesis_config_presets::get_authority_keys_from_seed, AccountId, AuthorNoting, Babe, Balance, Balances, Beefy, BeefyMmrLeaf, ContainerRegistrar, DataPreservers, Grandpa, InflationRewards, @@ -329,6 +331,7 @@ pub struct ExtBuilder { own_para_id: Option, next_free_para_id: ParaId, keystore: Option, + safe_xcm_version: Option, } impl Default for ExtBuilder { @@ -358,6 +361,7 @@ impl Default for ExtBuilder { own_para_id: Default::default(), next_free_para_id: Default::default(), keystore: None, + safe_xcm_version: Default::default(), } } } @@ -428,6 +432,11 @@ impl ExtBuilder { self } + pub fn with_safe_xcm_version(mut self, safe_xcm_version: u32) -> Self { + self.safe_xcm_version = Some(safe_xcm_version); + self + } + // Maybe change to with_collators_config? pub fn with_relay_config( mut self, @@ -548,6 +557,13 @@ impl ExtBuilder { .assimilate_storage(&mut t) .unwrap(); + pallet_xcm::GenesisConfig:: { + safe_xcm_version: self.safe_xcm_version, + ..Default::default() + } + .assimilate_storage(&mut t) + .unwrap(); + runtime_parachains::configuration::GenesisConfig:: { config: self.relay_config, } @@ -656,6 +672,13 @@ impl ExtBuilder { pallet_sudo::GenesisConfig:: { key: self.sudo } .assimilate_storage(&mut t) .unwrap(); + + if self.safe_xcm_version.is_some() { + // Disable run_block checks in XCM tests, because the XCM emulator runs on_initialize and + // on_finalize automatically + t.top.insert(b"__mock_is_xcm_test".to_vec(), b"1".to_vec()); + } + t } diff --git a/solo-chains/runtime/dancelight/src/tests/common/xcm/constants.rs b/solo-chains/runtime/dancelight/src/tests/common/xcm/constants.rs new file mode 100644 index 000000000..858776c35 --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/common/xcm/constants.rs @@ -0,0 +1,415 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Tanssi is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Tanssi. If not, see +use { + babe_primitives::AuthorityId as BabeId, + beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId, + cumulus_primitives_core::relay_chain::{ + AccountId, AssignmentId, AuthorityDiscoveryId, ValidatorId, + }, + emulated_integration_tests_common::build_genesis_storage, + sc_consensus_grandpa::AuthorityId as GrandpaId, + sp_core::{sr25519, storage::Storage, Pair, Public}, + sp_runtime::{ + traits::{IdentifyAccount, Verify}, + MultiSignature, + }, +}; + +type AccountPublic = ::Signer; + +/// Helper function to generate a crypto pair from seed +fn get_from_seed(seed: &str) -> ::Public { + TPublic::Pair::from_string(&format!("//{}", seed), None) + .expect("static values are valid; qed") + .public() +} + +/// Helper function to generate an account ID from seed. +fn get_account_id_from_seed(seed: &str) -> AccountId +where + AccountPublic: From<::Public>, +{ + AccountPublic::from(get_from_seed::(seed)).into_account() +} + +/// Helper function to generate stash, controller and session key from seed +pub fn get_authority_keys_from_seed_no_beefy( + seed: &str, +) -> ( + AccountId, + AccountId, + BabeId, + GrandpaId, + ValidatorId, + AssignmentId, + AuthorityDiscoveryId, +) { + ( + get_account_id_from_seed::(&format!("{}//stash", seed)), + get_account_id_from_seed::(seed), + get_from_seed::(seed), + get_from_seed::(seed), + get_from_seed::(seed), + get_from_seed::(seed), + get_from_seed::(seed), + ) +} + +pub mod accounts { + use super::*; + pub const ALICE: &str = "Alice"; + pub const BOB: &str = "Bob"; + pub const CHARLIE: &str = "Charlie"; + pub const DAVE: &str = "Dave"; + pub const EVE: &str = "Eve"; + pub const FERDIE: &str = "Ferdei"; + pub const ALICE_STASH: &str = "Alice//stash"; + pub const BOB_STASH: &str = "Bob//stash"; + pub const CHARLIE_STASH: &str = "Charlie//stash"; + pub const DAVE_STASH: &str = "Dave//stash"; + pub const EVE_STASH: &str = "Eve//stash"; + pub const FERDIE_STASH: &str = "Ferdie//stash"; + pub const RANDOM: &str = "Random//stash"; + + pub fn init_balances() -> Vec { + vec![ + get_account_id_from_seed::(ALICE), + get_account_id_from_seed::(BOB), + get_account_id_from_seed::(CHARLIE), + get_account_id_from_seed::(DAVE), + get_account_id_from_seed::(EVE), + get_account_id_from_seed::(FERDIE), + get_account_id_from_seed::(ALICE_STASH), + get_account_id_from_seed::(BOB_STASH), + get_account_id_from_seed::(CHARLIE_STASH), + get_account_id_from_seed::(DAVE_STASH), + get_account_id_from_seed::(EVE_STASH), + get_account_id_from_seed::(FERDIE_STASH), + ] + } +} + +pub mod validators { + use super::*; + + pub fn initial_authorities() -> Vec<( + AccountId, + AccountId, + BabeId, + GrandpaId, + ValidatorId, + AssignmentId, + AuthorityDiscoveryId, + )> { + vec![get_authority_keys_from_seed_no_beefy("Alice")] + } +} + +// Westend +pub mod westend { + use { + super::*, cumulus_primitives_core::relay_chain::BlockNumber, + runtime_parachains::configuration::HostConfiguration, sp_runtime::Perbill, + westend_runtime_constants::currency::UNITS as WND, + }; + const ENDOWMENT: u128 = 1_000_000 * WND; + const STASH: u128 = 100 * WND; + + pub fn get_host_config() -> HostConfiguration { + HostConfiguration { + max_upward_queue_count: 10, + max_upward_queue_size: 51200, + max_upward_message_size: 51200, + max_upward_message_num_per_candidate: 10, + max_downward_message_size: 51200, + ..Default::default() + } + } + + fn session_keys( + babe: BabeId, + grandpa: GrandpaId, + para_validator: ValidatorId, + para_assignment: AssignmentId, + authority_discovery: AuthorityDiscoveryId, + beefy: BeefyId, + ) -> westend_runtime::SessionKeys { + westend_runtime::SessionKeys { + babe, + grandpa, + para_validator, + para_assignment, + authority_discovery, + beefy, + } + } + + pub fn genesis() -> Storage { + let genesis_config = westend_runtime::RuntimeGenesisConfig { + balances: westend_runtime::BalancesConfig { + balances: accounts::init_balances() + .iter() + .cloned() + .map(|k| (k, ENDOWMENT)) + .collect(), + }, + session: westend_runtime::SessionConfig { + keys: validators::initial_authorities() + .iter() + .map(|x| { + ( + x.0.clone(), + x.0.clone(), + westend::session_keys( + x.2.clone(), + x.3.clone(), + x.4.clone(), + x.5.clone(), + x.6.clone(), + get_from_seed::("Alice"), + ), + ) + }) + .collect::>(), + ..Default::default() + }, + staking: westend_runtime::StakingConfig { + validator_count: validators::initial_authorities().len() as u32, + minimum_validator_count: 1, + stakers: validators::initial_authorities() + .iter() + .map(|x| { + ( + x.0.clone(), + x.1.clone(), + STASH, + runtime_common::StakerStatus::Validator, + ) + }) + .collect(), + invulnerables: validators::initial_authorities() + .iter() + .map(|x| x.0.clone()) + .collect(), + force_era: pallet_staking::Forcing::ForceNone, + slash_reward_fraction: Perbill::from_percent(10), + ..Default::default() + }, + babe: westend_runtime::BabeConfig { + authorities: Default::default(), + epoch_config: westend_runtime::BABE_GENESIS_EPOCH_CONFIG, + ..Default::default() + }, + configuration: westend_runtime::ConfigurationConfig { + config: get_host_config(), + }, + ..Default::default() + }; + build_genesis_storage(&genesis_config, westend_runtime::WASM_BINARY.unwrap()) + } +} + +// Rococo +pub mod rococo { + use { + super::*, + cumulus_primitives_core::relay_chain::BlockNumber, + polkadot_parachain_primitives::primitives::ValidationCode, + rococo_runtime_constants::currency::UNITS as ROC, + runtime_parachains::{ + configuration::HostConfiguration, + paras::{ParaGenesisArgs, ParaKind}, + }, + }; + const ENDOWMENT: u128 = 1_000_000 * ROC; + + pub fn get_host_config() -> HostConfiguration { + HostConfiguration { + max_upward_queue_count: 10, + max_upward_queue_size: 51200, + max_upward_message_size: 51200, + max_upward_message_num_per_candidate: 10, + max_downward_message_size: 51200, + ..Default::default() + } + } + + fn session_keys( + babe: BabeId, + grandpa: GrandpaId, + para_validator: ValidatorId, + para_assignment: AssignmentId, + authority_discovery: AuthorityDiscoveryId, + beefy: BeefyId, + ) -> rococo_runtime::SessionKeys { + rococo_runtime::SessionKeys { + babe, + grandpa, + para_validator, + para_assignment, + authority_discovery, + beefy, + } + } + + pub fn genesis() -> Storage { + let genesis_config = rococo_runtime::RuntimeGenesisConfig { + balances: rococo_runtime::BalancesConfig { + balances: accounts::init_balances() + .iter() + .cloned() + .map(|k| (k, crate::tests::common::xcm::constants::rococo::ENDOWMENT)) + .collect(), + }, + session: rococo_runtime::SessionConfig { + keys: validators::initial_authorities() + .iter() + .map(|x| { + ( + x.0.clone(), + x.0.clone(), + crate::tests::common::xcm::constants::rococo::session_keys( + x.2.clone(), + x.3.clone(), + x.4.clone(), + x.5.clone(), + x.6.clone(), + get_from_seed::("Alice"), + ), + ) + }) + .collect::>(), + ..Default::default() + }, + babe: rococo_runtime::BabeConfig { + authorities: Default::default(), + epoch_config: rococo_runtime::BABE_GENESIS_EPOCH_CONFIG, + ..Default::default() + }, + configuration: rococo_runtime::ConfigurationConfig { + config: crate::tests::common::xcm::constants::rococo::get_host_config(), + }, + paras: rococo_runtime::ParasConfig { + _config: Default::default(), + paras: vec![( + 3333.into(), + ParaGenesisArgs { + genesis_head: Default::default(), + validation_code: ValidationCode(vec![1, 1, 2, 3, 4]), + para_kind: ParaKind::Parathread, + }, + )], + }, + ..Default::default() + }; + build_genesis_storage(&genesis_config, rococo_runtime::WASM_BINARY.unwrap()) + } +} + +// Frontier template +pub mod frontier_template { + use { + container_chain_template_frontier_runtime::AccountId, + emulated_integration_tests_common::build_genesis_storage, hex_literal::hex, + }; + pub const PARA_ID: u32 = 2001; + pub const ORCHESTRATOR: u32 = 2000; + + pub fn genesis() -> sp_core::storage::Storage { + let genesis_config = container_chain_template_frontier_runtime::RuntimeGenesisConfig { + system: Default::default(), + balances: container_chain_template_frontier_runtime::BalancesConfig { + balances: pre_funded_accounts() + .iter() + .cloned() + .map(|k| (k, 1 << 80)) + .collect(), + }, + parachain_info: container_chain_template_frontier_runtime::ParachainInfoConfig { + parachain_id: PARA_ID.into(), + ..Default::default() + }, + // EVM compatibility + // We should change this to something different than Moonbeam + // For now moonwall is very tailored for moonbeam so we need it for tests + evm_chain_id: container_chain_template_frontier_runtime::EVMChainIdConfig { + chain_id: 1281, + ..Default::default() + }, + sudo: container_chain_template_frontier_runtime::SudoConfig { + key: Some(pre_funded_accounts()[0]), + }, + authorities_noting: + container_chain_template_frontier_runtime::AuthoritiesNotingConfig { + orchestrator_para_id: ORCHESTRATOR.into(), + ..Default::default() + }, + ..Default::default() + }; + + build_genesis_storage( + &genesis_config, + container_chain_template_frontier_runtime::WASM_BINARY.unwrap(), + ) + } + /// Get pre-funded accounts + pub fn pre_funded_accounts() -> Vec { + // These addresses are derived from Substrate's canonical mnemonic: + // bottom drive obey lake curtain smoke basket hold race lonely fit walk + vec![ + AccountId::from(hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac")), // Alith + AccountId::from(hex!("3Cd0A705a2DC65e5b1E1205896BaA2be8A07c6e0")), // Baltathar + AccountId::from(hex!("798d4Ba9baf0064Ec19eB4F0a1a45785ae9D6DFc")), // Charleth + AccountId::from(hex!("773539d4Ac0e786233D90A233654ccEE26a613D9")), // Dorothy + ] + } +} + +// Simple template +pub mod simple_template { + use {super::*, container_chain_template_simple_runtime::UNIT as DEV}; + pub const PARA_ID: u32 = 2002; + pub const ORCHESTRATOR: u32 = 2000; + const ENDOWMENT: u128 = 1_000_000 * DEV; + + pub fn genesis() -> sp_core::storage::Storage { + let genesis_config = container_chain_template_simple_runtime::RuntimeGenesisConfig { + balances: container_chain_template_simple_runtime::BalancesConfig { + balances: accounts::init_balances() + .iter() + .cloned() + .map(|k| (k, ENDOWMENT)) + .collect(), + }, + parachain_info: container_chain_template_simple_runtime::ParachainInfoConfig { + parachain_id: PARA_ID.into(), + ..Default::default() + }, + sudo: container_chain_template_simple_runtime::SudoConfig { + key: Some(accounts::init_balances()[0].clone()), + }, + authorities_noting: container_chain_template_simple_runtime::AuthoritiesNotingConfig { + orchestrator_para_id: ORCHESTRATOR.into(), + ..Default::default() + }, + ..Default::default() + }; + build_genesis_storage( + &genesis_config, + container_chain_template_simple_runtime::WASM_BINARY.unwrap(), + ) + } +} diff --git a/solo-chains/runtime/dancelight/src/tests/common/xcm/mocknets.rs b/solo-chains/runtime/dancelight/src/tests/common/xcm/mocknets.rs new file mode 100644 index 000000000..e4d738069 --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/common/xcm/mocknets.rs @@ -0,0 +1,128 @@ +// 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 +pub use sp_core::Get; +use { + super::constants::{ + accounts::{ALICE, BOB, RANDOM}, + frontier_template, simple_template, + }, + crate::tests::common::ExtBuilder, + dancelight_runtime_constants::currency::UNITS as UNIT, + emulated_integration_tests_common::xcm_emulator::decl_test_parachains, + frame_support::parameter_types, + xcm_emulator::{decl_test_networks, decl_test_relay_chains, Chain}, +}; + +decl_test_relay_chains! { + #[api_version(11)] + pub struct Dancelight { + genesis = ExtBuilder::default() + .with_balances(vec![ + // Alice gets 10k extra tokens for her mapping deposit + (crate::AccountId::from(crate::tests::common::ALICE), 210_000 * UNIT), + (crate::AccountId::from(crate::tests::common::BOB), 100_000 * UNIT), + ]) + .with_relay_config(runtime_parachains::configuration::HostConfiguration { + max_downward_message_size: 1024 * 1024, + ..Default::default() + }) + .with_safe_xcm_version(3) + .build_storage(), + on_init = (), + runtime = crate, + core = { + SovereignAccountOf: crate::xcm_config::LocationConverter, + }, + pallets = { + System: crate::System, + Session: crate::Session, + Configuration: crate::Configuration, + Balances: crate::Balances, + Registrar: crate::Registrar, + ParasSudoWrapper: crate::ParasSudoWrapper, + OnDemandAssignmentProvider: crate::OnDemandAssignmentProvider, + XcmPallet: crate::XcmPallet, + Sudo: crate::Sudo, + } + } +} + +decl_test_parachains! { + // Dancelight parachains + pub struct FrontierTemplateDancelight { + genesis = frontier_template::genesis(), + on_init = (), + runtime = container_chain_template_frontier_runtime, + core = { + XcmpMessageHandler: container_chain_template_frontier_runtime::XcmpQueue, + LocationToAccountId: container_chain_template_frontier_runtime::xcm_config::LocationToAccountId, + ParachainInfo: container_chain_template_frontier_runtime::ParachainInfo, + MessageOrigin: cumulus_primitives_core::AggregateMessageOrigin, + }, + pallets = { + System: container_chain_template_frontier_runtime::System, + Balances: container_chain_template_frontier_runtime::Balances, + ParachainSystem: container_chain_template_frontier_runtime::ParachainSystem, + PolkadotXcm: container_chain_template_frontier_runtime::PolkadotXcm, + ForeignAssets: container_chain_template_frontier_runtime::ForeignAssets, + AssetRate: container_chain_template_frontier_runtime::AssetRate, + ForeignAssetsCreator: container_chain_template_frontier_runtime::ForeignAssetsCreator, + } + }, + pub struct SimpleTemplateDancelight { + genesis = simple_template::genesis(), + on_init = (), + runtime = container_chain_template_simple_runtime, + core = { + XcmpMessageHandler: container_chain_template_simple_runtime::XcmpQueue, + LocationToAccountId: container_chain_template_simple_runtime::xcm_config::LocationToAccountId, + ParachainInfo: container_chain_template_simple_runtime::ParachainInfo, + MessageOrigin: cumulus_primitives_core::AggregateMessageOrigin, + }, + pallets = { + System: container_chain_template_simple_runtime::System, + Balances: container_chain_template_simple_runtime::Balances, + ParachainSystem: container_chain_template_simple_runtime::ParachainSystem, + PolkadotXcm: container_chain_template_simple_runtime::PolkadotXcm, + ForeignAssets: container_chain_template_simple_runtime::ForeignAssets, + AssetRate: container_chain_template_simple_runtime::AssetRate, + ForeignAssetsCreator: container_chain_template_simple_runtime::ForeignAssetsCreator, + } + } +} + +decl_test_networks! { + pub struct DancelightMockNet { + relay_chain = Dancelight, + parachains = vec![ + FrontierTemplateDancelight, + SimpleTemplateDancelight, + ], + bridge = () + } +} + +parameter_types! { + // Dancelight + pub DancelightSender: crate::AccountId = crate::AccountId::from(crate::tests::common::ALICE); + pub DancelightReceiver: crate::AccountId = crate::AccountId::from(crate::tests::common::BOB); + pub DancelightEmptyReceiver: crate::AccountId = DancelightRelay::account_id_of(RANDOM); + + // SimpleTemplate + pub SimpleTemplateDancelightSender: container_chain_template_simple_runtime::AccountId = SimpleTemplateDancelightPara::account_id_of(ALICE); + pub SimpleTemplateDancelightReceiver: container_chain_template_simple_runtime::AccountId = SimpleTemplateDancelightPara::account_id_of(BOB); + pub SimpleTemplateDancelightEmptyReceiver: container_chain_template_simple_runtime::AccountId = SimpleTemplateDancelightPara::account_id_of(RANDOM); +} diff --git a/solo-chains/runtime/dancelight/src/tests/common/xcm/mod.rs b/solo-chains/runtime/dancelight/src/tests/common/xcm/mod.rs new file mode 100644 index 000000000..f19b25444 --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/common/xcm/mod.rs @@ -0,0 +1,20 @@ +// 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 + +mod constants; +mod mocknets; +mod reserver_transfers_polkadot_xcm; +pub use xcm_emulator::{bx, TestExt}; diff --git a/solo-chains/runtime/dancelight/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs b/solo-chains/runtime/dancelight/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs new file mode 100644 index 000000000..fe98c8670 --- /dev/null +++ b/solo-chains/runtime/dancelight/src/tests/common/xcm/reserver_transfers_polkadot_xcm.rs @@ -0,0 +1,153 @@ +// Copyright (C) Moondance Labs Ltd. +// This file is part of Tanssi. + +// Tanssi is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Tanssi is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Tanssi. If not, see + +use { + crate::tests::common::xcm::{ + mocknets::{ + DancelightRelay as Dancelight, DancelightSender, + SimpleTemplateDancelightEmptyReceiver as SimpleTemplateEmptyReceiver, + SimpleTemplateDancelightPara as SimpleTemplateDancelight, + }, + *, + }, + frame_support::{ + assert_ok, + weights::{Weight, WeightToFee}, + }, + mocknets::{DancelightRelayPallet, SimpleTemplateDancelightParaPallet}, + sp_runtime::FixedU128, + xcm::{ + latest::prelude::{Junctions::*, *}, + VersionedLocation, + }, + xcm_emulator::{assert_expected_events, Chain}, +}; + +#[allow(unused_assignments)] +#[test] +fn transfer_assets_from_dancelight_to_one_of_its_parachains() { + // Dancelight origin (sender) + let dancelight_alice_origin = + ::RuntimeOrigin::signed(DancelightSender::get()); + + // Destination location from the dancelight relay viewpoint + let simple_template_dest: VersionedLocation = Location { + parents: 0, + interior: X1([Parachain(constants::simple_template::PARA_ID)].into()), + } + .into(); + + // Beneficiary location from the simple template parachain viewpoint + let simple_template_beneficiary: VersionedLocation = Location { + parents: 0, + interior: X1([AccountId32 { + network: None, + id: SimpleTemplateEmptyReceiver::get().into(), + }] + .into()), + } + .into(); + + let amount_to_send: crate::Balance = crate::ExistentialDeposit::get() * 1000; + + // Asset located in Dancelight relay + let assets: Assets = (Here, amount_to_send).into(); + let fee_asset_item = 0; + let dancelight_token_asset_id = 1u16; + + // Register the asset first in simple template chain + SimpleTemplateDancelight::execute_with(|| { + let root_origin = ::RuntimeOrigin::root(); + + // Create foreign asset from relay chain + assert_ok!( + ::ForeignAssetsCreator::create_foreign_asset( + root_origin.clone(), + Location { + parents: 1, + interior: Here, + }, + dancelight_token_asset_id, + SimpleTemplateEmptyReceiver::get(), + true, + 1 + ) + ); + + // Create asset rate + assert_ok!( + ::AssetRate::create( + root_origin, + bx!(1), + FixedU128::from_u32(1) + ) + ); + }); + + // Send XCM transfer from Dancelight + Dancelight::execute_with(|| { + assert_ok!( + ::XcmPallet::limited_reserve_transfer_assets( + dancelight_alice_origin, + bx!(simple_template_dest), + bx!(simple_template_beneficiary), + bx!(assets.into()), + fee_asset_item, + WeightLimit::Unlimited, + ) + ); + }); + + // Verify token reception in Simple Template chain + SimpleTemplateDancelight::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + let mut outcome_weight = Weight::default(); + + // Check message processing + assert_expected_events!( + SimpleTemplateDancelight, + vec![ + RuntimeEvent::MessageQueue( + pallet_message_queue::Event::Processed { + success: true, + weight_used, + .. + }) => { + weight_used: { + outcome_weight = *weight_used; + weight_used.all_gte(Weight::from_parts(0,0)) + }, + }, + ] + ); + + type ForeignAssets = + ::ForeignAssets; + + // Calculate native balance based on weight + let native_balance = + container_chain_template_simple_runtime::WeightToFee::weight_to_fee(&outcome_weight); + + // Verify receiver's balance + assert_eq!( + >::balance( + dancelight_token_asset_id, + &SimpleTemplateEmptyReceiver::get(), + ), + amount_to_send - native_balance + ); + }); +} diff --git a/solo-chains/runtime/dancelight/src/xcm_config.rs b/solo-chains/runtime/dancelight/src/xcm_config.rs index ab38f8a6a..269a29500 100644 --- a/solo-chains/runtime/dancelight/src/xcm_config.rs +++ b/solo-chains/runtime/dancelight/src/xcm_config.rs @@ -37,6 +37,7 @@ use { ToAuthor, }, sp_core::ConstU32, + tp_xcm_commons::NativeAssetReserve, xcm::latest::prelude::*, xcm_builder::{ AccountId32Aliases, AllowExplicitUnpaidExecutionFrom, AllowKnownQueryResponses, @@ -136,20 +137,10 @@ parameter_types! { pub StarForBridgeHub: (AssetFilter, Location) = (Star::get(), BridgeHub::get()); pub StarForPeople: (AssetFilter, Location) = (Star::get(), People::get()); pub StarForBroker: (AssetFilter, Location) = (Star::get(), Broker::get()); + pub const RelayNetwork: NetworkId = NetworkId::Westend; pub const MaxInstructions: u32 = 100; pub const MaxAssetsIntoHolding: u32 = 64; } -pub type TrustedTeleporters = ( - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, - xcm_builder::Case, -); pub struct OnlyParachains; impl Contains for OnlyParachains { @@ -187,7 +178,7 @@ pub type Barrier = TrailingSetTopicAsId<( /// Locations that will not be charged fees in the executor, neither for execution nor delivery. /// We only waive fees for system functions, which these locations represent. -pub type WaivedLocations = (SystemParachains, Equals, LocalPlurality); +pub type WaivedLocations = Equals; pub type XcmWeigher = FixedWeightBounds<(), RuntimeCall, MaxInstructions>; pub struct XcmConfig; @@ -196,8 +187,8 @@ impl xcm_executor::Config for XcmConfig { type XcmSender = XcmRouter; type AssetTransactor = LocalAssetTransactor; type OriginConverter = LocalOriginConverter; - type IsReserve = (); - type IsTeleporter = TrustedTeleporters; + type IsReserve = NativeAssetReserve; + type IsTeleporter = (); type UniversalLocation = UniversalLocation; type Barrier = Barrier; type Weigher = XcmWeigher; From e2da250f1e13a15f542fda98ba47b43c69438265 Mon Sep 17 00:00:00 2001 From: nanocryk <6422796+nanocryk@users.noreply.github.com> Date: Wed, 18 Dec 2024 16:02:22 +0100 Subject: [PATCH 6/6] Test operator from Ethereum bridge produces blocks (#785) * wip test operator produces blocks (not working) * properly fetch author * working test * simplify test * Add comment for key rotation Co-authored-by: girazoki --------- Co-authored-by: girazoki --- .../zombie_tanssi_relay_eth_bridge.json | 5 +++ test/moonwall.config.json | 5 +++ .../test_zombie_tanssi_relay_eth_bridge.ts | 33 ++++++++++++++++--- 3 files changed, 39 insertions(+), 4 deletions(-) diff --git a/test/configs/zombie_tanssi_relay_eth_bridge.json b/test/configs/zombie_tanssi_relay_eth_bridge.json index b7002f240..48c981d53 100644 --- a/test/configs/zombie_tanssi_relay_eth_bridge.json +++ b/test/configs/zombie_tanssi_relay_eth_bridge.json @@ -39,6 +39,11 @@ { "name": "bob", "validator": true + }, + { + "name": "charlie", + "ws_port": "9948", + "validator": true } ] }, diff --git a/test/moonwall.config.json b/test/moonwall.config.json index c446a77ba..57b30ecf3 100644 --- a/test/moonwall.config.json +++ b/test/moonwall.config.json @@ -859,6 +859,11 @@ "name": "Tanssi-relay", "type": "polkadotJs", "endpoints": ["ws://127.0.0.1:9947"] + }, + { + "name": "Tanssi-charlie", + "type": "polkadotJs", + "endpoints": ["ws://127.0.0.1:9948"] } ] }, diff --git a/test/suites/zombie_tanssi_relay_eth_bridge/test_zombie_tanssi_relay_eth_bridge.ts b/test/suites/zombie_tanssi_relay_eth_bridge/test_zombie_tanssi_relay_eth_bridge.ts index d747d93fd..708218b10 100644 --- a/test/suites/zombie_tanssi_relay_eth_bridge/test_zombie_tanssi_relay_eth_bridge.ts +++ b/test/suites/zombie_tanssi_relay_eth_bridge/test_zombie_tanssi_relay_eth_bridge.ts @@ -27,6 +27,7 @@ describeSuite({ foundationMethods: "zombie", testCases: function ({ it, context }) { let relayApi: ApiPromise; + let relayCharlieApi: ApiPromise; let ethereumNodeChildProcess; let relayerChildProcess; let alice; @@ -44,6 +45,8 @@ describeSuite({ const relayNetwork = relayApi.consts.system.version.specName.toString(); expect(relayNetwork, "Relay API incorrect").to.contain("dancelight"); + relayCharlieApi = context.polkadotJs("Tanssi-charlie"); + // //BeaconRelay const keyring = new Keyring({ type: "sr25519" }); alice = keyring.addFromUri("//Alice", { name: "Alice default" }); @@ -51,10 +54,11 @@ describeSuite({ const executionRelay = keyring.addFromUri("//ExecutionRelay", { name: "Execution relay default" }); // Operator keys - operatorAccount = keyring.addFromUri("//" + "Bob", { name: "COLLATOR" + " ACCOUNT" }); - operatorNimbusKey = keyring.addFromUri("//" + "COLLATOR_NIMBUS", { name: "COLLATOR" + " NIMBUS" }); - - await relayApi.tx.session.setKeys(u8aToHex(operatorNimbusKey), []).signAndSend(operatorAccount); + operatorAccount = keyring.addFromUri("//Charlie", { name: "Charlie default" }); + // We rotate the keys for charlie so that we have access to them from this test as well as the node + operatorNimbusKey = await relayCharlieApi.rpc.author.rotateKeys(); + console.log(`operatorNimbusKey: ${operatorNimbusKey}`); + await relayApi.tx.session.setKeys(operatorNimbusKey, []).signAndSend(operatorAccount); const fundingTxHash = await relayApi.tx.utility .batch([ @@ -182,6 +186,9 @@ describeSuite({ const externalValidatorsBefore = await relayApi.query.externalValidators.externalValidators(); + const sessionValidatorsBefore = await relayApi.query.session.validators(); + expect(!sessionValidatorsBefore.includes(operatorNimbusKey)); + const rawValidators = [ u8aToHex(operatorAccount.addressRaw), "0x7894567890123456789012345678901234567890123456789012345678901234", @@ -226,6 +233,24 @@ describeSuite({ }, }); + it({ + id: "T04", + title: "Operator produces blocks", + test: async function () { + for (let i = 0; i < 20; ++i) { + const latestBlockHash = await relayApi.rpc.chain.getBlockHash(); + const author = (await relayApi.derive.chain.getHeader(latestBlockHash)).author; + if (author == operatorAccount.address) { + return; + } + + await context.waitBlock(1, "Tanssi-relay"); + } + + expect.fail("operator didn't produce a block"); + }, + }); + afterAll(async () => { console.log("Cleaning up"); if (ethereumNodeChildProcess) {