From e2ab01d061070cf7a244b49eb671959092182a1d Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Thu, 25 Nov 2021 13:34:42 +0000 Subject: [PATCH] codegen: fix compact unnamed fields (#327) * codegen: fix compact unnamed fields * Fmt * Regenerate polkadot codegen example. * Ignore clippy for generated code * Limit the number of test threads * Revert "Limit the number of test threads" This reverts commit f1947dc659ee3ac4558ed86eff0d37af913a87ff. * Delete duplicate node_runtime metadata * Update node_runtime metadata * Update balances events --- codegen/src/types/tests.rs | 67 + codegen/src/types/type_def.rs | 7 +- tests/integration/codegen/mod.rs | 1 + tests/integration/codegen/polkadot.rs | 14929 ++++++++++++++++++++++++ tests/node_runtime.scale | Bin 301517 -> 0 bytes 5 files changed, 15003 insertions(+), 1 deletion(-) delete mode 100644 tests/node_runtime.scale diff --git a/codegen/src/types/tests.rs b/codegen/src/types/tests.rs index 94acde4684..dac5bf7c62 100644 --- a/codegen/src/types/tests.rs +++ b/codegen/src/types/tests.rs @@ -325,6 +325,73 @@ fn generate_enum() { ) } +#[test] +fn compact_fields() { + #[allow(unused)] + #[derive(TypeInfo)] + struct S { + #[codec(compact)] + a: u32, + } + + #[allow(unused)] + #[derive(TypeInfo)] + struct TupleStruct(#[codec(compact)] u32); + + #[allow(unused)] + #[derive(TypeInfo)] + enum E { + A { + #[codec(compact)] + a: u32, + }, + B(#[codec(compact)] u32), + } + + let mut registry = Registry::new(); + registry.register_type(&meta_type::()); + registry.register_type(&meta_type::()); + registry.register_type(&meta_type::()); + let portable_types: PortableRegistry = registry.into(); + + let type_gen = TypeGenerator::new( + &portable_types, + "root", + Default::default(), + Default::default(), + ); + let types = type_gen.generate_types_mod(); + let tests_mod = get_mod(&types, MOD_PATH).unwrap(); + + assert_eq!( + tests_mod.into_token_stream().to_string(), + quote! { + pub mod tests { + use super::root; + #[derive(::subxt::codec::Encode, ::subxt::codec::Decode)] + pub enum E { + # [codec (index = 0)] + A { + #[codec(compact)] + a: ::core::primitive::u32, + }, + # [codec (index = 1)] + B( #[codec(compact)] ::core::primitive::u32,), + } + + #[derive(::subxt::codec::Encode, ::subxt::codec::Decode)] + pub struct S { + #[codec(compact)] pub a: ::core::primitive::u32, + } + + #[derive(::subxt::codec::Encode, ::subxt::codec::Decode)] + pub struct TupleStruct(#[codec(compact)] pub ::core::primitive::u32,); + } + } + .to_string() + ) +} + #[test] fn generate_array_field() { #[allow(unused)] diff --git a/codegen/src/types/type_def.rs b/codegen/src/types/type_def.rs index 2c432b88fe..2ebd6351ff 100644 --- a/codegen/src/types/type_def.rs +++ b/codegen/src/types/type_def.rs @@ -279,7 +279,7 @@ impl<'a> TypeDefGen<'a> { let mut fields_tokens = type_paths .iter() .map(|(ty, ty_name)| { - match ty_name { + let field_type = match ty_name { Some(ty_name) => { let ty = ty_toks(ty_name, ty); if is_struct { @@ -291,6 +291,11 @@ impl<'a> TypeDefGen<'a> { None => { quote! { #ty } } + }; + if ty.is_compact() { + quote!( #[codec(compact)] #field_type ) + } else { + quote!( #field_type ) } }) .collect::>(); diff --git a/tests/integration/codegen/mod.rs b/tests/integration/codegen/mod.rs index 1120941d7c..aa1f6aa502 100644 --- a/tests/integration/codegen/mod.rs +++ b/tests/integration/codegen/mod.rs @@ -22,4 +22,5 @@ /// - run `polkadot --dev --tmp` node locally /// - `cargo run --release -p subxt-cli -- codegen | rustfmt --edition=2018 --emit=stdout > tests/integration/codegen/polkadot.rs` #[rustfmt::skip] +#[allow(clippy::all)] mod polkadot; diff --git a/tests/integration/codegen/polkadot.rs b/tests/integration/codegen/polkadot.rs index e69de29bb2..95ecb82005 100644 --- a/tests/integration/codegen/polkadot.rs +++ b/tests/integration/codegen/polkadot.rs @@ -0,0 +1,14929 @@ +#[allow(dead_code, unused_imports, non_camel_case_types)] +pub mod api { + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + System(system::Event), + #[codec(index = 3)] + Indices(indices::Event), + #[codec(index = 4)] + Balances(balances::Event), + #[codec(index = 7)] + Offences(offences::Event), + #[codec(index = 9)] + Session(session::Event), + #[codec(index = 10)] + Grandpa(grandpa::Event), + #[codec(index = 11)] + ImOnline(im_online::Event), + #[codec(index = 16)] + ParaInclusion(para_inclusion::Event), + #[codec(index = 19)] + Paras(paras::Event), + #[codec(index = 22)] + Ump(ump::Event), + #[codec(index = 23)] + Hrmp(hrmp::Event), + #[codec(index = 25)] + ParasDisputes(paras_disputes::Event), + #[codec(index = 26)] + Registrar(registrar::Event), + #[codec(index = 27)] + Auctions(auctions::Event), + #[codec(index = 28)] + Crowdloan(crowdloan::Event), + #[codec(index = 29)] + Slots(slots::Event), + #[codec(index = 31)] + Sudo(sudo::Event), + #[codec(index = 35)] + ValidatorManager(validator_manager::Event), + #[codec(index = 80)] + Collective(collective::Event), + #[codec(index = 81)] + Membership(membership::Event), + #[codec(index = 90)] + Utility(utility::Event), + #[codec(index = 91)] + Proxy(proxy::Event), + #[codec(index = 92)] + Multisig(multisig::Event), + #[codec(index = 99)] + XcmPallet(xcm_pallet::Event), + } + pub mod system { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct FillBlock { + pub ratio: runtime_types::sp_arithmetic::per_things::Perbill, + } + impl ::subxt::Call for FillBlock { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "fill_block"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Remark { + pub remark: ::std::vec::Vec<::core::primitive::u8>, + } + impl ::subxt::Call for Remark { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "remark"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHeapPages { + pub pages: ::core::primitive::u64, + } + impl ::subxt::Call for SetHeapPages { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "set_heap_pages"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetCode { + pub code: ::std::vec::Vec<::core::primitive::u8>, + } + impl ::subxt::Call for SetCode { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "set_code"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetCodeWithoutChecks { + pub code: ::std::vec::Vec<::core::primitive::u8>, + } + impl ::subxt::Call for SetCodeWithoutChecks { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "set_code_without_checks"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetChangesTrieConfig { + pub changes_trie_config: ::core::option::Option< + runtime_types::sp_core::changes_trie::ChangesTrieConfiguration, + >, + } + impl ::subxt::Call for SetChangesTrieConfig { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "set_changes_trie_config"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetStorage { + pub items: ::std::vec::Vec<( + ::std::vec::Vec<::core::primitive::u8>, + ::std::vec::Vec<::core::primitive::u8>, + )>, + } + impl ::subxt::Call for SetStorage { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "set_storage"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KillStorage { + pub keys: ::std::vec::Vec<::std::vec::Vec<::core::primitive::u8>>, + } + impl ::subxt::Call for KillStorage { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "kill_storage"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KillPrefix { + pub prefix: ::std::vec::Vec<::core::primitive::u8>, + pub subkeys: ::core::primitive::u32, + } + impl ::subxt::Call for KillPrefix { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "kill_prefix"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RemarkWithEvent { + pub remark: ::std::vec::Vec<::core::primitive::u8>, + } + impl ::subxt::Call for RemarkWithEvent { + const PALLET: &'static str = "System"; + const FUNCTION: &'static str = "remark_with_event"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn fill_block( + &self, + ratio: runtime_types::sp_arithmetic::per_things::Perbill, + ) -> ::subxt::SubmittableExtrinsic { + let call = FillBlock { ratio }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn remark( + &self, + remark: ::std::vec::Vec<::core::primitive::u8>, + ) -> ::subxt::SubmittableExtrinsic { + let call = Remark { remark }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_heap_pages( + &self, + pages: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetHeapPages { pages }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_code( + &self, + code: ::std::vec::Vec<::core::primitive::u8>, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetCode { code }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_code_without_checks( + &self, + code: ::std::vec::Vec<::core::primitive::u8>, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetCodeWithoutChecks { code }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_changes_trie_config( + &self, + changes_trie_config: ::core::option::Option< + runtime_types::sp_core::changes_trie::ChangesTrieConfiguration, + >, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetChangesTrieConfig { + changes_trie_config, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_storage( + &self, + items: ::std::vec::Vec<( + ::std::vec::Vec<::core::primitive::u8>, + ::std::vec::Vec<::core::primitive::u8>, + )>, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetStorage { items }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn kill_storage( + &self, + keys: ::std::vec::Vec<::std::vec::Vec<::core::primitive::u8>>, + ) -> ::subxt::SubmittableExtrinsic { + let call = KillStorage { keys }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn kill_prefix( + &self, + prefix: ::std::vec::Vec<::core::primitive::u8>, + subkeys: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = KillPrefix { prefix, subkeys }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn remark_with_event( + &self, + remark: ::std::vec::Vec<::core::primitive::u8>, + ) -> ::subxt::SubmittableExtrinsic { + let call = RemarkWithEvent { remark }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::frame_system::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ExtrinsicSuccess( + pub runtime_types::frame_support::weights::DispatchInfo, + ); + impl ::subxt::Event for ExtrinsicSuccess { + const PALLET: &'static str = "System"; + const EVENT: &'static str = "ExtrinsicSuccess"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ExtrinsicFailed( + pub runtime_types::sp_runtime::DispatchError, + pub runtime_types::frame_support::weights::DispatchInfo, + ); + impl ::subxt::Event for ExtrinsicFailed { + const PALLET: &'static str = "System"; + const EVENT: &'static str = "ExtrinsicFailed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CodeUpdated {} + impl ::subxt::Event for CodeUpdated { + const PALLET: &'static str = "System"; + const EVENT: &'static str = "CodeUpdated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewAccount(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::Event for NewAccount { + const PALLET: &'static str = "System"; + const EVENT: &'static str = "NewAccount"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KilledAccount(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::Event for KilledAccount { + const PALLET: &'static str = "System"; + const EVENT: &'static str = "KilledAccount"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Remarked( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::H256, + ); + impl ::subxt::Event for Remarked { + const PALLET: &'static str = "System"; + const EVENT: &'static str = "Remarked"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Account(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for Account { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "Account"; + type Value = runtime_types::frame_system::AccountInfo< + ::core::primitive::u32, + runtime_types::pallet_balances::AccountData<::core::primitive::u128>, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct ExtrinsicCount; + impl ::subxt::StorageEntry for ExtrinsicCount { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "ExtrinsicCount"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct BlockWeight; + impl ::subxt::StorageEntry for BlockWeight { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "BlockWeight"; + type Value = runtime_types::frame_support::weights::PerDispatchClass< + ::core::primitive::u64, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct AllExtrinsicsLen; + impl ::subxt::StorageEntry for AllExtrinsicsLen { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "AllExtrinsicsLen"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct BlockHash(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for BlockHash { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "BlockHash"; + type Value = ::subxt::sp_core::H256; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct ExtrinsicData(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for ExtrinsicData { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "ExtrinsicData"; + type Value = ::std::vec::Vec<::core::primitive::u8>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Number; + impl ::subxt::StorageEntry for Number { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "Number"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ParentHash; + impl ::subxt::StorageEntry for ParentHash { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "ParentHash"; + type Value = ::subxt::sp_core::H256; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Digest; + impl ::subxt::StorageEntry for Digest { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "Digest"; + type Value = runtime_types::sp_runtime::generic::digest::Digest< + ::subxt::sp_core::H256, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Events; + impl ::subxt::StorageEntry for Events { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "Events"; + type Value = ::std::vec::Vec< + runtime_types::frame_system::EventRecord< + runtime_types::rococo_runtime::Event, + ::subxt::sp_core::H256, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct EventCount; + impl ::subxt::StorageEntry for EventCount { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "EventCount"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct EventTopics(pub ::subxt::sp_core::H256); + impl ::subxt::StorageEntry for EventTopics { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "EventTopics"; + type Value = + ::std::vec::Vec<(::core::primitive::u32, ::core::primitive::u32)>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct LastRuntimeUpgrade; + impl ::subxt::StorageEntry for LastRuntimeUpgrade { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "LastRuntimeUpgrade"; + type Value = runtime_types::frame_system::LastRuntimeUpgradeInfo; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct UpgradedToU32RefCount; + impl ::subxt::StorageEntry for UpgradedToU32RefCount { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "UpgradedToU32RefCount"; + type Value = ::core::primitive::bool; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct UpgradedToTripleRefCount; + impl ::subxt::StorageEntry for UpgradedToTripleRefCount { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "UpgradedToTripleRefCount"; + type Value = ::core::primitive::bool; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ExecutionPhase; + impl ::subxt::StorageEntry for ExecutionPhase { + const PALLET: &'static str = "System"; + const STORAGE: &'static str = "ExecutionPhase"; + type Value = runtime_types::frame_system::Phase; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn account( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::frame_system::AccountInfo< + ::core::primitive::u32, + runtime_types::pallet_balances::AccountData< + ::core::primitive::u128, + >, + >, + ::subxt::Error, + > { + let entry = Account(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn account_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Account>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn extrinsic_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = ExtrinsicCount; + self.client.storage().fetch(&entry, hash).await + } + pub async fn block_weight( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::frame_support::weights::PerDispatchClass< + ::core::primitive::u64, + >, + ::subxt::Error, + > { + let entry = BlockWeight; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn all_extrinsics_len( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = AllExtrinsicsLen; + self.client.storage().fetch(&entry, hash).await + } + pub async fn block_hash( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::sp_core::H256, ::subxt::Error> + { + let entry = BlockHash(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn block_hash_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, BlockHash>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn extrinsic_data( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::core::primitive::u8>, + ::subxt::Error, + > { + let entry = ExtrinsicData(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn extrinsic_data_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ExtrinsicData>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn number( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = Number; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn parent_hash( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::sp_core::H256, ::subxt::Error> + { + let entry = ParentHash; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn digest( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::sp_runtime::generic::digest::Digest< + ::subxt::sp_core::H256, + >, + ::subxt::Error, + > { + let entry = Digest; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn events( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::frame_system::EventRecord< + runtime_types::rococo_runtime::Event, + ::subxt::sp_core::H256, + >, + >, + ::subxt::Error, + > { + let entry = Events; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn event_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = EventCount; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn event_topics( + &self, + _0: ::subxt::sp_core::H256, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<(::core::primitive::u32, ::core::primitive::u32)>, + ::subxt::Error, + > { + let entry = EventTopics(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn event_topics_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, EventTopics>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn last_runtime_upgrade( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::frame_system::LastRuntimeUpgradeInfo, + >, + ::subxt::Error, + > { + let entry = LastRuntimeUpgrade; + self.client.storage().fetch(&entry, hash).await + } + pub async fn upgraded_to_u32_ref_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::bool, ::subxt::Error> + { + let entry = UpgradedToU32RefCount; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn upgraded_to_triple_ref_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::bool, ::subxt::Error> + { + let entry = UpgradedToTripleRefCount; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn execution_phase( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option, + ::subxt::Error, + > { + let entry = ExecutionPhase; + self.client.storage().fetch(&entry, hash).await + } + } + } + } + pub mod babe { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReportEquivocation { + pub equivocation_proof: + runtime_types::sp_consensus_slots::EquivocationProof< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + runtime_types::sp_consensus_babe::app::Public, + >, + pub key_owner_proof: runtime_types::sp_session::MembershipProof, + } + impl ::subxt::Call for ReportEquivocation { + const PALLET: &'static str = "Babe"; + const FUNCTION: &'static str = "report_equivocation"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReportEquivocationUnsigned { + pub equivocation_proof: + runtime_types::sp_consensus_slots::EquivocationProof< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + runtime_types::sp_consensus_babe::app::Public, + >, + pub key_owner_proof: runtime_types::sp_session::MembershipProof, + } + impl ::subxt::Call for ReportEquivocationUnsigned { + const PALLET: &'static str = "Babe"; + const FUNCTION: &'static str = "report_equivocation_unsigned"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct PlanConfigChange { + pub config: + runtime_types::sp_consensus_babe::digests::NextConfigDescriptor, + } + impl ::subxt::Call for PlanConfigChange { + const PALLET: &'static str = "Babe"; + const FUNCTION: &'static str = "plan_config_change"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn report_equivocation( + &self, + equivocation_proof : runtime_types :: sp_consensus_slots :: EquivocationProof < runtime_types :: sp_runtime :: generic :: header :: Header < :: core :: primitive :: u32 , runtime_types :: sp_runtime :: traits :: BlakeTwo256 > , runtime_types :: sp_consensus_babe :: app :: Public >, + key_owner_proof: runtime_types::sp_session::MembershipProof, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ReportEquivocation { + equivocation_proof, + key_owner_proof, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn report_equivocation_unsigned( + &self, + equivocation_proof : runtime_types :: sp_consensus_slots :: EquivocationProof < runtime_types :: sp_runtime :: generic :: header :: Header < :: core :: primitive :: u32 , runtime_types :: sp_runtime :: traits :: BlakeTwo256 > , runtime_types :: sp_consensus_babe :: app :: Public >, + key_owner_proof: runtime_types::sp_session::MembershipProof, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ReportEquivocationUnsigned { + equivocation_proof, + key_owner_proof, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn plan_config_change( + &self, + config : runtime_types :: sp_consensus_babe :: digests :: NextConfigDescriptor, + ) -> ::subxt::SubmittableExtrinsic { + let call = PlanConfigChange { config }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub mod storage { + use super::runtime_types; + pub struct EpochIndex; + impl ::subxt::StorageEntry for EpochIndex { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "EpochIndex"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Authorities; + impl ::subxt::StorageEntry for Authorities { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "Authorities"; + type Value = runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < (runtime_types :: sp_consensus_babe :: app :: Public , :: core :: primitive :: u64 ,) > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct GenesisSlot; + impl ::subxt::StorageEntry for GenesisSlot { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "GenesisSlot"; + type Value = runtime_types::sp_consensus_slots::Slot; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct CurrentSlot; + impl ::subxt::StorageEntry for CurrentSlot { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "CurrentSlot"; + type Value = runtime_types::sp_consensus_slots::Slot; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Randomness; + impl ::subxt::StorageEntry for Randomness { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "Randomness"; + type Value = [::core::primitive::u8; 32usize]; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct PendingEpochConfigChange; + impl ::subxt::StorageEntry for PendingEpochConfigChange { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "PendingEpochConfigChange"; + type Value = + runtime_types::sp_consensus_babe::digests::NextConfigDescriptor; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextRandomness; + impl ::subxt::StorageEntry for NextRandomness { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "NextRandomness"; + type Value = [::core::primitive::u8; 32usize]; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextAuthorities; + impl ::subxt::StorageEntry for NextAuthorities { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "NextAuthorities"; + type Value = runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < (runtime_types :: sp_consensus_babe :: app :: Public , :: core :: primitive :: u64 ,) > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct SegmentIndex; + impl ::subxt::StorageEntry for SegmentIndex { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "SegmentIndex"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct UnderConstruction(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for UnderConstruction { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "UnderConstruction"; + type Value = + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + [::core::primitive::u8; 32usize], + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Initialized; + impl ::subxt::StorageEntry for Initialized { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "Initialized"; + type Value = ::core::option::Option<[::core::primitive::u8; 32usize]>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct AuthorVrfRandomness; + impl ::subxt::StorageEntry for AuthorVrfRandomness { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "AuthorVrfRandomness"; + type Value = ::core::option::Option<[::core::primitive::u8; 32usize]>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct EpochStart; + impl ::subxt::StorageEntry for EpochStart { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "EpochStart"; + type Value = (::core::primitive::u32, ::core::primitive::u32); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Lateness; + impl ::subxt::StorageEntry for Lateness { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "Lateness"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct EpochConfig; + impl ::subxt::StorageEntry for EpochConfig { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "EpochConfig"; + type Value = runtime_types::sp_consensus_babe::BabeEpochConfiguration; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextEpochConfig; + impl ::subxt::StorageEntry for NextEpochConfig { + const PALLET: &'static str = "Babe"; + const STORAGE: &'static str = "NextEpochConfig"; + type Value = runtime_types::sp_consensus_babe::BabeEpochConfiguration; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn epoch_index( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = EpochIndex; + self.client.storage().fetch_or_default(&entry, hash).await + } pub async fn authorities (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < (runtime_types :: sp_consensus_babe :: app :: Public , :: core :: primitive :: u64 ,) > , :: subxt :: Error >{ + let entry = Authorities; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn genesis_slot( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::sp_consensus_slots::Slot, + ::subxt::Error, + > { + let entry = GenesisSlot; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn current_slot( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::sp_consensus_slots::Slot, + ::subxt::Error, + > { + let entry = CurrentSlot; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn randomness( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + [::core::primitive::u8; 32usize], + ::subxt::Error, + > { + let entry = Randomness; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn pending_epoch_config_change( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::sp_consensus_babe::digests::NextConfigDescriptor, + >, + ::subxt::Error, + > { + let entry = PendingEpochConfigChange; + self.client.storage().fetch(&entry, hash).await + } + pub async fn next_randomness( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + [::core::primitive::u8; 32usize], + ::subxt::Error, + > { + let entry = NextRandomness; + self.client.storage().fetch_or_default(&entry, hash).await + } pub async fn next_authorities (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < (runtime_types :: sp_consensus_babe :: app :: Public , :: core :: primitive :: u64 ,) > , :: subxt :: Error >{ + let entry = NextAuthorities; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn segment_index( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = SegmentIndex; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn under_construction( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + [::core::primitive::u8; 32usize], + >, + ::subxt::Error, + > { + let entry = UnderConstruction(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn under_construction_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, UnderConstruction>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn initialized( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + ::core::option::Option<[::core::primitive::u8; 32usize]>, + >, + ::subxt::Error, + > { + let entry = Initialized; + self.client.storage().fetch(&entry, hash).await + } + pub async fn author_vrf_randomness( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<[::core::primitive::u8; 32usize]>, + ::subxt::Error, + > { + let entry = AuthorVrfRandomness; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn epoch_start( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + (::core::primitive::u32, ::core::primitive::u32), + ::subxt::Error, + > { + let entry = EpochStart; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn lateness( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = Lateness; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn epoch_config( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::sp_consensus_babe::BabeEpochConfiguration, + >, + ::subxt::Error, + > { + let entry = EpochConfig; + self.client.storage().fetch(&entry, hash).await + } + pub async fn next_epoch_config( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::sp_consensus_babe::BabeEpochConfiguration, + >, + ::subxt::Error, + > { + let entry = NextEpochConfig; + self.client.storage().fetch(&entry, hash).await + } + } + } + } + pub mod timestamp { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Set { + #[codec(compact)] + pub now: ::core::primitive::u64, + } + impl ::subxt::Call for Set { + const PALLET: &'static str = "Timestamp"; + const FUNCTION: &'static str = "set"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn set( + &self, + now: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic { + let call = Set { now }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub mod storage { + use super::runtime_types; + pub struct Now; + impl ::subxt::StorageEntry for Now { + const PALLET: &'static str = "Timestamp"; + const STORAGE: &'static str = "Now"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct DidUpdate; + impl ::subxt::StorageEntry for DidUpdate { + const PALLET: &'static str = "Timestamp"; + const STORAGE: &'static str = "DidUpdate"; + type Value = ::core::primitive::bool; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn now( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = Now; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn did_update( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::bool, ::subxt::Error> + { + let entry = DidUpdate; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod indices { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Claim { + pub index: ::core::primitive::u32, + } + impl ::subxt::Call for Claim { + const PALLET: &'static str = "Indices"; + const FUNCTION: &'static str = "claim"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Transfer { + pub new: ::subxt::sp_core::crypto::AccountId32, + pub index: ::core::primitive::u32, + } + impl ::subxt::Call for Transfer { + const PALLET: &'static str = "Indices"; + const FUNCTION: &'static str = "transfer"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Free { + pub index: ::core::primitive::u32, + } + impl ::subxt::Call for Free { + const PALLET: &'static str = "Indices"; + const FUNCTION: &'static str = "free"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceTransfer { + pub new: ::subxt::sp_core::crypto::AccountId32, + pub index: ::core::primitive::u32, + pub freeze: ::core::primitive::bool, + } + impl ::subxt::Call for ForceTransfer { + const PALLET: &'static str = "Indices"; + const FUNCTION: &'static str = "force_transfer"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Freeze { + pub index: ::core::primitive::u32, + } + impl ::subxt::Call for Freeze { + const PALLET: &'static str = "Indices"; + const FUNCTION: &'static str = "freeze"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn claim( + &self, + index: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Claim { index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn transfer( + &self, + new: ::subxt::sp_core::crypto::AccountId32, + index: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Transfer { new, index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn free( + &self, + index: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Free { index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_transfer( + &self, + new: ::subxt::sp_core::crypto::AccountId32, + index: ::core::primitive::u32, + freeze: ::core::primitive::bool, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceTransfer { new, index, freeze }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn freeze( + &self, + index: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Freeze { index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_indices::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct IndexAssigned( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for IndexAssigned { + const PALLET: &'static str = "Indices"; + const EVENT: &'static str = "IndexAssigned"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct IndexFreed(pub ::core::primitive::u32); + impl ::subxt::Event for IndexFreed { + const PALLET: &'static str = "Indices"; + const EVENT: &'static str = "IndexFreed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct IndexFrozen( + pub ::core::primitive::u32, + pub ::subxt::sp_core::crypto::AccountId32, + ); + impl ::subxt::Event for IndexFrozen { + const PALLET: &'static str = "Indices"; + const EVENT: &'static str = "IndexFrozen"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Accounts(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for Accounts { + const PALLET: &'static str = "Indices"; + const STORAGE: &'static str = "Accounts"; + type Value = ( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ::core::primitive::bool, + ); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn accounts( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ::core::primitive::bool, + )>, + ::subxt::Error, + > { + let entry = Accounts(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn accounts_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Accounts>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod balances { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Transfer { + pub dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + pub value: ::core::primitive::u128, + } + impl ::subxt::Call for Transfer { + const PALLET: &'static str = "Balances"; + const FUNCTION: &'static str = "transfer"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetBalance { + pub who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + pub new_free: ::core::primitive::u128, + #[codec(compact)] + pub new_reserved: ::core::primitive::u128, + } + impl ::subxt::Call for SetBalance { + const PALLET: &'static str = "Balances"; + const FUNCTION: &'static str = "set_balance"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceTransfer { + pub source: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + pub dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + pub value: ::core::primitive::u128, + } + impl ::subxt::Call for ForceTransfer { + const PALLET: &'static str = "Balances"; + const FUNCTION: &'static str = "force_transfer"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct TransferKeepAlive { + pub dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + pub value: ::core::primitive::u128, + } + impl ::subxt::Call for TransferKeepAlive { + const PALLET: &'static str = "Balances"; + const FUNCTION: &'static str = "transfer_keep_alive"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct TransferAll { + pub dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + pub keep_alive: ::core::primitive::bool, + } + impl ::subxt::Call for TransferAll { + const PALLET: &'static str = "Balances"; + const FUNCTION: &'static str = "transfer_all"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceUnreserve { + pub who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + pub amount: ::core::primitive::u128, + } + impl ::subxt::Call for ForceUnreserve { + const PALLET: &'static str = "Balances"; + const FUNCTION: &'static str = "force_unreserve"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn transfer( + &self, + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + value: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic { + let call = Transfer { dest, value }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_balance( + &self, + who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + new_free: ::core::primitive::u128, + new_reserved: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetBalance { + who, + new_free, + new_reserved, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_transfer( + &self, + source: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + value: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceTransfer { + source, + dest, + value, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn transfer_keep_alive( + &self, + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + value: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic { + let call = TransferKeepAlive { dest, value }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn transfer_all( + &self, + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + keep_alive: ::core::primitive::bool, + ) -> ::subxt::SubmittableExtrinsic { + let call = TransferAll { dest, keep_alive }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_unreserve( + &self, + who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + amount: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceUnreserve { who, amount }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_balances::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Endowed( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Endowed { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "Endowed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DustLost( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for DustLost { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "DustLost"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Transfer( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Transfer { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "Transfer"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BalanceSet( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for BalanceSet { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "BalanceSet"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Deposit( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Deposit { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "Deposit"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Reserved( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Reserved { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "Reserved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Unreserved( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Unreserved { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "Unreserved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReserveRepatriated( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + pub runtime_types::frame_support::traits::tokens::misc::BalanceStatus, + ); + impl ::subxt::Event for ReserveRepatriated { + const PALLET: &'static str = "Balances"; + const EVENT: &'static str = "ReserveRepatriated"; + } + } + pub mod storage { + use super::runtime_types; + pub struct TotalIssuance; + impl ::subxt::StorageEntry for TotalIssuance { + const PALLET: &'static str = "Balances"; + const STORAGE: &'static str = "TotalIssuance"; + type Value = ::core::primitive::u128; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Account(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for Account { + const PALLET: &'static str = "Balances"; + const STORAGE: &'static str = "Account"; + type Value = + runtime_types::pallet_balances::AccountData<::core::primitive::u128>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct Locks(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for Locks { + const PALLET: &'static str = "Balances"; + const STORAGE: &'static str = "Locks"; + type Value = runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < runtime_types :: pallet_balances :: BalanceLock < :: core :: primitive :: u128 > > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct Reserves(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for Reserves { + const PALLET: &'static str = "Balances"; + const STORAGE: &'static str = "Reserves"; + type Value = + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + runtime_types::pallet_balances::ReserveData< + [::core::primitive::u8; 8usize], + ::core::primitive::u128, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct StorageVersion; + impl ::subxt::StorageEntry for StorageVersion { + const PALLET: &'static str = "Balances"; + const STORAGE: &'static str = "StorageVersion"; + type Value = runtime_types::pallet_balances::Releases; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn total_issuance( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u128, ::subxt::Error> + { + let entry = TotalIssuance; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn account( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::pallet_balances::AccountData<::core::primitive::u128>, + ::subxt::Error, + > { + let entry = Account(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn account_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Account>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } pub async fn locks (& self , _0 : :: subxt :: sp_core :: crypto :: AccountId32 , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < runtime_types :: pallet_balances :: BalanceLock < :: core :: primitive :: u128 > > , :: subxt :: Error >{ + let entry = Locks(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn locks_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Locks>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + pub async fn reserves( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + runtime_types::pallet_balances::ReserveData< + [::core::primitive::u8; 8usize], + ::core::primitive::u128, + >, + >, + ::subxt::Error, + > { + let entry = Reserves(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn reserves_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Reserves>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn storage_version( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::pallet_balances::Releases, + ::subxt::Error, + > { + let entry = StorageVersion; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod transaction_payment { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub struct NextFeeMultiplier; + impl ::subxt::StorageEntry for NextFeeMultiplier { + const PALLET: &'static str = "TransactionPayment"; + const STORAGE: &'static str = "NextFeeMultiplier"; + type Value = runtime_types::sp_arithmetic::fixed_point::FixedU128; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageVersion; + impl ::subxt::StorageEntry for StorageVersion { + const PALLET: &'static str = "TransactionPayment"; + const STORAGE: &'static str = "StorageVersion"; + type Value = runtime_types::pallet_transaction_payment::Releases; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn next_fee_multiplier( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::sp_arithmetic::fixed_point::FixedU128, + ::subxt::Error, + > { + let entry = NextFeeMultiplier; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn storage_version( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::pallet_transaction_payment::Releases, + ::subxt::Error, + > { + let entry = StorageVersion; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod authorship { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetUncles { + pub new_uncles: ::std::vec::Vec< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + >, + } + impl ::subxt::Call for SetUncles { + const PALLET: &'static str = "Authorship"; + const FUNCTION: &'static str = "set_uncles"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn set_uncles( + &self, + new_uncles: ::std::vec::Vec< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + >, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetUncles { new_uncles }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub mod storage { + use super::runtime_types; + pub struct Uncles; + impl ::subxt::StorageEntry for Uncles { + const PALLET: &'static str = "Authorship"; + const STORAGE: &'static str = "Uncles"; + type Value = ::std::vec::Vec< + runtime_types::pallet_authorship::UncleEntryItem< + ::core::primitive::u32, + ::subxt::sp_core::H256, + ::subxt::sp_core::crypto::AccountId32, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Author; + impl ::subxt::StorageEntry for Author { + const PALLET: &'static str = "Authorship"; + const STORAGE: &'static str = "Author"; + type Value = ::subxt::sp_core::crypto::AccountId32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct DidSetUncles; + impl ::subxt::StorageEntry for DidSetUncles { + const PALLET: &'static str = "Authorship"; + const STORAGE: &'static str = "DidSetUncles"; + type Value = ::core::primitive::bool; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn uncles( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::pallet_authorship::UncleEntryItem< + ::core::primitive::u32, + ::subxt::sp_core::H256, + ::subxt::sp_core::crypto::AccountId32, + >, + >, + ::subxt::Error, + > { + let entry = Uncles; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn author( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = Author; + self.client.storage().fetch(&entry, hash).await + } + pub async fn did_set_uncles( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::bool, ::subxt::Error> + { + let entry = DidSetUncles; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod offences { + use super::runtime_types; + pub type Event = runtime_types::pallet_offences::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Offence( + pub [::core::primitive::u8; 16usize], + pub ::std::vec::Vec<::core::primitive::u8>, + ); + impl ::subxt::Event for Offence { + const PALLET: &'static str = "Offences"; + const EVENT: &'static str = "Offence"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Reports(pub ::subxt::sp_core::H256); + impl ::subxt::StorageEntry for Reports { + const PALLET: &'static str = "Offences"; + const STORAGE: &'static str = "Reports"; + type Value = runtime_types::sp_staking::offence::OffenceDetails< + ::subxt::sp_core::crypto::AccountId32, + (::subxt::sp_core::crypto::AccountId32, ()), + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct ConcurrentReportsIndex( + [::core::primitive::u8; 16usize], + ::std::vec::Vec<::core::primitive::u8>, + ); + impl ::subxt::StorageEntry for ConcurrentReportsIndex { + const PALLET: &'static str = "Offences"; + const STORAGE: &'static str = "ConcurrentReportsIndex"; + type Value = ::std::vec::Vec<::subxt::sp_core::H256>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Twox64Concat, + ), + ]) + } + } + pub struct ReportsByKindIndex(pub [::core::primitive::u8; 16usize]); + impl ::subxt::StorageEntry for ReportsByKindIndex { + const PALLET: &'static str = "Offences"; + const STORAGE: &'static str = "ReportsByKindIndex"; + type Value = ::std::vec::Vec<::core::primitive::u8>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn reports( + &self, + _0: ::subxt::sp_core::H256, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::sp_staking::offence::OffenceDetails< + ::subxt::sp_core::crypto::AccountId32, + (::subxt::sp_core::crypto::AccountId32, ()), + >, + >, + ::subxt::Error, + > { + let entry = Reports(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn reports_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Reports>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn concurrent_reports_index( + &self, + _0: [::core::primitive::u8; 16usize], + _1: ::std::vec::Vec<::core::primitive::u8>, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::subxt::sp_core::H256>, + ::subxt::Error, + > { + let entry = ConcurrentReportsIndex(_0, _1); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn concurrent_reports_index_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ConcurrentReportsIndex>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn reports_by_kind_index( + &self, + _0: [::core::primitive::u8; 16usize], + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::core::primitive::u8>, + ::subxt::Error, + > { + let entry = ReportsByKindIndex(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn reports_by_kind_index_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ReportsByKindIndex>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod historical { + use super::runtime_types; + } + pub mod session { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetKeys { + pub keys: runtime_types::rococo_runtime::SessionKeys, + pub proof: ::std::vec::Vec<::core::primitive::u8>, + } + impl ::subxt::Call for SetKeys { + const PALLET: &'static str = "Session"; + const FUNCTION: &'static str = "set_keys"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct PurgeKeys {} + impl ::subxt::Call for PurgeKeys { + const PALLET: &'static str = "Session"; + const FUNCTION: &'static str = "purge_keys"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn set_keys( + &self, + keys: runtime_types::rococo_runtime::SessionKeys, + proof: ::std::vec::Vec<::core::primitive::u8>, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetKeys { keys, proof }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn purge_keys(&self) -> ::subxt::SubmittableExtrinsic { + let call = PurgeKeys {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_session::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewSession(pub ::core::primitive::u32); + impl ::subxt::Event for NewSession { + const PALLET: &'static str = "Session"; + const EVENT: &'static str = "NewSession"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Validators; + impl ::subxt::StorageEntry for Validators { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "Validators"; + type Value = ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct CurrentIndex; + impl ::subxt::StorageEntry for CurrentIndex { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "CurrentIndex"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct QueuedChanged; + impl ::subxt::StorageEntry for QueuedChanged { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "QueuedChanged"; + type Value = ::core::primitive::bool; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct QueuedKeys; + impl ::subxt::StorageEntry for QueuedKeys { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "QueuedKeys"; + type Value = ::std::vec::Vec<( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::rococo_runtime::SessionKeys, + )>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct DisabledValidators; + impl ::subxt::StorageEntry for DisabledValidators { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "DisabledValidators"; + type Value = ::std::vec::Vec<::core::primitive::u32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextKeys(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for NextKeys { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "NextKeys"; + type Value = runtime_types::rococo_runtime::SessionKeys; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct KeyOwner( + runtime_types::sp_core::crypto::KeyTypeId, + ::std::vec::Vec<::core::primitive::u8>, + ); + impl ::subxt::StorageEntry for KeyOwner { + const PALLET: &'static str = "Session"; + const STORAGE: &'static str = "KeyOwner"; + type Value = ::subxt::sp_core::crypto::AccountId32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn validators( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = Validators; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn current_index( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = CurrentIndex; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn queued_changed( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::bool, ::subxt::Error> + { + let entry = QueuedChanged; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn queued_keys( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::rococo_runtime::SessionKeys, + )>, + ::subxt::Error, + > { + let entry = QueuedKeys; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn disabled_validators( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = DisabledValidators; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn next_keys( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option, + ::subxt::Error, + > { + let entry = NextKeys(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn next_keys_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, NextKeys>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn key_owner( + &self, + _0: runtime_types::sp_core::crypto::KeyTypeId, + _1: ::std::vec::Vec<::core::primitive::u8>, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = KeyOwner(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn key_owner_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, KeyOwner>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod grandpa { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReportEquivocation { + pub equivocation_proof: + runtime_types::sp_finality_grandpa::EquivocationProof< + ::subxt::sp_core::H256, + ::core::primitive::u32, + >, + pub key_owner_proof: runtime_types::sp_session::MembershipProof, + } + impl ::subxt::Call for ReportEquivocation { + const PALLET: &'static str = "Grandpa"; + const FUNCTION: &'static str = "report_equivocation"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReportEquivocationUnsigned { + pub equivocation_proof: + runtime_types::sp_finality_grandpa::EquivocationProof< + ::subxt::sp_core::H256, + ::core::primitive::u32, + >, + pub key_owner_proof: runtime_types::sp_session::MembershipProof, + } + impl ::subxt::Call for ReportEquivocationUnsigned { + const PALLET: &'static str = "Grandpa"; + const FUNCTION: &'static str = "report_equivocation_unsigned"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NoteStalled { + pub delay: ::core::primitive::u32, + pub best_finalized_block_number: ::core::primitive::u32, + } + impl ::subxt::Call for NoteStalled { + const PALLET: &'static str = "Grandpa"; + const FUNCTION: &'static str = "note_stalled"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn report_equivocation( + &self, + equivocation_proof : runtime_types :: sp_finality_grandpa :: EquivocationProof < :: subxt :: sp_core :: H256 , :: core :: primitive :: u32 >, + key_owner_proof: runtime_types::sp_session::MembershipProof, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ReportEquivocation { + equivocation_proof, + key_owner_proof, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn report_equivocation_unsigned( + &self, + equivocation_proof : runtime_types :: sp_finality_grandpa :: EquivocationProof < :: subxt :: sp_core :: H256 , :: core :: primitive :: u32 >, + key_owner_proof: runtime_types::sp_session::MembershipProof, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ReportEquivocationUnsigned { + equivocation_proof, + key_owner_proof, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn note_stalled( + &self, + delay: ::core::primitive::u32, + best_finalized_block_number: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = NoteStalled { + delay, + best_finalized_block_number, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_grandpa::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewAuthorities( + pub ::std::vec::Vec<( + runtime_types::sp_finality_grandpa::app::Public, + ::core::primitive::u64, + )>, + ); + impl ::subxt::Event for NewAuthorities { + const PALLET: &'static str = "Grandpa"; + const EVENT: &'static str = "NewAuthorities"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Paused {} + impl ::subxt::Event for Paused { + const PALLET: &'static str = "Grandpa"; + const EVENT: &'static str = "Paused"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Resumed {} + impl ::subxt::Event for Resumed { + const PALLET: &'static str = "Grandpa"; + const EVENT: &'static str = "Resumed"; + } + } + pub mod storage { + use super::runtime_types; + pub struct State; + impl ::subxt::StorageEntry for State { + const PALLET: &'static str = "Grandpa"; + const STORAGE: &'static str = "State"; + type Value = + runtime_types::pallet_grandpa::StoredState<::core::primitive::u32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct PendingChange; + impl ::subxt::StorageEntry for PendingChange { + const PALLET: &'static str = "Grandpa"; + const STORAGE: &'static str = "PendingChange"; + type Value = runtime_types::pallet_grandpa::StoredPendingChange< + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextForced; + impl ::subxt::StorageEntry for NextForced { + const PALLET: &'static str = "Grandpa"; + const STORAGE: &'static str = "NextForced"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Stalled; + impl ::subxt::StorageEntry for Stalled { + const PALLET: &'static str = "Grandpa"; + const STORAGE: &'static str = "Stalled"; + type Value = (::core::primitive::u32, ::core::primitive::u32); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct CurrentSetId; + impl ::subxt::StorageEntry for CurrentSetId { + const PALLET: &'static str = "Grandpa"; + const STORAGE: &'static str = "CurrentSetId"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct SetIdSession(pub ::core::primitive::u64); + impl ::subxt::StorageEntry for SetIdSession { + const PALLET: &'static str = "Grandpa"; + const STORAGE: &'static str = "SetIdSession"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn state( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::pallet_grandpa::StoredState<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = State; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn pending_change( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::pallet_grandpa::StoredPendingChange< + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = PendingChange; + self.client.storage().fetch(&entry, hash).await + } + pub async fn next_forced( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = NextForced; + self.client.storage().fetch(&entry, hash).await + } + pub async fn stalled( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<( + ::core::primitive::u32, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = Stalled; + self.client.storage().fetch(&entry, hash).await + } + pub async fn current_set_id( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = CurrentSetId; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn set_id_session( + &self, + _0: ::core::primitive::u64, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = SetIdSession(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn set_id_session_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, SetIdSession>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod im_online { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Heartbeat { + pub heartbeat: + runtime_types::pallet_im_online::Heartbeat<::core::primitive::u32>, + pub signature: + runtime_types::pallet_im_online::sr25519::app_sr25519::Signature, + } + impl ::subxt::Call for Heartbeat { + const PALLET: &'static str = "ImOnline"; + const FUNCTION: &'static str = "heartbeat"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn heartbeat( + &self, + heartbeat: runtime_types::pallet_im_online::Heartbeat< + ::core::primitive::u32, + >, + signature : runtime_types :: pallet_im_online :: sr25519 :: app_sr25519 :: Signature, + ) -> ::subxt::SubmittableExtrinsic { + let call = Heartbeat { + heartbeat, + signature, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_im_online::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HeartbeatReceived( + pub runtime_types::pallet_im_online::sr25519::app_sr25519::Public, + ); + impl ::subxt::Event for HeartbeatReceived { + const PALLET: &'static str = "ImOnline"; + const EVENT: &'static str = "HeartbeatReceived"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AllGood {} + impl ::subxt::Event for AllGood { + const PALLET: &'static str = "ImOnline"; + const EVENT: &'static str = "AllGood"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SomeOffline( + pub ::std::vec::Vec<(::subxt::sp_core::crypto::AccountId32, ())>, + ); + impl ::subxt::Event for SomeOffline { + const PALLET: &'static str = "ImOnline"; + const EVENT: &'static str = "SomeOffline"; + } + } + pub mod storage { + use super::runtime_types; + pub struct HeartbeatAfter; + impl ::subxt::StorageEntry for HeartbeatAfter { + const PALLET: &'static str = "ImOnline"; + const STORAGE: &'static str = "HeartbeatAfter"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Keys; + impl ::subxt::StorageEntry for Keys { + const PALLET: &'static str = "ImOnline"; + const STORAGE: &'static str = "Keys"; + type Value = runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < runtime_types :: pallet_im_online :: sr25519 :: app_sr25519 :: Public > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ReceivedHeartbeats(::core::primitive::u32, ::core::primitive::u32); + impl ::subxt::StorageEntry for ReceivedHeartbeats { + const PALLET: &'static str = "ImOnline"; + const STORAGE: &'static str = "ReceivedHeartbeats"; + type Value = runtime_types::frame_support::traits::misc::WrapperOpaque< + runtime_types::pallet_im_online::BoundedOpaqueNetworkState, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Twox64Concat, + ), + ]) + } + } + pub struct AuthoredBlocks( + ::core::primitive::u32, + ::subxt::sp_core::crypto::AccountId32, + ); + impl ::subxt::StorageEntry for AuthoredBlocks { + const PALLET: &'static str = "ImOnline"; + const STORAGE: &'static str = "AuthoredBlocks"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Twox64Concat, + ), + ]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn heartbeat_after( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = HeartbeatAfter; + self.client.storage().fetch_or_default(&entry, hash).await + } pub async fn keys (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < runtime_types :: pallet_im_online :: sr25519 :: app_sr25519 :: Public > , :: subxt :: Error >{ + let entry = Keys; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn received_heartbeats( + &self, + _0: ::core::primitive::u32, + _1: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::frame_support::traits::misc::WrapperOpaque< + runtime_types::pallet_im_online::BoundedOpaqueNetworkState, + >, + >, + ::subxt::Error, + > { + let entry = ReceivedHeartbeats(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn received_heartbeats_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ReceivedHeartbeats>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn authored_blocks( + &self, + _0: ::core::primitive::u32, + _1: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = AuthoredBlocks(_0, _1); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn authored_blocks_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, AuthoredBlocks>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod authority_discovery { + use super::runtime_types; + } + pub mod parachains_origin { + use super::runtime_types; + } + pub mod configuration { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetValidationUpgradeFrequency { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetValidationUpgradeFrequency { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_validation_upgrade_frequency"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetValidationUpgradeDelay { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetValidationUpgradeDelay { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_validation_upgrade_delay"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetCodeRetentionPeriod { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetCodeRetentionPeriod { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_code_retention_period"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxCodeSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxCodeSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_code_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxPovSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxPovSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_pov_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxHeadDataSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxHeadDataSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_head_data_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetParathreadCores { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetParathreadCores { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_parathread_cores"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetParathreadRetries { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetParathreadRetries { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_parathread_retries"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetGroupRotationFrequency { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetGroupRotationFrequency { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_group_rotation_frequency"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetChainAvailabilityPeriod { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetChainAvailabilityPeriod { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_chain_availability_period"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetThreadAvailabilityPeriod { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetThreadAvailabilityPeriod { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_thread_availability_period"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetSchedulingLookahead { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetSchedulingLookahead { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_scheduling_lookahead"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxValidatorsPerCore { + pub new: ::core::option::Option<::core::primitive::u32>, + } + impl ::subxt::Call for SetMaxValidatorsPerCore { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_validators_per_core"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxValidators { + pub new: ::core::option::Option<::core::primitive::u32>, + } + impl ::subxt::Call for SetMaxValidators { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_validators"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetDisputePeriod { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetDisputePeriod { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_dispute_period"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetDisputePostConclusionAcceptancePeriod { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetDisputePostConclusionAcceptancePeriod { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = + "set_dispute_post_conclusion_acceptance_period"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetDisputeMaxSpamSlots { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetDisputeMaxSpamSlots { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_dispute_max_spam_slots"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetDisputeConclusionByTimeOutPeriod { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetDisputeConclusionByTimeOutPeriod { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = + "set_dispute_conclusion_by_time_out_period"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetNoShowSlots { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetNoShowSlots { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_no_show_slots"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetNDelayTranches { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetNDelayTranches { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_n_delay_tranches"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetZerothDelayTrancheWidth { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetZerothDelayTrancheWidth { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_zeroth_delay_tranche_width"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetNeededApprovals { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetNeededApprovals { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_needed_approvals"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetRelayVrfModuloSamples { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetRelayVrfModuloSamples { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_relay_vrf_modulo_samples"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxUpwardQueueCount { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxUpwardQueueCount { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_upward_queue_count"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxUpwardQueueSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxUpwardQueueSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_upward_queue_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxDownwardMessageSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxDownwardMessageSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_downward_message_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetUmpServiceTotalWeight { + pub new: ::core::primitive::u64, + } + impl ::subxt::Call for SetUmpServiceTotalWeight { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_ump_service_total_weight"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxUpwardMessageSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxUpwardMessageSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_upward_message_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMaxUpwardMessageNumPerCandidate { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetMaxUpwardMessageNumPerCandidate { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_max_upward_message_num_per_candidate"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpOpenRequestTtl { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpOpenRequestTtl { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_open_request_ttl"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpSenderDeposit { + pub new: ::core::primitive::u128, + } + impl ::subxt::Call for SetHrmpSenderDeposit { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_sender_deposit"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpRecipientDeposit { + pub new: ::core::primitive::u128, + } + impl ::subxt::Call for SetHrmpRecipientDeposit { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_recipient_deposit"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpChannelMaxCapacity { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpChannelMaxCapacity { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_channel_max_capacity"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpChannelMaxTotalSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpChannelMaxTotalSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_channel_max_total_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpMaxParachainInboundChannels { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpMaxParachainInboundChannels { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_max_parachain_inbound_channels"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpMaxParathreadInboundChannels { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpMaxParathreadInboundChannels { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_max_parathread_inbound_channels"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpChannelMaxMessageSize { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpChannelMaxMessageSize { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_channel_max_message_size"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpMaxParachainOutboundChannels { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpMaxParachainOutboundChannels { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_max_parachain_outbound_channels"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpMaxParathreadOutboundChannels { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpMaxParathreadOutboundChannels { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = + "set_hrmp_max_parathread_outbound_channels"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetHrmpMaxMessageNumPerCandidate { + pub new: ::core::primitive::u32, + } + impl ::subxt::Call for SetHrmpMaxMessageNumPerCandidate { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_hrmp_max_message_num_per_candidate"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetUmpMaxIndividualWeight { + pub new: ::core::primitive::u64, + } + impl ::subxt::Call for SetUmpMaxIndividualWeight { + const PALLET: &'static str = "Configuration"; + const FUNCTION: &'static str = "set_ump_max_individual_weight"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn set_validation_upgrade_frequency( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetValidationUpgradeFrequency { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_validation_upgrade_delay( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetValidationUpgradeDelay { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_code_retention_period( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetCodeRetentionPeriod { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_code_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetMaxCodeSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_pov_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetMaxPovSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_head_data_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxHeadDataSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_parathread_cores( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetParathreadCores { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_parathread_retries( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetParathreadRetries { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_group_rotation_frequency( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetGroupRotationFrequency { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_chain_availability_period( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetChainAvailabilityPeriod { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_thread_availability_period( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetThreadAvailabilityPeriod { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_scheduling_lookahead( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetSchedulingLookahead { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_validators_per_core( + &self, + new: ::core::option::Option<::core::primitive::u32>, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxValidatorsPerCore { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_validators( + &self, + new: ::core::option::Option<::core::primitive::u32>, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetMaxValidators { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_dispute_period( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetDisputePeriod { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_dispute_post_conclusion_acceptance_period( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic< + T, + SetDisputePostConclusionAcceptancePeriod, + > { + let call = SetDisputePostConclusionAcceptancePeriod { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_dispute_max_spam_slots( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetDisputeMaxSpamSlots { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_dispute_conclusion_by_time_out_period( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetDisputeConclusionByTimeOutPeriod { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_no_show_slots( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetNoShowSlots { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_n_delay_tranches( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetNDelayTranches { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_zeroth_delay_tranche_width( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetZerothDelayTrancheWidth { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_needed_approvals( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetNeededApprovals { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_relay_vrf_modulo_samples( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetRelayVrfModuloSamples { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_upward_queue_count( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxUpwardQueueCount { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_upward_queue_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxUpwardQueueSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_downward_message_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxDownwardMessageSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_ump_service_total_weight( + &self, + new: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetUmpServiceTotalWeight { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_upward_message_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxUpwardMessageSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_max_upward_message_num_per_candidate( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetMaxUpwardMessageNumPerCandidate { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_open_request_ttl( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpOpenRequestTtl { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_sender_deposit( + &self, + new: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpSenderDeposit { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_recipient_deposit( + &self, + new: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpRecipientDeposit { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_channel_max_capacity( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpChannelMaxCapacity { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_channel_max_total_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpChannelMaxTotalSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_max_parachain_inbound_channels( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpMaxParachainInboundChannels { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_max_parathread_inbound_channels( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpMaxParathreadInboundChannels { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_channel_max_message_size( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpChannelMaxMessageSize { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_max_parachain_outbound_channels( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpMaxParachainOutboundChannels { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_max_parathread_outbound_channels( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpMaxParathreadOutboundChannels { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_hrmp_max_message_num_per_candidate( + &self, + new: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetHrmpMaxMessageNumPerCandidate { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_ump_max_individual_weight( + &self, + new: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SetUmpMaxIndividualWeight { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub mod storage { + use super::runtime_types; + pub struct ActiveConfig; + impl ::subxt::StorageEntry for ActiveConfig { + const PALLET: &'static str = "Configuration"; + const STORAGE: &'static str = "ActiveConfig"; + type Value = runtime_types :: polkadot_runtime_parachains :: configuration :: HostConfiguration < :: core :: primitive :: u32 > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct PendingConfig(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for PendingConfig { + const PALLET: &'static str = "Configuration"; + const STORAGE: &'static str = "PendingConfig"; + type Value = runtime_types :: polkadot_runtime_parachains :: configuration :: HostConfiguration < :: core :: primitive :: u32 > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } pub async fn active_config (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < runtime_types :: polkadot_runtime_parachains :: configuration :: HostConfiguration < :: core :: primitive :: u32 > , :: subxt :: Error >{ + let entry = ActiveConfig; + self.client.storage().fetch_or_default(&entry, hash).await + } pub async fn pending_config (& self , _0 : :: core :: primitive :: u32 , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: core :: option :: Option < runtime_types :: polkadot_runtime_parachains :: configuration :: HostConfiguration < :: core :: primitive :: u32 > > , :: subxt :: Error >{ + let entry = PendingConfig(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn pending_config_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, PendingConfig>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod paras_shared { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + } + } + pub mod storage { + use super::runtime_types; + pub struct CurrentSessionIndex; + impl ::subxt::StorageEntry for CurrentSessionIndex { + const PALLET: &'static str = "ParasShared"; + const STORAGE: &'static str = "CurrentSessionIndex"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ActiveValidatorIndices; + impl ::subxt::StorageEntry for ActiveValidatorIndices { + const PALLET: &'static str = "ParasShared"; + const STORAGE: &'static str = "ActiveValidatorIndices"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::ValidatorIndex, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ActiveValidatorKeys; + impl ::subxt::StorageEntry for ActiveValidatorKeys { + const PALLET: &'static str = "ParasShared"; + const STORAGE: &'static str = "ActiveValidatorKeys"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::validator_app::Public, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn current_session_index( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = CurrentSessionIndex; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn active_validator_indices( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::ValidatorIndex, + >, + ::subxt::Error, + > { + let entry = ActiveValidatorIndices; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn active_validator_keys( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::validator_app::Public, + >, + ::subxt::Error, + > { + let entry = ActiveValidatorKeys; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod para_inclusion { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + } + } + pub type Event = + runtime_types::polkadot_runtime_parachains::inclusion::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateBacked( + pub runtime_types::polkadot_primitives::v1::CandidateReceipt< + ::subxt::sp_core::H256, + >, + pub runtime_types::polkadot_parachain::primitives::HeadData, + pub runtime_types::polkadot_primitives::v1::CoreIndex, + pub runtime_types::polkadot_primitives::v1::GroupIndex, + ); + impl ::subxt::Event for CandidateBacked { + const PALLET: &'static str = "ParaInclusion"; + const EVENT: &'static str = "CandidateBacked"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateIncluded( + pub runtime_types::polkadot_primitives::v1::CandidateReceipt< + ::subxt::sp_core::H256, + >, + pub runtime_types::polkadot_parachain::primitives::HeadData, + pub runtime_types::polkadot_primitives::v1::CoreIndex, + pub runtime_types::polkadot_primitives::v1::GroupIndex, + ); + impl ::subxt::Event for CandidateIncluded { + const PALLET: &'static str = "ParaInclusion"; + const EVENT: &'static str = "CandidateIncluded"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateTimedOut( + pub runtime_types::polkadot_primitives::v1::CandidateReceipt< + ::subxt::sp_core::H256, + >, + pub runtime_types::polkadot_parachain::primitives::HeadData, + pub runtime_types::polkadot_primitives::v1::CoreIndex, + ); + impl ::subxt::Event for CandidateTimedOut { + const PALLET: &'static str = "ParaInclusion"; + const EVENT: &'static str = "CandidateTimedOut"; + } + } + pub mod storage { + use super::runtime_types; + pub struct AvailabilityBitfields( + pub runtime_types::polkadot_primitives::v0::ValidatorIndex, + ); + impl ::subxt::StorageEntry for AvailabilityBitfields { + const PALLET: &'static str = "ParaInclusion"; + const STORAGE: &'static str = "AvailabilityBitfields"; + type Value = runtime_types :: polkadot_runtime_parachains :: inclusion :: AvailabilityBitfieldRecord < :: core :: primitive :: u32 > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct PendingAvailability( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for PendingAvailability { + const PALLET: &'static str = "ParaInclusion"; + const STORAGE: &'static str = "PendingAvailability"; + type Value = runtime_types :: polkadot_runtime_parachains :: inclusion :: CandidatePendingAvailability < :: subxt :: sp_core :: H256 , :: core :: primitive :: u32 > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct PendingAvailabilityCommitments( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for PendingAvailabilityCommitments { + const PALLET: &'static str = "ParaInclusion"; + const STORAGE: &'static str = "PendingAvailabilityCommitments"; + type Value = runtime_types::polkadot_primitives::v1::CandidateCommitments< + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } pub async fn availability_bitfields (& self , _0 : runtime_types :: polkadot_primitives :: v0 :: ValidatorIndex , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: core :: option :: Option < runtime_types :: polkadot_runtime_parachains :: inclusion :: AvailabilityBitfieldRecord < :: core :: primitive :: u32 > > , :: subxt :: Error >{ + let entry = AvailabilityBitfields(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn availability_bitfields_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, AvailabilityBitfields>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } pub async fn pending_availability (& self , _0 : runtime_types :: polkadot_parachain :: primitives :: Id , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: core :: option :: Option < runtime_types :: polkadot_runtime_parachains :: inclusion :: CandidatePendingAvailability < :: subxt :: sp_core :: H256 , :: core :: primitive :: u32 > > , :: subxt :: Error >{ + let entry = PendingAvailability(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn pending_availability_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, PendingAvailability>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn pending_availability_commitments( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::CandidateCommitments< + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = PendingAvailabilityCommitments(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn pending_availability_commitments_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, PendingAvailabilityCommitments>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod para_inherent { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Enter { + pub data: runtime_types::polkadot_primitives::v1::InherentData< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + >, + } + impl ::subxt::Call for Enter { + const PALLET: &'static str = "ParaInherent"; + const FUNCTION: &'static str = "enter"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn enter( + &self, + data: runtime_types::polkadot_primitives::v1::InherentData< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + >, + ) -> ::subxt::SubmittableExtrinsic { + let call = Enter { data }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub mod storage { + use super::runtime_types; + pub struct Included; + impl ::subxt::StorageEntry for Included { + const PALLET: &'static str = "ParaInherent"; + const STORAGE: &'static str = "Included"; + type Value = (); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn included( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::option::Option<()>, ::subxt::Error> + { + let entry = Included; + self.client.storage().fetch(&entry, hash).await + } + } + } + } + pub mod para_scheduler { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub struct ValidatorGroups; + impl ::subxt::StorageEntry for ValidatorGroups { + const PALLET: &'static str = "ParaScheduler"; + const STORAGE: &'static str = "ValidatorGroups"; + type Value = ::std::vec::Vec< + ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::ValidatorIndex, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ParathreadQueue; + impl ::subxt::StorageEntry for ParathreadQueue { + const PALLET: &'static str = "ParaScheduler"; + const STORAGE: &'static str = "ParathreadQueue"; + type Value = runtime_types :: polkadot_runtime_parachains :: scheduler :: ParathreadClaimQueue ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct AvailabilityCores; + impl ::subxt::StorageEntry for AvailabilityCores { + const PALLET: &'static str = "ParaScheduler"; + const STORAGE: &'static str = "AvailabilityCores"; + type Value = ::std::vec::Vec< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::CoreOccupied, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ParathreadClaimIndex; + impl ::subxt::StorageEntry for ParathreadClaimIndex { + const PALLET: &'static str = "ParaScheduler"; + const STORAGE: &'static str = "ParathreadClaimIndex"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct SessionStartBlock; + impl ::subxt::StorageEntry for SessionStartBlock { + const PALLET: &'static str = "ParaScheduler"; + const STORAGE: &'static str = "SessionStartBlock"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Scheduled; + impl ::subxt::StorageEntry for Scheduled { + const PALLET: &'static str = "ParaScheduler"; + const STORAGE: &'static str = "Scheduled"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_runtime_parachains::scheduler::CoreAssignment, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn validator_groups( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::ValidatorIndex, + >, + >, + ::subxt::Error, + > { + let entry = ValidatorGroups; + self.client.storage().fetch_or_default(&entry, hash).await + } pub async fn parathread_queue (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < runtime_types :: polkadot_runtime_parachains :: scheduler :: ParathreadClaimQueue , :: subxt :: Error >{ + let entry = ParathreadQueue; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn availability_cores( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::CoreOccupied, + >, + >, + ::subxt::Error, + > { + let entry = AvailabilityCores; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn parathread_claim_index( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = ParathreadClaimIndex; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn session_start_block( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = SessionStartBlock; + self.client.storage().fetch_or_default(&entry, hash).await + } pub async fn scheduled (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: std :: vec :: Vec < runtime_types :: polkadot_runtime_parachains :: scheduler :: CoreAssignment > , :: subxt :: Error >{ + let entry = Scheduled; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod paras { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceSetCurrentCode { + pub para: runtime_types::polkadot_parachain::primitives::Id, + pub new_code: + runtime_types::polkadot_parachain::primitives::ValidationCode, + } + impl ::subxt::Call for ForceSetCurrentCode { + const PALLET: &'static str = "Paras"; + const FUNCTION: &'static str = "force_set_current_code"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceSetCurrentHead { + pub para: runtime_types::polkadot_parachain::primitives::Id, + pub new_head: runtime_types::polkadot_parachain::primitives::HeadData, + } + impl ::subxt::Call for ForceSetCurrentHead { + const PALLET: &'static str = "Paras"; + const FUNCTION: &'static str = "force_set_current_head"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceScheduleCodeUpgrade { + pub para: runtime_types::polkadot_parachain::primitives::Id, + pub new_code: + runtime_types::polkadot_parachain::primitives::ValidationCode, + pub relay_parent_number: ::core::primitive::u32, + } + impl ::subxt::Call for ForceScheduleCodeUpgrade { + const PALLET: &'static str = "Paras"; + const FUNCTION: &'static str = "force_schedule_code_upgrade"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceNoteNewHead { + pub para: runtime_types::polkadot_parachain::primitives::Id, + pub new_head: runtime_types::polkadot_parachain::primitives::HeadData, + } + impl ::subxt::Call for ForceNoteNewHead { + const PALLET: &'static str = "Paras"; + const FUNCTION: &'static str = "force_note_new_head"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceQueueAction { + pub para: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for ForceQueueAction { + const PALLET: &'static str = "Paras"; + const FUNCTION: &'static str = "force_queue_action"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn force_set_current_code( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + new_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceSetCurrentCode { para, new_code }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_set_current_head( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + new_head: runtime_types::polkadot_parachain::primitives::HeadData, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceSetCurrentHead { para, new_head }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_schedule_code_upgrade( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + new_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode, + relay_parent_number: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceScheduleCodeUpgrade { + para, + new_code, + relay_parent_number, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_note_new_head( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + new_head: runtime_types::polkadot_parachain::primitives::HeadData, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceNoteNewHead { para, new_head }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_queue_action( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceQueueAction { para }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::polkadot_runtime_parachains::paras::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CurrentCodeUpdated( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for CurrentCodeUpdated { + const PALLET: &'static str = "Paras"; + const EVENT: &'static str = "CurrentCodeUpdated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CurrentHeadUpdated( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for CurrentHeadUpdated { + const PALLET: &'static str = "Paras"; + const EVENT: &'static str = "CurrentHeadUpdated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CodeUpgradeScheduled( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for CodeUpgradeScheduled { + const PALLET: &'static str = "Paras"; + const EVENT: &'static str = "CodeUpgradeScheduled"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewHeadNoted( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for NewHeadNoted { + const PALLET: &'static str = "Paras"; + const EVENT: &'static str = "NewHeadNoted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ActionQueued( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for ActionQueued { + const PALLET: &'static str = "Paras"; + const EVENT: &'static str = "ActionQueued"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Parachains; + impl ::subxt::StorageEntry for Parachains { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "Parachains"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ParaLifecycles( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for ParaLifecycles { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "ParaLifecycles"; + type Value = + runtime_types::polkadot_runtime_parachains::paras::ParaLifecycle; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Heads(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::StorageEntry for Heads { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "Heads"; + type Value = runtime_types::polkadot_parachain::primitives::HeadData; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct CurrentCodeHash( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for CurrentCodeHash { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "CurrentCodeHash"; + type Value = + runtime_types::polkadot_parachain::primitives::ValidationCodeHash; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct PastCodeHash( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + ); + impl ::subxt::StorageEntry for PastCodeHash { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "PastCodeHash"; + type Value = + runtime_types::polkadot_parachain::primitives::ValidationCodeHash; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct PastCodeMeta( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for PastCodeMeta { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "PastCodeMeta"; + type Value = + runtime_types::polkadot_runtime_parachains::paras::ParaPastCodeMeta< + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct PastCodePruning; + impl ::subxt::StorageEntry for PastCodePruning { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "PastCodePruning"; + type Value = ::std::vec::Vec<( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + )>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct FutureCodeUpgrades( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for FutureCodeUpgrades { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "FutureCodeUpgrades"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct FutureCodeHash( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for FutureCodeHash { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "FutureCodeHash"; + type Value = + runtime_types::polkadot_parachain::primitives::ValidationCodeHash; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct UpgradeGoAheadSignal( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for UpgradeGoAheadSignal { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "UpgradeGoAheadSignal"; + type Value = runtime_types::polkadot_primitives::v1::UpgradeGoAhead; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct UpgradeRestrictionSignal( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for UpgradeRestrictionSignal { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "UpgradeRestrictionSignal"; + type Value = runtime_types::polkadot_primitives::v1::UpgradeRestriction; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct UpgradeCooldowns; + impl ::subxt::StorageEntry for UpgradeCooldowns { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "UpgradeCooldowns"; + type Value = ::std::vec::Vec<( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + )>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct UpcomingUpgrades; + impl ::subxt::StorageEntry for UpcomingUpgrades { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "UpcomingUpgrades"; + type Value = ::std::vec::Vec<( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + )>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ActionsQueue(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for ActionsQueue { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "ActionsQueue"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct UpcomingParasGenesis( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for UpcomingParasGenesis { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "UpcomingParasGenesis"; + type Value = + runtime_types::polkadot_runtime_parachains::paras::ParaGenesisArgs; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct CodeByHashRefs( + pub runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + ); + impl ::subxt::StorageEntry for CodeByHashRefs { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "CodeByHashRefs"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct CodeByHash( + pub runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + ); + impl ::subxt::StorageEntry for CodeByHash { + const PALLET: &'static str = "Paras"; + const STORAGE: &'static str = "CodeByHash"; + type Value = + runtime_types::polkadot_parachain::primitives::ValidationCode; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn parachains( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = Parachains; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn para_lifecycles( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_runtime_parachains::paras::ParaLifecycle, + >, + ::subxt::Error, + > { + let entry = ParaLifecycles(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn para_lifecycles_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ParaLifecycles>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn heads( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::HeadData, + >, + ::subxt::Error, + > { + let entry = Heads(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn heads_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Heads>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + pub async fn current_code_hash( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + >, + ::subxt::Error, + > { + let entry = CurrentCodeHash(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn current_code_hash_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, CurrentCodeHash>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn past_code_hash( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + _1: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + >, + ::subxt::Error, + > { + let entry = PastCodeHash(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn past_code_hash_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, PastCodeHash>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn past_code_meta( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::polkadot_runtime_parachains::paras::ParaPastCodeMeta< + ::core::primitive::u32, + >, + ::subxt::Error, + > { + let entry = PastCodeMeta(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn past_code_meta_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, PastCodeMeta>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn past_code_pruning( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = PastCodePruning; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn future_code_upgrades( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = FutureCodeUpgrades(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn future_code_upgrades_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, FutureCodeUpgrades>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn future_code_hash( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + >, + ::subxt::Error, + > { + let entry = FutureCodeHash(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn future_code_hash_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, FutureCodeHash>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn upgrade_go_ahead_signal( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::UpgradeGoAhead, + >, + ::subxt::Error, + > { + let entry = UpgradeGoAheadSignal(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn upgrade_go_ahead_signal_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, UpgradeGoAheadSignal>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn upgrade_restriction_signal( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::UpgradeRestriction, + >, + ::subxt::Error, + > { + let entry = UpgradeRestrictionSignal(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn upgrade_restriction_signal_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, UpgradeRestrictionSignal>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn upgrade_cooldowns( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = UpgradeCooldowns; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn upcoming_upgrades( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = UpcomingUpgrades; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn actions_queue( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = ActionsQueue(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn actions_queue_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ActionsQueue>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } pub async fn upcoming_paras_genesis (& self , _0 : runtime_types :: polkadot_parachain :: primitives :: Id , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: core :: option :: Option < runtime_types :: polkadot_runtime_parachains :: paras :: ParaGenesisArgs > , :: subxt :: Error >{ + let entry = UpcomingParasGenesis(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn upcoming_paras_genesis_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, UpcomingParasGenesis>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn code_by_hash_refs( + &self, + _0: runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = CodeByHashRefs(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn code_by_hash_refs_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, CodeByHashRefs>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn code_by_hash( + &self, + _0: runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::ValidationCode, + >, + ::subxt::Error, + > { + let entry = CodeByHash(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn code_by_hash_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, CodeByHash>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod initializer { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceApprove { + pub up_to: ::core::primitive::u32, + } + impl ::subxt::Call for ForceApprove { + const PALLET: &'static str = "Initializer"; + const FUNCTION: &'static str = "force_approve"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn force_approve( + &self, + up_to: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceApprove { up_to }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub mod storage { + use super::runtime_types; + pub struct HasInitialized; + impl ::subxt::StorageEntry for HasInitialized { + const PALLET: &'static str = "Initializer"; + const STORAGE: &'static str = "HasInitialized"; + type Value = (); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct BufferedSessionChanges; + impl ::subxt::StorageEntry for BufferedSessionChanges { + const PALLET: &'static str = "Initializer"; + const STORAGE: &'static str = "BufferedSessionChanges"; + type Value = :: std :: vec :: Vec < runtime_types :: polkadot_runtime_parachains :: initializer :: BufferedSessionChange > ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn has_initialized( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::option::Option<()>, ::subxt::Error> + { + let entry = HasInitialized; + self.client.storage().fetch(&entry, hash).await + } pub async fn buffered_session_changes (& self , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: std :: vec :: Vec < runtime_types :: polkadot_runtime_parachains :: initializer :: BufferedSessionChange > , :: subxt :: Error >{ + let entry = BufferedSessionChanges; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod dmp { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + } + } + pub mod storage { + use super::runtime_types; + pub struct DownwardMessageQueues( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for DownwardMessageQueues { + const PALLET: &'static str = "Dmp"; + const STORAGE: &'static str = "DownwardMessageQueues"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_core_primitives::InboundDownwardMessage< + ::core::primitive::u32, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct DownwardMessageQueueHeads( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for DownwardMessageQueueHeads { + const PALLET: &'static str = "Dmp"; + const STORAGE: &'static str = "DownwardMessageQueueHeads"; + type Value = ::subxt::sp_core::H256; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn downward_message_queues( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_core_primitives::InboundDownwardMessage< + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = DownwardMessageQueues(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn downward_message_queues_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, DownwardMessageQueues>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn downward_message_queue_heads( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::sp_core::H256, ::subxt::Error> + { + let entry = DownwardMessageQueueHeads(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn downward_message_queue_heads_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, DownwardMessageQueueHeads>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod ump { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ServiceOverweight { + pub index: ::core::primitive::u64, + pub weight_limit: ::core::primitive::u64, + } + impl ::subxt::Call for ServiceOverweight { + const PALLET: &'static str = "Ump"; + const FUNCTION: &'static str = "service_overweight"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn service_overweight( + &self, + index: ::core::primitive::u64, + weight_limit: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic { + let call = ServiceOverweight { + index, + weight_limit, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::polkadot_runtime_parachains::ump::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct InvalidFormat(pub [::core::primitive::u8; 32usize]); + impl ::subxt::Event for InvalidFormat { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "InvalidFormat"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct UnsupportedVersion(pub [::core::primitive::u8; 32usize]); + impl ::subxt::Event for UnsupportedVersion { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "UnsupportedVersion"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ExecutedUpward( + pub [::core::primitive::u8; 32usize], + pub runtime_types::xcm::v2::traits::Outcome, + ); + impl ::subxt::Event for ExecutedUpward { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "ExecutedUpward"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct WeightExhausted( + pub [::core::primitive::u8; 32usize], + pub ::core::primitive::u64, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for WeightExhausted { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "WeightExhausted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct UpwardMessagesReceived( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for UpwardMessagesReceived { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "UpwardMessagesReceived"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OverweightEnqueued( + pub runtime_types::polkadot_parachain::primitives::Id, + pub [::core::primitive::u8; 32usize], + pub ::core::primitive::u64, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for OverweightEnqueued { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "OverweightEnqueued"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OverweightServiced( + pub ::core::primitive::u64, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for OverweightServiced { + const PALLET: &'static str = "Ump"; + const EVENT: &'static str = "OverweightServiced"; + } + } + pub mod storage { + use super::runtime_types; + pub struct RelayDispatchQueues( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for RelayDispatchQueues { + const PALLET: &'static str = "Ump"; + const STORAGE: &'static str = "RelayDispatchQueues"; + type Value = ::std::vec::Vec<::std::vec::Vec<::core::primitive::u8>>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct RelayDispatchQueueSize( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for RelayDispatchQueueSize { + const PALLET: &'static str = "Ump"; + const STORAGE: &'static str = "RelayDispatchQueueSize"; + type Value = (::core::primitive::u32, ::core::primitive::u32); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct NeedsDispatch; + impl ::subxt::StorageEntry for NeedsDispatch { + const PALLET: &'static str = "Ump"; + const STORAGE: &'static str = "NeedsDispatch"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextDispatchRoundStartWith; + impl ::subxt::StorageEntry for NextDispatchRoundStartWith { + const PALLET: &'static str = "Ump"; + const STORAGE: &'static str = "NextDispatchRoundStartWith"; + type Value = runtime_types::polkadot_parachain::primitives::Id; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Overweight(pub ::core::primitive::u64); + impl ::subxt::StorageEntry for Overweight { + const PALLET: &'static str = "Ump"; + const STORAGE: &'static str = "Overweight"; + type Value = ( + runtime_types::polkadot_parachain::primitives::Id, + ::std::vec::Vec<::core::primitive::u8>, + ); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct OverweightCount; + impl ::subxt::StorageEntry for OverweightCount { + const PALLET: &'static str = "Ump"; + const STORAGE: &'static str = "OverweightCount"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn relay_dispatch_queues( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::std::vec::Vec<::core::primitive::u8>>, + ::subxt::Error, + > { + let entry = RelayDispatchQueues(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn relay_dispatch_queues_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, RelayDispatchQueues>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn relay_dispatch_queue_size( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + (::core::primitive::u32, ::core::primitive::u32), + ::subxt::Error, + > { + let entry = RelayDispatchQueueSize(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn relay_dispatch_queue_size_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, RelayDispatchQueueSize>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn needs_dispatch( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = NeedsDispatch; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn next_dispatch_round_start_with( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::Id, + >, + ::subxt::Error, + > { + let entry = NextDispatchRoundStartWith; + self.client.storage().fetch(&entry, hash).await + } + pub async fn overweight( + &self, + _0: ::core::primitive::u64, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<( + runtime_types::polkadot_parachain::primitives::Id, + ::std::vec::Vec<::core::primitive::u8>, + )>, + ::subxt::Error, + > { + let entry = Overweight(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn overweight_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Overweight>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn overweight_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = OverweightCount; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod hrmp { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpInitOpenChannel { + pub recipient: runtime_types::polkadot_parachain::primitives::Id, + pub proposed_max_capacity: ::core::primitive::u32, + pub proposed_max_message_size: ::core::primitive::u32, + } + impl ::subxt::Call for HrmpInitOpenChannel { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "hrmp_init_open_channel"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpAcceptOpenChannel { + pub sender: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for HrmpAcceptOpenChannel { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "hrmp_accept_open_channel"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpCloseChannel { + pub channel_id: + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + } + impl ::subxt::Call for HrmpCloseChannel { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "hrmp_close_channel"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceCleanHrmp { + pub para: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for ForceCleanHrmp { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "force_clean_hrmp"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceProcessHrmpOpen {} + impl ::subxt::Call for ForceProcessHrmpOpen { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "force_process_hrmp_open"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceProcessHrmpClose {} + impl ::subxt::Call for ForceProcessHrmpClose { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "force_process_hrmp_close"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpCancelOpenRequest { + pub channel_id: + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + } + impl ::subxt::Call for HrmpCancelOpenRequest { + const PALLET: &'static str = "Hrmp"; + const FUNCTION: &'static str = "hrmp_cancel_open_request"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn hrmp_init_open_channel( + &self, + recipient: runtime_types::polkadot_parachain::primitives::Id, + proposed_max_capacity: ::core::primitive::u32, + proposed_max_message_size: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = HrmpInitOpenChannel { + recipient, + proposed_max_capacity, + proposed_max_message_size, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn hrmp_accept_open_channel( + &self, + sender: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic + { + let call = HrmpAcceptOpenChannel { sender }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn hrmp_close_channel( + &self, + channel_id : runtime_types :: polkadot_parachain :: primitives :: HrmpChannelId, + ) -> ::subxt::SubmittableExtrinsic { + let call = HrmpCloseChannel { channel_id }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_clean_hrmp( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceCleanHrmp { para }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_process_hrmp_open( + &self, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceProcessHrmpOpen {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_process_hrmp_close( + &self, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceProcessHrmpClose {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn hrmp_cancel_open_request( + &self, + channel_id : runtime_types :: polkadot_parachain :: primitives :: HrmpChannelId, + ) -> ::subxt::SubmittableExtrinsic + { + let call = HrmpCancelOpenRequest { channel_id }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::polkadot_runtime_parachains::hrmp::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OpenChannelRequested( + pub runtime_types::polkadot_parachain::primitives::Id, + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for OpenChannelRequested { + const PALLET: &'static str = "Hrmp"; + const EVENT: &'static str = "OpenChannelRequested"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OpenChannelCanceled( + pub runtime_types::polkadot_parachain::primitives::Id, + pub runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ); + impl ::subxt::Event for OpenChannelCanceled { + const PALLET: &'static str = "Hrmp"; + const EVENT: &'static str = "OpenChannelCanceled"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OpenChannelAccepted( + pub runtime_types::polkadot_parachain::primitives::Id, + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for OpenChannelAccepted { + const PALLET: &'static str = "Hrmp"; + const EVENT: &'static str = "OpenChannelAccepted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ChannelClosed( + pub runtime_types::polkadot_parachain::primitives::Id, + pub runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ); + impl ::subxt::Event for ChannelClosed { + const PALLET: &'static str = "Hrmp"; + const EVENT: &'static str = "ChannelClosed"; + } + } + pub mod storage { + use super::runtime_types; + pub struct HrmpOpenChannelRequests( + pub runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ); + impl ::subxt::StorageEntry for HrmpOpenChannelRequests { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpOpenChannelRequests"; + type Value = runtime_types :: polkadot_runtime_parachains :: hrmp :: HrmpOpenChannelRequest ; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpOpenChannelRequestsList; + impl ::subxt::StorageEntry for HrmpOpenChannelRequestsList { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpOpenChannelRequestsList"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct HrmpOpenChannelRequestCount( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for HrmpOpenChannelRequestCount { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpOpenChannelRequestCount"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpAcceptedChannelRequestCount( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for HrmpAcceptedChannelRequestCount { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpAcceptedChannelRequestCount"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpCloseChannelRequests( + pub runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ); + impl ::subxt::StorageEntry for HrmpCloseChannelRequests { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpCloseChannelRequests"; + type Value = (); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpCloseChannelRequestsList; + impl ::subxt::StorageEntry for HrmpCloseChannelRequestsList { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpCloseChannelRequestsList"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct HrmpWatermarks( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for HrmpWatermarks { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpWatermarks"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpChannels( + pub runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ); + impl ::subxt::StorageEntry for HrmpChannels { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpChannels"; + type Value = + runtime_types::polkadot_runtime_parachains::hrmp::HrmpChannel; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpIngressChannelsIndex( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for HrmpIngressChannelsIndex { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpIngressChannelsIndex"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpEgressChannelsIndex( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for HrmpEgressChannelsIndex { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpEgressChannelsIndex"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpChannelContents( + pub runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ); + impl ::subxt::StorageEntry for HrmpChannelContents { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpChannelContents"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_core_primitives::InboundHrmpMessage< + ::core::primitive::u32, + >, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct HrmpChannelDigests( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for HrmpChannelDigests { + const PALLET: &'static str = "Hrmp"; + const STORAGE: &'static str = "HrmpChannelDigests"; + type Value = ::std::vec::Vec<( + ::core::primitive::u32, + ::std::vec::Vec, + )>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } pub async fn hrmp_open_channel_requests (& self , _0 : runtime_types :: polkadot_parachain :: primitives :: HrmpChannelId , hash : :: core :: option :: Option < T :: Hash > ,) -> :: core :: result :: Result < :: core :: option :: Option < runtime_types :: polkadot_runtime_parachains :: hrmp :: HrmpOpenChannelRequest > , :: subxt :: Error >{ + let entry = HrmpOpenChannelRequests(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn hrmp_open_channel_requests_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpOpenChannelRequests>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_open_channel_requests_list( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + >, + ::subxt::Error, + > { + let entry = HrmpOpenChannelRequestsList; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_open_channel_request_count( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = HrmpOpenChannelRequestCount(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_open_channel_request_count_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpOpenChannelRequestCount>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_accepted_channel_request_count( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = HrmpAcceptedChannelRequestCount(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_accepted_channel_request_count_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpAcceptedChannelRequestCount>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_close_channel_requests( + &self, + _0: runtime_types::polkadot_parachain::primitives::HrmpChannelId, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::option::Option<()>, ::subxt::Error> + { + let entry = HrmpCloseChannelRequests(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn hrmp_close_channel_requests_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpCloseChannelRequests>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_close_channel_requests_list( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + >, + ::subxt::Error, + > { + let entry = HrmpCloseChannelRequestsList; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_watermarks( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = HrmpWatermarks(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn hrmp_watermarks_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpWatermarks>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_channels( + &self, + _0: runtime_types::polkadot_parachain::primitives::HrmpChannelId, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_runtime_parachains::hrmp::HrmpChannel, + >, + ::subxt::Error, + > { + let entry = HrmpChannels(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn hrmp_channels_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpChannels>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_ingress_channels_index( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = HrmpIngressChannelsIndex(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_ingress_channels_index_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpIngressChannelsIndex>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_egress_channels_index( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = HrmpEgressChannelsIndex(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_egress_channels_index_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpEgressChannelsIndex>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_channel_contents( + &self, + _0: runtime_types::polkadot_parachain::primitives::HrmpChannelId, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_core_primitives::InboundHrmpMessage< + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = HrmpChannelContents(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_channel_contents_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpChannelContents>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn hrmp_channel_digests( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<( + ::core::primitive::u32, + ::std::vec::Vec< + runtime_types::polkadot_parachain::primitives::Id, + >, + )>, + ::subxt::Error, + > { + let entry = HrmpChannelDigests(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn hrmp_channel_digests_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, HrmpChannelDigests>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod para_session_info { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub struct AssignmentKeysUnsafe; + impl ::subxt::StorageEntry for AssignmentKeysUnsafe { + const PALLET: &'static str = "ParaSessionInfo"; + const STORAGE: &'static str = "AssignmentKeysUnsafe"; + type Value = ::std::vec::Vec< + runtime_types::polkadot_primitives::v1::assignment_app::Public, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct EarliestStoredSession; + impl ::subxt::StorageEntry for EarliestStoredSession { + const PALLET: &'static str = "ParaSessionInfo"; + const STORAGE: &'static str = "EarliestStoredSession"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Sessions(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for Sessions { + const PALLET: &'static str = "ParaSessionInfo"; + const STORAGE: &'static str = "Sessions"; + type Value = runtime_types::polkadot_primitives::v1::SessionInfo; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn assignment_keys_unsafe( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + runtime_types::polkadot_primitives::v1::assignment_app::Public, + >, + ::subxt::Error, + > { + let entry = AssignmentKeysUnsafe; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn earliest_stored_session( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = EarliestStoredSession; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn sessions( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::SessionInfo, + >, + ::subxt::Error, + > { + let entry = Sessions(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn sessions_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Sessions>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod paras_disputes { + use super::runtime_types; + pub type Event = + runtime_types::polkadot_runtime_parachains::disputes::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DisputeInitiated( + pub runtime_types::polkadot_core_primitives::CandidateHash, + pub runtime_types::polkadot_runtime_parachains::disputes::DisputeLocation, + ); + impl ::subxt::Event for DisputeInitiated { + const PALLET: &'static str = "ParasDisputes"; + const EVENT: &'static str = "DisputeInitiated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DisputeConcluded( + pub runtime_types::polkadot_core_primitives::CandidateHash, + pub runtime_types::polkadot_runtime_parachains::disputes::DisputeResult, + ); + impl ::subxt::Event for DisputeConcluded { + const PALLET: &'static str = "ParasDisputes"; + const EVENT: &'static str = "DisputeConcluded"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DisputeTimedOut( + pub runtime_types::polkadot_core_primitives::CandidateHash, + ); + impl ::subxt::Event for DisputeTimedOut { + const PALLET: &'static str = "ParasDisputes"; + const EVENT: &'static str = "DisputeTimedOut"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Revert(pub ::core::primitive::u32); + impl ::subxt::Event for Revert { + const PALLET: &'static str = "ParasDisputes"; + const EVENT: &'static str = "Revert"; + } + } + pub mod storage { + use super::runtime_types; + pub struct LastPrunedSession; + impl ::subxt::StorageEntry for LastPrunedSession { + const PALLET: &'static str = "ParasDisputes"; + const STORAGE: &'static str = "LastPrunedSession"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Disputes( + ::core::primitive::u32, + runtime_types::polkadot_core_primitives::CandidateHash, + ); + impl ::subxt::StorageEntry for Disputes { + const PALLET: &'static str = "ParasDisputes"; + const STORAGE: &'static str = "Disputes"; + type Value = runtime_types::polkadot_primitives::v1::DisputeState< + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Blake2_128Concat, + ), + ]) + } + } + pub struct Included( + ::core::primitive::u32, + runtime_types::polkadot_core_primitives::CandidateHash, + ); + impl ::subxt::StorageEntry for Included { + const PALLET: &'static str = "ParasDisputes"; + const STORAGE: &'static str = "Included"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Blake2_128Concat, + ), + ]) + } + } + pub struct SpamSlots(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for SpamSlots { + const PALLET: &'static str = "ParasDisputes"; + const STORAGE: &'static str = "SpamSlots"; + type Value = ::std::vec::Vec<::core::primitive::u32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Frozen; + impl ::subxt::StorageEntry for Frozen { + const PALLET: &'static str = "ParasDisputes"; + const STORAGE: &'static str = "Frozen"; + type Value = ::core::option::Option<::core::primitive::u32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn last_pruned_session( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = LastPrunedSession; + self.client.storage().fetch(&entry, hash).await + } + pub async fn disputes( + &self, + _0: ::core::primitive::u32, + _1: runtime_types::polkadot_core_primitives::CandidateHash, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_primitives::v1::DisputeState< + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = Disputes(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn disputes_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Disputes>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn included( + &self, + _0: ::core::primitive::u32, + _1: runtime_types::polkadot_core_primitives::CandidateHash, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = Included(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn included_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Included>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn spam_slots( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::std::vec::Vec<::core::primitive::u32>>, + ::subxt::Error, + > { + let entry = SpamSlots(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn spam_slots_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, SpamSlots>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn frozen( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = Frozen; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod registrar { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Register { + pub id: runtime_types::polkadot_parachain::primitives::Id, + pub genesis_head: runtime_types::polkadot_parachain::primitives::HeadData, + pub validation_code: + runtime_types::polkadot_parachain::primitives::ValidationCode, + } + impl ::subxt::Call for Register { + const PALLET: &'static str = "Registrar"; + const FUNCTION: &'static str = "register"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceRegister { + pub who: ::subxt::sp_core::crypto::AccountId32, + pub deposit: ::core::primitive::u128, + pub id: runtime_types::polkadot_parachain::primitives::Id, + pub genesis_head: runtime_types::polkadot_parachain::primitives::HeadData, + pub validation_code: + runtime_types::polkadot_parachain::primitives::ValidationCode, + } + impl ::subxt::Call for ForceRegister { + const PALLET: &'static str = "Registrar"; + const FUNCTION: &'static str = "force_register"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Deregister { + pub id: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for Deregister { + const PALLET: &'static str = "Registrar"; + const FUNCTION: &'static str = "deregister"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Swap { + pub id: runtime_types::polkadot_parachain::primitives::Id, + pub other: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for Swap { + const PALLET: &'static str = "Registrar"; + const FUNCTION: &'static str = "swap"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceRemoveLock { + pub para: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for ForceRemoveLock { + const PALLET: &'static str = "Registrar"; + const FUNCTION: &'static str = "force_remove_lock"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Reserve {} + impl ::subxt::Call for Reserve { + const PALLET: &'static str = "Registrar"; + const FUNCTION: &'static str = "reserve"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn register( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + genesis_head: runtime_types::polkadot_parachain::primitives::HeadData, + validation_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode, + ) -> ::subxt::SubmittableExtrinsic { + let call = Register { + id, + genesis_head, + validation_code, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_register( + &self, + who: ::subxt::sp_core::crypto::AccountId32, + deposit: ::core::primitive::u128, + id: runtime_types::polkadot_parachain::primitives::Id, + genesis_head: runtime_types::polkadot_parachain::primitives::HeadData, + validation_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceRegister { + who, + deposit, + id, + genesis_head, + validation_code, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn deregister( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = Deregister { id }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn swap( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + other: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = Swap { id, other }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_remove_lock( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceRemoveLock { para }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn reserve(&self) -> ::subxt::SubmittableExtrinsic { + let call = Reserve {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = + runtime_types::polkadot_runtime_common::paras_registrar::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Registered( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::subxt::sp_core::crypto::AccountId32, + ); + impl ::subxt::Event for Registered { + const PALLET: &'static str = "Registrar"; + const EVENT: &'static str = "Registered"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Deregistered( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for Deregistered { + const PALLET: &'static str = "Registrar"; + const EVENT: &'static str = "Deregistered"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Reserved( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::subxt::sp_core::crypto::AccountId32, + ); + impl ::subxt::Event for Reserved { + const PALLET: &'static str = "Registrar"; + const EVENT: &'static str = "Reserved"; + } + } + pub mod storage { + use super::runtime_types; + pub struct PendingSwap(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::StorageEntry for PendingSwap { + const PALLET: &'static str = "Registrar"; + const STORAGE: &'static str = "PendingSwap"; + type Value = runtime_types::polkadot_parachain::primitives::Id; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Paras(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::StorageEntry for Paras { + const PALLET: &'static str = "Registrar"; + const STORAGE: &'static str = "Paras"; + type Value = + runtime_types::polkadot_runtime_common::paras_registrar::ParaInfo< + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct NextFreeParaId; + impl ::subxt::StorageEntry for NextFreeParaId { + const PALLET: &'static str = "Registrar"; + const STORAGE: &'static str = "NextFreeParaId"; + type Value = runtime_types::polkadot_parachain::primitives::Id; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn pending_swap( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_parachain::primitives::Id, + >, + ::subxt::Error, + > { + let entry = PendingSwap(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn pending_swap_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, PendingSwap>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn paras( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_runtime_common::paras_registrar::ParaInfo< + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + >, + >, + ::subxt::Error, + > { + let entry = Paras(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn paras_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Paras>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + pub async fn next_free_para_id( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::polkadot_parachain::primitives::Id, + ::subxt::Error, + > { + let entry = NextFreeParaId; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod auctions { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewAuction { + #[codec(compact)] + pub duration: ::core::primitive::u32, + #[codec(compact)] + pub lease_period_index: ::core::primitive::u32, + } + impl ::subxt::Call for NewAuction { + const PALLET: &'static str = "Auctions"; + const FUNCTION: &'static str = "new_auction"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Bid { + #[codec(compact)] + pub para: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + pub auction_index: ::core::primitive::u32, + #[codec(compact)] + pub first_slot: ::core::primitive::u32, + #[codec(compact)] + pub last_slot: ::core::primitive::u32, + #[codec(compact)] + pub amount: ::core::primitive::u128, + } + impl ::subxt::Call for Bid { + const PALLET: &'static str = "Auctions"; + const FUNCTION: &'static str = "bid"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CancelAuction {} + impl ::subxt::Call for CancelAuction { + const PALLET: &'static str = "Auctions"; + const FUNCTION: &'static str = "cancel_auction"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn new_auction( + &self, + duration: ::core::primitive::u32, + lease_period_index: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = NewAuction { + duration, + lease_period_index, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn bid( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + auction_index: ::core::primitive::u32, + first_slot: ::core::primitive::u32, + last_slot: ::core::primitive::u32, + amount: ::core::primitive::u128, + ) -> ::subxt::SubmittableExtrinsic { + let call = Bid { + para, + auction_index, + first_slot, + last_slot, + amount, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn cancel_auction( + &self, + ) -> ::subxt::SubmittableExtrinsic { + let call = CancelAuction {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::polkadot_runtime_common::auctions::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AuctionStarted( + pub ::core::primitive::u32, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for AuctionStarted { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "AuctionStarted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AuctionClosed(pub ::core::primitive::u32); + impl ::subxt::Event for AuctionClosed { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "AuctionClosed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Reserved( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Reserved { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "Reserved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Unreserved( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Unreserved { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "Unreserved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReserveConfiscated( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for ReserveConfiscated { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "ReserveConfiscated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BidAccepted( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::primitive::u128, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for BidAccepted { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "BidAccepted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct WinningOffset( + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for WinningOffset { + const PALLET: &'static str = "Auctions"; + const EVENT: &'static str = "WinningOffset"; + } + } + pub mod storage { + use super::runtime_types; + pub struct AuctionCounter; + impl ::subxt::StorageEntry for AuctionCounter { + const PALLET: &'static str = "Auctions"; + const STORAGE: &'static str = "AuctionCounter"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct AuctionInfo; + impl ::subxt::StorageEntry for AuctionInfo { + const PALLET: &'static str = "Auctions"; + const STORAGE: &'static str = "AuctionInfo"; + type Value = (::core::primitive::u32, ::core::primitive::u32); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ReservedAmounts( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::StorageEntry for ReservedAmounts { + const PALLET: &'static str = "Auctions"; + const STORAGE: &'static str = "ReservedAmounts"; + type Value = ::core::primitive::u128; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Winning(pub ::core::primitive::u32); + impl ::subxt::StorageEntry for Winning { + const PALLET: &'static str = "Auctions"; + const STORAGE: &'static str = "Winning"; + type Value = [::core::option::Option<( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u128, + )>; 36usize]; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn auction_counter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = AuctionCounter; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn auction_info( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<( + ::core::primitive::u32, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = AuctionInfo; + self.client.storage().fetch(&entry, hash).await + } + pub async fn reserved_amounts( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + _1: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u128>, + ::subxt::Error, + > { + let entry = ReservedAmounts(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn reserved_amounts_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ReservedAmounts>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn winning( + &self, + _0: ::core::primitive::u32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + [::core::option::Option<( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u128, + )>; 36usize], + >, + ::subxt::Error, + > { + let entry = Winning(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn winning_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Winning>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod crowdloan { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Create { + #[codec(compact)] + pub index: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + pub cap: ::core::primitive::u128, + #[codec(compact)] + pub first_period: ::core::primitive::u32, + #[codec(compact)] + pub last_period: ::core::primitive::u32, + #[codec(compact)] + pub end: ::core::primitive::u32, + pub verifier: + ::core::option::Option, + } + impl ::subxt::Call for Create { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "create"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Contribute { + #[codec(compact)] + pub index: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + pub value: ::core::primitive::u128, + pub signature: + ::core::option::Option, + } + impl ::subxt::Call for Contribute { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "contribute"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Withdraw { + pub who: ::subxt::sp_core::crypto::AccountId32, + #[codec(compact)] + pub index: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for Withdraw { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "withdraw"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Refund { + #[codec(compact)] + pub index: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for Refund { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "refund"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Dissolve { + #[codec(compact)] + pub index: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for Dissolve { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "dissolve"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Edit { + #[codec(compact)] + pub index: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + pub cap: ::core::primitive::u128, + #[codec(compact)] + pub first_period: ::core::primitive::u32, + #[codec(compact)] + pub last_period: ::core::primitive::u32, + #[codec(compact)] + pub end: ::core::primitive::u32, + pub verifier: + ::core::option::Option, + } + impl ::subxt::Call for Edit { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "edit"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AddMemo { + pub index: runtime_types::polkadot_parachain::primitives::Id, + pub memo: ::std::vec::Vec<::core::primitive::u8>, + } + impl ::subxt::Call for AddMemo { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "add_memo"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Poke { + pub index: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for Poke { + const PALLET: &'static str = "Crowdloan"; + const FUNCTION: &'static str = "poke"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn create( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + cap: ::core::primitive::u128, + first_period: ::core::primitive::u32, + last_period: ::core::primitive::u32, + end: ::core::primitive::u32, + verifier: ::core::option::Option< + runtime_types::sp_runtime::MultiSigner, + >, + ) -> ::subxt::SubmittableExtrinsic { + let call = Create { + index, + cap, + first_period, + last_period, + end, + verifier, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn contribute( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + value: ::core::primitive::u128, + signature: ::core::option::Option< + runtime_types::sp_runtime::MultiSignature, + >, + ) -> ::subxt::SubmittableExtrinsic { + let call = Contribute { + index, + value, + signature, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn withdraw( + &self, + who: ::subxt::sp_core::crypto::AccountId32, + index: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = Withdraw { who, index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn refund( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = Refund { index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn dissolve( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = Dissolve { index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn edit( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + cap: ::core::primitive::u128, + first_period: ::core::primitive::u32, + last_period: ::core::primitive::u32, + end: ::core::primitive::u32, + verifier: ::core::option::Option< + runtime_types::sp_runtime::MultiSigner, + >, + ) -> ::subxt::SubmittableExtrinsic { + let call = Edit { + index, + cap, + first_period, + last_period, + end, + verifier, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn add_memo( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + memo: ::std::vec::Vec<::core::primitive::u8>, + ) -> ::subxt::SubmittableExtrinsic { + let call = AddMemo { index, memo }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn poke( + &self, + index: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = Poke { index }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::polkadot_runtime_common::crowdloan::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Created(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::Event for Created { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "Created"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Contributed( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Contributed { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "Contributed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Withdrew( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Withdrew { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "Withdrew"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct PartiallyRefunded( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for PartiallyRefunded { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "PartiallyRefunded"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AllRefunded(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::Event for AllRefunded { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "AllRefunded"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Dissolved(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::Event for Dissolved { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "Dissolved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HandleBidResult( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for HandleBidResult { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "HandleBidResult"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Edited(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::Event for Edited { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "Edited"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MemoUpdated( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::std::vec::Vec<::core::primitive::u8>, + ); + impl ::subxt::Event for MemoUpdated { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "MemoUpdated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AddedToNewRaise( + pub runtime_types::polkadot_parachain::primitives::Id, + ); + impl ::subxt::Event for AddedToNewRaise { + const PALLET: &'static str = "Crowdloan"; + const EVENT: &'static str = "AddedToNewRaise"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Funds(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::StorageEntry for Funds { + const PALLET: &'static str = "Crowdloan"; + const STORAGE: &'static str = "Funds"; + type Value = runtime_types::polkadot_runtime_common::crowdloan::FundInfo< + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ::core::primitive::u32, + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct NewRaise; + impl ::subxt::StorageEntry for NewRaise { + const PALLET: &'static str = "Crowdloan"; + const STORAGE: &'static str = "NewRaise"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct EndingsCount; + impl ::subxt::StorageEntry for EndingsCount { + const PALLET: &'static str = "Crowdloan"; + const STORAGE: &'static str = "EndingsCount"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextTrieIndex; + impl ::subxt::StorageEntry for NextTrieIndex { + const PALLET: &'static str = "Crowdloan"; + const STORAGE: &'static str = "NextTrieIndex"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn funds( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::polkadot_runtime_common::crowdloan::FundInfo< + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ::core::primitive::u32, + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = Funds(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn funds_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Funds>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + pub async fn new_raise( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = NewRaise; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn endings_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = EndingsCount; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn next_trie_index( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = NextTrieIndex; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod slots { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceLease { + pub para: runtime_types::polkadot_parachain::primitives::Id, + pub leaser: ::subxt::sp_core::crypto::AccountId32, + pub amount: ::core::primitive::u128, + pub period_begin: ::core::primitive::u32, + pub period_count: ::core::primitive::u32, + } + impl ::subxt::Call for ForceLease { + const PALLET: &'static str = "Slots"; + const FUNCTION: &'static str = "force_lease"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ClearAllLeases { + pub para: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for ClearAllLeases { + const PALLET: &'static str = "Slots"; + const FUNCTION: &'static str = "clear_all_leases"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct TriggerOnboard { + pub para: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for TriggerOnboard { + const PALLET: &'static str = "Slots"; + const FUNCTION: &'static str = "trigger_onboard"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn force_lease( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + leaser: ::subxt::sp_core::crypto::AccountId32, + amount: ::core::primitive::u128, + period_begin: ::core::primitive::u32, + period_count: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceLease { + para, + leaser, + amount, + period_begin, + period_count, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn clear_all_leases( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = ClearAllLeases { para }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn trigger_onboard( + &self, + para: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic { + let call = TriggerOnboard { para }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::polkadot_runtime_common::slots::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewLeasePeriod(pub ::core::primitive::u32); + impl ::subxt::Event for NewLeasePeriod { + const PALLET: &'static str = "Slots"; + const EVENT: &'static str = "NewLeasePeriod"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Leased( + pub runtime_types::polkadot_parachain::primitives::Id, + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + pub ::core::primitive::u128, + pub ::core::primitive::u128, + ); + impl ::subxt::Event for Leased { + const PALLET: &'static str = "Slots"; + const EVENT: &'static str = "Leased"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Leases(pub runtime_types::polkadot_parachain::primitives::Id); + impl ::subxt::StorageEntry for Leases { + const PALLET: &'static str = "Slots"; + const STORAGE: &'static str = "Leases"; + type Value = ::std::vec::Vec< + ::core::option::Option<( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + )>, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn leases( + &self, + _0: runtime_types::polkadot_parachain::primitives::Id, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec< + ::core::option::Option<( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + )>, + >, + ::subxt::Error, + > { + let entry = Leases(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn leases_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Leases>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + } + } + } + pub mod paras_sudo_wrapper { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoScheduleParaInitialize { + pub id: runtime_types::polkadot_parachain::primitives::Id, + pub genesis: + runtime_types::polkadot_runtime_parachains::paras::ParaGenesisArgs, + } + impl ::subxt::Call for SudoScheduleParaInitialize { + const PALLET: &'static str = "ParasSudoWrapper"; + const FUNCTION: &'static str = "sudo_schedule_para_initialize"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoScheduleParaCleanup { + pub id: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for SudoScheduleParaCleanup { + const PALLET: &'static str = "ParasSudoWrapper"; + const FUNCTION: &'static str = "sudo_schedule_para_cleanup"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoScheduleParathreadUpgrade { + pub id: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for SudoScheduleParathreadUpgrade { + const PALLET: &'static str = "ParasSudoWrapper"; + const FUNCTION: &'static str = "sudo_schedule_parathread_upgrade"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoScheduleParachainDowngrade { + pub id: runtime_types::polkadot_parachain::primitives::Id, + } + impl ::subxt::Call for SudoScheduleParachainDowngrade { + const PALLET: &'static str = "ParasSudoWrapper"; + const FUNCTION: &'static str = "sudo_schedule_parachain_downgrade"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoQueueDownwardXcm { + pub id: runtime_types::polkadot_parachain::primitives::Id, + pub xcm: runtime_types::xcm::VersionedXcm, + } + impl ::subxt::Call for SudoQueueDownwardXcm { + const PALLET: &'static str = "ParasSudoWrapper"; + const FUNCTION: &'static str = "sudo_queue_downward_xcm"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoEstablishHrmpChannel { + pub sender: runtime_types::polkadot_parachain::primitives::Id, + pub recipient: runtime_types::polkadot_parachain::primitives::Id, + pub max_capacity: ::core::primitive::u32, + pub max_message_size: ::core::primitive::u32, + } + impl ::subxt::Call for SudoEstablishHrmpChannel { + const PALLET: &'static str = "ParasSudoWrapper"; + const FUNCTION: &'static str = "sudo_establish_hrmp_channel"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn sudo_schedule_para_initialize( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + genesis : runtime_types :: polkadot_runtime_parachains :: paras :: ParaGenesisArgs, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoScheduleParaInitialize { id, genesis }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_schedule_para_cleanup( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoScheduleParaCleanup { id }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_schedule_parathread_upgrade( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoScheduleParathreadUpgrade { id }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_schedule_parachain_downgrade( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoScheduleParachainDowngrade { id }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_queue_downward_xcm( + &self, + id: runtime_types::polkadot_parachain::primitives::Id, + xcm: runtime_types::xcm::VersionedXcm, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoQueueDownwardXcm { id, xcm }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_establish_hrmp_channel( + &self, + sender: runtime_types::polkadot_parachain::primitives::Id, + recipient: runtime_types::polkadot_parachain::primitives::Id, + max_capacity: ::core::primitive::u32, + max_message_size: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoEstablishHrmpChannel { + sender, + recipient, + max_capacity, + max_message_size, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + } + pub mod sudo { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Sudo { + pub call: runtime_types::rococo_runtime::Call, + } + impl ::subxt::Call for Sudo { + const PALLET: &'static str = "Sudo"; + const FUNCTION: &'static str = "sudo"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoUncheckedWeight { + pub call: runtime_types::rococo_runtime::Call, + pub weight: ::core::primitive::u64, + } + impl ::subxt::Call for SudoUncheckedWeight { + const PALLET: &'static str = "Sudo"; + const FUNCTION: &'static str = "sudo_unchecked_weight"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetKey { + pub new: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + } + impl ::subxt::Call for SetKey { + const PALLET: &'static str = "Sudo"; + const FUNCTION: &'static str = "set_key"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoAs { + pub who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + pub call: runtime_types::rococo_runtime::Call, + } + impl ::subxt::Call for SudoAs { + const PALLET: &'static str = "Sudo"; + const FUNCTION: &'static str = "sudo_as"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn sudo( + &self, + call: runtime_types::rococo_runtime::Call, + ) -> ::subxt::SubmittableExtrinsic { + let call = Sudo { call }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_unchecked_weight( + &self, + call: runtime_types::rococo_runtime::Call, + weight: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic + { + let call = SudoUncheckedWeight { call, weight }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_key( + &self, + new: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetKey { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn sudo_as( + &self, + who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + call: runtime_types::rococo_runtime::Call, + ) -> ::subxt::SubmittableExtrinsic { + let call = SudoAs { who, call }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_sudo::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Sudid( + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for Sudid { + const PALLET: &'static str = "Sudo"; + const EVENT: &'static str = "Sudid"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KeyChanged(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::Event for KeyChanged { + const PALLET: &'static str = "Sudo"; + const EVENT: &'static str = "KeyChanged"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SudoAsDone( + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for SudoAsDone { + const PALLET: &'static str = "Sudo"; + const EVENT: &'static str = "SudoAsDone"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Key; + impl ::subxt::StorageEntry for Key { + const PALLET: &'static str = "Sudo"; + const STORAGE: &'static str = "Key"; + type Value = ::subxt::sp_core::crypto::AccountId32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn key( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::sp_core::crypto::AccountId32, + ::subxt::Error, + > { + let entry = Key; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod mmr { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub struct RootHash; + impl ::subxt::StorageEntry for RootHash { + const PALLET: &'static str = "Mmr"; + const STORAGE: &'static str = "RootHash"; + type Value = ::subxt::sp_core::H256; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NumberOfLeaves; + impl ::subxt::StorageEntry for NumberOfLeaves { + const PALLET: &'static str = "Mmr"; + const STORAGE: &'static str = "NumberOfLeaves"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Nodes(pub ::core::primitive::u64); + impl ::subxt::StorageEntry for Nodes { + const PALLET: &'static str = "Mmr"; + const STORAGE: &'static str = "Nodes"; + type Value = ::subxt::sp_core::H256; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn root_hash( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::sp_core::H256, ::subxt::Error> + { + let entry = RootHash; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn number_of_leaves( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = NumberOfLeaves; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn nodes( + &self, + _0: ::core::primitive::u64, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::subxt::sp_core::H256>, + ::subxt::Error, + > { + let entry = Nodes(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn nodes_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Nodes>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + } + } + } + pub mod beefy { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub struct Authorities; + impl ::subxt::StorageEntry for Authorities { + const PALLET: &'static str = "Beefy"; + const STORAGE: &'static str = "Authorities"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ValidatorSetId; + impl ::subxt::StorageEntry for ValidatorSetId { + const PALLET: &'static str = "Beefy"; + const STORAGE: &'static str = "ValidatorSetId"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct NextAuthorities; + impl ::subxt::StorageEntry for NextAuthorities { + const PALLET: &'static str = "Beefy"; + const STORAGE: &'static str = "NextAuthorities"; + type Value = + ::std::vec::Vec; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn authorities( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = Authorities; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn validator_set_id( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = ValidatorSetId; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn next_authorities( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec, + ::subxt::Error, + > { + let entry = NextAuthorities; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod mmr_leaf { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub struct BeefyNextAuthorities; + impl ::subxt::StorageEntry for BeefyNextAuthorities { + const PALLET: &'static str = "MmrLeaf"; + const STORAGE: &'static str = "BeefyNextAuthorities"; + type Value = runtime_types::beefy_primitives::mmr::BeefyNextAuthoritySet< + ::subxt::sp_core::H256, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn beefy_next_authorities( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::beefy_primitives::mmr::BeefyNextAuthoritySet< + ::subxt::sp_core::H256, + >, + ::subxt::Error, + > { + let entry = BeefyNextAuthorities; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod validator_manager { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RegisterValidators { + pub validators: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + } + impl ::subxt::Call for RegisterValidators { + const PALLET: &'static str = "ValidatorManager"; + const FUNCTION: &'static str = "register_validators"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DeregisterValidators { + pub validators: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + } + impl ::subxt::Call for DeregisterValidators { + const PALLET: &'static str = "ValidatorManager"; + const FUNCTION: &'static str = "deregister_validators"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn register_validators( + &self, + validators: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ) -> ::subxt::SubmittableExtrinsic + { + let call = RegisterValidators { validators }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn deregister_validators( + &self, + validators: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ) -> ::subxt::SubmittableExtrinsic + { + let call = DeregisterValidators { validators }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::rococo_runtime::validator_manager::RawEvent< + ::subxt::sp_core::crypto::AccountId32, + >; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ValidatorsRegistered( + pub ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ); + impl ::subxt::Event for ValidatorsRegistered { + const PALLET: &'static str = "ValidatorManager"; + const EVENT: &'static str = "ValidatorsRegistered"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ValidatorsDeregistered( + pub ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ); + impl ::subxt::Event for ValidatorsDeregistered { + const PALLET: &'static str = "ValidatorManager"; + const EVENT: &'static str = "ValidatorsDeregistered"; + } + } + pub mod storage { + use super::runtime_types; + pub struct ValidatorsToRetire; + impl ::subxt::StorageEntry for ValidatorsToRetire { + const PALLET: &'static str = "ValidatorManager"; + const STORAGE: &'static str = "ValidatorsToRetire"; + type Value = ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ValidatorsToAdd; + impl ::subxt::StorageEntry for ValidatorsToAdd { + const PALLET: &'static str = "ValidatorManager"; + const STORAGE: &'static str = "ValidatorsToAdd"; + type Value = ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn validators_to_retire( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = ValidatorsToRetire; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn validators_to_add( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = ValidatorsToAdd; + self.client.storage().fetch_or_default(&entry, hash).await + } + } + } + } + pub mod collective { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetMembers { + pub new_members: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + pub prime: ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + pub old_count: ::core::primitive::u32, + } + impl ::subxt::Call for SetMembers { + const PALLET: &'static str = "Collective"; + const FUNCTION: &'static str = "set_members"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Execute { + pub proposal: runtime_types::rococo_runtime::Call, + #[codec(compact)] + pub length_bound: ::core::primitive::u32, + } + impl ::subxt::Call for Execute { + const PALLET: &'static str = "Collective"; + const FUNCTION: &'static str = "execute"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Propose { + #[codec(compact)] + pub threshold: ::core::primitive::u32, + pub proposal: runtime_types::rococo_runtime::Call, + #[codec(compact)] + pub length_bound: ::core::primitive::u32, + } + impl ::subxt::Call for Propose { + const PALLET: &'static str = "Collective"; + const FUNCTION: &'static str = "propose"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Vote { + pub proposal: ::subxt::sp_core::H256, + #[codec(compact)] + pub index: ::core::primitive::u32, + pub approve: ::core::primitive::bool, + } + impl ::subxt::Call for Vote { + const PALLET: &'static str = "Collective"; + const FUNCTION: &'static str = "vote"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Close { + pub proposal_hash: ::subxt::sp_core::H256, + #[codec(compact)] + pub index: ::core::primitive::u32, + #[codec(compact)] + pub proposal_weight_bound: ::core::primitive::u64, + #[codec(compact)] + pub length_bound: ::core::primitive::u32, + } + impl ::subxt::Call for Close { + const PALLET: &'static str = "Collective"; + const FUNCTION: &'static str = "close"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DisapproveProposal { + pub proposal_hash: ::subxt::sp_core::H256, + } + impl ::subxt::Call for DisapproveProposal { + const PALLET: &'static str = "Collective"; + const FUNCTION: &'static str = "disapprove_proposal"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn set_members( + &self, + new_members: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + prime: ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + old_count: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetMembers { + new_members, + prime, + old_count, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn execute( + &self, + proposal: runtime_types::rococo_runtime::Call, + length_bound: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Execute { + proposal, + length_bound, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn propose( + &self, + threshold: ::core::primitive::u32, + proposal: runtime_types::rococo_runtime::Call, + length_bound: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Propose { + threshold, + proposal, + length_bound, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn vote( + &self, + proposal: ::subxt::sp_core::H256, + index: ::core::primitive::u32, + approve: ::core::primitive::bool, + ) -> ::subxt::SubmittableExtrinsic { + let call = Vote { + proposal, + index, + approve, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn close( + &self, + proposal_hash: ::subxt::sp_core::H256, + index: ::core::primitive::u32, + proposal_weight_bound: ::core::primitive::u64, + length_bound: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = Close { + proposal_hash, + index, + proposal_weight_bound, + length_bound, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn disapprove_proposal( + &self, + proposal_hash: ::subxt::sp_core::H256, + ) -> ::subxt::SubmittableExtrinsic + { + let call = DisapproveProposal { proposal_hash }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_collective::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Proposed( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::core::primitive::u32, + pub ::subxt::sp_core::H256, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for Proposed { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "Proposed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Voted( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::H256, + pub ::core::primitive::bool, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for Voted { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "Voted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Approved(pub ::subxt::sp_core::H256); + impl ::subxt::Event for Approved { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "Approved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Disapproved(pub ::subxt::sp_core::H256); + impl ::subxt::Event for Disapproved { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "Disapproved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Executed( + pub ::subxt::sp_core::H256, + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for Executed { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "Executed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MemberExecuted( + pub ::subxt::sp_core::H256, + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for MemberExecuted { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "MemberExecuted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Closed( + pub ::subxt::sp_core::H256, + pub ::core::primitive::u32, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for Closed { + const PALLET: &'static str = "Collective"; + const EVENT: &'static str = "Closed"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Proposals; + impl ::subxt::StorageEntry for Proposals { + const PALLET: &'static str = "Collective"; + const STORAGE: &'static str = "Proposals"; + type Value = + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + ::subxt::sp_core::H256, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct ProposalOf(pub ::subxt::sp_core::H256); + impl ::subxt::StorageEntry for ProposalOf { + const PALLET: &'static str = "Collective"; + const STORAGE: &'static str = "ProposalOf"; + type Value = runtime_types::rococo_runtime::Call; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct Voting(pub ::subxt::sp_core::H256); + impl ::subxt::StorageEntry for Voting { + const PALLET: &'static str = "Collective"; + const STORAGE: &'static str = "Voting"; + type Value = runtime_types::pallet_collective::Votes< + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct ProposalCount; + impl ::subxt::StorageEntry for ProposalCount { + const PALLET: &'static str = "Collective"; + const STORAGE: &'static str = "ProposalCount"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Members; + impl ::subxt::StorageEntry for Members { + const PALLET: &'static str = "Collective"; + const STORAGE: &'static str = "Members"; + type Value = ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Prime; + impl ::subxt::StorageEntry for Prime { + const PALLET: &'static str = "Collective"; + const STORAGE: &'static str = "Prime"; + type Value = ::subxt::sp_core::crypto::AccountId32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn proposals( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + ::subxt::sp_core::H256, + >, + ::subxt::Error, + > { + let entry = Proposals; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn proposal_of( + &self, + _0: ::subxt::sp_core::H256, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option, + ::subxt::Error, + > { + let entry = ProposalOf(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn proposal_of_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, ProposalOf>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn voting( + &self, + _0: ::subxt::sp_core::H256, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::pallet_collective::Votes< + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = Voting(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn voting_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Voting>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + pub async fn proposal_count( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = ProposalCount; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn members( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = Members; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn prime( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = Prime; + self.client.storage().fetch(&entry, hash).await + } + } + } + } + pub mod membership { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AddMember { + pub who: ::subxt::sp_core::crypto::AccountId32, + } + impl ::subxt::Call for AddMember { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "add_member"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RemoveMember { + pub who: ::subxt::sp_core::crypto::AccountId32, + } + impl ::subxt::Call for RemoveMember { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "remove_member"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SwapMember { + pub remove: ::subxt::sp_core::crypto::AccountId32, + pub add: ::subxt::sp_core::crypto::AccountId32, + } + impl ::subxt::Call for SwapMember { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "swap_member"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ResetMembers { + pub members: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + } + impl ::subxt::Call for ResetMembers { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "reset_members"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ChangeKey { + pub new: ::subxt::sp_core::crypto::AccountId32, + } + impl ::subxt::Call for ChangeKey { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "change_key"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SetPrime { + pub who: ::subxt::sp_core::crypto::AccountId32, + } + impl ::subxt::Call for SetPrime { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "set_prime"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ClearPrime {} + impl ::subxt::Call for ClearPrime { + const PALLET: &'static str = "Membership"; + const FUNCTION: &'static str = "clear_prime"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn add_member( + &self, + who: ::subxt::sp_core::crypto::AccountId32, + ) -> ::subxt::SubmittableExtrinsic { + let call = AddMember { who }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn remove_member( + &self, + who: ::subxt::sp_core::crypto::AccountId32, + ) -> ::subxt::SubmittableExtrinsic { + let call = RemoveMember { who }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn swap_member( + &self, + remove: ::subxt::sp_core::crypto::AccountId32, + add: ::subxt::sp_core::crypto::AccountId32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SwapMember { remove, add }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn reset_members( + &self, + members: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ) -> ::subxt::SubmittableExtrinsic { + let call = ResetMembers { members }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn change_key( + &self, + new: ::subxt::sp_core::crypto::AccountId32, + ) -> ::subxt::SubmittableExtrinsic { + let call = ChangeKey { new }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn set_prime( + &self, + who: ::subxt::sp_core::crypto::AccountId32, + ) -> ::subxt::SubmittableExtrinsic { + let call = SetPrime { who }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn clear_prime( + &self, + ) -> ::subxt::SubmittableExtrinsic { + let call = ClearPrime {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_membership::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MemberAdded {} + impl ::subxt::Event for MemberAdded { + const PALLET: &'static str = "Membership"; + const EVENT: &'static str = "MemberAdded"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MemberRemoved {} + impl ::subxt::Event for MemberRemoved { + const PALLET: &'static str = "Membership"; + const EVENT: &'static str = "MemberRemoved"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MembersSwapped {} + impl ::subxt::Event for MembersSwapped { + const PALLET: &'static str = "Membership"; + const EVENT: &'static str = "MembersSwapped"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MembersReset {} + impl ::subxt::Event for MembersReset { + const PALLET: &'static str = "Membership"; + const EVENT: &'static str = "MembersReset"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KeyChanged {} + impl ::subxt::Event for KeyChanged { + const PALLET: &'static str = "Membership"; + const EVENT: &'static str = "KeyChanged"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Dummy {} + impl ::subxt::Event for Dummy { + const PALLET: &'static str = "Membership"; + const EVENT: &'static str = "Dummy"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Members; + impl ::subxt::StorageEntry for Members { + const PALLET: &'static str = "Membership"; + const STORAGE: &'static str = "Members"; + type Value = ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Prime; + impl ::subxt::StorageEntry for Prime { + const PALLET: &'static str = "Membership"; + const STORAGE: &'static str = "Prime"; + type Value = ::subxt::sp_core::crypto::AccountId32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn members( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = Members; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn prime( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + ::subxt::Error, + > { + let entry = Prime; + self.client.storage().fetch(&entry, hash).await + } + } + } + } + pub mod utility { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Batch { + pub calls: ::std::vec::Vec, + } + impl ::subxt::Call for Batch { + const PALLET: &'static str = "Utility"; + const FUNCTION: &'static str = "batch"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AsDerivative { + pub index: ::core::primitive::u16, + pub call: runtime_types::rococo_runtime::Call, + } + impl ::subxt::Call for AsDerivative { + const PALLET: &'static str = "Utility"; + const FUNCTION: &'static str = "as_derivative"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BatchAll { + pub calls: ::std::vec::Vec, + } + impl ::subxt::Call for BatchAll { + const PALLET: &'static str = "Utility"; + const FUNCTION: &'static str = "batch_all"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn batch( + &self, + calls: ::std::vec::Vec, + ) -> ::subxt::SubmittableExtrinsic { + let call = Batch { calls }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn as_derivative( + &self, + index: ::core::primitive::u16, + call: runtime_types::rococo_runtime::Call, + ) -> ::subxt::SubmittableExtrinsic { + let call = AsDerivative { index, call }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn batch_all( + &self, + calls: ::std::vec::Vec, + ) -> ::subxt::SubmittableExtrinsic { + let call = BatchAll { calls }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_utility::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BatchInterrupted( + pub ::core::primitive::u32, + pub runtime_types::sp_runtime::DispatchError, + ); + impl ::subxt::Event for BatchInterrupted { + const PALLET: &'static str = "Utility"; + const EVENT: &'static str = "BatchInterrupted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BatchCompleted {} + impl ::subxt::Event for BatchCompleted { + const PALLET: &'static str = "Utility"; + const EVENT: &'static str = "BatchCompleted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ItemCompleted {} + impl ::subxt::Event for ItemCompleted { + const PALLET: &'static str = "Utility"; + const EVENT: &'static str = "ItemCompleted"; + } + } + } + pub mod proxy { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Proxy { + pub real: ::subxt::sp_core::crypto::AccountId32, + pub force_proxy_type: + ::core::option::Option, + pub call: runtime_types::rococo_runtime::Call, + } + impl ::subxt::Call for Proxy { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "proxy"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AddProxy { + pub delegate: ::subxt::sp_core::crypto::AccountId32, + pub proxy_type: runtime_types::rococo_runtime::ProxyType, + pub delay: ::core::primitive::u32, + } + impl ::subxt::Call for AddProxy { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "add_proxy"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RemoveProxy { + pub delegate: ::subxt::sp_core::crypto::AccountId32, + pub proxy_type: runtime_types::rococo_runtime::ProxyType, + pub delay: ::core::primitive::u32, + } + impl ::subxt::Call for RemoveProxy { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "remove_proxy"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RemoveProxies {} + impl ::subxt::Call for RemoveProxies { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "remove_proxies"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Anonymous { + pub proxy_type: runtime_types::rococo_runtime::ProxyType, + pub delay: ::core::primitive::u32, + pub index: ::core::primitive::u16, + } + impl ::subxt::Call for Anonymous { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "anonymous"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KillAnonymous { + pub spawner: ::subxt::sp_core::crypto::AccountId32, + pub proxy_type: runtime_types::rococo_runtime::ProxyType, + pub index: ::core::primitive::u16, + #[codec(compact)] + pub height: ::core::primitive::u32, + #[codec(compact)] + pub ext_index: ::core::primitive::u32, + } + impl ::subxt::Call for KillAnonymous { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "kill_anonymous"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Announce { + pub real: ::subxt::sp_core::crypto::AccountId32, + pub call_hash: ::subxt::sp_core::H256, + } + impl ::subxt::Call for Announce { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "announce"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RemoveAnnouncement { + pub real: ::subxt::sp_core::crypto::AccountId32, + pub call_hash: ::subxt::sp_core::H256, + } + impl ::subxt::Call for RemoveAnnouncement { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "remove_announcement"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RejectAnnouncement { + pub delegate: ::subxt::sp_core::crypto::AccountId32, + pub call_hash: ::subxt::sp_core::H256, + } + impl ::subxt::Call for RejectAnnouncement { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "reject_announcement"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ProxyAnnounced { + pub delegate: ::subxt::sp_core::crypto::AccountId32, + pub real: ::subxt::sp_core::crypto::AccountId32, + pub force_proxy_type: + ::core::option::Option, + pub call: runtime_types::rococo_runtime::Call, + } + impl ::subxt::Call for ProxyAnnounced { + const PALLET: &'static str = "Proxy"; + const FUNCTION: &'static str = "proxy_announced"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn proxy( + &self, + real: ::subxt::sp_core::crypto::AccountId32, + force_proxy_type: ::core::option::Option< + runtime_types::rococo_runtime::ProxyType, + >, + call: runtime_types::rococo_runtime::Call, + ) -> ::subxt::SubmittableExtrinsic { + let call = Proxy { + real, + force_proxy_type, + call, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn add_proxy( + &self, + delegate: ::subxt::sp_core::crypto::AccountId32, + proxy_type: runtime_types::rococo_runtime::ProxyType, + delay: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = AddProxy { + delegate, + proxy_type, + delay, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn remove_proxy( + &self, + delegate: ::subxt::sp_core::crypto::AccountId32, + proxy_type: runtime_types::rococo_runtime::ProxyType, + delay: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = RemoveProxy { + delegate, + proxy_type, + delay, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn remove_proxies( + &self, + ) -> ::subxt::SubmittableExtrinsic { + let call = RemoveProxies {}; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn anonymous( + &self, + proxy_type: runtime_types::rococo_runtime::ProxyType, + delay: ::core::primitive::u32, + index: ::core::primitive::u16, + ) -> ::subxt::SubmittableExtrinsic { + let call = Anonymous { + proxy_type, + delay, + index, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn kill_anonymous( + &self, + spawner: ::subxt::sp_core::crypto::AccountId32, + proxy_type: runtime_types::rococo_runtime::ProxyType, + index: ::core::primitive::u16, + height: ::core::primitive::u32, + ext_index: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = KillAnonymous { + spawner, + proxy_type, + index, + height, + ext_index, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn announce( + &self, + real: ::subxt::sp_core::crypto::AccountId32, + call_hash: ::subxt::sp_core::H256, + ) -> ::subxt::SubmittableExtrinsic { + let call = Announce { real, call_hash }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn remove_announcement( + &self, + real: ::subxt::sp_core::crypto::AccountId32, + call_hash: ::subxt::sp_core::H256, + ) -> ::subxt::SubmittableExtrinsic + { + let call = RemoveAnnouncement { real, call_hash }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn reject_announcement( + &self, + delegate: ::subxt::sp_core::crypto::AccountId32, + call_hash: ::subxt::sp_core::H256, + ) -> ::subxt::SubmittableExtrinsic + { + let call = RejectAnnouncement { + delegate, + call_hash, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn proxy_announced( + &self, + delegate: ::subxt::sp_core::crypto::AccountId32, + real: ::subxt::sp_core::crypto::AccountId32, + force_proxy_type: ::core::option::Option< + runtime_types::rococo_runtime::ProxyType, + >, + call: runtime_types::rococo_runtime::Call, + ) -> ::subxt::SubmittableExtrinsic { + let call = ProxyAnnounced { + delegate, + real, + force_proxy_type, + call, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_proxy::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ProxyExecuted( + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for ProxyExecuted { + const PALLET: &'static str = "Proxy"; + const EVENT: &'static str = "ProxyExecuted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AnonymousCreated( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::rococo_runtime::ProxyType, + pub ::core::primitive::u16, + ); + impl ::subxt::Event for AnonymousCreated { + const PALLET: &'static str = "Proxy"; + const EVENT: &'static str = "AnonymousCreated"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Announced( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::H256, + ); + impl ::subxt::Event for Announced { + const PALLET: &'static str = "Proxy"; + const EVENT: &'static str = "Announced"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ProxyAdded( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::rococo_runtime::ProxyType, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for ProxyAdded { + const PALLET: &'static str = "Proxy"; + const EVENT: &'static str = "ProxyAdded"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Proxies(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for Proxies { + const PALLET: &'static str = "Proxy"; + const STORAGE: &'static str = "Proxies"; + type Value = ( + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + runtime_types::pallet_proxy::ProxyDefinition< + ::subxt::sp_core::crypto::AccountId32, + runtime_types::rococo_runtime::ProxyType, + ::core::primitive::u32, + >, + >, + ::core::primitive::u128, + ); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct Announcements(pub ::subxt::sp_core::crypto::AccountId32); + impl ::subxt::StorageEntry for Announcements { + const PALLET: &'static str = "Proxy"; + const STORAGE: &'static str = "Announcements"; + type Value = ( + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + runtime_types::pallet_proxy::Announcement< + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::H256, + ::core::primitive::u32, + >, + >, + ::core::primitive::u128, + ); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn proxies( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ( + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + runtime_types::pallet_proxy::ProxyDefinition< + ::subxt::sp_core::crypto::AccountId32, + runtime_types::rococo_runtime::ProxyType, + ::core::primitive::u32, + >, + >, + ::core::primitive::u128, + ), + ::subxt::Error, + > { + let entry = Proxies(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn proxies_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Proxies>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn announcements( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ( + runtime_types::frame_support::storage::bounded_vec::BoundedVec< + runtime_types::pallet_proxy::Announcement< + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::H256, + ::core::primitive::u32, + >, + >, + ::core::primitive::u128, + ), + ::subxt::Error, + > { + let entry = Announcements(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn announcements_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Announcements>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + } + } + } + pub mod multisig { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AsMultiThreshold1 { + pub other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + pub call: runtime_types::rococo_runtime::Call, + } + impl ::subxt::Call for AsMultiThreshold1 { + const PALLET: &'static str = "Multisig"; + const FUNCTION: &'static str = "as_multi_threshold1"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AsMulti { + pub threshold: ::core::primitive::u16, + pub other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + pub maybe_timepoint: ::core::option::Option< + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + >, + pub call: ::std::vec::Vec<::core::primitive::u8>, + pub store_call: ::core::primitive::bool, + pub max_weight: ::core::primitive::u64, + } + impl ::subxt::Call for AsMulti { + const PALLET: &'static str = "Multisig"; + const FUNCTION: &'static str = "as_multi"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ApproveAsMulti { + pub threshold: ::core::primitive::u16, + pub other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + pub maybe_timepoint: ::core::option::Option< + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + >, + pub call_hash: [::core::primitive::u8; 32usize], + pub max_weight: ::core::primitive::u64, + } + impl ::subxt::Call for ApproveAsMulti { + const PALLET: &'static str = "Multisig"; + const FUNCTION: &'static str = "approve_as_multi"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CancelAsMulti { + pub threshold: ::core::primitive::u16, + pub other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + pub timepoint: + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + pub call_hash: [::core::primitive::u8; 32usize], + } + impl ::subxt::Call for CancelAsMulti { + const PALLET: &'static str = "Multisig"; + const FUNCTION: &'static str = "cancel_as_multi"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn as_multi_threshold1( + &self, + other_signatories: ::std::vec::Vec< + ::subxt::sp_core::crypto::AccountId32, + >, + call: runtime_types::rococo_runtime::Call, + ) -> ::subxt::SubmittableExtrinsic { + let call = AsMultiThreshold1 { + other_signatories, + call, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn as_multi( + &self, + threshold: ::core::primitive::u16, + other_signatories: ::std::vec::Vec< + ::subxt::sp_core::crypto::AccountId32, + >, + maybe_timepoint: ::core::option::Option< + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + >, + call: ::std::vec::Vec<::core::primitive::u8>, + store_call: ::core::primitive::bool, + max_weight: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic { + let call = AsMulti { + threshold, + other_signatories, + maybe_timepoint, + call, + store_call, + max_weight, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn approve_as_multi( + &self, + threshold: ::core::primitive::u16, + other_signatories: ::std::vec::Vec< + ::subxt::sp_core::crypto::AccountId32, + >, + maybe_timepoint: ::core::option::Option< + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + >, + call_hash: [::core::primitive::u8; 32usize], + max_weight: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic { + let call = ApproveAsMulti { + threshold, + other_signatories, + maybe_timepoint, + call_hash, + max_weight, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn cancel_as_multi( + &self, + threshold: ::core::primitive::u16, + other_signatories: ::std::vec::Vec< + ::subxt::sp_core::crypto::AccountId32, + >, + timepoint: runtime_types::pallet_multisig::Timepoint< + ::core::primitive::u32, + >, + call_hash: [::core::primitive::u8; 32usize], + ) -> ::subxt::SubmittableExtrinsic { + let call = CancelAsMulti { + threshold, + other_signatories, + timepoint, + call_hash, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_multisig::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NewMultisig( + pub ::subxt::sp_core::crypto::AccountId32, + pub ::subxt::sp_core::crypto::AccountId32, + pub [::core::primitive::u8; 32usize], + ); + impl ::subxt::Event for NewMultisig { + const PALLET: &'static str = "Multisig"; + const EVENT: &'static str = "NewMultisig"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MultisigApproval( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + pub ::subxt::sp_core::crypto::AccountId32, + pub [::core::primitive::u8; 32usize], + ); + impl ::subxt::Event for MultisigApproval { + const PALLET: &'static str = "Multisig"; + const EVENT: &'static str = "MultisigApproval"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MultisigExecuted( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + pub ::subxt::sp_core::crypto::AccountId32, + pub [::core::primitive::u8; 32usize], + pub ::core::result::Result<(), runtime_types::sp_runtime::DispatchError>, + ); + impl ::subxt::Event for MultisigExecuted { + const PALLET: &'static str = "Multisig"; + const EVENT: &'static str = "MultisigExecuted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MultisigCancelled( + pub ::subxt::sp_core::crypto::AccountId32, + pub runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + pub ::subxt::sp_core::crypto::AccountId32, + pub [::core::primitive::u8; 32usize], + ); + impl ::subxt::Event for MultisigCancelled { + const PALLET: &'static str = "Multisig"; + const EVENT: &'static str = "MultisigCancelled"; + } + } + pub mod storage { + use super::runtime_types; + pub struct Multisigs( + ::subxt::sp_core::crypto::AccountId32, + [::core::primitive::u8; 32usize], + ); + impl ::subxt::StorageEntry for Multisigs { + const PALLET: &'static str = "Multisig"; + const STORAGE: &'static str = "Multisigs"; + type Value = runtime_types::pallet_multisig::Multisig< + ::core::primitive::u32, + ::core::primitive::u128, + ::subxt::sp_core::crypto::AccountId32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Blake2_128Concat, + ), + ]) + } + } + pub struct Calls(pub [::core::primitive::u8; 32usize]); + impl ::subxt::StorageEntry for Calls { + const PALLET: &'static str = "Multisig"; + const STORAGE: &'static str = "Calls"; + type Value = ( + ::std::vec::Vec<::core::primitive::u8>, + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn multisigs( + &self, + _0: ::subxt::sp_core::crypto::AccountId32, + _1: [::core::primitive::u8; 32usize], + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::pallet_multisig::Multisig< + ::core::primitive::u32, + ::core::primitive::u128, + ::subxt::sp_core::crypto::AccountId32, + >, + >, + ::subxt::Error, + > { + let entry = Multisigs(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn multisigs_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Multisigs>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn calls( + &self, + _0: [::core::primitive::u8; 32usize], + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<( + ::std::vec::Vec<::core::primitive::u8>, + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + )>, + ::subxt::Error, + > { + let entry = Calls(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn calls_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::subxt::KeyIter<'a, T, Calls>, ::subxt::Error> + { + self.client.storage().iter(hash).await + } + } + } + } + pub mod xcm_pallet { + use super::runtime_types; + pub mod calls { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Send { + pub dest: runtime_types::xcm::VersionedMultiLocation, + pub message: runtime_types::xcm::VersionedXcm, + } + impl ::subxt::Call for Send { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "send"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct TeleportAssets { + pub dest: runtime_types::xcm::VersionedMultiLocation, + pub beneficiary: runtime_types::xcm::VersionedMultiLocation, + pub assets: runtime_types::xcm::VersionedMultiAssets, + pub fee_asset_item: ::core::primitive::u32, + } + impl ::subxt::Call for TeleportAssets { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "teleport_assets"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReserveTransferAssets { + pub dest: runtime_types::xcm::VersionedMultiLocation, + pub beneficiary: runtime_types::xcm::VersionedMultiLocation, + pub assets: runtime_types::xcm::VersionedMultiAssets, + pub fee_asset_item: ::core::primitive::u32, + } + impl ::subxt::Call for ReserveTransferAssets { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "reserve_transfer_assets"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Execute { + pub message: runtime_types::xcm::VersionedXcm, + pub max_weight: ::core::primitive::u64, + } + impl ::subxt::Call for Execute { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "execute"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceXcmVersion { + pub location: runtime_types::xcm::v1::multilocation::MultiLocation, + pub xcm_version: ::core::primitive::u32, + } + impl ::subxt::Call for ForceXcmVersion { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "force_xcm_version"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceDefaultXcmVersion { + pub maybe_xcm_version: ::core::option::Option<::core::primitive::u32>, + } + impl ::subxt::Call for ForceDefaultXcmVersion { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "force_default_xcm_version"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceSubscribeVersionNotify { + pub location: runtime_types::xcm::VersionedMultiLocation, + } + impl ::subxt::Call for ForceSubscribeVersionNotify { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "force_subscribe_version_notify"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ForceUnsubscribeVersionNotify { + pub location: runtime_types::xcm::VersionedMultiLocation, + } + impl ::subxt::Call for ForceUnsubscribeVersionNotify { + const PALLET: &'static str = "XcmPallet"; + const FUNCTION: &'static str = "force_unsubscribe_version_notify"; + } + pub struct TransactionApi< + 'a, + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + > { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub fn send( + &self, + dest: runtime_types::xcm::VersionedMultiLocation, + message: runtime_types::xcm::VersionedXcm, + ) -> ::subxt::SubmittableExtrinsic { + let call = Send { dest, message }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn teleport_assets( + &self, + dest: runtime_types::xcm::VersionedMultiLocation, + beneficiary: runtime_types::xcm::VersionedMultiLocation, + assets: runtime_types::xcm::VersionedMultiAssets, + fee_asset_item: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = TeleportAssets { + dest, + beneficiary, + assets, + fee_asset_item, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn reserve_transfer_assets( + &self, + dest: runtime_types::xcm::VersionedMultiLocation, + beneficiary: runtime_types::xcm::VersionedMultiLocation, + assets: runtime_types::xcm::VersionedMultiAssets, + fee_asset_item: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ReserveTransferAssets { + dest, + beneficiary, + assets, + fee_asset_item, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn execute( + &self, + message: runtime_types::xcm::VersionedXcm, + max_weight: ::core::primitive::u64, + ) -> ::subxt::SubmittableExtrinsic { + let call = Execute { + message, + max_weight, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_xcm_version( + &self, + location: runtime_types::xcm::v1::multilocation::MultiLocation, + xcm_version: ::core::primitive::u32, + ) -> ::subxt::SubmittableExtrinsic { + let call = ForceXcmVersion { + location, + xcm_version, + }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_default_xcm_version( + &self, + maybe_xcm_version: ::core::option::Option<::core::primitive::u32>, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceDefaultXcmVersion { maybe_xcm_version }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_subscribe_version_notify( + &self, + location: runtime_types::xcm::VersionedMultiLocation, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceSubscribeVersionNotify { location }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + pub fn force_unsubscribe_version_notify( + &self, + location: runtime_types::xcm::VersionedMultiLocation, + ) -> ::subxt::SubmittableExtrinsic + { + let call = ForceUnsubscribeVersionNotify { location }; + ::subxt::SubmittableExtrinsic::new(self.client, call) + } + } + } + pub type Event = runtime_types::pallet_xcm::pallet::Event; + pub mod events { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Attempted(pub runtime_types::xcm::v2::traits::Outcome); + impl ::subxt::Event for Attempted { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "Attempted"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Sent( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub runtime_types::xcm::v2::Xcm, + ); + impl ::subxt::Event for Sent { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "Sent"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct UnexpectedResponse( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for UnexpectedResponse { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "UnexpectedResponse"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ResponseReady( + pub ::core::primitive::u64, + pub runtime_types::xcm::v2::Response, + ); + impl ::subxt::Event for ResponseReady { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "ResponseReady"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Notified( + pub ::core::primitive::u64, + pub ::core::primitive::u8, + pub ::core::primitive::u8, + ); + impl ::subxt::Event for Notified { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "Notified"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NotifyOverweight( + pub ::core::primitive::u64, + pub ::core::primitive::u8, + pub ::core::primitive::u8, + pub ::core::primitive::u64, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for NotifyOverweight { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "NotifyOverweight"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NotifyDispatchError( + pub ::core::primitive::u64, + pub ::core::primitive::u8, + pub ::core::primitive::u8, + ); + impl ::subxt::Event for NotifyDispatchError { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "NotifyDispatchError"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NotifyDecodeFailed( + pub ::core::primitive::u64, + pub ::core::primitive::u8, + pub ::core::primitive::u8, + ); + impl ::subxt::Event for NotifyDecodeFailed { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "NotifyDecodeFailed"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct InvalidResponder( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub ::core::primitive::u64, + pub ::core::option::Option< + runtime_types::xcm::v1::multilocation::MultiLocation, + >, + ); + impl ::subxt::Event for InvalidResponder { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "InvalidResponder"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct InvalidResponderVersion( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for InvalidResponderVersion { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "InvalidResponderVersion"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ResponseTaken(pub ::core::primitive::u64); + impl ::subxt::Event for ResponseTaken { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "ResponseTaken"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AssetsTrapped( + pub ::subxt::sp_core::H256, + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub runtime_types::xcm::VersionedMultiAssets, + ); + impl ::subxt::Event for AssetsTrapped { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "AssetsTrapped"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct VersionChangeNotified( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for VersionChangeNotified { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "VersionChangeNotified"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SupportedVersionChanged( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub ::core::primitive::u32, + ); + impl ::subxt::Event for SupportedVersionChanged { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "SupportedVersionChanged"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NotifyTargetSendFail( + pub runtime_types::xcm::v1::multilocation::MultiLocation, + pub ::core::primitive::u64, + pub runtime_types::xcm::v2::traits::Error, + ); + impl ::subxt::Event for NotifyTargetSendFail { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "NotifyTargetSendFail"; + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct NotifyTargetMigrationFail( + pub runtime_types::xcm::VersionedMultiLocation, + pub ::core::primitive::u64, + ); + impl ::subxt::Event for NotifyTargetMigrationFail { + const PALLET: &'static str = "XcmPallet"; + const EVENT: &'static str = "NotifyTargetMigrationFail"; + } + } + pub mod storage { + use super::runtime_types; + pub struct QueryCounter; + impl ::subxt::StorageEntry for QueryCounter { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "QueryCounter"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct Queries(pub ::core::primitive::u64); + impl ::subxt::StorageEntry for Queries { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "Queries"; + type Value = runtime_types::pallet_xcm::pallet::QueryStatus< + ::core::primitive::u32, + >; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Blake2_128Concat, + )]) + } + } + pub struct AssetTraps(pub ::subxt::sp_core::H256); + impl ::subxt::StorageEntry for AssetTraps { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "AssetTraps"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Identity, + )]) + } + } + pub struct SafeXcmVersion; + impl ::subxt::StorageEntry for SafeXcmVersion { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "SafeXcmVersion"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct SupportedVersion( + ::core::primitive::u32, + runtime_types::xcm::VersionedMultiLocation, + ); + impl ::subxt::StorageEntry for SupportedVersion { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "SupportedVersion"; + type Value = ::core::primitive::u32; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Blake2_128Concat, + ), + ]) + } + } + pub struct VersionNotifiers( + ::core::primitive::u32, + runtime_types::xcm::VersionedMultiLocation, + ); + impl ::subxt::StorageEntry for VersionNotifiers { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "VersionNotifiers"; + type Value = ::core::primitive::u64; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Blake2_128Concat, + ), + ]) + } + } + pub struct VersionNotifyTargets( + ::core::primitive::u32, + runtime_types::xcm::VersionedMultiLocation, + ); + impl ::subxt::StorageEntry for VersionNotifyTargets { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "VersionNotifyTargets"; + type Value = ( + ::core::primitive::u64, + ::core::primitive::u64, + ::core::primitive::u32, + ); + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Map(vec![ + ::subxt::StorageMapKey::new( + &self.0, + ::subxt::StorageHasher::Twox64Concat, + ), + ::subxt::StorageMapKey::new( + &self.1, + ::subxt::StorageHasher::Blake2_128Concat, + ), + ]) + } + } + pub struct VersionDiscoveryQueue; + impl ::subxt::StorageEntry for VersionDiscoveryQueue { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "VersionDiscoveryQueue"; + type Value = + runtime_types::frame_support::storage::bounded_vec::BoundedVec<( + runtime_types::xcm::VersionedMultiLocation, + ::core::primitive::u32, + )>; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct CurrentMigration; + impl ::subxt::StorageEntry for CurrentMigration { + const PALLET: &'static str = "XcmPallet"; + const STORAGE: &'static str = "CurrentMigration"; + type Value = runtime_types::pallet_xcm::pallet::VersionMigrationStage; + fn key(&self) -> ::subxt::StorageEntryKey { + ::subxt::StorageEntryKey::Plain + } + } + pub struct StorageApi<'a, T: ::subxt::Config> { + client: &'a ::subxt::Client, + } + impl<'a, T: ::subxt::Config> StorageApi<'a, T> { + pub fn new(client: &'a ::subxt::Client) -> Self { + Self { client } + } + pub async fn query_counter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u64, ::subxt::Error> + { + let entry = QueryCounter; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn queries( + &self, + _0: ::core::primitive::u64, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::pallet_xcm::pallet::QueryStatus< + ::core::primitive::u32, + >, + >, + ::subxt::Error, + > { + let entry = Queries(_0); + self.client.storage().fetch(&entry, hash).await + } + pub async fn queries_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, Queries>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn asset_traps( + &self, + _0: ::subxt::sp_core::H256, + hash: ::core::option::Option, + ) -> ::core::result::Result<::core::primitive::u32, ::subxt::Error> + { + let entry = AssetTraps(_0); + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn asset_traps_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, AssetTraps>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn safe_xcm_version( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = SafeXcmVersion; + self.client.storage().fetch(&entry, hash).await + } + pub async fn supported_version( + &self, + _0: ::core::primitive::u32, + _1: runtime_types::xcm::VersionedMultiLocation, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u32>, + ::subxt::Error, + > { + let entry = SupportedVersion(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn supported_version_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, SupportedVersion>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn version_notifiers( + &self, + _0: ::core::primitive::u32, + _1: runtime_types::xcm::VersionedMultiLocation, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<::core::primitive::u64>, + ::subxt::Error, + > { + let entry = VersionNotifiers(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn version_notifiers_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, VersionNotifiers>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn version_notify_targets( + &self, + _0: ::core::primitive::u32, + _1: runtime_types::xcm::VersionedMultiLocation, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option<( + ::core::primitive::u64, + ::core::primitive::u64, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = VersionNotifyTargets(_0, _1); + self.client.storage().fetch(&entry, hash).await + } + pub async fn version_notify_targets_iter( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::subxt::KeyIter<'a, T, VersionNotifyTargets>, + ::subxt::Error, + > { + self.client.storage().iter(hash).await + } + pub async fn version_discovery_queue( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + runtime_types::frame_support::storage::bounded_vec::BoundedVec<( + runtime_types::xcm::VersionedMultiLocation, + ::core::primitive::u32, + )>, + ::subxt::Error, + > { + let entry = VersionDiscoveryQueue; + self.client.storage().fetch_or_default(&entry, hash).await + } + pub async fn current_migration( + &self, + hash: ::core::option::Option, + ) -> ::core::result::Result< + ::core::option::Option< + runtime_types::pallet_xcm::pallet::VersionMigrationStage, + >, + ::subxt::Error, + > { + let entry = CurrentMigration; + self.client.storage().fetch(&entry, hash).await + } + } + } + } + pub mod runtime_types { + use super::runtime_types; + pub mod beefy_primitives { + use super::runtime_types; + pub mod crypto { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub runtime_types::sp_core::ecdsa::Public); + } + pub mod mmr { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BeefyNextAuthoritySet<_0> { + pub id: ::core::primitive::u64, + pub len: ::core::primitive::u32, + pub root: _0, + } + } + } + pub mod bitvec { + use super::runtime_types; + pub mod order { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Lsb0 {} + } + } + pub mod finality_grandpa { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Equivocation<_0, _1, _2> { + pub round_number: ::core::primitive::u64, + pub identity: _0, + pub first: (_1, _2), + pub second: (_1, _2), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Precommit<_0, _1> { + pub target_hash: _0, + pub target_number: _1, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Prevote<_0, _1> { + pub target_hash: _0, + pub target_number: _1, + } + } + pub mod frame_support { + use super::runtime_types; + pub mod storage { + use super::runtime_types; + pub mod bounded_vec { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct BoundedVec<_0>(pub ::std::vec::Vec<_0>); + } + pub mod weak_bounded_vec { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct WeakBoundedVec<_0>(pub ::std::vec::Vec<_0>); + } + } + pub mod traits { + use super::runtime_types; + pub mod misc { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct WrapperOpaque<_0>( + #[codec(compact)] ::core::primitive::u32, + pub _0, + ); + } + pub mod tokens { + use super::runtime_types; + pub mod misc { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum BalanceStatus { + #[codec(index = 0)] + Free, + #[codec(index = 1)] + Reserved, + } + } + } + } + pub mod weights { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum DispatchClass { + #[codec(index = 0)] + Normal, + #[codec(index = 1)] + Operational, + #[codec(index = 2)] + Mandatory, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DispatchInfo { + pub weight: ::core::primitive::u64, + pub class: runtime_types::frame_support::weights::DispatchClass, + pub pays_fee: runtime_types::frame_support::weights::Pays, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Pays { + #[codec(index = 0)] + Yes, + #[codec(index = 1)] + No, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct PerDispatchClass<_0> { + pub normal: _0, + pub operational: _0, + pub mandatory: _0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RuntimeDbWeight { + pub read: ::core::primitive::u64, + pub write: ::core::primitive::u64, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct WeightToFeeCoefficient<_0> { + pub coeff_integer: _0, + pub coeff_frac: runtime_types::sp_arithmetic::per_things::Perbill, + pub negative: ::core::primitive::bool, + pub degree: ::core::primitive::u8, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct PalletId(pub [::core::primitive::u8; 8usize]); + } + pub mod frame_system { + use super::runtime_types; + pub mod extensions { + use super::runtime_types; + pub mod check_genesis { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct CheckGenesis {} + } + pub mod check_mortality { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct CheckMortality( + pub runtime_types::sp_runtime::generic::era::Era, + ); + } + pub mod check_nonce { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct CheckNonce(#[codec(compact)] pub ::core::primitive::u32); + } + pub mod check_spec_version { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct CheckSpecVersion {} + } + pub mod check_tx_version { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct CheckTxVersion {} + } + pub mod check_weight { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct CheckWeight {} + } + } + pub mod limits { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BlockLength { + pub max: runtime_types::frame_support::weights::PerDispatchClass< + ::core::primitive::u32, + >, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BlockWeights { + pub base_block: ::core::primitive::u64, + pub max_block: ::core::primitive::u64, + pub per_class: + runtime_types::frame_support::weights::PerDispatchClass< + runtime_types::frame_system::limits::WeightsPerClass, + >, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct WeightsPerClass { + pub base_extrinsic: ::core::primitive::u64, + pub max_extrinsic: ::core::option::Option<::core::primitive::u64>, + pub max_total: ::core::option::Option<::core::primitive::u64>, + pub reserved: ::core::option::Option<::core::primitive::u64>, + } + } + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + # [codec (index = 0)] fill_block { ratio : runtime_types :: sp_arithmetic :: per_things :: Perbill , } , # [codec (index = 1)] remark { remark : :: std :: vec :: Vec < :: core :: primitive :: u8 > , } , # [codec (index = 2)] set_heap_pages { pages : :: core :: primitive :: u64 , } , # [codec (index = 3)] set_code { code : :: std :: vec :: Vec < :: core :: primitive :: u8 > , } , # [codec (index = 4)] set_code_without_checks { code : :: std :: vec :: Vec < :: core :: primitive :: u8 > , } , # [codec (index = 5)] set_changes_trie_config { changes_trie_config : :: core :: option :: Option < runtime_types :: sp_core :: changes_trie :: ChangesTrieConfiguration > , } , # [codec (index = 6)] set_storage { items : :: std :: vec :: Vec < (:: std :: vec :: Vec < :: core :: primitive :: u8 > , :: std :: vec :: Vec < :: core :: primitive :: u8 > ,) > , } , # [codec (index = 7)] kill_storage { keys : :: std :: vec :: Vec < :: std :: vec :: Vec < :: core :: primitive :: u8 > > , } , # [codec (index = 8)] kill_prefix { prefix : :: std :: vec :: Vec < :: core :: primitive :: u8 > , subkeys : :: core :: primitive :: u32 , } , # [codec (index = 9)] remark_with_event { remark : :: std :: vec :: Vec < :: core :: primitive :: u8 > , } , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + InvalidSpecName, + #[codec(index = 1)] + SpecVersionNeedsToIncrease, + #[codec(index = 2)] + FailedToExtractRuntimeVersion, + #[codec(index = 3)] + NonDefaultComposite, + #[codec(index = 4)] + NonZeroRefCount, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + ExtrinsicSuccess(runtime_types::frame_support::weights::DispatchInfo), + #[codec(index = 1)] + ExtrinsicFailed( + runtime_types::sp_runtime::DispatchError, + runtime_types::frame_support::weights::DispatchInfo, + ), + #[codec(index = 2)] + CodeUpdated, + #[codec(index = 3)] + NewAccount(::subxt::sp_core::crypto::AccountId32), + #[codec(index = 4)] + KilledAccount(::subxt::sp_core::crypto::AccountId32), + #[codec(index = 5)] + Remarked( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::H256, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AccountInfo<_0, _1> { + pub nonce: _0, + pub consumers: _0, + pub providers: _0, + pub sufficients: _0, + pub data: _1, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct EventRecord<_0, _1> { + pub phase: runtime_types::frame_system::Phase, + pub event: _0, + pub topics: ::std::vec::Vec<_1>, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct LastRuntimeUpgradeInfo { + #[codec(compact)] + pub spec_version: ::core::primitive::u32, + pub spec_name: ::std::string::String, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Phase { + #[codec(index = 0)] + ApplyExtrinsic(::core::primitive::u32), + #[codec(index = 1)] + Finalization, + #[codec(index = 2)] + Initialization, + } + } + pub mod pallet_authorship { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + set_uncles { + new_uncles: ::std::vec::Vec< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + >, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + InvalidUncleParent, + #[codec(index = 1)] + UnclesAlreadySet, + #[codec(index = 2)] + TooManyUncles, + #[codec(index = 3)] + GenesisUncle, + #[codec(index = 4)] + TooHighUncle, + #[codec(index = 5)] + UncleAlreadyIncluded, + #[codec(index = 6)] + OldUncle, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum UncleEntryItem<_0, _1, _2> { + #[codec(index = 0)] + InclusionHeight(_0), + #[codec(index = 1)] + Uncle(_1, ::core::option::Option<_2>), + } + } + pub mod pallet_babe { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + # [codec (index = 0)] report_equivocation { equivocation_proof : :: std :: boxed :: Box < runtime_types :: sp_consensus_slots :: EquivocationProof < runtime_types :: sp_runtime :: generic :: header :: Header < :: core :: primitive :: u32 , runtime_types :: sp_runtime :: traits :: BlakeTwo256 > , runtime_types :: sp_consensus_babe :: app :: Public > > , key_owner_proof : runtime_types :: sp_session :: MembershipProof , } , # [codec (index = 1)] report_equivocation_unsigned { equivocation_proof : :: std :: boxed :: Box < runtime_types :: sp_consensus_slots :: EquivocationProof < runtime_types :: sp_runtime :: generic :: header :: Header < :: core :: primitive :: u32 , runtime_types :: sp_runtime :: traits :: BlakeTwo256 > , runtime_types :: sp_consensus_babe :: app :: Public > > , key_owner_proof : runtime_types :: sp_session :: MembershipProof , } , # [codec (index = 2)] plan_config_change { config : runtime_types :: sp_consensus_babe :: digests :: NextConfigDescriptor , } , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + InvalidEquivocationProof, + #[codec(index = 1)] + InvalidKeyOwnershipProof, + #[codec(index = 2)] + DuplicateOffenceReport, + } + } + } + pub mod pallet_balances { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + transfer { + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + value: ::core::primitive::u128, + }, + #[codec(index = 1)] + set_balance { + who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + new_free: ::core::primitive::u128, + #[codec(compact)] + new_reserved: ::core::primitive::u128, + }, + #[codec(index = 2)] + force_transfer { + source: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + value: ::core::primitive::u128, + }, + #[codec(index = 3)] + transfer_keep_alive { + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + #[codec(compact)] + value: ::core::primitive::u128, + }, + #[codec(index = 4)] + transfer_all { + dest: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + keep_alive: ::core::primitive::bool, + }, + #[codec(index = 5)] + force_unreserve { + who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + amount: ::core::primitive::u128, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + VestingBalance, + #[codec(index = 1)] + LiquidityRestrictions, + #[codec(index = 2)] + InsufficientBalance, + #[codec(index = 3)] + ExistentialDeposit, + #[codec(index = 4)] + KeepAlive, + #[codec(index = 5)] + ExistingVestingSchedule, + #[codec(index = 6)] + DeadAccount, + #[codec(index = 7)] + TooManyReserves, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + Endowed( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 1)] + DustLost( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 2)] + Transfer( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 3)] + BalanceSet( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ::core::primitive::u128, + ), + #[codec(index = 4)] + Deposit( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 5)] + Reserved( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 6)] + Unreserved( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 7)] + ReserveRepatriated( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + runtime_types::frame_support::traits::tokens::misc::BalanceStatus, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AccountData<_0> { + pub free: _0, + pub reserved: _0, + pub misc_frozen: _0, + pub fee_frozen: _0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BalanceLock<_0> { + pub id: [::core::primitive::u8; 8usize], + pub amount: _0, + pub reasons: runtime_types::pallet_balances::Reasons, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Reasons { + #[codec(index = 0)] + Fee, + #[codec(index = 1)] + Misc, + #[codec(index = 2)] + All, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Releases { + #[codec(index = 0)] + V1_0_0, + #[codec(index = 1)] + V2_0_0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReserveData<_0, _1> { + pub id: _0, + pub amount: _1, + } + } + pub mod pallet_collective { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + set_members { + new_members: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + prime: + ::core::option::Option<::subxt::sp_core::crypto::AccountId32>, + old_count: ::core::primitive::u32, + }, + #[codec(index = 1)] + execute { + proposal: ::std::boxed::Box, + #[codec(compact)] + length_bound: ::core::primitive::u32, + }, + #[codec(index = 2)] + propose { + #[codec(compact)] + threshold: ::core::primitive::u32, + proposal: ::std::boxed::Box, + #[codec(compact)] + length_bound: ::core::primitive::u32, + }, + #[codec(index = 3)] + vote { + proposal: ::subxt::sp_core::H256, + #[codec(compact)] + index: ::core::primitive::u32, + approve: ::core::primitive::bool, + }, + #[codec(index = 4)] + close { + proposal_hash: ::subxt::sp_core::H256, + #[codec(compact)] + index: ::core::primitive::u32, + #[codec(compact)] + proposal_weight_bound: ::core::primitive::u64, + #[codec(compact)] + length_bound: ::core::primitive::u32, + }, + #[codec(index = 5)] + disapprove_proposal { + proposal_hash: ::subxt::sp_core::H256, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + NotMember, + #[codec(index = 1)] + DuplicateProposal, + #[codec(index = 2)] + ProposalMissing, + #[codec(index = 3)] + WrongIndex, + #[codec(index = 4)] + DuplicateVote, + #[codec(index = 5)] + AlreadyInitialized, + #[codec(index = 6)] + TooEarly, + #[codec(index = 7)] + TooManyProposals, + #[codec(index = 8)] + WrongProposalWeight, + #[codec(index = 9)] + WrongProposalLength, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + Proposed( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u32, + ::subxt::sp_core::H256, + ::core::primitive::u32, + ), + #[codec(index = 1)] + Voted( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::H256, + ::core::primitive::bool, + ::core::primitive::u32, + ::core::primitive::u32, + ), + #[codec(index = 2)] + Approved(::subxt::sp_core::H256), + #[codec(index = 3)] + Disapproved(::subxt::sp_core::H256), + #[codec(index = 4)] + Executed( + ::subxt::sp_core::H256, + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + #[codec(index = 5)] + MemberExecuted( + ::subxt::sp_core::H256, + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + #[codec(index = 6)] + Closed( + ::subxt::sp_core::H256, + ::core::primitive::u32, + ::core::primitive::u32, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Votes<_0, _1> { + pub index: _1, + pub threshold: _1, + pub ayes: ::std::vec::Vec<_0>, + pub nays: ::std::vec::Vec<_0>, + pub end: _1, + } + } + pub mod pallet_grandpa { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + report_equivocation { + equivocation_proof: ::std::boxed::Box< + runtime_types::sp_finality_grandpa::EquivocationProof< + ::subxt::sp_core::H256, + ::core::primitive::u32, + >, + >, + key_owner_proof: runtime_types::sp_session::MembershipProof, + }, + #[codec(index = 1)] + report_equivocation_unsigned { + equivocation_proof: ::std::boxed::Box< + runtime_types::sp_finality_grandpa::EquivocationProof< + ::subxt::sp_core::H256, + ::core::primitive::u32, + >, + >, + key_owner_proof: runtime_types::sp_session::MembershipProof, + }, + #[codec(index = 2)] + note_stalled { + delay: ::core::primitive::u32, + best_finalized_block_number: ::core::primitive::u32, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + PauseFailed, + #[codec(index = 1)] + ResumeFailed, + #[codec(index = 2)] + ChangePending, + #[codec(index = 3)] + TooSoon, + #[codec(index = 4)] + InvalidKeyOwnershipProof, + #[codec(index = 5)] + InvalidEquivocationProof, + #[codec(index = 6)] + DuplicateOffenceReport, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + NewAuthorities( + ::std::vec::Vec<( + runtime_types::sp_finality_grandpa::app::Public, + ::core::primitive::u64, + )>, + ), + #[codec(index = 1)] + Paused, + #[codec(index = 2)] + Resumed, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct StoredPendingChange < _0 > { pub scheduled_at : _0 , pub delay : _0 , pub next_authorities : runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < (runtime_types :: sp_finality_grandpa :: app :: Public , :: core :: primitive :: u64 ,) > , pub forced : :: core :: option :: Option < _0 > , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum StoredState<_0> { + #[codec(index = 0)] + Live, + #[codec(index = 1)] + PendingPause { scheduled_at: _0, delay: _0 }, + #[codec(index = 2)] + Paused, + #[codec(index = 3)] + PendingResume { scheduled_at: _0, delay: _0 }, + } + } + pub mod pallet_im_online { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + # [codec (index = 0)] heartbeat { heartbeat : runtime_types :: pallet_im_online :: Heartbeat < :: core :: primitive :: u32 > , signature : runtime_types :: pallet_im_online :: sr25519 :: app_sr25519 :: Signature , } , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + InvalidKey, + #[codec(index = 1)] + DuplicatedHeartbeat, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + HeartbeatReceived( + runtime_types::pallet_im_online::sr25519::app_sr25519::Public, + ), + #[codec(index = 1)] + AllGood, + #[codec(index = 2)] + SomeOffline( + ::std::vec::Vec<(::subxt::sp_core::crypto::AccountId32, ())>, + ), + } + } + pub mod sr25519 { + use super::runtime_types; + pub mod app_sr25519 { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Public(pub runtime_types::sp_core::sr25519::Public); + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Signature(pub runtime_types::sp_core::sr25519::Signature); + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BoundedOpaqueNetworkState { pub peer_id : runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < :: core :: primitive :: u8 > , pub external_addresses : runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < runtime_types :: frame_support :: storage :: weak_bounded_vec :: WeakBoundedVec < :: core :: primitive :: u8 > > , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Heartbeat<_0> { + pub block_number: _0, + pub network_state: runtime_types::sp_core::offchain::OpaqueNetworkState, + pub session_index: _0, + pub authority_index: _0, + pub validators_len: _0, + } + } + pub mod pallet_indices { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + claim { index: ::core::primitive::u32 }, + #[codec(index = 1)] + transfer { + new: ::subxt::sp_core::crypto::AccountId32, + index: ::core::primitive::u32, + }, + #[codec(index = 2)] + free { index: ::core::primitive::u32 }, + #[codec(index = 3)] + force_transfer { + new: ::subxt::sp_core::crypto::AccountId32, + index: ::core::primitive::u32, + freeze: ::core::primitive::bool, + }, + #[codec(index = 4)] + freeze { index: ::core::primitive::u32 }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + NotAssigned, + #[codec(index = 1)] + NotOwner, + #[codec(index = 2)] + InUse, + #[codec(index = 3)] + NotTransfer, + #[codec(index = 4)] + Permanent, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + IndexAssigned( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u32, + ), + #[codec(index = 1)] + IndexFreed(::core::primitive::u32), + #[codec(index = 2)] + IndexFrozen( + ::core::primitive::u32, + ::subxt::sp_core::crypto::AccountId32, + ), + } + } + } + pub mod pallet_membership { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + add_member { + who: ::subxt::sp_core::crypto::AccountId32, + }, + #[codec(index = 1)] + remove_member { + who: ::subxt::sp_core::crypto::AccountId32, + }, + #[codec(index = 2)] + swap_member { + remove: ::subxt::sp_core::crypto::AccountId32, + add: ::subxt::sp_core::crypto::AccountId32, + }, + #[codec(index = 3)] + reset_members { + members: ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + }, + #[codec(index = 4)] + change_key { + new: ::subxt::sp_core::crypto::AccountId32, + }, + #[codec(index = 5)] + set_prime { + who: ::subxt::sp_core::crypto::AccountId32, + }, + #[codec(index = 6)] + clear_prime, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + AlreadyMember, + #[codec(index = 1)] + NotMember, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + MemberAdded, + #[codec(index = 1)] + MemberRemoved, + #[codec(index = 2)] + MembersSwapped, + #[codec(index = 3)] + MembersReset, + #[codec(index = 4)] + KeyChanged, + #[codec(index = 5)] + Dummy, + } + } + } + pub mod pallet_multisig { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + as_multi_threshold_1 { + other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + call: ::std::boxed::Box, + }, + #[codec(index = 1)] + as_multi { + threshold: ::core::primitive::u16, + other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + maybe_timepoint: ::core::option::Option< + runtime_types::pallet_multisig::Timepoint< + ::core::primitive::u32, + >, + >, + call: ::std::vec::Vec<::core::primitive::u8>, + store_call: ::core::primitive::bool, + max_weight: ::core::primitive::u64, + }, + #[codec(index = 2)] + approve_as_multi { + threshold: ::core::primitive::u16, + other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + maybe_timepoint: ::core::option::Option< + runtime_types::pallet_multisig::Timepoint< + ::core::primitive::u32, + >, + >, + call_hash: [::core::primitive::u8; 32usize], + max_weight: ::core::primitive::u64, + }, + #[codec(index = 3)] + cancel_as_multi { + threshold: ::core::primitive::u16, + other_signatories: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + timepoint: runtime_types::pallet_multisig::Timepoint< + ::core::primitive::u32, + >, + call_hash: [::core::primitive::u8; 32usize], + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + MinimumThreshold, + #[codec(index = 1)] + AlreadyApproved, + #[codec(index = 2)] + NoApprovalsNeeded, + #[codec(index = 3)] + TooFewSignatories, + #[codec(index = 4)] + TooManySignatories, + #[codec(index = 5)] + SignatoriesOutOfOrder, + #[codec(index = 6)] + SenderInSignatories, + #[codec(index = 7)] + NotFound, + #[codec(index = 8)] + NotOwner, + #[codec(index = 9)] + NoTimepoint, + #[codec(index = 10)] + WrongTimepoint, + #[codec(index = 11)] + UnexpectedTimepoint, + #[codec(index = 12)] + MaxWeightTooLow, + #[codec(index = 13)] + AlreadyStored, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + NewMultisig( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::crypto::AccountId32, + [::core::primitive::u8; 32usize], + ), + #[codec(index = 1)] + MultisigApproval( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + ::subxt::sp_core::crypto::AccountId32, + [::core::primitive::u8; 32usize], + ), + #[codec(index = 2)] + MultisigExecuted( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + ::subxt::sp_core::crypto::AccountId32, + [::core::primitive::u8; 32usize], + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + #[codec(index = 3)] + MultisigCancelled( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::pallet_multisig::Timepoint<::core::primitive::u32>, + ::subxt::sp_core::crypto::AccountId32, + [::core::primitive::u8; 32usize], + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Multisig<_0, _1, _2> { + pub when: runtime_types::pallet_multisig::Timepoint<_0>, + pub deposit: _1, + pub depositor: _2, + pub approvals: ::std::vec::Vec<_2>, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Timepoint<_0> { + pub height: _0, + pub index: _0, + } + } + pub mod pallet_offences { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + Offence( + [::core::primitive::u8; 16usize], + ::std::vec::Vec<::core::primitive::u8>, + ), + } + } + } + pub mod pallet_proxy { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + proxy { + real: ::subxt::sp_core::crypto::AccountId32, + force_proxy_type: ::core::option::Option< + runtime_types::rococo_runtime::ProxyType, + >, + call: ::std::boxed::Box, + }, + #[codec(index = 1)] + add_proxy { + delegate: ::subxt::sp_core::crypto::AccountId32, + proxy_type: runtime_types::rococo_runtime::ProxyType, + delay: ::core::primitive::u32, + }, + #[codec(index = 2)] + remove_proxy { + delegate: ::subxt::sp_core::crypto::AccountId32, + proxy_type: runtime_types::rococo_runtime::ProxyType, + delay: ::core::primitive::u32, + }, + #[codec(index = 3)] + remove_proxies, + #[codec(index = 4)] + anonymous { + proxy_type: runtime_types::rococo_runtime::ProxyType, + delay: ::core::primitive::u32, + index: ::core::primitive::u16, + }, + #[codec(index = 5)] + kill_anonymous { + spawner: ::subxt::sp_core::crypto::AccountId32, + proxy_type: runtime_types::rococo_runtime::ProxyType, + index: ::core::primitive::u16, + #[codec(compact)] + height: ::core::primitive::u32, + #[codec(compact)] + ext_index: ::core::primitive::u32, + }, + #[codec(index = 6)] + announce { + real: ::subxt::sp_core::crypto::AccountId32, + call_hash: ::subxt::sp_core::H256, + }, + #[codec(index = 7)] + remove_announcement { + real: ::subxt::sp_core::crypto::AccountId32, + call_hash: ::subxt::sp_core::H256, + }, + #[codec(index = 8)] + reject_announcement { + delegate: ::subxt::sp_core::crypto::AccountId32, + call_hash: ::subxt::sp_core::H256, + }, + #[codec(index = 9)] + proxy_announced { + delegate: ::subxt::sp_core::crypto::AccountId32, + real: ::subxt::sp_core::crypto::AccountId32, + force_proxy_type: ::core::option::Option< + runtime_types::rococo_runtime::ProxyType, + >, + call: ::std::boxed::Box, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + TooMany, + #[codec(index = 1)] + NotFound, + #[codec(index = 2)] + NotProxy, + #[codec(index = 3)] + Unproxyable, + #[codec(index = 4)] + Duplicate, + #[codec(index = 5)] + NoPermission, + #[codec(index = 6)] + Unannounced, + #[codec(index = 7)] + NoSelfProxy, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + ProxyExecuted( + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + #[codec(index = 1)] + AnonymousCreated( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::crypto::AccountId32, + runtime_types::rococo_runtime::ProxyType, + ::core::primitive::u16, + ), + #[codec(index = 2)] + Announced( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::H256, + ), + #[codec(index = 3)] + ProxyAdded( + ::subxt::sp_core::crypto::AccountId32, + ::subxt::sp_core::crypto::AccountId32, + runtime_types::rococo_runtime::ProxyType, + ::core::primitive::u32, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Announcement<_0, _1, _2> { + pub real: _0, + pub call_hash: _1, + pub height: _2, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ProxyDefinition<_0, _1, _2> { + pub delegate: _0, + pub proxy_type: _1, + pub delay: _2, + } + } + pub mod pallet_session { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + set_keys { + keys: runtime_types::rococo_runtime::SessionKeys, + proof: ::std::vec::Vec<::core::primitive::u8>, + }, + #[codec(index = 1)] + purge_keys, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + InvalidProof, + #[codec(index = 1)] + NoAssociatedValidatorId, + #[codec(index = 2)] + DuplicatedKey, + #[codec(index = 3)] + NoKeys, + #[codec(index = 4)] + NoAccount, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + NewSession(::core::primitive::u32), + } + } + } + pub mod pallet_sudo { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + sudo { + call: ::std::boxed::Box, + }, + #[codec(index = 1)] + sudo_unchecked_weight { + call: ::std::boxed::Box, + weight: ::core::primitive::u64, + }, + #[codec(index = 2)] + set_key { + new: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + }, + #[codec(index = 3)] + sudo_as { + who: ::subxt::sp_runtime::MultiAddress< + ::subxt::sp_core::crypto::AccountId32, + (), + >, + call: ::std::boxed::Box, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + RequireSudo, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + Sudid( + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + #[codec(index = 1)] + KeyChanged(::subxt::sp_core::crypto::AccountId32), + #[codec(index = 2)] + SudoAsDone( + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + } + } + } + pub mod pallet_timestamp { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + set { + #[codec(compact)] + now: ::core::primitive::u64, + }, + } + } + } + pub mod pallet_transaction_payment { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ChargeTransactionPayment( + #[codec(compact)] pub ::core::primitive::u128, + ); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Releases { + #[codec(index = 0)] + V1Ancient, + #[codec(index = 1)] + V2, + } + } + pub mod pallet_utility { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + batch { + calls: ::std::vec::Vec, + }, + #[codec(index = 1)] + as_derivative { + index: ::core::primitive::u16, + call: ::std::boxed::Box, + }, + #[codec(index = 2)] + batch_all { + calls: ::std::vec::Vec, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + TooManyCalls, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + BatchInterrupted( + ::core::primitive::u32, + runtime_types::sp_runtime::DispatchError, + ), + #[codec(index = 1)] + BatchCompleted, + #[codec(index = 2)] + ItemCompleted, + } + } + } + pub mod pallet_xcm { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + send { + dest: + ::std::boxed::Box, + message: ::std::boxed::Box, + }, + #[codec(index = 1)] + teleport_assets { + dest: + ::std::boxed::Box, + beneficiary: + ::std::boxed::Box, + assets: + ::std::boxed::Box, + fee_asset_item: ::core::primitive::u32, + }, + #[codec(index = 2)] + reserve_transfer_assets { + dest: + ::std::boxed::Box, + beneficiary: + ::std::boxed::Box, + assets: + ::std::boxed::Box, + fee_asset_item: ::core::primitive::u32, + }, + #[codec(index = 3)] + execute { + message: ::std::boxed::Box, + max_weight: ::core::primitive::u64, + }, + #[codec(index = 4)] + force_xcm_version { + location: ::std::boxed::Box< + runtime_types::xcm::v1::multilocation::MultiLocation, + >, + xcm_version: ::core::primitive::u32, + }, + #[codec(index = 5)] + force_default_xcm_version { + maybe_xcm_version: ::core::option::Option<::core::primitive::u32>, + }, + #[codec(index = 6)] + force_subscribe_version_notify { + location: + ::std::boxed::Box, + }, + #[codec(index = 7)] + force_unsubscribe_version_notify { + location: + ::std::boxed::Box, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error { + #[codec(index = 0)] + Unreachable, + #[codec(index = 1)] + SendFailure, + #[codec(index = 2)] + Filtered, + #[codec(index = 3)] + UnweighableMessage, + #[codec(index = 4)] + DestinationNotInvertible, + #[codec(index = 5)] + Empty, + #[codec(index = 6)] + CannotReanchor, + #[codec(index = 7)] + TooManyAssets, + #[codec(index = 8)] + InvalidOrigin, + #[codec(index = 9)] + BadVersion, + #[codec(index = 10)] + BadLocation, + #[codec(index = 11)] + NoSubscription, + #[codec(index = 12)] + AlreadySubscribed, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + #[codec(index = 0)] + Attempted(runtime_types::xcm::v2::traits::Outcome), + #[codec(index = 1)] + Sent( + runtime_types::xcm::v1::multilocation::MultiLocation, + runtime_types::xcm::v1::multilocation::MultiLocation, + runtime_types::xcm::v2::Xcm, + ), + #[codec(index = 2)] + UnexpectedResponse( + runtime_types::xcm::v1::multilocation::MultiLocation, + ::core::primitive::u64, + ), + #[codec(index = 3)] + ResponseReady( + ::core::primitive::u64, + runtime_types::xcm::v2::Response, + ), + #[codec(index = 4)] + Notified( + ::core::primitive::u64, + ::core::primitive::u8, + ::core::primitive::u8, + ), + #[codec(index = 5)] + NotifyOverweight( + ::core::primitive::u64, + ::core::primitive::u8, + ::core::primitive::u8, + ::core::primitive::u64, + ::core::primitive::u64, + ), + #[codec(index = 6)] + NotifyDispatchError( + ::core::primitive::u64, + ::core::primitive::u8, + ::core::primitive::u8, + ), + #[codec(index = 7)] + NotifyDecodeFailed( + ::core::primitive::u64, + ::core::primitive::u8, + ::core::primitive::u8, + ), + #[codec(index = 8)] + InvalidResponder( + runtime_types::xcm::v1::multilocation::MultiLocation, + ::core::primitive::u64, + ::core::option::Option< + runtime_types::xcm::v1::multilocation::MultiLocation, + >, + ), + #[codec(index = 9)] + InvalidResponderVersion( + runtime_types::xcm::v1::multilocation::MultiLocation, + ::core::primitive::u64, + ), + #[codec(index = 10)] + ResponseTaken(::core::primitive::u64), + #[codec(index = 11)] + AssetsTrapped( + ::subxt::sp_core::H256, + runtime_types::xcm::v1::multilocation::MultiLocation, + runtime_types::xcm::VersionedMultiAssets, + ), + #[codec(index = 12)] + VersionChangeNotified( + runtime_types::xcm::v1::multilocation::MultiLocation, + ::core::primitive::u32, + ), + #[codec(index = 13)] + SupportedVersionChanged( + runtime_types::xcm::v1::multilocation::MultiLocation, + ::core::primitive::u32, + ), + #[codec(index = 14)] + NotifyTargetSendFail( + runtime_types::xcm::v1::multilocation::MultiLocation, + ::core::primitive::u64, + runtime_types::xcm::v2::traits::Error, + ), + #[codec(index = 15)] + NotifyTargetMigrationFail( + runtime_types::xcm::VersionedMultiLocation, + ::core::primitive::u64, + ), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum QueryStatus<_0> { + #[codec(index = 0)] + Pending { + responder: runtime_types::xcm::VersionedMultiLocation, + maybe_notify: ::core::option::Option<( + ::core::primitive::u8, + ::core::primitive::u8, + )>, + timeout: _0, + }, + #[codec(index = 1)] + VersionNotifier { + origin: runtime_types::xcm::VersionedMultiLocation, + is_active: ::core::primitive::bool, + }, + #[codec(index = 2)] + Ready { + response: runtime_types::xcm::VersionedResponse, + at: _0, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum VersionMigrationStage { + #[codec(index = 0)] + MigrateSupportedVersion, + #[codec(index = 1)] + MigrateVersionNotifiers, + #[codec(index = 2)] + NotifyCurrentTargets( + ::core::option::Option<::std::vec::Vec<::core::primitive::u8>>, + ), + #[codec(index = 3)] + MigrateAndNotifyOldTargets, + } + } + } + pub mod polkadot_core_primitives { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateHash(pub ::subxt::sp_core::H256); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct InboundDownwardMessage<_0> { + pub sent_at: _0, + pub msg: ::std::vec::Vec<::core::primitive::u8>, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct InboundHrmpMessage<_0> { + pub sent_at: _0, + pub data: ::std::vec::Vec<::core::primitive::u8>, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OutboundHrmpMessage<_0> { + pub recipient: _0, + pub data: ::std::vec::Vec<::core::primitive::u8>, + } + } + pub mod polkadot_parachain { + use super::runtime_types; + pub mod primitives { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HeadData(pub ::std::vec::Vec<::core::primitive::u8>); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpChannelId { + pub sender: runtime_types::polkadot_parachain::primitives::Id, + pub recipient: runtime_types::polkadot_parachain::primitives::Id, + } + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct Id(pub ::core::primitive::u32); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ValidationCode(pub ::std::vec::Vec<::core::primitive::u8>); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ValidationCodeHash(pub ::subxt::sp_core::H256); + } + } + pub mod polkadot_primitives { + use super::runtime_types; + pub mod v0 { + use super::runtime_types; + pub mod collator_app { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Public(pub runtime_types::sp_core::sr25519::Public); + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Signature(pub runtime_types::sp_core::sr25519::Signature); + } + pub mod validator_app { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Public(pub runtime_types::sp_core::sr25519::Public); + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Signature(pub runtime_types::sp_core::sr25519::Signature); + } + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct ValidatorIndex(pub ::core::primitive::u32); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum ValidityAttestation { + #[codec(index = 1)] + Implicit( + runtime_types::polkadot_primitives::v0::validator_app::Signature, + ), + #[codec(index = 2)] + Explicit( + runtime_types::polkadot_primitives::v0::validator_app::Signature, + ), + } + } + pub mod v1 { + use super::runtime_types; + pub mod assignment_app { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Public(pub runtime_types::sp_core::sr25519::Public); + } + pub mod signed { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct UncheckedSigned < _0 , _1 > { pub payload : _0 , pub validator_index : runtime_types :: polkadot_primitives :: v0 :: ValidatorIndex , pub signature : runtime_types :: polkadot_primitives :: v0 :: validator_app :: Signature , # [codec (skip)] pub __subxt_unused_type_params : :: core :: marker :: PhantomData < _1 > , } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AvailabilityBitfield( + pub ::subxt::bitvec::vec::BitVec< + ::subxt::bitvec::order::Lsb0, + ::core::primitive::u8, + >, + ); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BackedCandidate<_0> { + pub candidate: + runtime_types::polkadot_primitives::v1::CommittedCandidateReceipt< + _0, + >, + pub validity_votes: ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::ValidityAttestation, + >, + pub validator_indices: ::subxt::bitvec::vec::BitVec< + ::subxt::bitvec::order::Lsb0, + ::core::primitive::u8, + >, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateCommitments<_0> { + pub upward_messages: + ::std::vec::Vec<::std::vec::Vec<::core::primitive::u8>>, + pub horizontal_messages: ::std::vec::Vec< + runtime_types::polkadot_core_primitives::OutboundHrmpMessage< + runtime_types::polkadot_parachain::primitives::Id, + >, + >, + pub new_validation_code: ::core::option::Option< + runtime_types::polkadot_parachain::primitives::ValidationCode, + >, + pub head_data: + runtime_types::polkadot_parachain::primitives::HeadData, + pub processed_downward_messages: _0, + pub hrmp_watermark: _0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateDescriptor<_0> { + pub para_id: runtime_types::polkadot_parachain::primitives::Id, + pub relay_parent: _0, + pub collator: + runtime_types::polkadot_primitives::v0::collator_app::Public, + pub persisted_validation_data_hash: _0, + pub pov_hash: _0, + pub erasure_root: _0, + pub signature: + runtime_types::polkadot_primitives::v0::collator_app::Signature, + pub para_head: _0, + pub validation_code_hash: + runtime_types::polkadot_parachain::primitives::ValidationCodeHash, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidateReceipt<_0> { + pub descriptor: + runtime_types::polkadot_primitives::v1::CandidateDescriptor<_0>, + pub commitments_hash: _0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CommittedCandidateReceipt<_0> { + pub descriptor: + runtime_types::polkadot_primitives::v1::CandidateDescriptor<_0>, + pub commitments: + runtime_types::polkadot_primitives::v1::CandidateCommitments< + ::core::primitive::u32, + >, + } + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct CoreIndex(pub ::core::primitive::u32); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum CoreOccupied { + #[codec(index = 0)] + Parathread(runtime_types::polkadot_primitives::v1::ParathreadEntry), + #[codec(index = 1)] + Parachain, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DisputeState<_0> { + pub validators_for: ::subxt::bitvec::vec::BitVec< + ::subxt::bitvec::order::Lsb0, + ::core::primitive::u8, + >, + pub validators_against: ::subxt::bitvec::vec::BitVec< + ::subxt::bitvec::order::Lsb0, + ::core::primitive::u8, + >, + pub start: _0, + pub concluded_at: ::core::option::Option<_0>, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum DisputeStatement { + # [codec (index = 0)] Valid (runtime_types :: polkadot_primitives :: v1 :: ValidDisputeStatementKind ,) , # [codec (index = 1)] Invalid (runtime_types :: polkadot_primitives :: v1 :: InvalidDisputeStatementKind ,) , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DisputeStatementSet { + pub candidate_hash: + runtime_types::polkadot_core_primitives::CandidateHash, + pub session: ::core::primitive::u32, + pub statements: ::std::vec::Vec<( + runtime_types::polkadot_primitives::v1::DisputeStatement, + runtime_types::polkadot_primitives::v0::ValidatorIndex, + runtime_types::polkadot_primitives::v0::validator_app::Signature, + )>, + } + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct GroupIndex(pub ::core::primitive::u32); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct InherentData<_0> { + pub bitfields: ::std::vec::Vec< + runtime_types::polkadot_primitives::v1::signed::UncheckedSigned< + runtime_types::polkadot_primitives::v1::AvailabilityBitfield, + runtime_types::polkadot_primitives::v1::AvailabilityBitfield, + >, + >, + pub backed_candidates: ::std::vec::Vec< + runtime_types::polkadot_primitives::v1::BackedCandidate< + ::subxt::sp_core::H256, + >, + >, + pub disputes: ::std::vec::Vec< + runtime_types::polkadot_primitives::v1::DisputeStatementSet, + >, + pub parent_header: _0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum InvalidDisputeStatementKind { + #[codec(index = 0)] + Explicit, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ParathreadClaim( + pub runtime_types::polkadot_parachain::primitives::Id, + pub runtime_types::polkadot_primitives::v0::collator_app::Public, + ); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ParathreadEntry { + pub claim: runtime_types::polkadot_primitives::v1::ParathreadClaim, + pub retries: ::core::primitive::u32, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SessionInfo { + pub validators: ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::validator_app::Public, + >, + pub discovery_keys: ::std::vec::Vec< + runtime_types::sp_authority_discovery::app::Public, + >, + pub assignment_keys: ::std::vec::Vec< + runtime_types::polkadot_primitives::v1::assignment_app::Public, + >, + pub validator_groups: ::std::vec::Vec< + ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::ValidatorIndex, + >, + >, + pub n_cores: ::core::primitive::u32, + pub zeroth_delay_tranche_width: ::core::primitive::u32, + pub relay_vrf_modulo_samples: ::core::primitive::u32, + pub n_delay_tranches: ::core::primitive::u32, + pub no_show_slots: ::core::primitive::u32, + pub needed_approvals: ::core::primitive::u32, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum UpgradeGoAhead { + #[codec(index = 0)] + Abort, + #[codec(index = 1)] + GoAhead, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum UpgradeRestriction { + #[codec(index = 0)] + Present, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum ValidDisputeStatementKind { + #[codec(index = 0)] + Explicit, + #[codec(index = 1)] + BackingSeconded(::subxt::sp_core::H256), + #[codec(index = 2)] + BackingValid(::subxt::sp_core::H256), + #[codec(index = 3)] + ApprovalChecking, + } + } + } + pub mod polkadot_runtime_common { + use super::runtime_types; + pub mod auctions { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + new_auction { + #[codec(compact)] + duration: ::core::primitive::u32, + #[codec(compact)] + lease_period_index: ::core::primitive::u32, + }, + #[codec(index = 1)] + bid { + #[codec(compact)] + para: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + auction_index: ::core::primitive::u32, + #[codec(compact)] + first_slot: ::core::primitive::u32, + #[codec(compact)] + last_slot: ::core::primitive::u32, + #[codec(compact)] + amount: ::core::primitive::u128, + }, + #[codec(index = 2)] + cancel_auction, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + AuctionInProgress, + #[codec(index = 1)] + LeasePeriodInPast, + #[codec(index = 2)] + ParaNotRegistered, + #[codec(index = 3)] + NotCurrentAuction, + #[codec(index = 4)] + NotAuction, + #[codec(index = 5)] + AuctionEnded, + #[codec(index = 6)] + AlreadyLeasedOut, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + AuctionStarted( + ::core::primitive::u32, + ::core::primitive::u32, + ::core::primitive::u32, + ), + #[codec(index = 1)] + AuctionClosed(::core::primitive::u32), + #[codec(index = 2)] + Reserved( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ::core::primitive::u128, + ), + #[codec(index = 3)] + Unreserved( + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 4)] + ReserveConfiscated( + runtime_types::polkadot_parachain::primitives::Id, + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u128, + ), + #[codec(index = 5)] + BidAccepted( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u128, + ::core::primitive::u32, + ::core::primitive::u32, + ), + #[codec(index = 6)] + WinningOffset(::core::primitive::u32, ::core::primitive::u32), + } + } + } + pub mod crowdloan { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + create { + #[codec(compact)] + index: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + cap: ::core::primitive::u128, + #[codec(compact)] + first_period: ::core::primitive::u32, + #[codec(compact)] + last_period: ::core::primitive::u32, + #[codec(compact)] + end: ::core::primitive::u32, + verifier: ::core::option::Option< + runtime_types::sp_runtime::MultiSigner, + >, + }, + #[codec(index = 1)] + contribute { + #[codec(compact)] + index: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + value: ::core::primitive::u128, + signature: ::core::option::Option< + runtime_types::sp_runtime::MultiSignature, + >, + }, + #[codec(index = 2)] + withdraw { + who: ::subxt::sp_core::crypto::AccountId32, + #[codec(compact)] + index: runtime_types::polkadot_parachain::primitives::Id, + }, + #[codec(index = 3)] + refund { + #[codec(compact)] + index: runtime_types::polkadot_parachain::primitives::Id, + }, + #[codec(index = 4)] + dissolve { + #[codec(compact)] + index: runtime_types::polkadot_parachain::primitives::Id, + }, + #[codec(index = 5)] + edit { + #[codec(compact)] + index: runtime_types::polkadot_parachain::primitives::Id, + #[codec(compact)] + cap: ::core::primitive::u128, + #[codec(compact)] + first_period: ::core::primitive::u32, + #[codec(compact)] + last_period: ::core::primitive::u32, + #[codec(compact)] + end: ::core::primitive::u32, + verifier: ::core::option::Option< + runtime_types::sp_runtime::MultiSigner, + >, + }, + #[codec(index = 6)] + add_memo { + index: runtime_types::polkadot_parachain::primitives::Id, + memo: ::std::vec::Vec<::core::primitive::u8>, + }, + #[codec(index = 7)] + poke { + index: runtime_types::polkadot_parachain::primitives::Id, + }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + FirstPeriodInPast, + #[codec(index = 1)] + FirstPeriodTooFarInFuture, + #[codec(index = 2)] + LastPeriodBeforeFirstPeriod, + #[codec(index = 3)] + LastPeriodTooFarInFuture, + #[codec(index = 4)] + CannotEndInPast, + #[codec(index = 5)] + EndTooFarInFuture, + #[codec(index = 6)] + Overflow, + #[codec(index = 7)] + ContributionTooSmall, + #[codec(index = 8)] + InvalidParaId, + #[codec(index = 9)] + CapExceeded, + #[codec(index = 10)] + ContributionPeriodOver, + #[codec(index = 11)] + InvalidOrigin, + #[codec(index = 12)] + NotParachain, + #[codec(index = 13)] + LeaseActive, + #[codec(index = 14)] + BidOrLeaseActive, + #[codec(index = 15)] + FundNotEnded, + #[codec(index = 16)] + NoContributions, + #[codec(index = 17)] + NotReadyToDissolve, + #[codec(index = 18)] + InvalidSignature, + #[codec(index = 19)] + MemoTooLarge, + #[codec(index = 20)] + AlreadyInNewRaise, + #[codec(index = 21)] + VrfDelayInProgress, + #[codec(index = 22)] + NoLeasePeriod, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + Created(runtime_types::polkadot_parachain::primitives::Id), + #[codec(index = 1)] + Contributed( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u128, + ), + #[codec(index = 2)] + Withdrew( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u128, + ), + #[codec(index = 3)] + PartiallyRefunded( + runtime_types::polkadot_parachain::primitives::Id, + ), + #[codec(index = 4)] + AllRefunded(runtime_types::polkadot_parachain::primitives::Id), + #[codec(index = 5)] + Dissolved(runtime_types::polkadot_parachain::primitives::Id), + #[codec(index = 6)] + HandleBidResult( + runtime_types::polkadot_parachain::primitives::Id, + ::core::result::Result< + (), + runtime_types::sp_runtime::DispatchError, + >, + ), + #[codec(index = 7)] + Edited(runtime_types::polkadot_parachain::primitives::Id), + #[codec(index = 8)] + MemoUpdated( + ::subxt::sp_core::crypto::AccountId32, + runtime_types::polkadot_parachain::primitives::Id, + ::std::vec::Vec<::core::primitive::u8>, + ), + #[codec(index = 9)] + AddedToNewRaise( + runtime_types::polkadot_parachain::primitives::Id, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct FundInfo < _0 , _1 , _2 , _3 > { pub depositor : _0 , pub verifier : :: core :: option :: Option < runtime_types :: sp_runtime :: MultiSigner > , pub deposit : _1 , pub raised : _1 , pub end : _2 , pub cap : _1 , pub last_contribution : runtime_types :: polkadot_runtime_common :: crowdloan :: LastContribution < _2 > , pub first_period : _2 , pub last_period : _2 , pub trie_index : _2 , # [codec (skip)] pub __subxt_unused_type_params : :: core :: marker :: PhantomData < _3 > , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum LastContribution<_0> { + #[codec(index = 0)] + Never, + #[codec(index = 1)] + PreEnding(_0), + #[codec(index = 2)] + Ending(_0), + } + } + pub mod paras_registrar { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + # [codec (index = 0)] register { id : runtime_types :: polkadot_parachain :: primitives :: Id , genesis_head : runtime_types :: polkadot_parachain :: primitives :: HeadData , validation_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode , } , # [codec (index = 1)] force_register { who : :: subxt :: sp_core :: crypto :: AccountId32 , deposit : :: core :: primitive :: u128 , id : runtime_types :: polkadot_parachain :: primitives :: Id , genesis_head : runtime_types :: polkadot_parachain :: primitives :: HeadData , validation_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode , } , # [codec (index = 2)] deregister { id : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 3)] swap { id : runtime_types :: polkadot_parachain :: primitives :: Id , other : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 4)] force_remove_lock { para : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 5)] reserve , } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + NotRegistered, + #[codec(index = 1)] + AlreadyRegistered, + #[codec(index = 2)] + NotOwner, + #[codec(index = 3)] + CodeTooLarge, + #[codec(index = 4)] + HeadDataTooLarge, + #[codec(index = 5)] + NotParachain, + #[codec(index = 6)] + NotParathread, + #[codec(index = 7)] + CannotDeregister, + #[codec(index = 8)] + CannotDowngrade, + #[codec(index = 9)] + CannotUpgrade, + #[codec(index = 10)] + ParaLocked, + #[codec(index = 11)] + NotReserved, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + Registered( + runtime_types::polkadot_parachain::primitives::Id, + ::subxt::sp_core::crypto::AccountId32, + ), + #[codec(index = 1)] + Deregistered(runtime_types::polkadot_parachain::primitives::Id), + #[codec(index = 2)] + Reserved( + runtime_types::polkadot_parachain::primitives::Id, + ::subxt::sp_core::crypto::AccountId32, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ParaInfo<_0, _1> { + pub manager: _0, + pub deposit: _1, + pub locked: ::core::primitive::bool, + } + } + pub mod paras_sudo_wrapper { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + # [codec (index = 0)] sudo_schedule_para_initialize { id : runtime_types :: polkadot_parachain :: primitives :: Id , genesis : runtime_types :: polkadot_runtime_parachains :: paras :: ParaGenesisArgs , } , # [codec (index = 1)] sudo_schedule_para_cleanup { id : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 2)] sudo_schedule_parathread_upgrade { id : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 3)] sudo_schedule_parachain_downgrade { id : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 4)] sudo_queue_downward_xcm { id : runtime_types :: polkadot_parachain :: primitives :: Id , xcm : :: std :: boxed :: Box < runtime_types :: xcm :: VersionedXcm > , } , # [codec (index = 5)] sudo_establish_hrmp_channel { sender : runtime_types :: polkadot_parachain :: primitives :: Id , recipient : runtime_types :: polkadot_parachain :: primitives :: Id , max_capacity : :: core :: primitive :: u32 , max_message_size : :: core :: primitive :: u32 , } , } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + ParaDoesntExist, + #[codec(index = 1)] + ParaAlreadyExists, + #[codec(index = 2)] + ExceedsMaxMessageSize, + #[codec(index = 3)] + CouldntCleanup, + #[codec(index = 4)] + NotParathread, + #[codec(index = 5)] + NotParachain, + #[codec(index = 6)] + CannotUpgrade, + #[codec(index = 7)] + CannotDowngrade, + } + } + } + pub mod slots { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + force_lease { + para: runtime_types::polkadot_parachain::primitives::Id, + leaser: ::subxt::sp_core::crypto::AccountId32, + amount: ::core::primitive::u128, + period_begin: ::core::primitive::u32, + period_count: ::core::primitive::u32, + }, + #[codec(index = 1)] + clear_all_leases { + para: runtime_types::polkadot_parachain::primitives::Id, + }, + #[codec(index = 2)] + trigger_onboard { + para: runtime_types::polkadot_parachain::primitives::Id, + }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + ParaNotOnboarding, + #[codec(index = 1)] + LeaseError, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + NewLeasePeriod(::core::primitive::u32), + #[codec(index = 1)] + Leased( + runtime_types::polkadot_parachain::primitives::Id, + ::subxt::sp_core::crypto::AccountId32, + ::core::primitive::u32, + ::core::primitive::u32, + ::core::primitive::u128, + ::core::primitive::u128, + ), + } + } + } + } + pub mod polkadot_runtime_parachains { + use super::runtime_types; + pub mod configuration { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + set_validation_upgrade_frequency { new: ::core::primitive::u32 }, + #[codec(index = 1)] + set_validation_upgrade_delay { new: ::core::primitive::u32 }, + #[codec(index = 2)] + set_code_retention_period { new: ::core::primitive::u32 }, + #[codec(index = 3)] + set_max_code_size { new: ::core::primitive::u32 }, + #[codec(index = 4)] + set_max_pov_size { new: ::core::primitive::u32 }, + #[codec(index = 5)] + set_max_head_data_size { new: ::core::primitive::u32 }, + #[codec(index = 6)] + set_parathread_cores { new: ::core::primitive::u32 }, + #[codec(index = 7)] + set_parathread_retries { new: ::core::primitive::u32 }, + #[codec(index = 8)] + set_group_rotation_frequency { new: ::core::primitive::u32 }, + #[codec(index = 9)] + set_chain_availability_period { new: ::core::primitive::u32 }, + #[codec(index = 10)] + set_thread_availability_period { new: ::core::primitive::u32 }, + #[codec(index = 11)] + set_scheduling_lookahead { new: ::core::primitive::u32 }, + #[codec(index = 12)] + set_max_validators_per_core { + new: ::core::option::Option<::core::primitive::u32>, + }, + #[codec(index = 13)] + set_max_validators { + new: ::core::option::Option<::core::primitive::u32>, + }, + #[codec(index = 14)] + set_dispute_period { new: ::core::primitive::u32 }, + #[codec(index = 15)] + set_dispute_post_conclusion_acceptance_period { + new: ::core::primitive::u32, + }, + #[codec(index = 16)] + set_dispute_max_spam_slots { new: ::core::primitive::u32 }, + #[codec(index = 17)] + set_dispute_conclusion_by_time_out_period { + new: ::core::primitive::u32, + }, + #[codec(index = 18)] + set_no_show_slots { new: ::core::primitive::u32 }, + #[codec(index = 19)] + set_n_delay_tranches { new: ::core::primitive::u32 }, + #[codec(index = 20)] + set_zeroth_delay_tranche_width { new: ::core::primitive::u32 }, + #[codec(index = 21)] + set_needed_approvals { new: ::core::primitive::u32 }, + #[codec(index = 22)] + set_relay_vrf_modulo_samples { new: ::core::primitive::u32 }, + #[codec(index = 23)] + set_max_upward_queue_count { new: ::core::primitive::u32 }, + #[codec(index = 24)] + set_max_upward_queue_size { new: ::core::primitive::u32 }, + #[codec(index = 25)] + set_max_downward_message_size { new: ::core::primitive::u32 }, + #[codec(index = 26)] + set_ump_service_total_weight { new: ::core::primitive::u64 }, + #[codec(index = 27)] + set_max_upward_message_size { new: ::core::primitive::u32 }, + #[codec(index = 28)] + set_max_upward_message_num_per_candidate { + new: ::core::primitive::u32, + }, + #[codec(index = 29)] + set_hrmp_open_request_ttl { new: ::core::primitive::u32 }, + #[codec(index = 30)] + set_hrmp_sender_deposit { new: ::core::primitive::u128 }, + #[codec(index = 31)] + set_hrmp_recipient_deposit { new: ::core::primitive::u128 }, + #[codec(index = 32)] + set_hrmp_channel_max_capacity { new: ::core::primitive::u32 }, + #[codec(index = 33)] + set_hrmp_channel_max_total_size { new: ::core::primitive::u32 }, + #[codec(index = 34)] + set_hrmp_max_parachain_inbound_channels { + new: ::core::primitive::u32, + }, + #[codec(index = 35)] + set_hrmp_max_parathread_inbound_channels { + new: ::core::primitive::u32, + }, + #[codec(index = 36)] + set_hrmp_channel_max_message_size { new: ::core::primitive::u32 }, + #[codec(index = 37)] + set_hrmp_max_parachain_outbound_channels { + new: ::core::primitive::u32, + }, + #[codec(index = 38)] + set_hrmp_max_parathread_outbound_channels { + new: ::core::primitive::u32, + }, + #[codec(index = 39)] + set_hrmp_max_message_num_per_candidate { + new: ::core::primitive::u32, + }, + #[codec(index = 40)] + set_ump_max_individual_weight { new: ::core::primitive::u64 }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + InvalidNewValue, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HostConfiguration<_0> { + pub max_code_size: _0, + pub max_head_data_size: _0, + pub max_upward_queue_count: _0, + pub max_upward_queue_size: _0, + pub max_upward_message_size: _0, + pub max_upward_message_num_per_candidate: _0, + pub hrmp_max_message_num_per_candidate: _0, + pub validation_upgrade_frequency: _0, + pub validation_upgrade_delay: _0, + pub max_pov_size: _0, + pub max_downward_message_size: _0, + pub ump_service_total_weight: ::core::primitive::u64, + pub hrmp_max_parachain_outbound_channels: _0, + pub hrmp_max_parathread_outbound_channels: _0, + pub hrmp_sender_deposit: ::core::primitive::u128, + pub hrmp_recipient_deposit: ::core::primitive::u128, + pub hrmp_channel_max_capacity: _0, + pub hrmp_channel_max_total_size: _0, + pub hrmp_max_parachain_inbound_channels: _0, + pub hrmp_max_parathread_inbound_channels: _0, + pub hrmp_channel_max_message_size: _0, + pub code_retention_period: _0, + pub parathread_cores: _0, + pub parathread_retries: _0, + pub group_rotation_frequency: _0, + pub chain_availability_period: _0, + pub thread_availability_period: _0, + pub scheduling_lookahead: _0, + pub max_validators_per_core: ::core::option::Option<_0>, + pub max_validators: ::core::option::Option<_0>, + pub dispute_period: _0, + pub dispute_post_conclusion_acceptance_period: _0, + pub dispute_max_spam_slots: _0, + pub dispute_conclusion_by_time_out_period: _0, + pub no_show_slots: _0, + pub n_delay_tranches: _0, + pub zeroth_delay_tranche_width: _0, + pub needed_approvals: _0, + pub relay_vrf_modulo_samples: _0, + pub ump_max_individual_weight: ::core::primitive::u64, + } + } + pub mod disputes { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + DuplicateDisputeStatementSets, + #[codec(index = 1)] + AncientDisputeStatement, + #[codec(index = 2)] + ValidatorIndexOutOfBounds, + #[codec(index = 3)] + InvalidSignature, + #[codec(index = 4)] + DuplicateStatement, + #[codec(index = 5)] + PotentialSpam, + #[codec(index = 6)] + SingleSidedDispute, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + # [codec (index = 0)] DisputeInitiated (runtime_types :: polkadot_core_primitives :: CandidateHash , runtime_types :: polkadot_runtime_parachains :: disputes :: DisputeLocation ,) , # [codec (index = 1)] DisputeConcluded (runtime_types :: polkadot_core_primitives :: CandidateHash , runtime_types :: polkadot_runtime_parachains :: disputes :: DisputeResult ,) , # [codec (index = 2)] DisputeTimedOut (runtime_types :: polkadot_core_primitives :: CandidateHash ,) , # [codec (index = 3)] Revert (:: core :: primitive :: u32 ,) , } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum DisputeLocation { + #[codec(index = 0)] + Local, + #[codec(index = 1)] + Remote, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum DisputeResult { + #[codec(index = 0)] + Valid, + #[codec(index = 1)] + Invalid, + } + } + pub mod dmp { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call {} + } + } + pub mod hrmp { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + # [codec (index = 0)] hrmp_init_open_channel { recipient : runtime_types :: polkadot_parachain :: primitives :: Id , proposed_max_capacity : :: core :: primitive :: u32 , proposed_max_message_size : :: core :: primitive :: u32 , } , # [codec (index = 1)] hrmp_accept_open_channel { sender : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 2)] hrmp_close_channel { channel_id : runtime_types :: polkadot_parachain :: primitives :: HrmpChannelId , } , # [codec (index = 3)] force_clean_hrmp { para : runtime_types :: polkadot_parachain :: primitives :: Id , } , # [codec (index = 4)] force_process_hrmp_open , # [codec (index = 5)] force_process_hrmp_close , # [codec (index = 6)] hrmp_cancel_open_request { channel_id : runtime_types :: polkadot_parachain :: primitives :: HrmpChannelId , } , } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + OpenHrmpChannelToSelf, + #[codec(index = 1)] + OpenHrmpChannelInvalidRecipient, + #[codec(index = 2)] + OpenHrmpChannelZeroCapacity, + #[codec(index = 3)] + OpenHrmpChannelCapacityExceedsLimit, + #[codec(index = 4)] + OpenHrmpChannelZeroMessageSize, + #[codec(index = 5)] + OpenHrmpChannelMessageSizeExceedsLimit, + #[codec(index = 6)] + OpenHrmpChannelAlreadyExists, + #[codec(index = 7)] + OpenHrmpChannelAlreadyRequested, + #[codec(index = 8)] + OpenHrmpChannelLimitExceeded, + #[codec(index = 9)] + AcceptHrmpChannelDoesntExist, + #[codec(index = 10)] + AcceptHrmpChannelAlreadyConfirmed, + #[codec(index = 11)] + AcceptHrmpChannelLimitExceeded, + #[codec(index = 12)] + CloseHrmpChannelUnauthorized, + #[codec(index = 13)] + CloseHrmpChannelDoesntExist, + #[codec(index = 14)] + CloseHrmpChannelAlreadyUnderway, + #[codec(index = 15)] + CancelHrmpOpenChannelUnauthorized, + #[codec(index = 16)] + OpenHrmpChannelDoesntExist, + #[codec(index = 17)] + OpenHrmpChannelAlreadyConfirmed, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + OpenChannelRequested( + runtime_types::polkadot_parachain::primitives::Id, + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + ::core::primitive::u32, + ), + #[codec(index = 1)] + OpenChannelCanceled( + runtime_types::polkadot_parachain::primitives::Id, + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ), + #[codec(index = 2)] + OpenChannelAccepted( + runtime_types::polkadot_parachain::primitives::Id, + runtime_types::polkadot_parachain::primitives::Id, + ), + #[codec(index = 3)] + ChannelClosed( + runtime_types::polkadot_parachain::primitives::Id, + runtime_types::polkadot_parachain::primitives::HrmpChannelId, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpChannel { + pub max_capacity: ::core::primitive::u32, + pub max_total_size: ::core::primitive::u32, + pub max_message_size: ::core::primitive::u32, + pub msg_count: ::core::primitive::u32, + pub total_size: ::core::primitive::u32, + pub mqc_head: ::core::option::Option<::subxt::sp_core::H256>, + pub sender_deposit: ::core::primitive::u128, + pub recipient_deposit: ::core::primitive::u128, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct HrmpOpenChannelRequest { + pub confirmed: ::core::primitive::bool, + pub _age: ::core::primitive::u32, + pub sender_deposit: ::core::primitive::u128, + pub max_message_size: ::core::primitive::u32, + pub max_capacity: ::core::primitive::u32, + pub max_total_size: ::core::primitive::u32, + } + } + pub mod inclusion { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call {} + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + WrongBitfieldSize, + #[codec(index = 1)] + BitfieldDuplicateOrUnordered, + #[codec(index = 2)] + ValidatorIndexOutOfBounds, + #[codec(index = 3)] + InvalidBitfieldSignature, + #[codec(index = 4)] + UnscheduledCandidate, + #[codec(index = 5)] + CandidateScheduledBeforeParaFree, + #[codec(index = 6)] + WrongCollator, + #[codec(index = 7)] + ScheduledOutOfOrder, + #[codec(index = 8)] + HeadDataTooLarge, + #[codec(index = 9)] + PrematureCodeUpgrade, + #[codec(index = 10)] + NewCodeTooLarge, + #[codec(index = 11)] + CandidateNotInParentContext, + #[codec(index = 12)] + UnoccupiedBitInBitfield, + #[codec(index = 13)] + InvalidGroupIndex, + #[codec(index = 14)] + InsufficientBacking, + #[codec(index = 15)] + InvalidBacking, + #[codec(index = 16)] + NotCollatorSigned, + #[codec(index = 17)] + ValidationDataHashMismatch, + #[codec(index = 18)] + InternalError, + #[codec(index = 19)] + IncorrectDownwardMessageHandling, + #[codec(index = 20)] + InvalidUpwardMessages, + #[codec(index = 21)] + HrmpWatermarkMishandling, + #[codec(index = 22)] + InvalidOutboundHrmp, + #[codec(index = 23)] + InvalidValidationCodeHash, + #[codec(index = 24)] + ParaHeadMismatch, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + CandidateBacked( + runtime_types::polkadot_primitives::v1::CandidateReceipt< + ::subxt::sp_core::H256, + >, + runtime_types::polkadot_parachain::primitives::HeadData, + runtime_types::polkadot_primitives::v1::CoreIndex, + runtime_types::polkadot_primitives::v1::GroupIndex, + ), + #[codec(index = 1)] + CandidateIncluded( + runtime_types::polkadot_primitives::v1::CandidateReceipt< + ::subxt::sp_core::H256, + >, + runtime_types::polkadot_parachain::primitives::HeadData, + runtime_types::polkadot_primitives::v1::CoreIndex, + runtime_types::polkadot_primitives::v1::GroupIndex, + ), + #[codec(index = 2)] + CandidateTimedOut( + runtime_types::polkadot_primitives::v1::CandidateReceipt< + ::subxt::sp_core::H256, + >, + runtime_types::polkadot_parachain::primitives::HeadData, + runtime_types::polkadot_primitives::v1::CoreIndex, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AvailabilityBitfieldRecord<_0> { + pub bitfield: + runtime_types::polkadot_primitives::v1::AvailabilityBitfield, + pub submitted_at: _0, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CandidatePendingAvailability<_0, _1> { + pub core: runtime_types::polkadot_primitives::v1::CoreIndex, + pub hash: runtime_types::polkadot_core_primitives::CandidateHash, + pub descriptor: + runtime_types::polkadot_primitives::v1::CandidateDescriptor<_0>, + pub availability_votes: ::subxt::bitvec::vec::BitVec< + ::subxt::bitvec::order::Lsb0, + ::core::primitive::u8, + >, + pub backers: ::subxt::bitvec::vec::BitVec< + ::subxt::bitvec::order::Lsb0, + ::core::primitive::u8, + >, + pub relay_parent_number: _1, + pub backed_in_number: _1, + pub backing_group: runtime_types::polkadot_primitives::v1::GroupIndex, + } + } + pub mod initializer { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + force_approve { up_to: ::core::primitive::u32 }, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BufferedSessionChange { + pub validators: ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::validator_app::Public, + >, + pub queued: ::std::vec::Vec< + runtime_types::polkadot_primitives::v0::validator_app::Public, + >, + pub session_index: ::core::primitive::u32, + } + } + pub mod paras { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + # [codec (index = 0)] force_set_current_code { para : runtime_types :: polkadot_parachain :: primitives :: Id , new_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode , } , # [codec (index = 1)] force_set_current_head { para : runtime_types :: polkadot_parachain :: primitives :: Id , new_head : runtime_types :: polkadot_parachain :: primitives :: HeadData , } , # [codec (index = 2)] force_schedule_code_upgrade { para : runtime_types :: polkadot_parachain :: primitives :: Id , new_code : runtime_types :: polkadot_parachain :: primitives :: ValidationCode , relay_parent_number : :: core :: primitive :: u32 , } , # [codec (index = 3)] force_note_new_head { para : runtime_types :: polkadot_parachain :: primitives :: Id , new_head : runtime_types :: polkadot_parachain :: primitives :: HeadData , } , # [codec (index = 4)] force_queue_action { para : runtime_types :: polkadot_parachain :: primitives :: Id , } , } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + NotRegistered, + #[codec(index = 1)] + CannotOnboard, + #[codec(index = 2)] + CannotOffboard, + #[codec(index = 3)] + CannotUpgrade, + #[codec(index = 4)] + CannotDowngrade, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + CurrentCodeUpdated( + runtime_types::polkadot_parachain::primitives::Id, + ), + #[codec(index = 1)] + CurrentHeadUpdated( + runtime_types::polkadot_parachain::primitives::Id, + ), + #[codec(index = 2)] + CodeUpgradeScheduled( + runtime_types::polkadot_parachain::primitives::Id, + ), + #[codec(index = 3)] + NewHeadNoted(runtime_types::polkadot_parachain::primitives::Id), + #[codec(index = 4)] + ActionQueued( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + ), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ParaGenesisArgs { + pub genesis_head: + runtime_types::polkadot_parachain::primitives::HeadData, + pub validation_code: + runtime_types::polkadot_parachain::primitives::ValidationCode, + pub parachain: ::core::primitive::bool, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum ParaLifecycle { + #[codec(index = 0)] + Onboarding, + #[codec(index = 1)] + Parathread, + #[codec(index = 2)] + Parachain, + #[codec(index = 3)] + UpgradingParathread, + #[codec(index = 4)] + DowngradingParachain, + #[codec(index = 5)] + OffboardingParathread, + #[codec(index = 6)] + OffboardingParachain, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ParaPastCodeMeta < _0 > { pub upgrade_times : :: std :: vec :: Vec < runtime_types :: polkadot_runtime_parachains :: paras :: ReplacementTimes < _0 > > , pub last_pruned : :: core :: option :: Option < _0 > , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ReplacementTimes<_0> { + pub expected_at: _0, + pub activated_at: _0, + } + } + pub mod paras_inherent { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + enter { + data: runtime_types::polkadot_primitives::v1::InherentData< + runtime_types::sp_runtime::generic::header::Header< + ::core::primitive::u32, + runtime_types::sp_runtime::traits::BlakeTwo256, + >, + >, + }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + TooManyInclusionInherents, + #[codec(index = 1)] + InvalidParentHeader, + #[codec(index = 2)] + CandidateConcludedInvalid, + } + } + } + pub mod scheduler { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum AssignmentKind { + #[codec(index = 0)] + Parachain, + #[codec(index = 1)] + Parathread( + runtime_types::polkadot_primitives::v0::collator_app::Public, + ::core::primitive::u32, + ), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct CoreAssignment { pub core : runtime_types :: polkadot_primitives :: v1 :: CoreIndex , pub para_id : runtime_types :: polkadot_parachain :: primitives :: Id , pub kind : runtime_types :: polkadot_runtime_parachains :: scheduler :: AssignmentKind , pub group_idx : runtime_types :: polkadot_primitives :: v1 :: GroupIndex , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ParathreadClaimQueue { pub queue : :: std :: vec :: Vec < runtime_types :: polkadot_runtime_parachains :: scheduler :: QueuedParathread > , pub next_core_offset : :: core :: primitive :: u32 , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct QueuedParathread { + pub claim: runtime_types::polkadot_primitives::v1::ParathreadEntry, + pub core_offset: ::core::primitive::u32, + } + } + pub mod shared { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call {} + } + } + pub mod ump { + use super::runtime_types; + pub mod pallet { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Call { + #[codec(index = 0)] + service_overweight { + index: ::core::primitive::u64, + weight_limit: ::core::primitive::u64, + }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + UnknownMessageIndex, + #[codec(index = 1)] + WeightOverLimit, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Event { + #[codec(index = 0)] + InvalidFormat([::core::primitive::u8; 32usize]), + #[codec(index = 1)] + UnsupportedVersion([::core::primitive::u8; 32usize]), + #[codec(index = 2)] + ExecutedUpward( + [::core::primitive::u8; 32usize], + runtime_types::xcm::v2::traits::Outcome, + ), + #[codec(index = 3)] + WeightExhausted( + [::core::primitive::u8; 32usize], + ::core::primitive::u64, + ::core::primitive::u64, + ), + #[codec(index = 4)] + UpwardMessagesReceived( + runtime_types::polkadot_parachain::primitives::Id, + ::core::primitive::u32, + ::core::primitive::u32, + ), + #[codec(index = 5)] + OverweightEnqueued( + runtime_types::polkadot_parachain::primitives::Id, + [::core::primitive::u8; 32usize], + ::core::primitive::u64, + ::core::primitive::u64, + ), + #[codec(index = 6)] + OverweightServiced( + ::core::primitive::u64, + ::core::primitive::u64, + ), + } + } + } + } + pub mod primitive_types { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct H256(pub [::core::primitive::u8; 32usize]); + } + pub mod rococo_runtime { + use super::runtime_types; + pub mod validator_manager { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + #[codec(index = 0)] + register_validators { + validators: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + }, + #[codec(index = 1)] + deregister_validators { + validators: + ::std::vec::Vec<::subxt::sp_core::crypto::AccountId32>, + }, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Error {} + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum RawEvent<_0> { + #[codec(index = 0)] + ValidatorsRegistered(::std::vec::Vec<_0>), + #[codec(index = 1)] + ValidatorsDeregistered(::std::vec::Vec<_0>), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Call { + # [codec (index = 0)] System (runtime_types :: frame_system :: pallet :: Call ,) , # [codec (index = 1)] Babe (runtime_types :: pallet_babe :: pallet :: Call ,) , # [codec (index = 2)] Timestamp (runtime_types :: pallet_timestamp :: pallet :: Call ,) , # [codec (index = 3)] Indices (runtime_types :: pallet_indices :: pallet :: Call ,) , # [codec (index = 4)] Balances (runtime_types :: pallet_balances :: pallet :: Call ,) , # [codec (index = 6)] Authorship (runtime_types :: pallet_authorship :: pallet :: Call ,) , # [codec (index = 9)] Session (runtime_types :: pallet_session :: pallet :: Call ,) , # [codec (index = 10)] Grandpa (runtime_types :: pallet_grandpa :: pallet :: Call ,) , # [codec (index = 11)] ImOnline (runtime_types :: pallet_im_online :: pallet :: Call ,) , # [codec (index = 14)] Configuration (runtime_types :: polkadot_runtime_parachains :: configuration :: pallet :: Call ,) , # [codec (index = 15)] ParasShared (runtime_types :: polkadot_runtime_parachains :: shared :: pallet :: Call ,) , # [codec (index = 16)] ParaInclusion (runtime_types :: polkadot_runtime_parachains :: inclusion :: pallet :: Call ,) , # [codec (index = 17)] ParaInherent (runtime_types :: polkadot_runtime_parachains :: paras_inherent :: pallet :: Call ,) , # [codec (index = 19)] Paras (runtime_types :: polkadot_runtime_parachains :: paras :: pallet :: Call ,) , # [codec (index = 20)] Initializer (runtime_types :: polkadot_runtime_parachains :: initializer :: pallet :: Call ,) , # [codec (index = 21)] Dmp (runtime_types :: polkadot_runtime_parachains :: dmp :: pallet :: Call ,) , # [codec (index = 22)] Ump (runtime_types :: polkadot_runtime_parachains :: ump :: pallet :: Call ,) , # [codec (index = 23)] Hrmp (runtime_types :: polkadot_runtime_parachains :: hrmp :: pallet :: Call ,) , # [codec (index = 26)] Registrar (runtime_types :: polkadot_runtime_common :: paras_registrar :: pallet :: Call ,) , # [codec (index = 27)] Auctions (runtime_types :: polkadot_runtime_common :: auctions :: pallet :: Call ,) , # [codec (index = 28)] Crowdloan (runtime_types :: polkadot_runtime_common :: crowdloan :: pallet :: Call ,) , # [codec (index = 29)] Slots (runtime_types :: polkadot_runtime_common :: slots :: pallet :: Call ,) , # [codec (index = 30)] ParasSudoWrapper (runtime_types :: polkadot_runtime_common :: paras_sudo_wrapper :: pallet :: Call ,) , # [codec (index = 31)] Sudo (runtime_types :: pallet_sudo :: pallet :: Call ,) , # [codec (index = 35)] ValidatorManager (runtime_types :: rococo_runtime :: validator_manager :: Call ,) , # [codec (index = 80)] Collective (runtime_types :: pallet_collective :: pallet :: Call ,) , # [codec (index = 81)] Membership (runtime_types :: pallet_membership :: pallet :: Call ,) , # [codec (index = 90)] Utility (runtime_types :: pallet_utility :: pallet :: Call ,) , # [codec (index = 91)] Proxy (runtime_types :: pallet_proxy :: pallet :: Call ,) , # [codec (index = 92)] Multisig (runtime_types :: pallet_multisig :: pallet :: Call ,) , # [codec (index = 99)] XcmPallet (runtime_types :: pallet_xcm :: pallet :: Call ,) , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Event { + # [codec (index = 0)] System (runtime_types :: frame_system :: pallet :: Event ,) , # [codec (index = 3)] Indices (runtime_types :: pallet_indices :: pallet :: Event ,) , # [codec (index = 4)] Balances (runtime_types :: pallet_balances :: pallet :: Event ,) , # [codec (index = 7)] Offences (runtime_types :: pallet_offences :: pallet :: Event ,) , # [codec (index = 9)] Session (runtime_types :: pallet_session :: pallet :: Event ,) , # [codec (index = 10)] Grandpa (runtime_types :: pallet_grandpa :: pallet :: Event ,) , # [codec (index = 11)] ImOnline (runtime_types :: pallet_im_online :: pallet :: Event ,) , # [codec (index = 16)] ParaInclusion (runtime_types :: polkadot_runtime_parachains :: inclusion :: pallet :: Event ,) , # [codec (index = 19)] Paras (runtime_types :: polkadot_runtime_parachains :: paras :: pallet :: Event ,) , # [codec (index = 22)] Ump (runtime_types :: polkadot_runtime_parachains :: ump :: pallet :: Event ,) , # [codec (index = 23)] Hrmp (runtime_types :: polkadot_runtime_parachains :: hrmp :: pallet :: Event ,) , # [codec (index = 25)] ParasDisputes (runtime_types :: polkadot_runtime_parachains :: disputes :: pallet :: Event ,) , # [codec (index = 26)] Registrar (runtime_types :: polkadot_runtime_common :: paras_registrar :: pallet :: Event ,) , # [codec (index = 27)] Auctions (runtime_types :: polkadot_runtime_common :: auctions :: pallet :: Event ,) , # [codec (index = 28)] Crowdloan (runtime_types :: polkadot_runtime_common :: crowdloan :: pallet :: Event ,) , # [codec (index = 29)] Slots (runtime_types :: polkadot_runtime_common :: slots :: pallet :: Event ,) , # [codec (index = 31)] Sudo (runtime_types :: pallet_sudo :: pallet :: Event ,) , # [codec (index = 35)] ValidatorManager (runtime_types :: rococo_runtime :: validator_manager :: RawEvent < :: subxt :: sp_core :: crypto :: AccountId32 > ,) , # [codec (index = 80)] Collective (runtime_types :: pallet_collective :: pallet :: Event ,) , # [codec (index = 81)] Membership (runtime_types :: pallet_membership :: pallet :: Event ,) , # [codec (index = 90)] Utility (runtime_types :: pallet_utility :: pallet :: Event ,) , # [codec (index = 91)] Proxy (runtime_types :: pallet_proxy :: pallet :: Event ,) , # [codec (index = 92)] Multisig (runtime_types :: pallet_multisig :: pallet :: Event ,) , # [codec (index = 99)] XcmPallet (runtime_types :: pallet_xcm :: pallet :: Event ,) , } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum ProxyType { + #[codec(index = 0)] + Any, + #[codec(index = 1)] + CancelProxy, + #[codec(index = 2)] + Auction, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Runtime {} + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct SessionKeys { + pub grandpa: runtime_types::sp_finality_grandpa::app::Public, + pub babe: runtime_types::sp_consensus_babe::app::Public, + pub im_online: + runtime_types::pallet_im_online::sr25519::app_sr25519::Public, + pub para_validator: + runtime_types::polkadot_primitives::v0::validator_app::Public, + pub para_assignment: + runtime_types::polkadot_primitives::v1::assignment_app::Public, + pub authority_discovery: + runtime_types::sp_authority_discovery::app::Public, + pub beefy: runtime_types::beefy_primitives::crypto::Public, + } + } + pub mod sp_arithmetic { + use super::runtime_types; + pub mod fixed_point { + use super::runtime_types; + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct FixedU128(pub ::core::primitive::u128); + } + pub mod per_things { + use super::runtime_types; + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct Perbill(pub ::core::primitive::u32); + } + } + pub mod sp_authority_discovery { + use super::runtime_types; + pub mod app { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub runtime_types::sp_core::sr25519::Public); + } + } + pub mod sp_consensus_babe { + use super::runtime_types; + pub mod app { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub runtime_types::sp_core::sr25519::Public); + } + pub mod digests { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum NextConfigDescriptor { + #[codec(index = 1)] + V1 { + c: (::core::primitive::u64, ::core::primitive::u64), + allowed_slots: runtime_types::sp_consensus_babe::AllowedSlots, + }, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum AllowedSlots { + #[codec(index = 0)] + PrimarySlots, + #[codec(index = 1)] + PrimaryAndSecondaryPlainSlots, + #[codec(index = 2)] + PrimaryAndSecondaryVRFSlots, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BabeEpochConfiguration { + pub c: (::core::primitive::u64, ::core::primitive::u64), + pub allowed_slots: runtime_types::sp_consensus_babe::AllowedSlots, + } + } + pub mod sp_consensus_slots { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct EquivocationProof<_0, _1> { + pub offender: _1, + pub slot: runtime_types::sp_consensus_slots::Slot, + pub first_header: _0, + pub second_header: _0, + } + #[derive( + :: subxt :: codec :: CompactAs, + :: subxt :: codec :: Encode, + :: subxt :: codec :: Decode, + )] + pub struct Slot(pub ::core::primitive::u64); + } + pub mod sp_core { + use super::runtime_types; + pub mod changes_trie { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct ChangesTrieConfiguration { + pub digest_interval: ::core::primitive::u32, + pub digest_levels: ::core::primitive::u32, + } + } + pub mod crypto { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct AccountId32(pub [::core::primitive::u8; 32usize]); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct KeyTypeId(pub [::core::primitive::u8; 4usize]); + } + pub mod ecdsa { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub [::core::primitive::u8; 33usize]); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Signature(pub [::core::primitive::u8; 65usize]); + } + pub mod ed25519 { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub [::core::primitive::u8; 32usize]); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Signature(pub [::core::primitive::u8; 64usize]); + } + pub mod offchain { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OpaqueMultiaddr(pub ::std::vec::Vec<::core::primitive::u8>); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OpaqueNetworkState { + pub peer_id: runtime_types::sp_core::OpaquePeerId, + pub external_addresses: ::std::vec::Vec< + runtime_types::sp_core::offchain::OpaqueMultiaddr, + >, + } + } + pub mod sr25519 { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub [::core::primitive::u8; 32usize]); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Signature(pub [::core::primitive::u8; 64usize]); + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OpaquePeerId(pub ::std::vec::Vec<::core::primitive::u8>); + } + pub mod sp_finality_grandpa { + use super::runtime_types; + pub mod app { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Public(pub runtime_types::sp_core::ed25519::Public); + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Signature(pub runtime_types::sp_core::ed25519::Signature); + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Equivocation<_0, _1> { + #[codec(index = 0)] + Prevote( + runtime_types::finality_grandpa::Equivocation< + runtime_types::sp_finality_grandpa::app::Public, + runtime_types::finality_grandpa::Prevote<_0, _1>, + runtime_types::sp_finality_grandpa::app::Signature, + >, + ), + #[codec(index = 1)] + Precommit( + runtime_types::finality_grandpa::Equivocation< + runtime_types::sp_finality_grandpa::app::Public, + runtime_types::finality_grandpa::Precommit<_0, _1>, + runtime_types::sp_finality_grandpa::app::Signature, + >, + ), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct EquivocationProof<_0, _1> { + pub set_id: ::core::primitive::u64, + pub equivocation: + runtime_types::sp_finality_grandpa::Equivocation<_0, _1>, + } + } + pub mod sp_runtime { + use super::runtime_types; + pub mod generic { + use super::runtime_types; + pub mod digest { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum ChangesTrieSignal { + # [codec (index = 0)] NewConfiguration (:: core :: option :: Option < runtime_types :: sp_core :: changes_trie :: ChangesTrieConfiguration > ,) , } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Digest<_0> { + pub logs: ::std::vec::Vec< + runtime_types::sp_runtime::generic::digest::DigestItem<_0>, + >, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum DigestItem<_0> { + #[codec(index = 2)] + ChangesTrieRoot(_0), + #[codec(index = 6)] + PreRuntime( + [::core::primitive::u8; 4usize], + ::std::vec::Vec<::core::primitive::u8>, + ), + #[codec(index = 4)] + Consensus( + [::core::primitive::u8; 4usize], + ::std::vec::Vec<::core::primitive::u8>, + ), + #[codec(index = 5)] + Seal( + [::core::primitive::u8; 4usize], + ::std::vec::Vec<::core::primitive::u8>, + ), + #[codec(index = 7)] + ChangesTrieSignal( + runtime_types::sp_runtime::generic::digest::ChangesTrieSignal, + ), + #[codec(index = 0)] + Other(::std::vec::Vec<::core::primitive::u8>), + #[codec(index = 8)] + RuntimeEnvironmentUpdated, + } + } + pub mod era { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Era { + #[codec(index = 0)] + Immortal, + #[codec(index = 1)] + Mortal1(::core::primitive::u8), + #[codec(index = 2)] + Mortal2(::core::primitive::u8), + #[codec(index = 3)] + Mortal3(::core::primitive::u8), + #[codec(index = 4)] + Mortal4(::core::primitive::u8), + #[codec(index = 5)] + Mortal5(::core::primitive::u8), + #[codec(index = 6)] + Mortal6(::core::primitive::u8), + #[codec(index = 7)] + Mortal7(::core::primitive::u8), + #[codec(index = 8)] + Mortal8(::core::primitive::u8), + #[codec(index = 9)] + Mortal9(::core::primitive::u8), + #[codec(index = 10)] + Mortal10(::core::primitive::u8), + #[codec(index = 11)] + Mortal11(::core::primitive::u8), + #[codec(index = 12)] + Mortal12(::core::primitive::u8), + #[codec(index = 13)] + Mortal13(::core::primitive::u8), + #[codec(index = 14)] + Mortal14(::core::primitive::u8), + #[codec(index = 15)] + Mortal15(::core::primitive::u8), + #[codec(index = 16)] + Mortal16(::core::primitive::u8), + #[codec(index = 17)] + Mortal17(::core::primitive::u8), + #[codec(index = 18)] + Mortal18(::core::primitive::u8), + #[codec(index = 19)] + Mortal19(::core::primitive::u8), + #[codec(index = 20)] + Mortal20(::core::primitive::u8), + #[codec(index = 21)] + Mortal21(::core::primitive::u8), + #[codec(index = 22)] + Mortal22(::core::primitive::u8), + #[codec(index = 23)] + Mortal23(::core::primitive::u8), + #[codec(index = 24)] + Mortal24(::core::primitive::u8), + #[codec(index = 25)] + Mortal25(::core::primitive::u8), + #[codec(index = 26)] + Mortal26(::core::primitive::u8), + #[codec(index = 27)] + Mortal27(::core::primitive::u8), + #[codec(index = 28)] + Mortal28(::core::primitive::u8), + #[codec(index = 29)] + Mortal29(::core::primitive::u8), + #[codec(index = 30)] + Mortal30(::core::primitive::u8), + #[codec(index = 31)] + Mortal31(::core::primitive::u8), + #[codec(index = 32)] + Mortal32(::core::primitive::u8), + #[codec(index = 33)] + Mortal33(::core::primitive::u8), + #[codec(index = 34)] + Mortal34(::core::primitive::u8), + #[codec(index = 35)] + Mortal35(::core::primitive::u8), + #[codec(index = 36)] + Mortal36(::core::primitive::u8), + #[codec(index = 37)] + Mortal37(::core::primitive::u8), + #[codec(index = 38)] + Mortal38(::core::primitive::u8), + #[codec(index = 39)] + Mortal39(::core::primitive::u8), + #[codec(index = 40)] + Mortal40(::core::primitive::u8), + #[codec(index = 41)] + Mortal41(::core::primitive::u8), + #[codec(index = 42)] + Mortal42(::core::primitive::u8), + #[codec(index = 43)] + Mortal43(::core::primitive::u8), + #[codec(index = 44)] + Mortal44(::core::primitive::u8), + #[codec(index = 45)] + Mortal45(::core::primitive::u8), + #[codec(index = 46)] + Mortal46(::core::primitive::u8), + #[codec(index = 47)] + Mortal47(::core::primitive::u8), + #[codec(index = 48)] + Mortal48(::core::primitive::u8), + #[codec(index = 49)] + Mortal49(::core::primitive::u8), + #[codec(index = 50)] + Mortal50(::core::primitive::u8), + #[codec(index = 51)] + Mortal51(::core::primitive::u8), + #[codec(index = 52)] + Mortal52(::core::primitive::u8), + #[codec(index = 53)] + Mortal53(::core::primitive::u8), + #[codec(index = 54)] + Mortal54(::core::primitive::u8), + #[codec(index = 55)] + Mortal55(::core::primitive::u8), + #[codec(index = 56)] + Mortal56(::core::primitive::u8), + #[codec(index = 57)] + Mortal57(::core::primitive::u8), + #[codec(index = 58)] + Mortal58(::core::primitive::u8), + #[codec(index = 59)] + Mortal59(::core::primitive::u8), + #[codec(index = 60)] + Mortal60(::core::primitive::u8), + #[codec(index = 61)] + Mortal61(::core::primitive::u8), + #[codec(index = 62)] + Mortal62(::core::primitive::u8), + #[codec(index = 63)] + Mortal63(::core::primitive::u8), + #[codec(index = 64)] + Mortal64(::core::primitive::u8), + #[codec(index = 65)] + Mortal65(::core::primitive::u8), + #[codec(index = 66)] + Mortal66(::core::primitive::u8), + #[codec(index = 67)] + Mortal67(::core::primitive::u8), + #[codec(index = 68)] + Mortal68(::core::primitive::u8), + #[codec(index = 69)] + Mortal69(::core::primitive::u8), + #[codec(index = 70)] + Mortal70(::core::primitive::u8), + #[codec(index = 71)] + Mortal71(::core::primitive::u8), + #[codec(index = 72)] + Mortal72(::core::primitive::u8), + #[codec(index = 73)] + Mortal73(::core::primitive::u8), + #[codec(index = 74)] + Mortal74(::core::primitive::u8), + #[codec(index = 75)] + Mortal75(::core::primitive::u8), + #[codec(index = 76)] + Mortal76(::core::primitive::u8), + #[codec(index = 77)] + Mortal77(::core::primitive::u8), + #[codec(index = 78)] + Mortal78(::core::primitive::u8), + #[codec(index = 79)] + Mortal79(::core::primitive::u8), + #[codec(index = 80)] + Mortal80(::core::primitive::u8), + #[codec(index = 81)] + Mortal81(::core::primitive::u8), + #[codec(index = 82)] + Mortal82(::core::primitive::u8), + #[codec(index = 83)] + Mortal83(::core::primitive::u8), + #[codec(index = 84)] + Mortal84(::core::primitive::u8), + #[codec(index = 85)] + Mortal85(::core::primitive::u8), + #[codec(index = 86)] + Mortal86(::core::primitive::u8), + #[codec(index = 87)] + Mortal87(::core::primitive::u8), + #[codec(index = 88)] + Mortal88(::core::primitive::u8), + #[codec(index = 89)] + Mortal89(::core::primitive::u8), + #[codec(index = 90)] + Mortal90(::core::primitive::u8), + #[codec(index = 91)] + Mortal91(::core::primitive::u8), + #[codec(index = 92)] + Mortal92(::core::primitive::u8), + #[codec(index = 93)] + Mortal93(::core::primitive::u8), + #[codec(index = 94)] + Mortal94(::core::primitive::u8), + #[codec(index = 95)] + Mortal95(::core::primitive::u8), + #[codec(index = 96)] + Mortal96(::core::primitive::u8), + #[codec(index = 97)] + Mortal97(::core::primitive::u8), + #[codec(index = 98)] + Mortal98(::core::primitive::u8), + #[codec(index = 99)] + Mortal99(::core::primitive::u8), + #[codec(index = 100)] + Mortal100(::core::primitive::u8), + #[codec(index = 101)] + Mortal101(::core::primitive::u8), + #[codec(index = 102)] + Mortal102(::core::primitive::u8), + #[codec(index = 103)] + Mortal103(::core::primitive::u8), + #[codec(index = 104)] + Mortal104(::core::primitive::u8), + #[codec(index = 105)] + Mortal105(::core::primitive::u8), + #[codec(index = 106)] + Mortal106(::core::primitive::u8), + #[codec(index = 107)] + Mortal107(::core::primitive::u8), + #[codec(index = 108)] + Mortal108(::core::primitive::u8), + #[codec(index = 109)] + Mortal109(::core::primitive::u8), + #[codec(index = 110)] + Mortal110(::core::primitive::u8), + #[codec(index = 111)] + Mortal111(::core::primitive::u8), + #[codec(index = 112)] + Mortal112(::core::primitive::u8), + #[codec(index = 113)] + Mortal113(::core::primitive::u8), + #[codec(index = 114)] + Mortal114(::core::primitive::u8), + #[codec(index = 115)] + Mortal115(::core::primitive::u8), + #[codec(index = 116)] + Mortal116(::core::primitive::u8), + #[codec(index = 117)] + Mortal117(::core::primitive::u8), + #[codec(index = 118)] + Mortal118(::core::primitive::u8), + #[codec(index = 119)] + Mortal119(::core::primitive::u8), + #[codec(index = 120)] + Mortal120(::core::primitive::u8), + #[codec(index = 121)] + Mortal121(::core::primitive::u8), + #[codec(index = 122)] + Mortal122(::core::primitive::u8), + #[codec(index = 123)] + Mortal123(::core::primitive::u8), + #[codec(index = 124)] + Mortal124(::core::primitive::u8), + #[codec(index = 125)] + Mortal125(::core::primitive::u8), + #[codec(index = 126)] + Mortal126(::core::primitive::u8), + #[codec(index = 127)] + Mortal127(::core::primitive::u8), + #[codec(index = 128)] + Mortal128(::core::primitive::u8), + #[codec(index = 129)] + Mortal129(::core::primitive::u8), + #[codec(index = 130)] + Mortal130(::core::primitive::u8), + #[codec(index = 131)] + Mortal131(::core::primitive::u8), + #[codec(index = 132)] + Mortal132(::core::primitive::u8), + #[codec(index = 133)] + Mortal133(::core::primitive::u8), + #[codec(index = 134)] + Mortal134(::core::primitive::u8), + #[codec(index = 135)] + Mortal135(::core::primitive::u8), + #[codec(index = 136)] + Mortal136(::core::primitive::u8), + #[codec(index = 137)] + Mortal137(::core::primitive::u8), + #[codec(index = 138)] + Mortal138(::core::primitive::u8), + #[codec(index = 139)] + Mortal139(::core::primitive::u8), + #[codec(index = 140)] + Mortal140(::core::primitive::u8), + #[codec(index = 141)] + Mortal141(::core::primitive::u8), + #[codec(index = 142)] + Mortal142(::core::primitive::u8), + #[codec(index = 143)] + Mortal143(::core::primitive::u8), + #[codec(index = 144)] + Mortal144(::core::primitive::u8), + #[codec(index = 145)] + Mortal145(::core::primitive::u8), + #[codec(index = 146)] + Mortal146(::core::primitive::u8), + #[codec(index = 147)] + Mortal147(::core::primitive::u8), + #[codec(index = 148)] + Mortal148(::core::primitive::u8), + #[codec(index = 149)] + Mortal149(::core::primitive::u8), + #[codec(index = 150)] + Mortal150(::core::primitive::u8), + #[codec(index = 151)] + Mortal151(::core::primitive::u8), + #[codec(index = 152)] + Mortal152(::core::primitive::u8), + #[codec(index = 153)] + Mortal153(::core::primitive::u8), + #[codec(index = 154)] + Mortal154(::core::primitive::u8), + #[codec(index = 155)] + Mortal155(::core::primitive::u8), + #[codec(index = 156)] + Mortal156(::core::primitive::u8), + #[codec(index = 157)] + Mortal157(::core::primitive::u8), + #[codec(index = 158)] + Mortal158(::core::primitive::u8), + #[codec(index = 159)] + Mortal159(::core::primitive::u8), + #[codec(index = 160)] + Mortal160(::core::primitive::u8), + #[codec(index = 161)] + Mortal161(::core::primitive::u8), + #[codec(index = 162)] + Mortal162(::core::primitive::u8), + #[codec(index = 163)] + Mortal163(::core::primitive::u8), + #[codec(index = 164)] + Mortal164(::core::primitive::u8), + #[codec(index = 165)] + Mortal165(::core::primitive::u8), + #[codec(index = 166)] + Mortal166(::core::primitive::u8), + #[codec(index = 167)] + Mortal167(::core::primitive::u8), + #[codec(index = 168)] + Mortal168(::core::primitive::u8), + #[codec(index = 169)] + Mortal169(::core::primitive::u8), + #[codec(index = 170)] + Mortal170(::core::primitive::u8), + #[codec(index = 171)] + Mortal171(::core::primitive::u8), + #[codec(index = 172)] + Mortal172(::core::primitive::u8), + #[codec(index = 173)] + Mortal173(::core::primitive::u8), + #[codec(index = 174)] + Mortal174(::core::primitive::u8), + #[codec(index = 175)] + Mortal175(::core::primitive::u8), + #[codec(index = 176)] + Mortal176(::core::primitive::u8), + #[codec(index = 177)] + Mortal177(::core::primitive::u8), + #[codec(index = 178)] + Mortal178(::core::primitive::u8), + #[codec(index = 179)] + Mortal179(::core::primitive::u8), + #[codec(index = 180)] + Mortal180(::core::primitive::u8), + #[codec(index = 181)] + Mortal181(::core::primitive::u8), + #[codec(index = 182)] + Mortal182(::core::primitive::u8), + #[codec(index = 183)] + Mortal183(::core::primitive::u8), + #[codec(index = 184)] + Mortal184(::core::primitive::u8), + #[codec(index = 185)] + Mortal185(::core::primitive::u8), + #[codec(index = 186)] + Mortal186(::core::primitive::u8), + #[codec(index = 187)] + Mortal187(::core::primitive::u8), + #[codec(index = 188)] + Mortal188(::core::primitive::u8), + #[codec(index = 189)] + Mortal189(::core::primitive::u8), + #[codec(index = 190)] + Mortal190(::core::primitive::u8), + #[codec(index = 191)] + Mortal191(::core::primitive::u8), + #[codec(index = 192)] + Mortal192(::core::primitive::u8), + #[codec(index = 193)] + Mortal193(::core::primitive::u8), + #[codec(index = 194)] + Mortal194(::core::primitive::u8), + #[codec(index = 195)] + Mortal195(::core::primitive::u8), + #[codec(index = 196)] + Mortal196(::core::primitive::u8), + #[codec(index = 197)] + Mortal197(::core::primitive::u8), + #[codec(index = 198)] + Mortal198(::core::primitive::u8), + #[codec(index = 199)] + Mortal199(::core::primitive::u8), + #[codec(index = 200)] + Mortal200(::core::primitive::u8), + #[codec(index = 201)] + Mortal201(::core::primitive::u8), + #[codec(index = 202)] + Mortal202(::core::primitive::u8), + #[codec(index = 203)] + Mortal203(::core::primitive::u8), + #[codec(index = 204)] + Mortal204(::core::primitive::u8), + #[codec(index = 205)] + Mortal205(::core::primitive::u8), + #[codec(index = 206)] + Mortal206(::core::primitive::u8), + #[codec(index = 207)] + Mortal207(::core::primitive::u8), + #[codec(index = 208)] + Mortal208(::core::primitive::u8), + #[codec(index = 209)] + Mortal209(::core::primitive::u8), + #[codec(index = 210)] + Mortal210(::core::primitive::u8), + #[codec(index = 211)] + Mortal211(::core::primitive::u8), + #[codec(index = 212)] + Mortal212(::core::primitive::u8), + #[codec(index = 213)] + Mortal213(::core::primitive::u8), + #[codec(index = 214)] + Mortal214(::core::primitive::u8), + #[codec(index = 215)] + Mortal215(::core::primitive::u8), + #[codec(index = 216)] + Mortal216(::core::primitive::u8), + #[codec(index = 217)] + Mortal217(::core::primitive::u8), + #[codec(index = 218)] + Mortal218(::core::primitive::u8), + #[codec(index = 219)] + Mortal219(::core::primitive::u8), + #[codec(index = 220)] + Mortal220(::core::primitive::u8), + #[codec(index = 221)] + Mortal221(::core::primitive::u8), + #[codec(index = 222)] + Mortal222(::core::primitive::u8), + #[codec(index = 223)] + Mortal223(::core::primitive::u8), + #[codec(index = 224)] + Mortal224(::core::primitive::u8), + #[codec(index = 225)] + Mortal225(::core::primitive::u8), + #[codec(index = 226)] + Mortal226(::core::primitive::u8), + #[codec(index = 227)] + Mortal227(::core::primitive::u8), + #[codec(index = 228)] + Mortal228(::core::primitive::u8), + #[codec(index = 229)] + Mortal229(::core::primitive::u8), + #[codec(index = 230)] + Mortal230(::core::primitive::u8), + #[codec(index = 231)] + Mortal231(::core::primitive::u8), + #[codec(index = 232)] + Mortal232(::core::primitive::u8), + #[codec(index = 233)] + Mortal233(::core::primitive::u8), + #[codec(index = 234)] + Mortal234(::core::primitive::u8), + #[codec(index = 235)] + Mortal235(::core::primitive::u8), + #[codec(index = 236)] + Mortal236(::core::primitive::u8), + #[codec(index = 237)] + Mortal237(::core::primitive::u8), + #[codec(index = 238)] + Mortal238(::core::primitive::u8), + #[codec(index = 239)] + Mortal239(::core::primitive::u8), + #[codec(index = 240)] + Mortal240(::core::primitive::u8), + #[codec(index = 241)] + Mortal241(::core::primitive::u8), + #[codec(index = 242)] + Mortal242(::core::primitive::u8), + #[codec(index = 243)] + Mortal243(::core::primitive::u8), + #[codec(index = 244)] + Mortal244(::core::primitive::u8), + #[codec(index = 245)] + Mortal245(::core::primitive::u8), + #[codec(index = 246)] + Mortal246(::core::primitive::u8), + #[codec(index = 247)] + Mortal247(::core::primitive::u8), + #[codec(index = 248)] + Mortal248(::core::primitive::u8), + #[codec(index = 249)] + Mortal249(::core::primitive::u8), + #[codec(index = 250)] + Mortal250(::core::primitive::u8), + #[codec(index = 251)] + Mortal251(::core::primitive::u8), + #[codec(index = 252)] + Mortal252(::core::primitive::u8), + #[codec(index = 253)] + Mortal253(::core::primitive::u8), + #[codec(index = 254)] + Mortal254(::core::primitive::u8), + #[codec(index = 255)] + Mortal255(::core::primitive::u8), + } + } + pub mod header { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct Header<_0, _1> { + pub parent_hash: ::subxt::sp_core::H256, + #[codec(compact)] + pub number: _0, + pub state_root: ::subxt::sp_core::H256, + pub extrinsics_root: ::subxt::sp_core::H256, + pub digest: runtime_types::sp_runtime::generic::digest::Digest< + ::subxt::sp_core::H256, + >, + #[codec(skip)] + pub __subxt_unused_type_params: ::core::marker::PhantomData<_1>, + } + } + pub mod unchecked_extrinsic { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct UncheckedExtrinsic<_0, _1, _2, _3>( + ::std::vec::Vec<::core::primitive::u8>, + #[codec(skip)] pub ::core::marker::PhantomData<(_0, _2, _1, _3)>, + ); + } + } + pub mod multiaddress { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum MultiAddress<_0, _1> { + #[codec(index = 0)] + Id(_0), + #[codec(index = 1)] + Index(#[codec(compact)] _1), + #[codec(index = 2)] + Raw(::std::vec::Vec<::core::primitive::u8>), + #[codec(index = 3)] + Address32([::core::primitive::u8; 32usize]), + #[codec(index = 4)] + Address20([::core::primitive::u8; 20usize]), + } + } + pub mod traits { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct BlakeTwo256 {} + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum ArithmeticError { + #[codec(index = 0)] + Underflow, + #[codec(index = 1)] + Overflow, + #[codec(index = 2)] + DivisionByZero, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum DispatchError { + #[codec(index = 0)] + Other, + #[codec(index = 1)] + CannotLookup, + #[codec(index = 2)] + BadOrigin, + #[codec(index = 3)] + Module { + index: ::core::primitive::u8, + error: ::core::primitive::u8, + }, + #[codec(index = 4)] + ConsumerRemaining, + #[codec(index = 5)] + NoProviders, + #[codec(index = 6)] + Token(runtime_types::sp_runtime::TokenError), + #[codec(index = 7)] + Arithmetic(runtime_types::sp_runtime::ArithmeticError), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum MultiSignature { + #[codec(index = 0)] + Ed25519(runtime_types::sp_core::ed25519::Signature), + #[codec(index = 1)] + Sr25519(runtime_types::sp_core::sr25519::Signature), + #[codec(index = 2)] + Ecdsa(runtime_types::sp_core::ecdsa::Signature), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum MultiSigner { + #[codec(index = 0)] + Ed25519(runtime_types::sp_core::ed25519::Public), + #[codec(index = 1)] + Sr25519(runtime_types::sp_core::sr25519::Public), + #[codec(index = 2)] + Ecdsa(runtime_types::sp_core::ecdsa::Public), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum TokenError { + #[codec(index = 0)] + NoFunds, + #[codec(index = 1)] + WouldDie, + #[codec(index = 2)] + BelowMinimum, + #[codec(index = 3)] + CannotCreate, + #[codec(index = 4)] + UnknownAsset, + #[codec(index = 5)] + Frozen, + #[codec(index = 6)] + Unsupported, + } + } + pub mod sp_session { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct MembershipProof { + pub session: ::core::primitive::u32, + pub trie_nodes: ::std::vec::Vec<::std::vec::Vec<::core::primitive::u8>>, + pub validator_count: ::core::primitive::u32, + } + } + pub mod sp_staking { + use super::runtime_types; + pub mod offence { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct OffenceDetails<_0, _1> { + pub offender: _1, + pub reporters: ::std::vec::Vec<_0>, + } + } + } + pub mod sp_version { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct RuntimeVersion { + pub spec_name: ::std::string::String, + pub impl_name: ::std::string::String, + pub authoring_version: ::core::primitive::u32, + pub spec_version: ::core::primitive::u32, + pub impl_version: ::core::primitive::u32, + pub apis: ::std::vec::Vec<( + [::core::primitive::u8; 8usize], + ::core::primitive::u32, + )>, + pub transaction_version: ::core::primitive::u32, + } + } + pub mod xcm { + use super::runtime_types; + pub mod double_encoded { + use super::runtime_types; + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct DoubleEncoded { + pub encoded: ::std::vec::Vec<::core::primitive::u8>, + } + } + pub mod v0 { + use super::runtime_types; + pub mod junction { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum BodyId { + #[codec(index = 0)] + Unit, + #[codec(index = 1)] + Named(::std::vec::Vec<::core::primitive::u8>), + #[codec(index = 2)] + Index(#[codec(compact)] ::core::primitive::u32), + #[codec(index = 3)] + Executive, + #[codec(index = 4)] + Technical, + #[codec(index = 5)] + Legislative, + #[codec(index = 6)] + Judicial, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum BodyPart { + #[codec(index = 0)] + Voice, + #[codec(index = 1)] + Members { + #[codec(compact)] + count: ::core::primitive::u32, + }, + #[codec(index = 2)] + Fraction { + #[codec(compact)] + nom: ::core::primitive::u32, + #[codec(compact)] + denom: ::core::primitive::u32, + }, + #[codec(index = 3)] + AtLeastProportion { + #[codec(compact)] + nom: ::core::primitive::u32, + #[codec(compact)] + denom: ::core::primitive::u32, + }, + #[codec(index = 4)] + MoreThanProportion { + #[codec(compact)] + nom: ::core::primitive::u32, + #[codec(compact)] + denom: ::core::primitive::u32, + }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Junction { + #[codec(index = 0)] + Parent, + #[codec(index = 1)] + Parachain(#[codec(compact)] ::core::primitive::u32), + #[codec(index = 2)] + AccountId32 { + network: runtime_types::xcm::v0::junction::NetworkId, + id: [::core::primitive::u8; 32usize], + }, + #[codec(index = 3)] + AccountIndex64 { + network: runtime_types::xcm::v0::junction::NetworkId, + #[codec(compact)] + index: ::core::primitive::u64, + }, + #[codec(index = 4)] + AccountKey20 { + network: runtime_types::xcm::v0::junction::NetworkId, + key: [::core::primitive::u8; 20usize], + }, + #[codec(index = 5)] + PalletInstance(::core::primitive::u8), + #[codec(index = 6)] + GeneralIndex(#[codec(compact)] ::core::primitive::u128), + #[codec(index = 7)] + GeneralKey(::std::vec::Vec<::core::primitive::u8>), + #[codec(index = 8)] + OnlyChild, + #[codec(index = 9)] + Plurality { + id: runtime_types::xcm::v0::junction::BodyId, + part: runtime_types::xcm::v0::junction::BodyPart, + }, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum NetworkId { + #[codec(index = 0)] + Any, + #[codec(index = 1)] + Named(::std::vec::Vec<::core::primitive::u8>), + #[codec(index = 2)] + Polkadot, + #[codec(index = 3)] + Kusama, + } + } + pub mod multi_asset { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum MultiAsset { + #[codec(index = 0)] + None, + #[codec(index = 1)] + All, + #[codec(index = 2)] + AllFungible, + #[codec(index = 3)] + AllNonFungible, + #[codec(index = 4)] + AllAbstractFungible { + id: ::std::vec::Vec<::core::primitive::u8>, + }, + #[codec(index = 5)] + AllAbstractNonFungible { + class: ::std::vec::Vec<::core::primitive::u8>, + }, + #[codec(index = 6)] + AllConcreteFungible { + id: runtime_types::xcm::v0::multi_location::MultiLocation, + }, + #[codec(index = 7)] + AllConcreteNonFungible { + class: runtime_types::xcm::v0::multi_location::MultiLocation, + }, + #[codec(index = 8)] + AbstractFungible { + id: ::std::vec::Vec<::core::primitive::u8>, + #[codec(compact)] + amount: ::core::primitive::u128, + }, + #[codec(index = 9)] + AbstractNonFungible { + class: ::std::vec::Vec<::core::primitive::u8>, + instance: runtime_types::xcm::v1::multiasset::AssetInstance, + }, + #[codec(index = 10)] + ConcreteFungible { + id: runtime_types::xcm::v0::multi_location::MultiLocation, + #[codec(compact)] + amount: ::core::primitive::u128, + }, + #[codec(index = 11)] + ConcreteNonFungible { + class: runtime_types::xcm::v0::multi_location::MultiLocation, + instance: runtime_types::xcm::v1::multiasset::AssetInstance, + }, + } + } + pub mod multi_location { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum MultiLocation { + #[codec(index = 0)] + Null, + #[codec(index = 1)] + X1(runtime_types::xcm::v0::junction::Junction), + #[codec(index = 2)] + X2( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + #[codec(index = 3)] + X3( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + #[codec(index = 4)] + X4( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + #[codec(index = 5)] + X5( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + #[codec(index = 6)] + X6( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + #[codec(index = 7)] + X7( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + #[codec(index = 8)] + X8( + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + runtime_types::xcm::v0::junction::Junction, + ), + } + } + pub mod order { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Order { + #[codec(index = 0)] + Null, + #[codec(index = 1)] + DepositAsset { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + dest: runtime_types::xcm::v0::multi_location::MultiLocation, + }, + #[codec(index = 2)] + DepositReserveAsset { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + dest: runtime_types::xcm::v0::multi_location::MultiLocation, + effects: + ::std::vec::Vec, + }, + #[codec(index = 3)] + ExchangeAsset { + give: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + receive: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + }, + #[codec(index = 4)] + InitiateReserveWithdraw { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + reserve: + runtime_types::xcm::v0::multi_location::MultiLocation, + effects: + ::std::vec::Vec, + }, + #[codec(index = 5)] + InitiateTeleport { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + dest: runtime_types::xcm::v0::multi_location::MultiLocation, + effects: + ::std::vec::Vec, + }, + #[codec(index = 6)] + QueryHolding { + #[codec(compact)] + query_id: ::core::primitive::u64, + dest: runtime_types::xcm::v0::multi_location::MultiLocation, + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + }, + #[codec(index = 7)] + BuyExecution { + fees: runtime_types::xcm::v0::multi_asset::MultiAsset, + weight: ::core::primitive::u64, + debt: ::core::primitive::u64, + halt_on_error: ::core::primitive::bool, + xcm: ::std::vec::Vec, + }, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum OriginKind { + #[codec(index = 0)] + Native, + #[codec(index = 1)] + SovereignAccount, + #[codec(index = 2)] + Superuser, + #[codec(index = 3)] + Xcm, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Response { + #[codec(index = 0)] + Assets( + ::std::vec::Vec, + ), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Xcm { + #[codec(index = 0)] + WithdrawAsset { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + effects: ::std::vec::Vec, + }, + #[codec(index = 1)] + ReserveAssetDeposit { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + effects: ::std::vec::Vec, + }, + #[codec(index = 2)] + TeleportAsset { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + effects: ::std::vec::Vec, + }, + #[codec(index = 3)] + QueryResponse { + #[codec(compact)] + query_id: ::core::primitive::u64, + response: runtime_types::xcm::v0::Response, + }, + #[codec(index = 4)] + TransferAsset { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + dest: runtime_types::xcm::v0::multi_location::MultiLocation, + }, + #[codec(index = 5)] + TransferReserveAsset { + assets: ::std::vec::Vec< + runtime_types::xcm::v0::multi_asset::MultiAsset, + >, + dest: runtime_types::xcm::v0::multi_location::MultiLocation, + effects: ::std::vec::Vec, + }, + #[codec(index = 6)] + Transact { + origin_type: runtime_types::xcm::v0::OriginKind, + require_weight_at_most: ::core::primitive::u64, + call: runtime_types::xcm::double_encoded::DoubleEncoded, + }, + #[codec(index = 7)] + HrmpNewChannelOpenRequest { + #[codec(compact)] + sender: ::core::primitive::u32, + #[codec(compact)] + max_message_size: ::core::primitive::u32, + #[codec(compact)] + max_capacity: ::core::primitive::u32, + }, + #[codec(index = 8)] + HrmpChannelAccepted { + #[codec(compact)] + recipient: ::core::primitive::u32, + }, + #[codec(index = 9)] + HrmpChannelClosing { + #[codec(compact)] + initiator: ::core::primitive::u32, + #[codec(compact)] + sender: ::core::primitive::u32, + #[codec(compact)] + recipient: ::core::primitive::u32, + }, + #[codec(index = 10)] + RelayedFrom { + who: runtime_types::xcm::v0::multi_location::MultiLocation, + message: ::std::boxed::Box, + }, + } + } + pub mod v1 { + use super::runtime_types; + pub mod junction { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Junction { + #[codec(index = 0)] + Parachain(#[codec(compact)] ::core::primitive::u32), + #[codec(index = 1)] + AccountId32 { + network: runtime_types::xcm::v0::junction::NetworkId, + id: [::core::primitive::u8; 32usize], + }, + #[codec(index = 2)] + AccountIndex64 { + network: runtime_types::xcm::v0::junction::NetworkId, + #[codec(compact)] + index: ::core::primitive::u64, + }, + #[codec(index = 3)] + AccountKey20 { + network: runtime_types::xcm::v0::junction::NetworkId, + key: [::core::primitive::u8; 20usize], + }, + #[codec(index = 4)] + PalletInstance(::core::primitive::u8), + #[codec(index = 5)] + GeneralIndex(#[codec(compact)] ::core::primitive::u128), + #[codec(index = 6)] + GeneralKey(::std::vec::Vec<::core::primitive::u8>), + #[codec(index = 7)] + OnlyChild, + #[codec(index = 8)] + Plurality { + id: runtime_types::xcm::v0::junction::BodyId, + part: runtime_types::xcm::v0::junction::BodyPart, + }, + } + } + pub mod multiasset { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum AssetId { + #[codec(index = 0)] + Concrete(runtime_types::xcm::v1::multilocation::MultiLocation), + #[codec(index = 1)] + Abstract(::std::vec::Vec<::core::primitive::u8>), + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum AssetInstance { + #[codec(index = 0)] + Undefined, + #[codec(index = 1)] + Index(#[codec(compact)] ::core::primitive::u128), + #[codec(index = 2)] + Array4([::core::primitive::u8; 4usize]), + #[codec(index = 3)] + Array8([::core::primitive::u8; 8usize]), + #[codec(index = 4)] + Array16([::core::primitive::u8; 16usize]), + #[codec(index = 5)] + Array32([::core::primitive::u8; 32usize]), + #[codec(index = 6)] + Blob(::std::vec::Vec<::core::primitive::u8>), + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Fungibility { + #[codec(index = 0)] + Fungible(#[codec(compact)] ::core::primitive::u128), + #[codec(index = 1)] + NonFungible(runtime_types::xcm::v1::multiasset::AssetInstance), + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct MultiAsset { + pub id: runtime_types::xcm::v1::multiasset::AssetId, + pub fun: runtime_types::xcm::v1::multiasset::Fungibility, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum MultiAssetFilter { + #[codec(index = 0)] + Definite(runtime_types::xcm::v1::multiasset::MultiAssets), + #[codec(index = 1)] + Wild(runtime_types::xcm::v1::multiasset::WildMultiAsset), + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct MultiAssets( + pub ::std::vec::Vec< + runtime_types::xcm::v1::multiasset::MultiAsset, + >, + ); + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum WildFungibility { + #[codec(index = 0)] + Fungible, + #[codec(index = 1)] + NonFungible, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum WildMultiAsset { + #[codec(index = 0)] + All, + #[codec(index = 1)] + AllOf { + id: runtime_types::xcm::v1::multiasset::AssetId, + fun: runtime_types::xcm::v1::multiasset::WildFungibility, + }, + } + } + pub mod multilocation { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Junctions { + #[codec(index = 0)] + Here, + #[codec(index = 1)] + X1(runtime_types::xcm::v1::junction::Junction), + #[codec(index = 2)] + X2( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + #[codec(index = 3)] + X3( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + #[codec(index = 4)] + X4( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + #[codec(index = 5)] + X5( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + #[codec(index = 6)] + X6( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + #[codec(index = 7)] + X7( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + #[codec(index = 8)] + X8( + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + runtime_types::xcm::v1::junction::Junction, + ), + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub struct MultiLocation { + pub parents: ::core::primitive::u8, + pub interior: runtime_types::xcm::v1::multilocation::Junctions, + } + } + pub mod order { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Order { + #[codec(index = 0)] + Noop, + #[codec(index = 1)] + DepositAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + max_assets: ::core::primitive::u32, + beneficiary: + runtime_types::xcm::v1::multilocation::MultiLocation, + }, + #[codec(index = 2)] + DepositReserveAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + max_assets: ::core::primitive::u32, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + effects: + ::std::vec::Vec, + }, + #[codec(index = 3)] + ExchangeAsset { + give: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + receive: runtime_types::xcm::v1::multiasset::MultiAssets, + }, + #[codec(index = 4)] + InitiateReserveWithdraw { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + reserve: runtime_types::xcm::v1::multilocation::MultiLocation, + effects: + ::std::vec::Vec, + }, + #[codec(index = 5)] + InitiateTeleport { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + effects: + ::std::vec::Vec, + }, + #[codec(index = 6)] + QueryHolding { + #[codec(compact)] + query_id: ::core::primitive::u64, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + }, + #[codec(index = 7)] + BuyExecution { + fees: runtime_types::xcm::v1::multiasset::MultiAsset, + weight: ::core::primitive::u64, + debt: ::core::primitive::u64, + halt_on_error: ::core::primitive::bool, + instructions: ::std::vec::Vec, + }, + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Response { + #[codec(index = 0)] + Assets(runtime_types::xcm::v1::multiasset::MultiAssets), + #[codec(index = 1)] + Version(::core::primitive::u32), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Xcm { + #[codec(index = 0)] + WithdrawAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + effects: ::std::vec::Vec, + }, + #[codec(index = 1)] + ReserveAssetDeposited { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + effects: ::std::vec::Vec, + }, + #[codec(index = 2)] + ReceiveTeleportedAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + effects: ::std::vec::Vec, + }, + #[codec(index = 3)] + QueryResponse { + #[codec(compact)] + query_id: ::core::primitive::u64, + response: runtime_types::xcm::v1::Response, + }, + #[codec(index = 4)] + TransferAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + beneficiary: runtime_types::xcm::v1::multilocation::MultiLocation, + }, + #[codec(index = 5)] + TransferReserveAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + effects: ::std::vec::Vec, + }, + #[codec(index = 6)] + Transact { + origin_type: runtime_types::xcm::v0::OriginKind, + require_weight_at_most: ::core::primitive::u64, + call: runtime_types::xcm::double_encoded::DoubleEncoded, + }, + #[codec(index = 7)] + HrmpNewChannelOpenRequest { + #[codec(compact)] + sender: ::core::primitive::u32, + #[codec(compact)] + max_message_size: ::core::primitive::u32, + #[codec(compact)] + max_capacity: ::core::primitive::u32, + }, + #[codec(index = 8)] + HrmpChannelAccepted { + #[codec(compact)] + recipient: ::core::primitive::u32, + }, + #[codec(index = 9)] + HrmpChannelClosing { + #[codec(compact)] + initiator: ::core::primitive::u32, + #[codec(compact)] + sender: ::core::primitive::u32, + #[codec(compact)] + recipient: ::core::primitive::u32, + }, + #[codec(index = 10)] + RelayedFrom { + who: runtime_types::xcm::v1::multilocation::Junctions, + message: ::std::boxed::Box, + }, + #[codec(index = 11)] + SubscribeVersion { + #[codec(compact)] + query_id: ::core::primitive::u64, + #[codec(compact)] + max_response_weight: ::core::primitive::u64, + }, + #[codec(index = 12)] + UnsubscribeVersion, + } + } + pub mod v2 { + use super::runtime_types; + pub mod traits { + use super::runtime_types; + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Error { + #[codec(index = 0)] + Overflow, + #[codec(index = 1)] + Unimplemented, + #[codec(index = 2)] + UntrustedReserveLocation, + #[codec(index = 3)] + UntrustedTeleportLocation, + #[codec(index = 4)] + MultiLocationFull, + #[codec(index = 5)] + MultiLocationNotInvertible, + #[codec(index = 6)] + BadOrigin, + #[codec(index = 7)] + InvalidLocation, + #[codec(index = 8)] + AssetNotFound, + #[codec(index = 9)] + FailedToTransactAsset, + #[codec(index = 10)] + NotWithdrawable, + #[codec(index = 11)] + LocationCannotHold, + #[codec(index = 12)] + ExceedsMaxMessageSize, + #[codec(index = 13)] + DestinationUnsupported, + #[codec(index = 14)] + Transport, + #[codec(index = 15)] + Unroutable, + #[codec(index = 16)] + UnknownClaim, + #[codec(index = 17)] + FailedToDecode, + #[codec(index = 18)] + TooMuchWeightRequired, + #[codec(index = 19)] + NotHoldingFees, + #[codec(index = 20)] + TooExpensive, + #[codec(index = 21)] + Trap(::core::primitive::u64), + #[codec(index = 22)] + UnhandledXcmVersion, + #[codec(index = 23)] + WeightLimitReached(::core::primitive::u64), + #[codec(index = 24)] + Barrier, + #[codec(index = 25)] + WeightNotComputable, + } + #[derive( + :: subxt :: codec :: Encode, :: subxt :: codec :: Decode, + )] + pub enum Outcome { + #[codec(index = 0)] + Complete(::core::primitive::u64), + #[codec(index = 1)] + Incomplete( + ::core::primitive::u64, + runtime_types::xcm::v2::traits::Error, + ), + #[codec(index = 2)] + Error(runtime_types::xcm::v2::traits::Error), + } + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Instruction { + #[codec(index = 0)] + WithdrawAsset(runtime_types::xcm::v1::multiasset::MultiAssets), + #[codec(index = 1)] + ReserveAssetDeposited( + runtime_types::xcm::v1::multiasset::MultiAssets, + ), + #[codec(index = 2)] + ReceiveTeleportedAsset( + runtime_types::xcm::v1::multiasset::MultiAssets, + ), + #[codec(index = 3)] + QueryResponse { + #[codec(compact)] + query_id: ::core::primitive::u64, + response: runtime_types::xcm::v2::Response, + #[codec(compact)] + max_weight: ::core::primitive::u64, + }, + #[codec(index = 4)] + TransferAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + beneficiary: runtime_types::xcm::v1::multilocation::MultiLocation, + }, + #[codec(index = 5)] + TransferReserveAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + xcm: runtime_types::xcm::v2::Xcm, + }, + #[codec(index = 6)] + Transact { + origin_type: runtime_types::xcm::v0::OriginKind, + #[codec(compact)] + require_weight_at_most: ::core::primitive::u64, + call: runtime_types::xcm::double_encoded::DoubleEncoded, + }, + #[codec(index = 7)] + HrmpNewChannelOpenRequest { + #[codec(compact)] + sender: ::core::primitive::u32, + #[codec(compact)] + max_message_size: ::core::primitive::u32, + #[codec(compact)] + max_capacity: ::core::primitive::u32, + }, + #[codec(index = 8)] + HrmpChannelAccepted { + #[codec(compact)] + recipient: ::core::primitive::u32, + }, + #[codec(index = 9)] + HrmpChannelClosing { + #[codec(compact)] + initiator: ::core::primitive::u32, + #[codec(compact)] + sender: ::core::primitive::u32, + #[codec(compact)] + recipient: ::core::primitive::u32, + }, + #[codec(index = 10)] + ClearOrigin, + #[codec(index = 11)] + DescendOrigin(runtime_types::xcm::v1::multilocation::Junctions), + #[codec(index = 12)] + ReportError { + #[codec(compact)] + query_id: ::core::primitive::u64, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + #[codec(compact)] + max_response_weight: ::core::primitive::u64, + }, + #[codec(index = 13)] + DepositAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + #[codec(compact)] + max_assets: ::core::primitive::u32, + beneficiary: runtime_types::xcm::v1::multilocation::MultiLocation, + }, + #[codec(index = 14)] + DepositReserveAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + #[codec(compact)] + max_assets: ::core::primitive::u32, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + xcm: runtime_types::xcm::v2::Xcm, + }, + #[codec(index = 15)] + ExchangeAsset { + give: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + receive: runtime_types::xcm::v1::multiasset::MultiAssets, + }, + #[codec(index = 16)] + InitiateReserveWithdraw { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + reserve: runtime_types::xcm::v1::multilocation::MultiLocation, + xcm: runtime_types::xcm::v2::Xcm, + }, + #[codec(index = 17)] + InitiateTeleport { + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + xcm: runtime_types::xcm::v2::Xcm, + }, + #[codec(index = 18)] + QueryHolding { + #[codec(compact)] + query_id: ::core::primitive::u64, + dest: runtime_types::xcm::v1::multilocation::MultiLocation, + assets: runtime_types::xcm::v1::multiasset::MultiAssetFilter, + #[codec(compact)] + max_response_weight: ::core::primitive::u64, + }, + #[codec(index = 19)] + BuyExecution { + fees: runtime_types::xcm::v1::multiasset::MultiAsset, + weight_limit: runtime_types::xcm::v2::WeightLimit, + }, + #[codec(index = 20)] + RefundSurplus, + #[codec(index = 21)] + SetErrorHandler(runtime_types::xcm::v2::Xcm), + #[codec(index = 22)] + SetAppendix(runtime_types::xcm::v2::Xcm), + #[codec(index = 23)] + ClearError, + #[codec(index = 24)] + ClaimAsset { + assets: runtime_types::xcm::v1::multiasset::MultiAssets, + ticket: runtime_types::xcm::v1::multilocation::MultiLocation, + }, + #[codec(index = 25)] + Trap(#[codec(compact)] ::core::primitive::u64), + #[codec(index = 26)] + SubscribeVersion { + #[codec(compact)] + query_id: ::core::primitive::u64, + #[codec(compact)] + max_response_weight: ::core::primitive::u64, + }, + #[codec(index = 27)] + UnsubscribeVersion, + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum Response { + #[codec(index = 0)] + Null, + #[codec(index = 1)] + Assets(runtime_types::xcm::v1::multiasset::MultiAssets), + #[codec(index = 2)] + ExecutionResult( + ::core::option::Option<( + ::core::primitive::u32, + runtime_types::xcm::v2::traits::Error, + )>, + ), + #[codec(index = 3)] + Version(::core::primitive::u32), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum WeightLimit { + #[codec(index = 0)] + Unlimited, + #[codec(index = 1)] + Limited(#[codec(compact)] ::core::primitive::u64), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub struct Xcm(pub ::std::vec::Vec); + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum VersionedMultiAssets { + #[codec(index = 0)] + V0(::std::vec::Vec), + #[codec(index = 1)] + V1(runtime_types::xcm::v1::multiasset::MultiAssets), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum VersionedMultiLocation { + #[codec(index = 0)] + V0(runtime_types::xcm::v0::multi_location::MultiLocation), + #[codec(index = 1)] + V1(runtime_types::xcm::v1::multilocation::MultiLocation), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum VersionedResponse { + #[codec(index = 0)] + V0(runtime_types::xcm::v0::Response), + #[codec(index = 1)] + V1(runtime_types::xcm::v1::Response), + #[codec(index = 2)] + V2(runtime_types::xcm::v2::Response), + } + #[derive(:: subxt :: codec :: Encode, :: subxt :: codec :: Decode)] + pub enum VersionedXcm { + #[codec(index = 0)] + V0(runtime_types::xcm::v0::Xcm), + #[codec(index = 1)] + V1(runtime_types::xcm::v1::Xcm), + #[codec(index = 2)] + V2(runtime_types::xcm::v2::Xcm), + } + } + } + #[doc = r" Default configuration of common types for a target Substrate runtime."] + #[derive(Clone, Debug, Default, Eq, PartialEq)] + pub struct DefaultConfig; + impl ::subxt::Config for DefaultConfig { + type Index = u32; + type BlockNumber = u32; + type Hash = ::subxt::sp_core::H256; + type Hashing = ::subxt::sp_runtime::traits::BlakeTwo256; + type AccountId = ::subxt::sp_runtime::AccountId32; + type Address = ::subxt::sp_runtime::MultiAddress; + type Header = ::subxt::sp_runtime::generic::Header< + Self::BlockNumber, + ::subxt::sp_runtime::traits::BlakeTwo256, + >; + type Signature = ::subxt::sp_runtime::MultiSignature; + type Extrinsic = ::subxt::sp_runtime::OpaqueExtrinsic; + } + impl ::subxt::ExtrinsicExtraData for DefaultConfig { + type AccountData = AccountData; + type Extra = ::subxt::DefaultExtra; + } + pub type AccountData = self::system::storage::Account; + impl ::subxt::AccountData for AccountData { + fn nonce( + result: &::Value, + ) -> ::Index { + result.nonce + } + fn storage_entry( + account_id: ::AccountId, + ) -> Self { + Self(account_id) + } + } + pub struct RuntimeApi> { + pub client: ::subxt::Client, + } + impl ::core::convert::From<::subxt::Client> for RuntimeApi + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + fn from(client: ::subxt::Client) -> Self { + Self { client } + } + } + impl<'a, T> RuntimeApi + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn storage(&'a self) -> StorageApi<'a, T> { + StorageApi { + client: &self.client, + } + } + pub fn tx(&'a self) -> TransactionApi<'a, T> { + TransactionApi { + client: &self.client, + } + } + } + pub struct StorageApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + client: &'a ::subxt::Client, + } + impl<'a, T> StorageApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn system(&self) -> system::storage::StorageApi<'a, T> { + system::storage::StorageApi::new(self.client) + } + pub fn babe(&self) -> babe::storage::StorageApi<'a, T> { + babe::storage::StorageApi::new(self.client) + } + pub fn timestamp(&self) -> timestamp::storage::StorageApi<'a, T> { + timestamp::storage::StorageApi::new(self.client) + } + pub fn indices(&self) -> indices::storage::StorageApi<'a, T> { + indices::storage::StorageApi::new(self.client) + } + pub fn balances(&self) -> balances::storage::StorageApi<'a, T> { + balances::storage::StorageApi::new(self.client) + } + pub fn transaction_payment( + &self, + ) -> transaction_payment::storage::StorageApi<'a, T> { + transaction_payment::storage::StorageApi::new(self.client) + } + pub fn authorship(&self) -> authorship::storage::StorageApi<'a, T> { + authorship::storage::StorageApi::new(self.client) + } + pub fn offences(&self) -> offences::storage::StorageApi<'a, T> { + offences::storage::StorageApi::new(self.client) + } + pub fn session(&self) -> session::storage::StorageApi<'a, T> { + session::storage::StorageApi::new(self.client) + } + pub fn grandpa(&self) -> grandpa::storage::StorageApi<'a, T> { + grandpa::storage::StorageApi::new(self.client) + } + pub fn im_online(&self) -> im_online::storage::StorageApi<'a, T> { + im_online::storage::StorageApi::new(self.client) + } + pub fn configuration(&self) -> configuration::storage::StorageApi<'a, T> { + configuration::storage::StorageApi::new(self.client) + } + pub fn paras_shared(&self) -> paras_shared::storage::StorageApi<'a, T> { + paras_shared::storage::StorageApi::new(self.client) + } + pub fn para_inclusion(&self) -> para_inclusion::storage::StorageApi<'a, T> { + para_inclusion::storage::StorageApi::new(self.client) + } + pub fn para_inherent(&self) -> para_inherent::storage::StorageApi<'a, T> { + para_inherent::storage::StorageApi::new(self.client) + } + pub fn para_scheduler(&self) -> para_scheduler::storage::StorageApi<'a, T> { + para_scheduler::storage::StorageApi::new(self.client) + } + pub fn paras(&self) -> paras::storage::StorageApi<'a, T> { + paras::storage::StorageApi::new(self.client) + } + pub fn initializer(&self) -> initializer::storage::StorageApi<'a, T> { + initializer::storage::StorageApi::new(self.client) + } + pub fn dmp(&self) -> dmp::storage::StorageApi<'a, T> { + dmp::storage::StorageApi::new(self.client) + } + pub fn ump(&self) -> ump::storage::StorageApi<'a, T> { + ump::storage::StorageApi::new(self.client) + } + pub fn hrmp(&self) -> hrmp::storage::StorageApi<'a, T> { + hrmp::storage::StorageApi::new(self.client) + } + pub fn para_session_info(&self) -> para_session_info::storage::StorageApi<'a, T> { + para_session_info::storage::StorageApi::new(self.client) + } + pub fn paras_disputes(&self) -> paras_disputes::storage::StorageApi<'a, T> { + paras_disputes::storage::StorageApi::new(self.client) + } + pub fn registrar(&self) -> registrar::storage::StorageApi<'a, T> { + registrar::storage::StorageApi::new(self.client) + } + pub fn auctions(&self) -> auctions::storage::StorageApi<'a, T> { + auctions::storage::StorageApi::new(self.client) + } + pub fn crowdloan(&self) -> crowdloan::storage::StorageApi<'a, T> { + crowdloan::storage::StorageApi::new(self.client) + } + pub fn slots(&self) -> slots::storage::StorageApi<'a, T> { + slots::storage::StorageApi::new(self.client) + } + pub fn sudo(&self) -> sudo::storage::StorageApi<'a, T> { + sudo::storage::StorageApi::new(self.client) + } + pub fn mmr(&self) -> mmr::storage::StorageApi<'a, T> { + mmr::storage::StorageApi::new(self.client) + } + pub fn beefy(&self) -> beefy::storage::StorageApi<'a, T> { + beefy::storage::StorageApi::new(self.client) + } + pub fn mmr_leaf(&self) -> mmr_leaf::storage::StorageApi<'a, T> { + mmr_leaf::storage::StorageApi::new(self.client) + } + pub fn validator_manager(&self) -> validator_manager::storage::StorageApi<'a, T> { + validator_manager::storage::StorageApi::new(self.client) + } + pub fn collective(&self) -> collective::storage::StorageApi<'a, T> { + collective::storage::StorageApi::new(self.client) + } + pub fn membership(&self) -> membership::storage::StorageApi<'a, T> { + membership::storage::StorageApi::new(self.client) + } + pub fn proxy(&self) -> proxy::storage::StorageApi<'a, T> { + proxy::storage::StorageApi::new(self.client) + } + pub fn multisig(&self) -> multisig::storage::StorageApi<'a, T> { + multisig::storage::StorageApi::new(self.client) + } + pub fn xcm_pallet(&self) -> xcm_pallet::storage::StorageApi<'a, T> { + xcm_pallet::storage::StorageApi::new(self.client) + } + } + pub struct TransactionApi<'a, T: ::subxt::Config + ::subxt::ExtrinsicExtraData> { + client: &'a ::subxt::Client, + } + impl<'a, T> TransactionApi<'a, T> + where + T: ::subxt::Config + ::subxt::ExtrinsicExtraData, + { + pub fn system(&self) -> system::calls::TransactionApi<'a, T> { + system::calls::TransactionApi::new(self.client) + } + pub fn babe(&self) -> babe::calls::TransactionApi<'a, T> { + babe::calls::TransactionApi::new(self.client) + } + pub fn timestamp(&self) -> timestamp::calls::TransactionApi<'a, T> { + timestamp::calls::TransactionApi::new(self.client) + } + pub fn indices(&self) -> indices::calls::TransactionApi<'a, T> { + indices::calls::TransactionApi::new(self.client) + } + pub fn balances(&self) -> balances::calls::TransactionApi<'a, T> { + balances::calls::TransactionApi::new(self.client) + } + pub fn authorship(&self) -> authorship::calls::TransactionApi<'a, T> { + authorship::calls::TransactionApi::new(self.client) + } + pub fn session(&self) -> session::calls::TransactionApi<'a, T> { + session::calls::TransactionApi::new(self.client) + } + pub fn grandpa(&self) -> grandpa::calls::TransactionApi<'a, T> { + grandpa::calls::TransactionApi::new(self.client) + } + pub fn im_online(&self) -> im_online::calls::TransactionApi<'a, T> { + im_online::calls::TransactionApi::new(self.client) + } + pub fn configuration(&self) -> configuration::calls::TransactionApi<'a, T> { + configuration::calls::TransactionApi::new(self.client) + } + pub fn paras_shared(&self) -> paras_shared::calls::TransactionApi<'a, T> { + paras_shared::calls::TransactionApi::new(self.client) + } + pub fn para_inclusion(&self) -> para_inclusion::calls::TransactionApi<'a, T> { + para_inclusion::calls::TransactionApi::new(self.client) + } + pub fn para_inherent(&self) -> para_inherent::calls::TransactionApi<'a, T> { + para_inherent::calls::TransactionApi::new(self.client) + } + pub fn paras(&self) -> paras::calls::TransactionApi<'a, T> { + paras::calls::TransactionApi::new(self.client) + } + pub fn initializer(&self) -> initializer::calls::TransactionApi<'a, T> { + initializer::calls::TransactionApi::new(self.client) + } + pub fn dmp(&self) -> dmp::calls::TransactionApi<'a, T> { + dmp::calls::TransactionApi::new(self.client) + } + pub fn ump(&self) -> ump::calls::TransactionApi<'a, T> { + ump::calls::TransactionApi::new(self.client) + } + pub fn hrmp(&self) -> hrmp::calls::TransactionApi<'a, T> { + hrmp::calls::TransactionApi::new(self.client) + } + pub fn registrar(&self) -> registrar::calls::TransactionApi<'a, T> { + registrar::calls::TransactionApi::new(self.client) + } + pub fn auctions(&self) -> auctions::calls::TransactionApi<'a, T> { + auctions::calls::TransactionApi::new(self.client) + } + pub fn crowdloan(&self) -> crowdloan::calls::TransactionApi<'a, T> { + crowdloan::calls::TransactionApi::new(self.client) + } + pub fn slots(&self) -> slots::calls::TransactionApi<'a, T> { + slots::calls::TransactionApi::new(self.client) + } + pub fn paras_sudo_wrapper( + &self, + ) -> paras_sudo_wrapper::calls::TransactionApi<'a, T> { + paras_sudo_wrapper::calls::TransactionApi::new(self.client) + } + pub fn sudo(&self) -> sudo::calls::TransactionApi<'a, T> { + sudo::calls::TransactionApi::new(self.client) + } + pub fn validator_manager( + &self, + ) -> validator_manager::calls::TransactionApi<'a, T> { + validator_manager::calls::TransactionApi::new(self.client) + } + pub fn collective(&self) -> collective::calls::TransactionApi<'a, T> { + collective::calls::TransactionApi::new(self.client) + } + pub fn membership(&self) -> membership::calls::TransactionApi<'a, T> { + membership::calls::TransactionApi::new(self.client) + } + pub fn utility(&self) -> utility::calls::TransactionApi<'a, T> { + utility::calls::TransactionApi::new(self.client) + } + pub fn proxy(&self) -> proxy::calls::TransactionApi<'a, T> { + proxy::calls::TransactionApi::new(self.client) + } + pub fn multisig(&self) -> multisig::calls::TransactionApi<'a, T> { + multisig::calls::TransactionApi::new(self.client) + } + pub fn xcm_pallet(&self) -> xcm_pallet::calls::TransactionApi<'a, T> { + xcm_pallet::calls::TransactionApi::new(self.client) + } + } +} diff --git a/tests/node_runtime.scale b/tests/node_runtime.scale deleted file mode 100644 index 80692153a8cb67479eeb2a05a7e42334dc3bea02..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 301517 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 AbpQYW