Skip to content

Instantly share code, notes, and snippets.

@wenxingxing

wenxingxing/runtime_expanded.rs

Last active October 21, 2022 13:35
Show Gist options
  • Save wenxingxing/d8175fc1935e06dacf2a95abe0ec1a82 to your computer and use it in GitHub Desktop.
Save wenxingxing/d8175fc1935e06dacf2a95abe0ec1a82 to your computer and use it in GitHub Desktop.
Download ZIP
expand runtime/src/lib.rs
Raw
runtime_expanded.rs
#![feature(prelude_import)]
#![recursion_limit = "256"]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
pub use frame_support::{
construct_runtime, parameter_types,
traits::{
ConstU128, ConstU32, ConstU64, ConstU8, KeyOwnerProofSystem, Randomness, StorageInfo,
},
weights::{
constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
IdentityFee, Weight,
},
StorageValue,
};
pub use frame_system::Call as SystemCall;
pub use pallet_balances::Call as BalancesCall;
use pallet_grandpa::{
fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList,
};
/// Import the template pallet.
pub use pallet_template;
pub use pallet_timestamp::Call as TimestampCall;
use pallet_transaction_payment::CurrencyAdapter;
use sp_api::impl_runtime_apis;
use sp_consensus_aura::sr25519::AuthorityId as AuraId;
use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;
use sp_runtime::{
create_runtime_str, generic, impl_opaque_keys,
traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, IdentifyAccount, NumberFor, Verify},
transaction_validity::{TransactionSource, TransactionValidity},
ApplyExtrinsicResult, MultiSignature,
};
pub use sp_runtime::{Perbill, Permill};
use sp_std::prelude::*;
#[cfg(feature = "std")]
use sp_version::NativeVersion;
use sp_version::RuntimeVersion;
/// An index to a block.
pub type BlockNumber = u32;
/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
pub type Signature = MultiSignature;
/// Some way of identifying an account on the chain. We intentionally make it equivalent
/// to the public key of our transaction signing scheme.
pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
/// Balance of an account.
pub type Balance = u128;
/// Index of a transaction in the chain.
pub type Index = u32;
/// A hash of some data used by the chain.
pub type Hash = sp_core::H256;
/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
/// the specifics of the runtime. They can then be made to be agnostic over specific formats
/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
/// to even the core data structures.
pub mod opaque {
use super::*;
pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
/// Opaque block header type.
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
/// Opaque block type.
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
/// Opaque block identifier type.
pub type BlockId = generic::BlockId<Block>;
use ::sp_runtime::serde as __opaque_keys_serde_import__SessionKeys;
#[serde(crate = "__opaque_keys_serde_import__SessionKeys")]
pub struct SessionKeys {
pub aura: <Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
pub grandpa: <Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
}
#[automatically_derived]
impl ::core::clone::Clone for SessionKeys {
#[inline]
fn clone(&self) -> SessionKeys {
SessionKeys {
aura: ::core::clone::Clone::clone(&self.aura),
grandpa: ::core::clone::Clone::clone(&self.grandpa),
}
}
}
impl ::core::marker::StructuralPartialEq for SessionKeys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for SessionKeys {
#[inline]
fn eq(&self, other: &SessionKeys) -> bool {
self.aura == other.aura && self.grandpa == other.grandpa
}
}
impl ::core::marker::StructuralEq for SessionKeys {}
#[automatically_derived]
impl ::core::cmp::Eq for SessionKeys {
#[inline]
#[doc(hidden)]
#[no_coverage]
fn assert_receiver_is_total_eq(&self) -> () {
let _: ::core::cmp::AssertParamIsEq<
<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
>;
let _: ::core::cmp::AssertParamIsEq<
<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
>;
}
}
#[allow(deprecated)]
const _: () = {
#[automatically_derived]
impl ::codec::Encode for SessionKeys {
fn encode_to<__CodecOutputEdqy: ::codec::Output + ?::core::marker::Sized>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy,
) {
::codec::Encode::encode_to(&self.aura, __codec_dest_edqy);
::codec::Encode::encode_to(&self.grandpa, __codec_dest_edqy);
}
}
#[automatically_derived]
impl ::codec::EncodeLike for SessionKeys {}
};
#[allow(deprecated)]
const _: () = {
#[automatically_derived]
impl ::codec::Decode for SessionKeys {
fn decode<__CodecInputEdqy: ::codec::Input>(
__codec_input_edqy: &mut __CodecInputEdqy,
) -> ::core::result::Result<Self, ::codec::Error> {
::core::result::Result::Ok(SessionKeys {
aura: {
let __codec_res_edqy = <<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `SessionKeys::aura`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
},
grandpa: {
let __codec_res_edqy = <<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `SessionKeys::grandpa`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
},
})
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
impl ::scale_info::TypeInfo for SessionKeys {
type Identity = Self;
fn type_info() -> ::scale_info::Type {
::scale_info::Type::builder()
.path(::scale_info::Path::new("SessionKeys", "node_template_runtime::opaque"))
.type_params(::alloc::vec::Vec::new())
.docs(&[])
.composite(
::scale_info::build::Fields::named()
.field(|f| {
f.ty::<<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public>()
.name("aura")
.type_name("<Aura as $crate::BoundToRuntimeAppPublic>::Public")
.docs(&[])
})
.field(|f| {
f.ty::<<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public>()
.name("grandpa")
.type_name(
"<Grandpa as $crate::BoundToRuntimeAppPublic>::Public",
)
.docs(&[])
}),
)
}
}
};
impl core::fmt::Debug for SessionKeys {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
fmt.debug_struct("SessionKeys")
.field("aura", &self.aura)
.field("grandpa", &self.grandpa)
.finish()
}
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
use __opaque_keys_serde_import__SessionKeys as _serde;
#[automatically_derived]
impl __opaque_keys_serde_import__SessionKeys::Serialize for SessionKeys {
fn serialize<__S>(
&self,
__serializer: __S,
) -> __opaque_keys_serde_import__SessionKeys::__private::Result<__S::Ok, __S::Error>
where
__S: __opaque_keys_serde_import__SessionKeys::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"SessionKeys",
false as usize + 1 + 1,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"aura",
&self.aura,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"grandpa",
&self.grandpa,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
use __opaque_keys_serde_import__SessionKeys as _serde;
#[automatically_derived]
impl<'de> __opaque_keys_serde_import__SessionKeys::Deserialize<'de> for SessionKeys {
fn deserialize<__D>(
__deserializer: __D,
) -> __opaque_keys_serde_import__SessionKeys::__private::Result<Self, __D::Error>
where
__D: __opaque_keys_serde_import__SessionKeys::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::__private::Ok(__Field::__field1),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"aura" => _serde::__private::Ok(__Field::__field0),
"grandpa" => _serde::__private::Ok(__Field::__field1),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"aura" => _serde::__private::Ok(__Field::__field0),
b"grandpa" => _serde::__private::Ok(__Field::__field1),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::__private::PhantomData<SessionKeys>,
lifetime: _serde::__private::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = SessionKeys;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(__formatter, "struct SessionKeys")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
>(&mut __seq)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize,
&"struct SessionKeys with 2 elements",
));
},
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
>(&mut __seq)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize,
&"struct SessionKeys with 2 elements",
));
},
};
_serde::__private::Ok(SessionKeys { aura: __field0, grandpa: __field1 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::__private::Option<
<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
> = _serde::__private::None;
let mut __field1: _serde::__private::Option<
<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
> = _serde::__private::None;
while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
match __key {
__Field::__field0 => {
if _serde::__private::Option::is_some(&__field0) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"aura",
),
);
}
__field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<
<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
>(&mut __map)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
__Field::__field1 => {
if _serde::__private::Option::is_some(&__field1) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"grandpa",
),
);
}
__field1 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<
<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public,
>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
},
);
},
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
},
}
}
let __field0 = match __field0 {
_serde::__private::Some(__field0) => __field0,
_serde::__private::None => {
match _serde::__private::de::missing_field("aura") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
let __field1 = match __field1 {
_serde::__private::Some(__field1) => __field1,
_serde::__private::None => {
match _serde::__private::de::missing_field("grandpa") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
_serde::__private::Ok(SessionKeys { aura: __field0, grandpa: __field1 })
}
}
const FIELDS: &'static [&'static str] = &["aura", "grandpa"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"SessionKeys",
FIELDS,
__Visitor {
marker: _serde::__private::PhantomData::<SessionKeys>,
lifetime: _serde::__private::PhantomData,
},
)
}
}
};
impl SessionKeys {
/// Generate a set of keys with optionally using the given seed.
///
/// The generated key pairs are stored in the keystore.
///
/// Returns the concatenated SCALE encoded public keys.
pub fn generate(
seed: Option<::sp_runtime::sp_std::vec::Vec<u8>>,
) -> ::sp_runtime::sp_std::vec::Vec<u8> {
let keys = Self {
aura: <<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::generate_pair(
seed.clone(),
),
grandpa: <<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::generate_pair(
seed.clone(),
),
};
::sp_runtime::codec::Encode::encode(&keys)
}
/// Converts `Self` into a `Vec` of `(raw public key, KeyTypeId)`.
pub fn into_raw_public_keys(
self,
) -> ::sp_runtime::sp_std::vec::Vec<(
::sp_runtime::sp_std::vec::Vec<u8>,
::sp_runtime::KeyTypeId,
)> {
let mut keys = Vec::new();
keys.push((
::sp_runtime::RuntimeAppPublic::to_raw_vec(&self.aura),
<<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::ID,
));
keys.push((
::sp_runtime::RuntimeAppPublic::to_raw_vec(&self.grandpa),
<<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::ID,
));
keys
}
/// Decode `Self` from the given `encoded` slice and convert `Self` into the raw public
/// keys (see [`Self::into_raw_public_keys`]).
///
/// Returns `None` when the decoding failed, otherwise `Some(_)`.
pub fn decode_into_raw_public_keys(
encoded: &[u8],
) -> Option<
::sp_runtime::sp_std::vec::Vec<(
::sp_runtime::sp_std::vec::Vec<u8>,
::sp_runtime::KeyTypeId,
)>,
> {
<Self as ::sp_runtime::codec::Decode>::decode(&mut &encoded[..])
.ok()
.map(|s| s.into_raw_public_keys())
}
}
impl ::sp_runtime::traits::OpaqueKeys for SessionKeys {
type KeyTypeIdProviders = (Aura, Grandpa);
fn key_ids() -> &'static [::sp_runtime::KeyTypeId] {
&[
<<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::ID,
<<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::ID,
]
}
fn get_raw(&self, i: ::sp_runtime::KeyTypeId) -> &[u8] {
match i {
i if i
== <<Aura as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::ID => {
self.aura.as_ref()
}
i if i
== <<Grandpa as ::sp_runtime::BoundToRuntimeAppPublic>::Public as ::sp_runtime::RuntimeAppPublic>::ID => {
self.grandpa.as_ref()
}
_ => &[],
}
}
}
}
pub const VERSION: RuntimeVersion = RuntimeVersion {
spec_name: { ::sp_runtime::RuntimeString::Borrowed("node-template") },
impl_name: { ::sp_runtime::RuntimeString::Borrowed("node-template") },
authoring_version: 1,
spec_version: 100,
impl_version: 1,
apis: RUNTIME_API_VERSIONS,
transaction_version: 1,
state_version: 1,
};
const _: () = {};
/// This determines the average expected block time that we are targeting.
/// Blocks will be produced at a minimum duration defined by `SLOT_DURATION`.
/// `SLOT_DURATION` is picked up by `pallet_timestamp` which is in turn picked
/// up by `pallet_aura` to implement `fn slot_duration()`.
///
/// Change this to adjust the block time.
pub const MILLISECS_PER_BLOCK: u64 = 6000;
pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
pub const HOURS: BlockNumber = MINUTES * 60;
pub const DAYS: BlockNumber = HOURS * 24;
/// The version information used to identify this runtime when compiled natively.
#[cfg(feature = "std")]
pub fn native_version() -> NativeVersion {
NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
}
const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
pub struct BlockHashCount;
impl BlockHashCount {
/// Returns the value of this parameter type.
pub const fn get() -> BlockNumber {
2400
}
}
impl<I: From<BlockNumber>> ::frame_support::traits::Get<I> for BlockHashCount {
fn get() -> I {
I::from(Self::get())
}
}
impl ::frame_support::traits::TypedGet for BlockHashCount {
type Type = BlockNumber;
fn get() -> BlockNumber {
Self::get()
}
}
pub struct Version;
impl Version {
/// Returns the value of this parameter type.
pub const fn get() -> RuntimeVersion {
VERSION
}
}
impl<I: From<RuntimeVersion>> ::frame_support::traits::Get<I> for Version {
fn get() -> I {
I::from(Self::get())
}
}
impl ::frame_support::traits::TypedGet for Version {
type Type = RuntimeVersion;
fn get() -> RuntimeVersion {
Self::get()
}
}
/// We allow for 2 seconds of compute with a 6 second average block time.
pub struct BlockWeights;
impl BlockWeights {
/// Returns the value of this parameter type.
pub fn get() -> frame_system::limits::BlockWeights {
frame_system::limits::BlockWeights::with_sensible_defaults(
2 * WEIGHT_PER_SECOND,
NORMAL_DISPATCH_RATIO,
)
}
}
impl<I: From<frame_system::limits::BlockWeights>> ::frame_support::traits::Get<I> for BlockWeights {
fn get() -> I {
I::from(Self::get())
}
}
impl ::frame_support::traits::TypedGet for BlockWeights {
type Type = frame_system::limits::BlockWeights;
fn get() -> frame_system::limits::BlockWeights {
Self::get()
}
}
pub struct BlockLength;
impl BlockLength {
/// Returns the value of this parameter type.
pub fn get() -> frame_system::limits::BlockLength {
frame_system::limits::BlockLength::max_with_normal_ratio(
5 * 1024 * 1024,
NORMAL_DISPATCH_RATIO,
)
}
}
impl<I: From<frame_system::limits::BlockLength>> ::frame_support::traits::Get<I> for BlockLength {
fn get() -> I {
I::from(Self::get())
}
}
impl ::frame_support::traits::TypedGet for BlockLength {
type Type = frame_system::limits::BlockLength;
fn get() -> frame_system::limits::BlockLength {
Self::get()
}
}
pub struct SS58Prefix;
impl SS58Prefix {
/// Returns the value of this parameter type.
pub const fn get() -> u8 {
42
}
}
impl<I: From<u8>> ::frame_support::traits::Get<I> for SS58Prefix {
fn get() -> I {
I::from(Self::get())
}
}
impl ::frame_support::traits::TypedGet for SS58Prefix {
type Type = u8;
fn get() -> u8 {
Self::get()
}
}
impl frame_system::Config for Runtime {
/// The basic call filter to use in dispatchable.
type BaseCallFilter = frame_support::traits::Everything;
/// Block & extrinsics weights: base values and limits.
type BlockWeights = BlockWeights;
/// The maximum length of a block (in bytes).
type BlockLength = BlockLength;
/// The identifier used to distinguish between accounts.
type AccountId = AccountId;
/// The aggregated dispatch type that is available for extrinsics.
type Call = Call;
/// The lookup mechanism to get account ID from whatever is passed in dispatchers.
type Lookup = AccountIdLookup<AccountId, ()>;
/// The index type for storing how many extrinsics an account has signed.
type Index = Index;
/// The index type for blocks.
type BlockNumber = BlockNumber;
/// The type for hashing blocks and tries.
type Hash = Hash;
/// The hashing algorithm used.
type Hashing = BlakeTwo256;
/// The header type.
type Header = generic::Header<BlockNumber, BlakeTwo256>;
/// The ubiquitous event type.
type Event = Event;
/// The ubiquitous origin type.
type Origin = Origin;
/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
type BlockHashCount = BlockHashCount;
/// The weight of database operations that the runtime can invoke.
type DbWeight = RocksDbWeight;
/// Version of the runtime.
type Version = Version;
/// Converts a module to the index of the module in `construct_runtime!`.
///
/// This type is being generated by `construct_runtime!`.
type PalletInfo = PalletInfo;
/// What to do if a new account is created.
type OnNewAccount = ();
/// What to do if an account is fully reaped from the system.
type OnKilledAccount = ();
/// The data to be stored in an account.
type AccountData = pallet_balances::AccountData<Balance>;
/// Weight information for the extrinsics of this pallet.
type SystemWeightInfo = ();
/// This is used as an identifier of the chain. 42 is the generic substrate prefix.
type SS58Prefix = SS58Prefix;
/// The set code logic, just the default since we're not a parachain.
type OnSetCode = ();
type MaxConsumers = frame_support::traits::ConstU32<16>;
}
impl pallet_randomness_collective_flip::Config for Runtime {}
impl pallet_aura::Config for Runtime {
type AuthorityId = AuraId;
type DisabledValidators = ();
type MaxAuthorities = ConstU32<32>;
}
impl pallet_grandpa::Config for Runtime {
type Event = Event;
type Call = Call;
type KeyOwnerProofSystem = ();
type KeyOwnerProof =
<Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof;
type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
KeyTypeId,
GrandpaId,
)>>::IdentificationTuple;
type HandleEquivocation = ();
type WeightInfo = ();
type MaxAuthorities = ConstU32<32>;
}
impl pallet_timestamp::Config for Runtime {
/// A timestamp: milliseconds since the unix epoch.
type Moment = u64;
type OnTimestampSet = Aura;
type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;
type WeightInfo = ();
}
/// Existential deposit.
pub const EXISTENTIAL_DEPOSIT: u128 = 500;
impl pallet_balances::Config for Runtime {
type MaxLocks = ConstU32<50>;
type MaxReserves = ();
type ReserveIdentifier = [u8; 8];
/// The type for recording an account's balance.
type Balance = Balance;
/// The ubiquitous event type.
type Event = Event;
type DustRemoval = ();
type ExistentialDeposit = ConstU128<EXISTENTIAL_DEPOSIT>;
type AccountStore = System;
type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
}
impl pallet_transaction_payment::Config for Runtime {
type Event = Event;
type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
type OperationalFeeMultiplier = ConstU8<5>;
type WeightToFee = IdentityFee<Balance>;
type LengthToFee = IdentityFee<Balance>;
type FeeMultiplierUpdate = ();
}
impl pallet_sudo::Config for Runtime {
type Event = Event;
type Call = Call;
}
/// Configure the pallet-template in pallets/template.
impl pallet_template::Config for Runtime {
type Event = Event;
}
#[doc(hidden)]
mod sp_api_hidden_includes_construct_runtime {
pub extern crate frame_support as hidden_include;
}
const _: () = {
#[allow(unused)]
type __hidden_use_of_unchecked_extrinsic = UncheckedExtrinsic;
};
pub struct Runtime;
#[automatically_derived]
impl ::core::clone::Clone for Runtime {
#[inline]
fn clone(&self) -> Runtime {
*self
}
}
#[automatically_derived]
impl ::core::marker::Copy for Runtime {}
impl ::core::marker::StructuralPartialEq for Runtime {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Runtime {
#[inline]
fn eq(&self, other: &Runtime) -> bool {
true
}
}
impl ::core::marker::StructuralEq for Runtime {}
#[automatically_derived]
impl ::core::cmp::Eq for Runtime {
#[inline]
#[doc(hidden)]
#[no_coverage]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl core::fmt::Debug for Runtime {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
fmt.debug_tuple("Runtime").finish()
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
impl ::scale_info::TypeInfo for Runtime {
type Identity = Self;
fn type_info() -> ::scale_info::Type {
::scale_info::Type::builder()
.path(::scale_info::Path::new("Runtime", "node_template_runtime"))
.type_params(::alloc::vec::Vec::new())
.docs(&[])
.composite(::scale_info::build::Fields::unit())
}
}
};
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::GetNodeBlockType
for Runtime {
type NodeBlock = opaque::Block;
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::GetRuntimeBlockType
for Runtime {
type RuntimeBlock = Block;
}
#[allow(non_camel_case_types)]
pub enum Event {
#[codec(index = 0u8)]
System(frame_system::Event<Runtime>),
#[codec(index = 4u8)]
Grandpa(pallet_grandpa::Event),
#[codec(index = 5u8)]
Balances(pallet_balances::Event<Runtime>),
#[codec(index = 6u8)]
TransactionPayment(pallet_transaction_payment::Event<Runtime>),
#[codec(index = 7u8)]
Sudo(pallet_sudo::Event<Runtime>),
#[codec(index = 8u8)]
TemplateModule(pallet_template::Event<Runtime>),
}
#[automatically_derived]
#[allow(non_camel_case_types)]
impl ::core::clone::Clone for Event {
#[inline]
fn clone(&self) -> Event {
match self {
Event::System(__self_0) => Event::System(::core::clone::Clone::clone(__self_0)),
Event::Grandpa(__self_0) => Event::Grandpa(::core::clone::Clone::clone(__self_0)),
Event::Balances(__self_0) => Event::Balances(::core::clone::Clone::clone(__self_0)),
Event::TransactionPayment(__self_0) => {
Event::TransactionPayment(::core::clone::Clone::clone(__self_0))
},
Event::Sudo(__self_0) => Event::Sudo(::core::clone::Clone::clone(__self_0)),
Event::TemplateModule(__self_0) => {
Event::TemplateModule(::core::clone::Clone::clone(__self_0))
},
}
}
}
#[allow(non_camel_case_types)]
impl ::core::marker::StructuralPartialEq for Event {}
#[automatically_derived]
#[allow(non_camel_case_types)]
impl ::core::cmp::PartialEq for Event {
#[inline]
fn eq(&self, other: &Event) -> bool {
let __self_tag = ::core::intrinsics::discriminant_value(self);
let __arg1_tag = ::core::intrinsics::discriminant_value(other);
__self_tag == __arg1_tag
&& match (self, other) {
(Event::System(__self_0), Event::System(__arg1_0)) => *__self_0 == *__arg1_0,
(Event::Grandpa(__self_0), Event::Grandpa(__arg1_0)) => *__self_0 == *__arg1_0,
(Event::Balances(__self_0), Event::Balances(__arg1_0)) => *__self_0 == *__arg1_0,
(Event::TransactionPayment(__self_0), Event::TransactionPayment(__arg1_0)) => {
*__self_0 == *__arg1_0
},
(Event::Sudo(__self_0), Event::Sudo(__arg1_0)) => *__self_0 == *__arg1_0,
(Event::TemplateModule(__self_0), Event::TemplateModule(__arg1_0)) => {
*__self_0 == *__arg1_0
},
_ => unsafe { ::core::intrinsics::unreachable() },
}
}
}
#[allow(non_camel_case_types)]
impl ::core::marker::StructuralEq for Event {}
#[automatically_derived]
#[allow(non_camel_case_types)]
impl ::core::cmp::Eq for Event {
#[inline]
#[doc(hidden)]
#[no_coverage]
fn assert_receiver_is_total_eq(&self) -> () {
let _: ::core::cmp::AssertParamIsEq<frame_system::Event<Runtime>>;
let _: ::core::cmp::AssertParamIsEq<pallet_grandpa::Event>;
let _: ::core::cmp::AssertParamIsEq<pallet_balances::Event<Runtime>>;
let _: ::core::cmp::AssertParamIsEq<pallet_transaction_payment::Event<Runtime>>;
let _: ::core::cmp::AssertParamIsEq<pallet_sudo::Event<Runtime>>;
let _: ::core::cmp::AssertParamIsEq<pallet_template::Event<Runtime>>;
}
}
#[allow(deprecated)]
const _: () = {
#[allow(non_camel_case_types)]
#[automatically_derived]
impl ::codec::Encode for Event {
fn encode_to<__CodecOutputEdqy: ::codec::Output + ?::core::marker::Sized>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy,
) {
match *self {
Event::System(ref aa) => {
__codec_dest_edqy.push_byte(0u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Event::Grandpa(ref aa) => {
__codec_dest_edqy.push_byte(4u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Event::Balances(ref aa) => {
__codec_dest_edqy.push_byte(5u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Event::TransactionPayment(ref aa) => {
__codec_dest_edqy.push_byte(6u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Event::Sudo(ref aa) => {
__codec_dest_edqy.push_byte(7u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Event::TemplateModule(ref aa) => {
__codec_dest_edqy.push_byte(8u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
_ => {},
}
}
}
#[automatically_derived]
impl ::codec::EncodeLike for Event {}
};
#[allow(deprecated)]
const _: () = {
#[allow(non_camel_case_types)]
#[automatically_derived]
impl ::codec::Decode for Event {
fn decode<__CodecInputEdqy: ::codec::Input>(
__codec_input_edqy: &mut __CodecInputEdqy,
) -> ::core::result::Result<Self, ::codec::Error> {
match __codec_input_edqy
.read_byte()
.map_err(|e| e.chain("Could not decode `Event`, failed to read variant byte"))?
{
__codec_x_edqy if __codec_x_edqy == 0u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Event::System({
let __codec_res_edqy =
<frame_system::Event<Runtime> as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Event::System.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 4u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Event::Grandpa({
let __codec_res_edqy =
<pallet_grandpa::Event as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Event::Grandpa.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 5u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Event::Balances({
let __codec_res_edqy =
<pallet_balances::Event<Runtime> as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Event::Balances.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 6u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Event::TransactionPayment({
let __codec_res_edqy =
<pallet_transaction_payment::Event<Runtime> as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Event::TransactionPayment.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 7u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Event::Sudo({
let __codec_res_edqy =
<pallet_sudo::Event<Runtime> as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Event::Sudo.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 8u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Event::TemplateModule({
let __codec_res_edqy =
<pallet_template::Event<Runtime> as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Event::TemplateModule.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
_ => ::core::result::Result::Err(<_ as ::core::convert::Into<_>>::into(
"Could not decode `Event`, variant doesn't exist",
)),
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
impl ::scale_info::TypeInfo for Event {
type Identity = Self;
fn type_info() -> ::scale_info::Type {
::scale_info::Type::builder()
.path(::scale_info::Path::new("Event", "node_template_runtime"))
.type_params(::alloc::vec::Vec::new())
.docs(&[])
.variant(
::scale_info::build::Variants::new()
.variant("System", |v| {
v.index(0u8 as ::core::primitive::u8)
.fields(::scale_info::build::Fields::unnamed().field(|f| {
f.ty::<frame_system::Event<Runtime>>()
.type_name("frame_system::Event<Runtime>")
.docs(&[])
}))
.docs(&[])
})
.variant("Grandpa", |v| {
v.index(4u8 as ::core::primitive::u8)
.fields(::scale_info::build::Fields::unnamed().field(|f| {
f.ty::<pallet_grandpa::Event>()
.type_name("pallet_grandpa::Event")
.docs(&[])
}))
.docs(&[])
})
.variant("Balances", |v| {
v.index(5u8 as ::core::primitive::u8)
.fields(::scale_info::build::Fields::unnamed().field(|f| {
f.ty::<pallet_balances::Event<Runtime>>()
.type_name("pallet_balances::Event<Runtime>")
.docs(&[])
}))
.docs(&[])
})
.variant("TransactionPayment", |v| {
v.index(6u8 as ::core::primitive::u8)
.fields(::scale_info::build::Fields::unnamed().field(|f| {
f.ty::<pallet_transaction_payment::Event<Runtime>>()
.type_name("pallet_transaction_payment::Event<Runtime>")
.docs(&[])
}))
.docs(&[])
})
.variant("Sudo", |v| {
v.index(7u8 as ::core::primitive::u8)
.fields(::scale_info::build::Fields::unnamed().field(|f| {
f.ty::<pallet_sudo::Event<Runtime>>()
.type_name("pallet_sudo::Event<Runtime>")
.docs(&[])
}))
.docs(&[])
})
.variant("TemplateModule", |v| {
v.index(8u8 as ::core::primitive::u8)
.fields(::scale_info::build::Fields::unnamed().field(|f| {
f.ty::<pallet_template::Event<Runtime>>()
.type_name("pallet_template::Event<Runtime>")
.docs(&[])
}))
.docs(&[])
}),
)
}
}
};
impl core::fmt::Debug for Event {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
match self {
Self::System(ref a0) => fmt.debug_tuple("Event::System").field(a0).finish(),
Self::Grandpa(ref a0) => fmt.debug_tuple("Event::Grandpa").field(a0).finish(),
Self::Balances(ref a0) => fmt.debug_tuple("Event::Balances").field(a0).finish(),
Self::TransactionPayment(ref a0) => {
fmt.debug_tuple("Event::TransactionPayment").field(a0).finish()
},
Self::Sudo(ref a0) => fmt.debug_tuple("Event::Sudo").field(a0).finish(),
Self::TemplateModule(ref a0) => {
fmt.debug_tuple("Event::TemplateModule").field(a0).finish()
},
_ => Ok(()),
}
}
}
impl From<frame_system::Event<Runtime>> for Event {
fn from(x: frame_system::Event<Runtime>) -> Self {
Event::System(x)
}
}
impl TryInto<frame_system::Event<Runtime>> for Event {
type Error = ();
fn try_into(
self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
frame_system::Event<Runtime>,
Self::Error,
> {
match self {
Self::System(evt) => Ok(evt),
_ => Err(()),
}
}
}
impl From<pallet_grandpa::Event> for Event {
fn from(x: pallet_grandpa::Event) -> Self {
Event::Grandpa(x)
}
}
impl TryInto<pallet_grandpa::Event> for Event {
type Error = ();
fn try_into(
self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
pallet_grandpa::Event,
Self::Error,
> {
match self {
Self::Grandpa(evt) => Ok(evt),
_ => Err(()),
}
}
}
impl From<pallet_balances::Event<Runtime>> for Event {
fn from(x: pallet_balances::Event<Runtime>) -> Self {
Event::Balances(x)
}
}
impl TryInto<pallet_balances::Event<Runtime>> for Event {
type Error = ();
fn try_into(
self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
pallet_balances::Event<Runtime>,
Self::Error,
> {
match self {
Self::Balances(evt) => Ok(evt),
_ => Err(()),
}
}
}
impl From<pallet_transaction_payment::Event<Runtime>> for Event {
fn from(x: pallet_transaction_payment::Event<Runtime>) -> Self {
Event::TransactionPayment(x)
}
}
impl TryInto<pallet_transaction_payment::Event<Runtime>> for Event {
type Error = ();
fn try_into(
self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
pallet_transaction_payment::Event<Runtime>,
Self::Error,
> {
match self {
Self::TransactionPayment(evt) => Ok(evt),
_ => Err(()),
}
}
}
impl From<pallet_sudo::Event<Runtime>> for Event {
fn from(x: pallet_sudo::Event<Runtime>) -> Self {
Event::Sudo(x)
}
}
impl TryInto<pallet_sudo::Event<Runtime>> for Event {
type Error = ();
fn try_into(
self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
pallet_sudo::Event<Runtime>,
Self::Error,
> {
match self {
Self::Sudo(evt) => Ok(evt),
_ => Err(()),
}
}
}
impl From<pallet_template::Event<Runtime>> for Event {
fn from(x: pallet_template::Event<Runtime>) -> Self {
Event::TemplateModule(x)
}
}
impl TryInto<pallet_template::Event<Runtime>> for Event {
type Error = ();
fn try_into(
self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
pallet_template::Event<Runtime>,
Self::Error,
> {
match self {
Self::TemplateModule(evt) => Ok(evt),
_ => Err(()),
}
}
}
/// The runtime origin type representing the origin of a call.
///
/// Origin is always created with the base filter configured in [`frame_system::Config::BaseCallFilter`].
pub struct Origin {
caller: OriginCaller,
filter: self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::rc::Rc<
Box<dyn Fn(&<Runtime as frame_system::Config>::Call) -> bool>,
>,
}
#[automatically_derived]
impl ::core::clone::Clone for Origin {
#[inline]
fn clone(&self) -> Origin {
Origin {
caller: ::core::clone::Clone::clone(&self.caller),
filter: ::core::clone::Clone::clone(&self.filter),
}
}
}
#[cfg(feature = "std")]
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::fmt::Debug for Origin {
fn fmt(
&self,
fmt: &mut self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::fmt::Formatter,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
(),
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::fmt::Error,
> {
fmt.debug_struct("Origin")
.field("caller", &self.caller)
.field("filter", &"[function ptr]")
.finish()
}
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OriginTrait
for Origin
{
type Call = <Runtime as frame_system::Config>::Call;
type PalletsOrigin = OriginCaller;
type AccountId = <Runtime as frame_system::Config>::AccountId;
fn add_filter(&mut self, filter: impl Fn(&Self::Call) -> bool + 'static) {
let f = self.filter.clone();
self.filter =
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::rc::Rc::new(
Box::new(move |call| f(call) && filter(call)),
);
}
fn reset_filter(&mut self) {
let filter = <<Runtime as frame_system::Config>::BaseCallFilter as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::Contains<
<Runtime as frame_system::Config>::Call,
>>::contains;
self.filter =
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::rc::Rc::new(
Box::new(filter),
);
}
fn set_caller_from(&mut self, other: impl Into<Self>) {
self.caller = other.into().caller;
}
fn filter_call(&self, call: &Self::Call) -> bool {
match self.caller {
OriginCaller::system(frame_system::Origin::<Runtime>::Root) => true,
_ => (self.filter)(call),
}
}
fn caller(&self) -> &Self::PalletsOrigin {
&self.caller
}
fn try_with_caller<R>(
mut self,
f: impl FnOnce(Self::PalletsOrigin) -> Result<R, Self::PalletsOrigin>,
) -> Result<R, Self> {
match f(self.caller) {
Ok(r) => Ok(r),
Err(caller) => {
self.caller = caller;
Err(self)
},
}
}
fn none() -> Self {
frame_system::RawOrigin::None.into()
}
fn root() -> Self {
frame_system::RawOrigin::Root.into()
}
fn signed(by: Self::AccountId) -> Self {
frame_system::RawOrigin::Signed(by).into()
}
fn as_signed(self) -> Option<Self::AccountId> {
match self.caller {
OriginCaller::system(frame_system::RawOrigin::Signed(by)) => Some(by),
_ => None,
}
}
}
#[allow(non_camel_case_types)]
pub enum OriginCaller {
#[codec(index = 0u8)]
system(frame_system::Origin<Runtime>),
#[allow(dead_code)]
Void(self::sp_api_hidden_includes_construct_runtime::hidden_include::Void),
}
#[automatically_derived]
#[allow(non_camel_case_types)]
impl ::core::clone::Clone for OriginCaller {
#[inline]
fn clone(&self) -> OriginCaller {
match self {
OriginCaller::system(__self_0) => {
OriginCaller::system(::core::clone::Clone::clone(__self_0))
},
OriginCaller::Void(__self_0) => {
OriginCaller::Void(::core::clone::Clone::clone(__self_0))
},
}
}
}
#[allow(non_camel_case_types)]
impl ::core::marker::StructuralPartialEq for OriginCaller {}
#[automatically_derived]
#[allow(non_camel_case_types)]
impl ::core::cmp::PartialEq for OriginCaller {
#[inline]
fn eq(&self, other: &OriginCaller) -> bool {
let __self_tag = ::core::intrinsics::discriminant_value(self);
let __arg1_tag = ::core::intrinsics::discriminant_value(other);
__self_tag == __arg1_tag
&& match (self, other) {
(OriginCaller::system(__self_0), OriginCaller::system(__arg1_0)) => {
*__self_0 == *__arg1_0
},
(OriginCaller::Void(__self_0), OriginCaller::Void(__arg1_0)) => {
*__self_0 == *__arg1_0
},
_ => unsafe { ::core::intrinsics::unreachable() },
}
}
}
#[allow(non_camel_case_types)]
impl ::core::marker::StructuralEq for OriginCaller {}
#[automatically_derived]
#[allow(non_camel_case_types)]
impl ::core::cmp::Eq for OriginCaller {
#[inline]
#[doc(hidden)]
#[no_coverage]
fn assert_receiver_is_total_eq(&self) -> () {
let _: ::core::cmp::AssertParamIsEq<frame_system::Origin<Runtime>>;
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::Void,
>;
}
}
impl core::fmt::Debug for OriginCaller {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
match self {
Self::system(ref a0) => fmt.debug_tuple("OriginCaller::system").field(a0).finish(),
Self::Void(ref a0) => fmt.debug_tuple("OriginCaller::Void").field(a0).finish(),
_ => Ok(()),
}
}
}
#[allow(deprecated)]
const _: () = {
#[allow(non_camel_case_types)]
#[automatically_derived]
impl ::codec::Encode for OriginCaller {
fn encode_to<__CodecOutputEdqy: ::codec::Output + ?::core::marker::Sized>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy,
) {
match *self {
OriginCaller::system(ref aa) => {
__codec_dest_edqy.push_byte(0u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
OriginCaller::Void(ref aa) => {
__codec_dest_edqy.push_byte(1usize as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
_ => {},
}
}
}
#[automatically_derived]
impl ::codec::EncodeLike for OriginCaller {}
};
#[allow(deprecated)]
const _: () = {
#[allow(non_camel_case_types)]
#[automatically_derived]
impl ::codec::Decode for OriginCaller {
fn decode<__CodecInputEdqy: ::codec::Input>(
__codec_input_edqy: &mut __CodecInputEdqy,
) -> ::core::result::Result<Self, ::codec::Error> {
match __codec_input_edqy.read_byte().map_err(|e| {
e.chain("Could not decode `OriginCaller`, failed to read variant byte")
})? {
__codec_x_edqy if __codec_x_edqy == 0u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(OriginCaller::system({
let __codec_res_edqy =
<frame_system::Origin<Runtime> as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `OriginCaller::system.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 1usize as ::core::primitive::u8 => {
::core::result::Result::Ok(OriginCaller::Void({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::Void as ::codec::Decode>::decode(
__codec_input_edqy,
);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `OriginCaller::Void.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
_ => ::core::result::Result::Err(<_ as ::core::convert::Into<_>>::into(
"Could not decode `OriginCaller`, variant doesn't exist",
)),
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
impl ::scale_info::TypeInfo for OriginCaller {
type Identity = Self;
fn type_info() -> ::scale_info::Type {
::scale_info::Type::builder()
.path(::scale_info::Path::new("OriginCaller", "node_template_runtime"))
.type_params(::alloc::vec::Vec::new())
.docs(&[])
.variant(
::scale_info::build::Variants::new()
.variant(
"system",
|v| {
v
.index(0u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<frame_system::Origin<Runtime>>()
.type_name("frame_system::Origin<Runtime>")
.docs(&[])
}),
)
.docs(&[])
},
)
.variant(
"Void",
|v| {
v
.index(1usize as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::Void,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::Void",
)
.docs(&[])
}),
)
.docs(&[])
},
),
)
}
}
};
const _: () = {
impl ::codec::MaxEncodedLen for OriginCaller {
fn max_encoded_len() -> ::core::primitive::usize {
0_usize
.max(
0_usize
.saturating_add(
<frame_system::Origin<Runtime>>::max_encoded_len(),
),
)
.max(
0_usize
.saturating_add(
<self::sp_api_hidden_includes_construct_runtime::hidden_include::Void>::max_encoded_len(),
),
)
.saturating_add(1)
}
}
};
#[allow(dead_code)]
impl Origin {
/// Create with system none origin and [`frame_system::Config::BaseCallFilter`].
pub fn none() -> Self {
<Origin as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OriginTrait>::none()
}
/// Create with system root origin and [`frame_system::Config::BaseCallFilter`].
pub fn root() -> Self {
<Origin as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OriginTrait>::root()
}
/// Create with system signed origin and [`frame_system::Config::BaseCallFilter`].
pub fn signed(by: <Runtime as frame_system::Config>::AccountId) -> Self {
<Origin as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OriginTrait>::signed(
by,
)
}
}
impl From<frame_system::Origin<Runtime>> for OriginCaller {
fn from(x: frame_system::Origin<Runtime>) -> Self {
OriginCaller::system(x)
}
}
impl TryFrom<OriginCaller> for frame_system::Origin<Runtime> {
type Error = OriginCaller;
fn try_from(
x: OriginCaller,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
frame_system::Origin<Runtime>,
OriginCaller,
> {
if let OriginCaller::system(l) = x {
Ok(l)
} else {
Err(x)
}
}
}
impl From<frame_system::Origin<Runtime>> for Origin {
/// Convert to runtime origin, using as filter: [`frame_system::Config::BaseCallFilter`].
fn from(x: frame_system::Origin<Runtime>) -> Self {
let o: OriginCaller = x.into();
o.into()
}
}
impl From<OriginCaller> for Origin {
fn from(x: OriginCaller) -> Self {
let mut o = Origin {
caller: x,
filter:
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::rc::Rc::new(
Box::new(|_| true),
),
};
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OriginTrait::reset_filter(
&mut o,
);
o
}
}
impl From<Origin>
for self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result<
frame_system::Origin<Runtime>,
Origin,
>
{
/// NOTE: converting to pallet origin loses the origin filter information.
fn from(val: Origin) -> Self {
if let OriginCaller::system(l) = val.caller {
Ok(l)
} else {
Err(val)
}
}
}
impl From<Option<<Runtime as frame_system::Config>::AccountId>> for Origin {
/// Convert to runtime origin with caller being system signed or none and use filter [`frame_system::Config::BaseCallFilter`].
fn from(x: Option<<Runtime as frame_system::Config>::AccountId>) -> Self {
<frame_system::Origin<Runtime>>::from(x).into()
}
}
pub type System = frame_system::Pallet<Runtime>;
pub type RandomnessCollectiveFlip = pallet_randomness_collective_flip::Pallet<Runtime>;
pub type Timestamp = pallet_timestamp::Pallet<Runtime>;
pub type Aura = pallet_aura::Pallet<Runtime>;
pub type Grandpa = pallet_grandpa::Pallet<Runtime>;
pub type Balances = pallet_balances::Pallet<Runtime>;
pub type TransactionPayment = pallet_transaction_payment::Pallet<Runtime>;
pub type Sudo = pallet_sudo::Pallet<Runtime>;
pub type TemplateModule = pallet_template::Pallet<Runtime>;
/// All pallets included in the runtime as a nested tuple of types.
#[deprecated(note = "The type definition has changed from representing all pallets \
excluding system, in reversed order to become the representation of all pallets \
including system pallet in regular order. For this reason it is encouraged to use \
explicitly one of `AllPalletsWithSystem`, `AllPalletsWithoutSystem`, \
`AllPalletsWithSystemReversed`, `AllPalletsWithoutSystemReversed`. \
Note that the type `frame_executive::Executive` expects one of `AllPalletsWithSystem` \
, `AllPalletsWithSystemReversed`, `AllPalletsReversedWithSystemFirst`. More details in \
https://github.com/paritytech/substrate/pull/10043")]
pub type AllPallets = AllPalletsWithSystem;
/// All pallets included in the runtime as a nested tuple of types.
pub type AllPalletsWithSystem = ((
System,
(
RandomnessCollectiveFlip,
(Timestamp, (Aura, (Grandpa, (Balances, (TransactionPayment, (Sudo, (TemplateModule,))))))),
),
));
/// All pallets included in the runtime as a nested tuple of types.
/// Excludes the System pallet.
pub type AllPalletsWithoutSystem = ((
RandomnessCollectiveFlip,
(Timestamp, (Aura, (Grandpa, (Balances, (TransactionPayment, (Sudo, (TemplateModule,))))))),
));
/// All pallets included in the runtime as a nested tuple of types in reversed order.
/// Excludes the System pallet.
pub type AllPalletsWithoutSystemReversed = ((
TemplateModule,
(
Sudo,
(
TransactionPayment,
(Balances, (Grandpa, (Aura, (Timestamp, (RandomnessCollectiveFlip,))))),
),
),
));
/// All pallets included in the runtime as a nested tuple of types in reversed order.
pub type AllPalletsWithSystemReversed = ((
TemplateModule,
(
Sudo,
(
TransactionPayment,
(Balances, (Grandpa, (Aura, (Timestamp, (RandomnessCollectiveFlip, (System,)))))),
),
),
));
/// All pallets included in the runtime as a nested tuple of types in reversed order.
/// With the system pallet first.
pub type AllPalletsReversedWithSystemFirst = (System, AllPalletsWithoutSystemReversed);
/// Provides an implementation of `PalletInfo` to provide information
/// about the pallet setup in the runtime.
pub struct PalletInfo;
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfo
for PalletInfo
{
fn index<P: 'static>() -> Option<usize> {
let type_id =
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
P,
>();
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
System,
>()
{
return Some(0usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
RandomnessCollectiveFlip,
>()
{
return Some(1usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Timestamp,
>()
{
return Some(2usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Aura,
>()
{
return Some(3usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Grandpa,
>()
{
return Some(4usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Balances,
>()
{
return Some(5usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TransactionPayment,
>()
{
return Some(6usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Sudo,
>()
{
return Some(7usize);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TemplateModule,
>()
{
return Some(8usize);
}
None
}
fn name<P: 'static>() -> Option<&'static str> {
let type_id =
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
P,
>();
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
System,
>()
{
return Some("System");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
RandomnessCollectiveFlip,
>()
{
return Some("RandomnessCollectiveFlip");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Timestamp,
>()
{
return Some("Timestamp");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Aura,
>()
{
return Some("Aura");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Grandpa,
>()
{
return Some("Grandpa");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Balances,
>()
{
return Some("Balances");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TransactionPayment,
>()
{
return Some("TransactionPayment");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Sudo,
>()
{
return Some("Sudo");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TemplateModule,
>()
{
return Some("TemplateModule");
}
None
}
fn module_name<P: 'static>() -> Option<&'static str> {
let type_id =
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
P,
>();
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
System,
>()
{
return Some("frame_system");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
RandomnessCollectiveFlip,
>()
{
return Some("pallet_randomness_collective_flip");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Timestamp,
>()
{
return Some("pallet_timestamp");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Aura,
>()
{
return Some("pallet_aura");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Grandpa,
>()
{
return Some("pallet_grandpa");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Balances,
>()
{
return Some("pallet_balances");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TransactionPayment,
>()
{
return Some("pallet_transaction_payment");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Sudo,
>()
{
return Some("pallet_sudo");
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TemplateModule,
>()
{
return Some("pallet_template");
}
None
}
fn crate_version<P: 'static>(
) -> Option<self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::CrateVersion>
{
let type_id =
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
P,
>();
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
System,
>()
{
return Some(
<frame_system::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
RandomnessCollectiveFlip,
>()
{
return Some(
<pallet_randomness_collective_flip::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Timestamp,
>()
{
return Some(
<pallet_timestamp::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Aura,
>()
{
return Some(
<pallet_aura::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Grandpa,
>()
{
return Some(
<pallet_grandpa::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Balances,
>()
{
return Some(
<pallet_balances::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TransactionPayment,
>()
{
return Some(
<pallet_transaction_payment::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
Sudo,
>()
{
return Some(
<pallet_sudo::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
if type_id
== self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::any::TypeId::of::<
TemplateModule,
>()
{
return Some(
<pallet_template::Pallet<
Runtime,
> as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::PalletInfoAccess>::crate_version(),
);
}
None
}
}
pub enum Call {
#[codec(index = 0u8)]
System(
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
),
#[codec(index = 2u8)]
Timestamp(
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
),
#[codec(index = 4u8)]
Grandpa(
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
),
#[codec(index = 5u8)]
Balances(
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
),
#[codec(index = 7u8)]
Sudo(
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
),
#[codec(index = 8u8)]
TemplateModule(
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
),
}
#[automatically_derived]
impl ::core::clone::Clone for Call {
#[inline]
fn clone(&self) -> Call {
match self {
Call::System(__self_0) => Call::System(::core::clone::Clone::clone(__self_0)),
Call::Timestamp(__self_0) => Call::Timestamp(::core::clone::Clone::clone(__self_0)),
Call::Grandpa(__self_0) => Call::Grandpa(::core::clone::Clone::clone(__self_0)),
Call::Balances(__self_0) => Call::Balances(::core::clone::Clone::clone(__self_0)),
Call::Sudo(__self_0) => Call::Sudo(::core::clone::Clone::clone(__self_0)),
Call::TemplateModule(__self_0) => {
Call::TemplateModule(::core::clone::Clone::clone(__self_0))
},
}
}
}
impl ::core::marker::StructuralPartialEq for Call {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Call {
#[inline]
fn eq(&self, other: &Call) -> bool {
let __self_tag = ::core::intrinsics::discriminant_value(self);
let __arg1_tag = ::core::intrinsics::discriminant_value(other);
__self_tag == __arg1_tag
&& match (self, other) {
(Call::System(__self_0), Call::System(__arg1_0)) => *__self_0 == *__arg1_0,
(Call::Timestamp(__self_0), Call::Timestamp(__arg1_0)) => *__self_0 == *__arg1_0,
(Call::Grandpa(__self_0), Call::Grandpa(__arg1_0)) => *__self_0 == *__arg1_0,
(Call::Balances(__self_0), Call::Balances(__arg1_0)) => *__self_0 == *__arg1_0,
(Call::Sudo(__self_0), Call::Sudo(__arg1_0)) => *__self_0 == *__arg1_0,
(Call::TemplateModule(__self_0), Call::TemplateModule(__arg1_0)) => {
*__self_0 == *__arg1_0
},
_ => unsafe { ::core::intrinsics::unreachable() },
}
}
}
impl ::core::marker::StructuralEq for Call {}
#[automatically_derived]
impl ::core::cmp::Eq for Call {
#[inline]
#[doc(hidden)]
#[no_coverage]
fn assert_receiver_is_total_eq(&self) -> () {
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
>;
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
>;
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
>;
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
>;
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
>;
let _: ::core::cmp::AssertParamIsEq<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
>;
}
}
#[allow(deprecated)]
const _: () = {
#[automatically_derived]
impl ::codec::Encode for Call {
fn encode_to<__CodecOutputEdqy: ::codec::Output + ?::core::marker::Sized>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy,
) {
match *self {
Call::System(ref aa) => {
__codec_dest_edqy.push_byte(0u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Call::Timestamp(ref aa) => {
__codec_dest_edqy.push_byte(2u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Call::Grandpa(ref aa) => {
__codec_dest_edqy.push_byte(4u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Call::Balances(ref aa) => {
__codec_dest_edqy.push_byte(5u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Call::Sudo(ref aa) => {
__codec_dest_edqy.push_byte(7u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
Call::TemplateModule(ref aa) => {
__codec_dest_edqy.push_byte(8u8 as ::core::primitive::u8);
::codec::Encode::encode_to(aa, __codec_dest_edqy);
},
_ => {},
}
}
}
#[automatically_derived]
impl ::codec::EncodeLike for Call {}
};
#[allow(deprecated)]
const _: () = {
#[automatically_derived]
impl ::codec::Decode for Call {
fn decode<__CodecInputEdqy: ::codec::Input>(
__codec_input_edqy: &mut __CodecInputEdqy,
) -> ::core::result::Result<Self, ::codec::Error> {
match __codec_input_edqy
.read_byte()
.map_err(|e| e.chain("Could not decode `Call`, failed to read variant byte"))?
{
__codec_x_edqy if __codec_x_edqy == 0u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Call::System({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
> as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Call::System.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 2u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Call::Timestamp({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
> as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Call::Timestamp.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 4u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Call::Grandpa({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
> as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Call::Grandpa.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 5u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Call::Balances({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
> as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Call::Balances.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 7u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Call::Sudo({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
> as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Call::Sudo.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
__codec_x_edqy if __codec_x_edqy == 8u8 as ::core::primitive::u8 => {
::core::result::Result::Ok(Call::TemplateModule({
let __codec_res_edqy = <self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
> as ::codec::Decode>::decode(__codec_input_edqy);
match __codec_res_edqy {
::core::result::Result::Err(e) => {
return ::core::result::Result::Err(
e.chain("Could not decode `Call::TemplateModule.0`"),
);
},
::core::result::Result::Ok(__codec_res_edqy) => __codec_res_edqy,
}
}))
},
_ => ::core::result::Result::Err(<_ as ::core::convert::Into<_>>::into(
"Could not decode `Call`, variant doesn't exist",
)),
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
impl ::scale_info::TypeInfo for Call {
type Identity = Self;
fn type_info() -> ::scale_info::Type {
::scale_info::Type::builder()
.path(::scale_info::Path::new("Call", "node_template_runtime"))
.type_params(::alloc::vec::Vec::new())
.docs(&[])
.variant(
::scale_info::build::Variants::new()
.variant(
"System",
|v| {
v
.index(0u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch\n::CallableCallFor<System, Runtime>",
)
.docs(&[])
}),
)
.docs(&[])
},
)
.variant(
"Timestamp",
|v| {
v
.index(2u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch\n::CallableCallFor<Timestamp, Runtime>",
)
.docs(&[])
}),
)
.docs(&[])
},
)
.variant(
"Grandpa",
|v| {
v
.index(4u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch\n::CallableCallFor<Grandpa, Runtime>",
)
.docs(&[])
}),
)
.docs(&[])
},
)
.variant(
"Balances",
|v| {
v
.index(5u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch\n::CallableCallFor<Balances, Runtime>",
)
.docs(&[])
}),
)
.docs(&[])
},
)
.variant(
"Sudo",
|v| {
v
.index(7u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch\n::CallableCallFor<Sudo, Runtime>",
)
.docs(&[])
}),
)
.docs(&[])
},
)
.variant(
"TemplateModule",
|v| {
v
.index(8u8 as ::core::primitive::u8)
.fields(
::scale_info::build::Fields::unnamed()
.field(|f| {
f
.ty::<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
>()
.type_name(
"self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch\n::CallableCallFor<TemplateModule, Runtime>",
)
.docs(&[])
}),
)
.docs(&[])
},
),
)
}
}
};
impl core::fmt::Debug for Call {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
match self {
Self::System(ref a0) => fmt.debug_tuple("Call::System").field(a0).finish(),
Self::Timestamp(ref a0) => fmt.debug_tuple("Call::Timestamp").field(a0).finish(),
Self::Grandpa(ref a0) => fmt.debug_tuple("Call::Grandpa").field(a0).finish(),
Self::Balances(ref a0) => fmt.debug_tuple("Call::Balances").field(a0).finish(),
Self::Sudo(ref a0) => fmt.debug_tuple("Call::Sudo").field(a0).finish(),
Self::TemplateModule(ref a0) => {
fmt.debug_tuple("Call::TemplateModule").field(a0).finish()
},
_ => Ok(()),
}
}
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::GetDispatchInfo
for Call
{
fn get_dispatch_info(
&self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::DispatchInfo {
match self {
Call::System(call) => call.get_dispatch_info(),
Call::Timestamp(call) => call.get_dispatch_info(),
Call::Grandpa(call) => call.get_dispatch_info(),
Call::Balances(call) => call.get_dispatch_info(),
Call::Sudo(call) => call.get_dispatch_info(),
Call::TemplateModule(call) => call.get_dispatch_info(),
}
}
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::GetCallMetadata
for Call
{
fn get_call_metadata(
&self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
use self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::GetCallName;
match self {
Call::System(call) => {
let function_name = call.get_call_name();
let pallet_name = "System";
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
function_name,
pallet_name,
}
},
Call::Timestamp(call) => {
let function_name = call.get_call_name();
let pallet_name = "Timestamp";
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
function_name,
pallet_name,
}
},
Call::Grandpa(call) => {
let function_name = call.get_call_name();
let pallet_name = "Grandpa";
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
function_name,
pallet_name,
}
},
Call::Balances(call) => {
let function_name = call.get_call_name();
let pallet_name = "Balances";
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
function_name,
pallet_name,
}
},
Call::Sudo(call) => {
let function_name = call.get_call_name();
let pallet_name = "Sudo";
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
function_name,
pallet_name,
}
},
Call::TemplateModule(call) => {
let function_name = call.get_call_name();
let pallet_name = "TemplateModule";
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallMetadata {
function_name,
pallet_name,
}
},
}
}
fn get_module_names() -> &'static [&'static str] {
&["System", "Timestamp", "Grandpa", "Balances", "Sudo", "TemplateModule"]
}
fn get_call_names(module: &str) -> &'static [&'static str] {
use self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::{
Callable, GetCallName,
};
match module {
"System" => <<System as Callable<Runtime>>::Call as GetCallName>::get_call_names(),
"Timestamp" => {
<<Timestamp as Callable<Runtime>>::Call as GetCallName>::get_call_names()
},
"Grandpa" => <<Grandpa as Callable<Runtime>>::Call as GetCallName>::get_call_names(),
"Balances" => <<Balances as Callable<Runtime>>::Call as GetCallName>::get_call_names(),
"Sudo" => <<Sudo as Callable<Runtime>>::Call as GetCallName>::get_call_names(),
"TemplateModule" => {
<<TemplateModule as Callable<Runtime>>::Call as GetCallName>::get_call_names()
},
_ => ::core::panicking::panic("internal error: entered unreachable code"),
}
}
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::Dispatchable
for Call
{
type Origin = Origin;
type Config = Call;
type Info =
self::sp_api_hidden_includes_construct_runtime::hidden_include::weights::DispatchInfo;
type PostInfo =
self::sp_api_hidden_includes_construct_runtime::hidden_include::weights::PostDispatchInfo;
fn dispatch(
self,
origin: Origin,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::DispatchResultWithPostInfo{
if !<Self::Origin as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OriginTrait>::filter_call(
&origin,
&self,
) {
return self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_std::result::Result::Err(
frame_system::Error::<Runtime>::CallFiltered.into(),
);
}
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
self,
origin,
)
}
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable
for Call
{
type Origin = Origin;
fn dispatch_bypass_filter(
self,
origin: Origin,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::DispatchResultWithPostInfo{
match self {
Call::System(call) => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
call,
origin,
)
}
Call::Timestamp(call) => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
call,
origin,
)
}
Call::Grandpa(call) => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
call,
origin,
)
}
Call::Balances(call) => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
call,
origin,
)
}
Call::Sudo(call) => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
call,
origin,
)
}
Call::TemplateModule(call) => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::UnfilteredDispatchable::dispatch_bypass_filter(
call,
origin,
)
}
}
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::IsSubType<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
> for Call
{
#[allow(unreachable_patterns)]
fn is_sub_type(
&self,
) -> Option<
&self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
> {
match self {
Call::System(call) => Some(call),
_ => None,
}
}
}
impl
From<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
> for Call
{
fn from(
call: self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
System,
Runtime,
>,
) -> Self {
Call::System(call)
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::IsSubType<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
> for Call
{
#[allow(unreachable_patterns)]
fn is_sub_type(
&self,
) -> Option<
&self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
> {
match self {
Call::Timestamp(call) => Some(call),
_ => None,
}
}
}
impl
From<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
> for Call
{
fn from(
call: self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Timestamp,
Runtime,
>,
) -> Self {
Call::Timestamp(call)
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::IsSubType<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
> for Call
{
#[allow(unreachable_patterns)]
fn is_sub_type(
&self,
) -> Option<
&self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
> {
match self {
Call::Grandpa(call) => Some(call),
_ => None,
}
}
}
impl
From<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
> for Call
{
fn from(
call: self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Grandpa,
Runtime,
>,
) -> Self {
Call::Grandpa(call)
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::IsSubType<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
> for Call
{
#[allow(unreachable_patterns)]
fn is_sub_type(
&self,
) -> Option<
&self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
> {
match self {
Call::Balances(call) => Some(call),
_ => None,
}
}
}
impl
From<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
> for Call
{
fn from(
call: self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Balances,
Runtime,
>,
) -> Self {
Call::Balances(call)
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::IsSubType<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
> for Call
{
#[allow(unreachable_patterns)]
fn is_sub_type(
&self,
) -> Option<
&self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
> {
match self {
Call::Sudo(call) => Some(call),
_ => None,
}
}
}
impl
From<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
> for Call
{
fn from(
call: self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
Sudo,
Runtime,
>,
) -> Self {
Call::Sudo(call)
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::IsSubType<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
> for Call
{
#[allow(unreachable_patterns)]
fn is_sub_type(
&self,
) -> Option<
&self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
> {
match self {
Call::TemplateModule(call) => Some(call),
_ => None,
}
}
}
impl
From<
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
> for Call
{
fn from(
call: self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch::CallableCallFor<
TemplateModule,
Runtime,
>,
) -> Self {
Call::TemplateModule(call)
}
}
impl Runtime {
pub fn metadata() -> self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::RuntimeMetadataPrefixed{
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::RuntimeMetadataLastVersion::new(
<[_]>::into_vec(
#[rustc_box]
::alloc::boxed::Box::new([
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "System",
index: 0u8,
storage: Some(
frame_system::Pallet::<Runtime>::storage_metadata(),
),
calls: Some(
frame_system::Pallet::<Runtime>::call_functions(),
),
event: Some(self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletEventMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
frame_system::Event<Runtime>,
>(),
}),
constants: frame_system::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: frame_system::Pallet::<Runtime>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "RandomnessCollectiveFlip",
index: 1u8,
storage: Some(
pallet_randomness_collective_flip::Pallet::<
Runtime,
>::storage_metadata(),
),
calls: None,
event: None,
constants: pallet_randomness_collective_flip::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_randomness_collective_flip::Pallet::<
Runtime,
>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "Timestamp",
index: 2u8,
storage: Some(
pallet_timestamp::Pallet::<Runtime>::storage_metadata(),
),
calls: Some(
pallet_timestamp::Pallet::<Runtime>::call_functions(),
),
event: None,
constants: pallet_timestamp::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_timestamp::Pallet::<Runtime>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "Aura",
index: 3u8,
storage: Some(
pallet_aura::Pallet::<Runtime>::storage_metadata(),
),
calls: None,
event: None,
constants: pallet_aura::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_aura::Pallet::<Runtime>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "Grandpa",
index: 4u8,
storage: Some(
pallet_grandpa::Pallet::<Runtime>::storage_metadata(),
),
calls: Some(
pallet_grandpa::Pallet::<Runtime>::call_functions(),
),
event: Some(self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletEventMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
pallet_grandpa::Event,
>(),
}),
constants: pallet_grandpa::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_grandpa::Pallet::<Runtime>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "Balances",
index: 5u8,
storage: Some(
pallet_balances::Pallet::<Runtime>::storage_metadata(),
),
calls: Some(
pallet_balances::Pallet::<Runtime>::call_functions(),
),
event: Some(self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletEventMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
pallet_balances::Event<Runtime>,
>(),
}),
constants: pallet_balances::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_balances::Pallet::<Runtime>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "TransactionPayment",
index: 6u8,
storage: Some(
pallet_transaction_payment::Pallet::<
Runtime,
>::storage_metadata(),
),
calls: None,
event: Some(self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletEventMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
pallet_transaction_payment::Event<Runtime>,
>(),
}),
constants: pallet_transaction_payment::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_transaction_payment::Pallet::<
Runtime,
>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "Sudo",
index: 7u8,
storage: Some(
pallet_sudo::Pallet::<Runtime>::storage_metadata(),
),
calls: Some(
pallet_sudo::Pallet::<Runtime>::call_functions(),
),
event: Some(self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletEventMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
pallet_sudo::Event<Runtime>,
>(),
}),
constants: pallet_sudo::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_sudo::Pallet::<Runtime>::error_metadata(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletMetadata {
name: "TemplateModule",
index: 8u8,
storage: Some(
pallet_template::Pallet::<Runtime>::storage_metadata(),
),
calls: Some(
pallet_template::Pallet::<Runtime>::call_functions(),
),
event: Some(self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::PalletEventMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
pallet_template::Event<Runtime>,
>(),
}),
constants: pallet_template::Pallet::<
Runtime,
>::pallet_constants_metadata(),
error: pallet_template::Pallet::<Runtime>::error_metadata(),
},
]),
),
self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::ExtrinsicMetadata {
ty: self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
UncheckedExtrinsic,
>(),
version: <UncheckedExtrinsic as self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::ExtrinsicMetadata>::VERSION,
signed_extensions: <<UncheckedExtrinsic as self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::ExtrinsicMetadata>::SignedExtensions as self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::SignedExtension>::metadata()
.into_iter()
.map(|meta| self::sp_api_hidden_includes_construct_runtime::hidden_include::metadata::SignedExtensionMetadata {
identifier: meta.identifier,
ty: meta.ty,
additional_signed: meta.additional_signed,
})
.collect(),
},
self::sp_api_hidden_includes_construct_runtime::hidden_include::scale_info::meta_type::<
Runtime,
>(),
)
.into()
}
}
#[cfg(any(feature = "std", test))]
pub type SystemConfig = frame_system::GenesisConfig;
#[cfg(any(feature = "std", test))]
pub type AuraConfig = pallet_aura::GenesisConfig<Runtime>;
#[cfg(any(feature = "std", test))]
pub type GrandpaConfig = pallet_grandpa::GenesisConfig;
#[cfg(any(feature = "std", test))]
pub type BalancesConfig = pallet_balances::GenesisConfig<Runtime>;
#[cfg(any(feature = "std", test))]
pub type TransactionPaymentConfig = pallet_transaction_payment::GenesisConfig;
#[cfg(any(feature = "std", test))]
pub type SudoConfig = pallet_sudo::GenesisConfig<Runtime>;
#[cfg(any(feature = "std", test))]
use self::sp_api_hidden_includes_construct_runtime::hidden_include::serde as __genesis_config_serde_import__;
#[cfg(any(feature = "std", test))]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
#[serde(crate = "__genesis_config_serde_import__")]
pub struct GenesisConfig {
pub system: SystemConfig,
pub aura: AuraConfig,
pub grandpa: GrandpaConfig,
pub balances: BalancesConfig,
pub transaction_payment: TransactionPaymentConfig,
pub sudo: SudoConfig,
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
use __genesis_config_serde_import__ as _serde;
#[automatically_derived]
impl __genesis_config_serde_import__::Serialize for GenesisConfig {
fn serialize<__S>(
&self,
__serializer: __S,
) -> __genesis_config_serde_import__::__private::Result<__S::Ok, __S::Error>
where
__S: __genesis_config_serde_import__::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GenesisConfig",
false as usize + 1 + 1 + 1 + 1 + 1 + 1,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"system",
&self.system,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"aura",
&self.aura,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"grandpa",
&self.grandpa,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"balances",
&self.balances,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"transactionPayment",
&self.transaction_payment,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"sudo",
&self.sudo,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
use __genesis_config_serde_import__ as _serde;
#[automatically_derived]
impl<'de> __genesis_config_serde_import__::Deserialize<'de> for GenesisConfig {
fn deserialize<__D>(
__deserializer: __D,
) -> __genesis_config_serde_import__::__private::Result<Self, __D::Error>
where
__D: __genesis_config_serde_import__::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::__private::Ok(__Field::__field1),
2u64 => _serde::__private::Ok(__Field::__field2),
3u64 => _serde::__private::Ok(__Field::__field3),
4u64 => _serde::__private::Ok(__Field::__field4),
5u64 => _serde::__private::Ok(__Field::__field5),
_ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 6",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"system" => _serde::__private::Ok(__Field::__field0),
"aura" => _serde::__private::Ok(__Field::__field1),
"grandpa" => _serde::__private::Ok(__Field::__field2),
"balances" => _serde::__private::Ok(__Field::__field3),
"transactionPayment" => _serde::__private::Ok(__Field::__field4),
"sudo" => _serde::__private::Ok(__Field::__field5),
_ => _serde::__private::Err(_serde::de::Error::unknown_field(
__value, FIELDS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"system" => _serde::__private::Ok(__Field::__field0),
b"aura" => _serde::__private::Ok(__Field::__field1),
b"grandpa" => _serde::__private::Ok(__Field::__field2),
b"balances" => _serde::__private::Ok(__Field::__field3),
b"transactionPayment" => _serde::__private::Ok(__Field::__field4),
b"sudo" => _serde::__private::Ok(__Field::__field5),
_ => {
let __value = &_serde::__private::from_utf8_lossy(__value);
_serde::__private::Err(_serde::de::Error::unknown_field(
__value, FIELDS,
))
},
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::__private::PhantomData<GenesisConfig>,
lifetime: _serde::__private::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GenesisConfig;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(__formatter, "struct GenesisConfig")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<SystemConfig>(&mut __seq)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize,
&"struct GenesisConfig with 6 elements",
));
},
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<AuraConfig>(&mut __seq) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize,
&"struct GenesisConfig with 6 elements",
));
},
};
let __field2 = match match _serde::de::SeqAccess::next_element::<GrandpaConfig>(
&mut __seq,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
2usize,
&"struct GenesisConfig with 6 elements",
));
},
};
let __field3 = match match _serde::de::SeqAccess::next_element::<BalancesConfig>(
&mut __seq,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
3usize,
&"struct GenesisConfig with 6 elements",
));
},
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
TransactionPaymentConfig,
>(&mut __seq)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
4usize,
&"struct GenesisConfig with 6 elements",
));
},
};
let __field5 =
match match _serde::de::SeqAccess::next_element::<SudoConfig>(&mut __seq) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
5usize,
&"struct GenesisConfig with 6 elements",
));
},
};
_serde::__private::Ok(GenesisConfig {
system: __field0,
aura: __field1,
grandpa: __field2,
balances: __field3,
transaction_payment: __field4,
sudo: __field5,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::__private::Option<SystemConfig> =
_serde::__private::None;
let mut __field1: _serde::__private::Option<AuraConfig> =
_serde::__private::None;
let mut __field2: _serde::__private::Option<GrandpaConfig> =
_serde::__private::None;
let mut __field3: _serde::__private::Option<BalancesConfig> =
_serde::__private::None;
let mut __field4: _serde::__private::Option<TransactionPaymentConfig> =
_serde::__private::None;
let mut __field5: _serde::__private::Option<SudoConfig> =
_serde::__private::None;
while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
} {
match __key {
__Field::__field0 => {
if _serde::__private::Option::is_some(&__field0) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"system",
),
);
}
__field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<SystemConfig>(
&mut __map,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
__Field::__field1 => {
if _serde::__private::Option::is_some(&__field1) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("aura"),
);
}
__field1 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<AuraConfig>(
&mut __map,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
__Field::__field2 => {
if _serde::__private::Option::is_some(&__field2) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"grandpa",
),
);
}
__field2 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<GrandpaConfig>(
&mut __map,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
__Field::__field3 => {
if _serde::__private::Option::is_some(&__field3) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"balances",
),
);
}
__field3 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<BalancesConfig>(
&mut __map,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
__Field::__field4 => {
if _serde::__private::Option::is_some(&__field4) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"transactionPayment",
),
);
}
__field4 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<
TransactionPaymentConfig,
>(&mut __map)
{
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
__Field::__field5 => {
if _serde::__private::Option::is_some(&__field5) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("sudo"),
);
}
__field5 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<SudoConfig>(
&mut __map,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
},
);
},
}
}
let __field0 = match __field0 {
_serde::__private::Some(__field0) => __field0,
_serde::__private::None => {
match _serde::__private::de::missing_field("system") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
let __field1 = match __field1 {
_serde::__private::Some(__field1) => __field1,
_serde::__private::None => {
match _serde::__private::de::missing_field("aura") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
let __field2 = match __field2 {
_serde::__private::Some(__field2) => __field2,
_serde::__private::None => {
match _serde::__private::de::missing_field("grandpa") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
let __field3 = match __field3 {
_serde::__private::Some(__field3) => __field3,
_serde::__private::None => {
match _serde::__private::de::missing_field("balances") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
let __field4 = match __field4 {
_serde::__private::Some(__field4) => __field4,
_serde::__private::None => {
match _serde::__private::de::missing_field("transactionPayment") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
let __field5 = match __field5 {
_serde::__private::Some(__field5) => __field5,
_serde::__private::None => {
match _serde::__private::de::missing_field("sudo") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
},
}
},
};
_serde::__private::Ok(GenesisConfig {
system: __field0,
aura: __field1,
grandpa: __field2,
balances: __field3,
transaction_payment: __field4,
sudo: __field5,
})
}
}
const FIELDS: &'static [&'static str] =
&["system", "aura", "grandpa", "balances", "transactionPayment", "sudo"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GenesisConfig",
FIELDS,
__Visitor {
marker: _serde::__private::PhantomData::<GenesisConfig>,
lifetime: _serde::__private::PhantomData,
},
)
}
}
};
#[automatically_derived]
impl ::core::default::Default for GenesisConfig {
#[inline]
fn default() -> GenesisConfig {
GenesisConfig {
system: ::core::default::Default::default(),
aura: ::core::default::Default::default(),
grandpa: ::core::default::Default::default(),
balances: ::core::default::Default::default(),
transaction_payment: ::core::default::Default::default(),
sudo: ::core::default::Default::default(),
}
}
}
#[cfg(any(feature = "std", test))]
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildStorage
for GenesisConfig
{
fn assimilate_storage(
&self,
storage: &mut self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::Storage,
) -> std::result::Result<(), String> {
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildModuleGenesisStorage::<
Runtime,
frame_system::__InherentHiddenInstance,
>::build_module_genesis_storage(&self.system, storage)?;
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildModuleGenesisStorage::<
Runtime,
pallet_aura::__InherentHiddenInstance,
>::build_module_genesis_storage(&self.aura, storage)?;
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildModuleGenesisStorage::<
Runtime,
pallet_grandpa::__InherentHiddenInstance,
>::build_module_genesis_storage(&self.grandpa, storage)?;
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildModuleGenesisStorage::<
Runtime,
pallet_balances::__InherentHiddenInstance,
>::build_module_genesis_storage(&self.balances, storage)?;
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildModuleGenesisStorage::<
Runtime,
pallet_transaction_payment::__InherentHiddenInstance,
>::build_module_genesis_storage(&self.transaction_payment, storage)?;
self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::BuildModuleGenesisStorage::<
Runtime,
pallet_sudo::__InherentHiddenInstance,
>::build_module_genesis_storage(&self.sudo, storage)?;
self::sp_api_hidden_includes_construct_runtime::hidden_include::BasicExternalities::execute_with_storage(
storage,
|| {
<AllPalletsWithSystem as self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::OnGenesis>::on_genesis();
},
);
Ok(())
}
}
trait InherentDataExt {
fn create_extrinsics(
&self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::Vec<
<Block as self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::BlockT>::Extrinsic,
>;
fn check_extrinsics(
&self,
block: &Block,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::CheckInherentsResult;
}
impl InherentDataExt
for self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::InherentData
{
fn create_extrinsics(
&self,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::Vec<
<Block as self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::BlockT>::Extrinsic,
>{
use self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::ProvideInherent;
let mut inherents = Vec::new();
if let Some(inherent) = Timestamp::create_inherent(self) {
let inherent = <UncheckedExtrinsic as self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::Extrinsic>::new(
inherent.into(),
None,
)
.expect(
"Runtime UncheckedExtrinsic is not Opaque, so it has to return \
`Some`; qed",
);
inherents.push(inherent);
}
inherents
}
fn check_extrinsics(
&self,
block: &Block,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::CheckInherentsResult{
use self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::{
IsFatalError, ProvideInherent,
};
use self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::Block as _;
use self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::{
ExtrinsicCall, IsSubType,
};
let mut result = self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::CheckInherentsResult::new();
for xt in block.extrinsics() {
if self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::Extrinsic::is_signed(
xt,
)
.unwrap_or(false)
{
break;
}
let mut is_inherent = false;
{
let call = <UncheckedExtrinsic as ExtrinsicCall>::call(xt);
if let Some(call) = IsSubType::<_>::is_sub_type(call) {
if Timestamp::is_inherent(call) {
is_inherent = true;
if let Err(e) = Timestamp::check_inherent(call, self) {
result
.put_error(Timestamp::INHERENT_IDENTIFIER, &e)
.expect("There is only one fatal error; qed");
if e.is_fatal_error() {
return result;
}
}
}
}
}
if !is_inherent {
break;
}
}
match Timestamp::is_inherent_required(self) {
Ok(Some(e)) => {
let found = block
.extrinsics()
.iter()
.any(|xt| {
let is_signed = self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::Extrinsic::is_signed(
xt,
)
.unwrap_or(false);
if !is_signed {
let call = <UncheckedExtrinsic as ExtrinsicCall>::call(xt);
if let Some(call) = IsSubType::<_>::is_sub_type(call) {
Timestamp::is_inherent(&call)
} else {
false
}
} else {
false
}
});
if !found {
result
.put_error(Timestamp::INHERENT_IDENTIFIER, &e)
.expect("There is only one fatal error; qed");
if e.is_fatal_error() {
return result;
}
}
},
Ok(None) => {},
Err(e) => {
result
.put_error(Timestamp::INHERENT_IDENTIFIER, &e)
.expect("There is only one fatal error; qed");
if e.is_fatal_error() {
return result;
}
},
}
result
}
}
impl
self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::EnsureInherentsAreFirst<
Block,
> for Runtime
{
fn ensure_inherents_are_first(block: &Block) -> Result<(), u32> {
use self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::ProvideInherent;
use self::sp_api_hidden_includes_construct_runtime::hidden_include::sp_runtime::traits::Block as _;
use self::sp_api_hidden_includes_construct_runtime::hidden_include::traits::{
ExtrinsicCall, IsSubType,
};
let mut first_signed_observed = false;
for (i, xt) in block.extrinsics().iter().enumerate() {
let is_signed = self::sp_api_hidden_includes_construct_runtime::hidden_include::inherent::Extrinsic::is_signed(
xt,
)
.unwrap_or(false);
let is_inherent = if is_signed {
false
} else {
let mut is_inherent = false;
{
let call = <UncheckedExtrinsic as ExtrinsicCall>::call(xt);
if let Some(call) = IsSubType::<_>::is_sub_type(call) {
if Timestamp::is_inherent(&call) {
is_inherent = true;
}
}
}
is_inherent
};
if !is_inherent {
first_signed_observed = true;
}
if first_signed_observed && is_inherent {
return Err(i as u32);
}
}
Ok(())
}
}
impl self::sp_api_hidden_includes_construct_runtime::hidden_include::unsigned::ValidateUnsigned
for Runtime
{
type Call = Call;
fn pre_dispatch(
call: &Self::Call,
) -> Result<
(),
self::sp_api_hidden_includes_construct_runtime::hidden_include::unsigned::TransactionValidityError,
>{
#[allow(unreachable_patterns)]
match call {
Call::Grandpa(inner_call) => Grandpa::pre_dispatch(inner_call),
_ => Ok(()),
}
}
fn validate_unsigned(
#[allow(unused_variables)]
source: self::sp_api_hidden_includes_construct_runtime::hidden_include::unsigned::TransactionSource,
call: &Self::Call,
) -> self::sp_api_hidden_includes_construct_runtime::hidden_include::unsigned::TransactionValidity
{
#[allow(unreachable_patterns)]
match call {
Call::Grandpa(inner_call) => Grandpa::validate_unsigned(source, inner_call),
_ => {
self::sp_api_hidden_includes_construct_runtime::hidden_include::unsigned::UnknownTransaction::NoUnsignedValidator
.into()
}
}
}
}
const _: () =
if !(<frame_system::Error<Runtime> as ::frame_support::traits::PalletError>::MAX_ENCODED_SIZE
<= ::frame_support::MAX_MODULE_ERROR_ENCODED_SIZE)
{
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&[
"The maximum encoded size of the error type in the `System` pallet exceeds `MAX_MODULE_ERROR_ENCODED_SIZE`",
],
&[],
),
)
};
const _: () =
if !(<pallet_grandpa::Error<Runtime> as ::frame_support::traits::PalletError>::MAX_ENCODED_SIZE
<= ::frame_support::MAX_MODULE_ERROR_ENCODED_SIZE)
{
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&[
"The maximum encoded size of the error type in the `Grandpa` pallet exceeds `MAX_MODULE_ERROR_ENCODED_SIZE`",
],
&[],
),
)
};
const _: () =
if !(<pallet_balances::Error<Runtime> as ::frame_support::traits::PalletError>::MAX_ENCODED_SIZE
<= ::frame_support::MAX_MODULE_ERROR_ENCODED_SIZE)
{
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&[
"The maximum encoded size of the error type in the `Balances` pallet exceeds `MAX_MODULE_ERROR_ENCODED_SIZE`",
],
&[],
),
)
};
const _: () =
if !(<pallet_sudo::Error<Runtime> as ::frame_support::traits::PalletError>::MAX_ENCODED_SIZE
<= ::frame_support::MAX_MODULE_ERROR_ENCODED_SIZE)
{
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&[
"The maximum encoded size of the error type in the `Sudo` pallet exceeds `MAX_MODULE_ERROR_ENCODED_SIZE`",
],
&[],
),
)
};
const _: () =
if !(<pallet_template::Error<Runtime> as ::frame_support::traits::PalletError>::MAX_ENCODED_SIZE
<= ::frame_support::MAX_MODULE_ERROR_ENCODED_SIZE)
{
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&[
"The maximum encoded size of the error type in the `TemplateModule` pallet exceeds `MAX_MODULE_ERROR_ENCODED_SIZE`",
],
&[],
),
)
};
/// The address format for describing accounts.
pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
/// Block header type as expected by this runtime.
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
/// Block type as expected by this runtime.
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
/// The SignedExtension to the basic transaction logic.
pub type SignedExtra = (
frame_system::CheckNonZeroSender<Runtime>,
frame_system::CheckSpecVersion<Runtime>,
frame_system::CheckTxVersion<Runtime>,
frame_system::CheckGenesis<Runtime>,
frame_system::CheckEra<Runtime>,
frame_system::CheckNonce<Runtime>,
frame_system::CheckWeight<Runtime>,
pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
/// Executive: handles dispatch to the various modules.
pub type Executive = frame_executive::Executive<
Runtime,
Block,
frame_system::ChainContext<Runtime>,
Runtime,
AllPalletsWithSystem,
>;
#[doc(hidden)]
mod sp_api_hidden_includes_IMPL_RUNTIME_APIS {
pub extern crate sp_api as sp_api;
}
pub struct RuntimeApi {}
/// Implements all runtime apis for the client side.
#[cfg(any(feature = "std", test))]
pub struct RuntimeApiImpl<
Block: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT,
C: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<Block> + 'static,
> {
call: &'static C,
commit_on_success: std::cell::RefCell<bool>,
changes: std::cell::RefCell<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges,
>,
storage_transaction_cache: std::cell::RefCell<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StorageTransactionCache<
Block,
C::StateBackend,
>,
>,
recorder: std::option::Option<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ProofRecorder<Block>,
>,
}
#[cfg(any(feature = "std", test))]
unsafe impl<
Block: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT,
C: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<Block>,
> Send for RuntimeApiImpl<Block, C>
{
}
#[cfg(any(feature = "std", test))]
unsafe impl<
Block: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT,
C: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<Block>,
> Sync for RuntimeApiImpl<Block, C>
{
}
#[cfg(any(feature = "std", test))]
impl<
Block: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT,
C: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<Block>,
> self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiExt<Block>
for RuntimeApiImpl<Block, C>
{
type StateBackend = C::StateBackend;
fn execute_in_transaction<
F: FnOnce(
&Self,
) -> self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::TransactionOutcome<R>,
R,
>(
&self,
call: F,
) -> R
where
Self: Sized,
{
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
*std::cell::RefCell::borrow_mut(&self.commit_on_success) = false;
let res = call(self);
*std::cell::RefCell::borrow_mut(&self.commit_on_success) = true;
self.commit_or_rollback(match res {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::TransactionOutcome::Commit(
_,
) => true,
_ => false,
});
res.into_inner()
}
fn has_api<A: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeApiInfo + ?Sized>(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<Block>,
) -> std::result::Result<bool, self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError>
where
Self: Sized,
{
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
Block,
>::runtime_version_at(self.call, at)
.map(|v| self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion::has_api_with(
&v,
&A::ID,
|v| v == A::VERSION,
))
}
fn has_api_with<
A: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeApiInfo + ?Sized,
P: Fn(u32) -> bool,
>(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<Block>,
pred: P,
) -> std::result::Result<bool, self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError>
where
Self: Sized,
{
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
Block,
>::runtime_version_at(self.call, at)
.map(|v| self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion::has_api_with(
&v,
&A::ID,
pred,
))
}
fn api_version<
A: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeApiInfo + ?Sized,
>(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<Block>,
) -> std::result::Result<
Option<u32>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
>
where
Self: Sized,
{
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
Block,
>::runtime_version_at(self.call, at)
.map(|v| self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion::api_version(
&v,
&A::ID,
))
}
fn record_proof(&mut self) {
self.recorder = std::option::Option::Some(std::default::Default::default());
}
fn proof_recorder(
&self,
) -> std::option::Option<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ProofRecorder<Block>,
> {
std::clone::Clone::clone(&self.recorder)
}
fn extract_proof(
&mut self,
) -> std::option::Option<self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StorageProof> {
std::option::Option::take(&mut self.recorder).map(|recorder| {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ProofRecorder::<
Block,
>::to_storage_proof(&recorder)
})
}
fn into_storage_changes(
&self,
backend: &Self::StateBackend,
parent_hash: Block::Hash,
) -> core::result::Result<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StorageChanges<
C::StateBackend,
Block,
>,
String,
>
where
Self: Sized,
{
let at = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId::Hash(
std::clone::Clone::clone(&parent_hash),
);
let state_version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
Block,
>::runtime_version_at(self.call, &at)
.map(|v| {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion::state_version(
&v,
)
})
.map_err(|e| {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Failed to get state version: "],
&[::core::fmt::ArgumentV1::new_display(&e)],
));
res
})?;
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::into_storage_changes(
std::cell::RefCell::take(&self.changes),
backend,
core::cell::RefCell::take(&self.storage_transaction_cache),
state_version,
)
}
}
#[cfg(any(feature = "std", test))]
impl<Block: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT, C>
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ConstructRuntimeApi<Block, C> for RuntimeApi
where
C: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<Block> + 'static,
{
type RuntimeApi = RuntimeApiImpl<Block, C>;
fn construct_runtime_api<'a>(
call: &'a C,
) -> self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiRef<'a, Self::RuntimeApi> {
RuntimeApiImpl {
call: unsafe { std::mem::transmute(call) },
commit_on_success: true.into(),
changes: std::default::Default::default(),
recorder: std::default::Default::default(),
storage_transaction_cache: std::default::Default::default(),
}
.into()
}
}
#[cfg(any(feature = "std", test))]
impl<
Block: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT,
C: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<Block>,
> RuntimeApiImpl<Block, C>
{
fn commit_or_rollback(&self, commit: bool) {
let proof = "\
We only close a transaction when we opened one ourself.
Other parts of the runtime that make use of transactions (state-machine)
also balance their transactions. The runtime cannot close client initiated
transactions; qed";
if *std::cell::RefCell::borrow(&self.commit_on_success) {
let res = if commit {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::commit_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
)
} else {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::rollback_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
)
};
std::result::Result::expect(res, proof);
}
}
}
impl sp_api::runtime_decl_for_Core::Core<Block> for Runtime {
fn version() -> RuntimeVersion {
VERSION
}
fn execute_block(block: Block) {
Executive::execute_block(block);
}
fn initialize_block(header: &<Block as BlockT>::Header) {
Executive::initialize_block(header)
}
}
impl sp_api::runtime_decl_for_Metadata::Metadata<Block> for Runtime {
fn metadata() -> OpaqueMetadata {
OpaqueMetadata::new(Runtime::metadata().into())
}
}
impl sp_block_builder::runtime_decl_for_BlockBuilder::BlockBuilder<Block> for Runtime {
fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
Executive::apply_extrinsic(extrinsic)
}
fn finalize_block() -> <Block as BlockT>::Header {
Executive::finalize_block()
}
fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
data.create_extrinsics()
}
fn check_inherents(
block: Block,
data: sp_inherents::InherentData,
) -> sp_inherents::CheckInherentsResult {
data.check_extrinsics(&block)
}
}
impl sp_transaction_pool::runtime_api::runtime_decl_for_TaggedTransactionQueue::TaggedTransactionQueue<
Block,
> for Runtime {
fn validate_transaction(
source: TransactionSource,
tx: <Block as BlockT>::Extrinsic,
block_hash: <Block as BlockT>::Hash,
) -> TransactionValidity {
Executive::validate_transaction(source, tx, block_hash)
}
}
impl sp_offchain::runtime_decl_for_OffchainWorkerApi::OffchainWorkerApi<Block> for Runtime {
fn offchain_worker(header: &<Block as BlockT>::Header) {
Executive::offchain_worker(header)
}
}
impl sp_consensus_aura::runtime_decl_for_AuraApi::AuraApi<Block, AuraId> for Runtime {
fn slot_duration() -> sp_consensus_aura::SlotDuration {
sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())
}
fn authorities() -> Vec<AuraId> {
Aura::authorities().into_inner()
}
}
impl sp_session::runtime_decl_for_SessionKeys::SessionKeys<Block> for Runtime {
fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
opaque::SessionKeys::generate(seed)
}
fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {
opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
}
}
impl fg_primitives::runtime_decl_for_GrandpaApi::GrandpaApi<Block> for Runtime {
fn grandpa_authorities() -> GrandpaAuthorityList {
Grandpa::grandpa_authorities()
}
fn current_set_id() -> fg_primitives::SetId {
Grandpa::current_set_id()
}
fn submit_report_equivocation_unsigned_extrinsic(
_equivocation_proof: fg_primitives::EquivocationProof<
<Block as BlockT>::Hash,
NumberFor<Block>,
>,
_key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof,
) -> Option<()> {
None
}
fn generate_key_ownership_proof(
_set_id: fg_primitives::SetId,
_authority_id: GrandpaId,
) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {
None
}
}
impl
frame_system_rpc_runtime_api::runtime_decl_for_AccountNonceApi::AccountNonceApi<
Block,
AccountId,
Index,
> for Runtime
{
fn account_nonce(account: AccountId) -> Index {
System::account_nonce(account)
}
}
impl pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentApi::TransactionPaymentApi<
Block,
Balance,
> for Runtime {
fn query_info(
uxt: <Block as BlockT>::Extrinsic,
len: u32,
) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> {
TransactionPayment::query_info(uxt, len)
}
fn query_fee_details(
uxt: <Block as BlockT>::Extrinsic,
len: u32,
) -> pallet_transaction_payment::FeeDetails<Balance> {
TransactionPayment::query_fee_details(uxt, len)
}
}
impl pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentCallApi::TransactionPaymentCallApi<
Block,
Balance,
Call,
> for Runtime {
fn query_call_info(
call: Call,
len: u32,
) -> pallet_transaction_payment::RuntimeDispatchInfo<Balance> {
TransactionPayment::query_call_info(call, len)
}
fn query_call_fee_details(
call: Call,
len: u32,
) -> pallet_transaction_payment::FeeDetails<Balance> {
TransactionPayment::query_call_fee_details(call, len)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_api::Core<__SR_API_BLOCK__> for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
RuntimeVersion: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
<__SR_API_BLOCK__ as BlockT>::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_api::Metadata<__SR_API_BLOCK__> for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
OpaqueMetadata: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_block_builder::BlockBuilder<__SR_API_BLOCK__>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
<__SR_API_BLOCK__ as BlockT>::Extrinsic: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
ApplyExtrinsicResult: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
<__SR_API_BLOCK__ as BlockT>::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
sp_inherents::InherentData: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Vec<<__SR_API_BLOCK__ as BlockT>::Extrinsic>:
std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
sp_inherents::InherentData: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
sp_inherents::CheckInherentsResult: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_transaction_pool::runtime_api::TaggedTransactionQueue<__SR_API_BLOCK__>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
TransactionSource: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
<__SR_API_BLOCK__ as BlockT>::Extrinsic: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
<__SR_API_BLOCK__ as BlockT>::Hash: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
TransactionValidity: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_offchain::OffchainWorkerApi<__SR_API_BLOCK__>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
<__SR_API_BLOCK__ as BlockT>::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_consensus_aura::AuraApi<__SR_API_BLOCK__, AuraId>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
sp_consensus_aura::SlotDuration: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Vec<AuraId>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> sp_session::SessionKeys<__SR_API_BLOCK__> for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
Option<Vec<u8>>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Vec<u8>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Vec<u8>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Option<Vec<(Vec<u8>, KeyTypeId)>>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> fg_primitives::GrandpaApi<__SR_API_BLOCK__>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
GrandpaAuthorityList: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
fg_primitives::SetId: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
fg_primitives::EquivocationProof<
<__SR_API_BLOCK__ as BlockT>::Hash,
NumberFor<__SR_API_BLOCK__>,
>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
fg_primitives::OpaqueKeyOwnershipProof: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Option<()>: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
fg_primitives::SetId: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
GrandpaId: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Option<fg_primitives::OpaqueKeyOwnershipProof>:
std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> frame_system_rpc_runtime_api::AccountNonceApi<__SR_API_BLOCK__, AccountId, Index>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
AccountId: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Index: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
> pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<__SR_API_BLOCK__, Balance>
for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
<__SR_API_BLOCK__ as BlockT>::Extrinsic: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
u32: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance>:
std::panic::UnwindSafe + std::panic::RefUnwindSafe,
<__SR_API_BLOCK__ as BlockT>::Extrinsic: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
u32: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
pallet_transaction_payment::FeeDetails<Balance>:
std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
#[cfg(any(feature = "std", test))]
impl<
__SR_API_BLOCK__: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockT
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe,
RuntimeApiImplCall: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt<__SR_API_BLOCK__>
+ 'static,
>
pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi<
__SR_API_BLOCK__,
Balance,
Call,
> for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall>
where
RuntimeApiImplCall::StateBackend:
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::StateBackend<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::HashFor<__SR_API_BLOCK__>,
>,
Call: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
u32: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
pallet_transaction_payment::RuntimeDispatchInfo<Balance>:
std::panic::UnwindSafe + std::panic::RefUnwindSafe,
Call: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
u32: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
pallet_transaction_payment::FeeDetails<Balance>:
std::panic::UnwindSafe + std::panic::RefUnwindSafe,
__SR_API_BLOCK__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe,
{
fn __runtime_api_internal_call_api_at(
&self,
at: &self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::BlockId<__SR_API_BLOCK__>,
context: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ExecutionContext,
params: std::vec::Vec<u8>,
fn_name: &dyn Fn(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::RuntimeVersion,
) -> &'static str,
) -> std::result::Result<
std::vec::Vec<u8>,
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApiError,
> {
if *std::cell::RefCell::borrow(&self.commit_on_success) {
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::OverlayedChanges::start_transaction(
&mut std::cell::RefCell::borrow_mut(&self.changes),
);
}
let res = (|| {
let version = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::runtime_version_at(self.call, at)?;
let params = self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAtParams::<
_,
fn() -> _,
_,
> {
at,
function: (*fn_name)(version),
native_call: None,
arguments: params,
overlayed_changes: &self.changes,
storage_transaction_cache: &self.storage_transaction_cache,
context,
recorder: &self.recorder,
};
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::CallApiAt::<
__SR_API_BLOCK__,
>::call_api_at::<
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NeverNativeValue,
_,
>(self.call, params)
})();
self.commit_or_rollback(std::result::Result::is_ok(&res));
res.map(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::NativeOrEncoded::into_encoded,
)
}
}
const RUNTIME_API_VERSIONS: self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::ApisVec = ::sp_version::sp_std::borrow::Cow::Borrowed(
&[
(sp_api::runtime_decl_for_Core::ID, sp_api::runtime_decl_for_Core::VERSION),
(
sp_api::runtime_decl_for_Metadata::ID,
sp_api::runtime_decl_for_Metadata::VERSION,
),
(
sp_block_builder::runtime_decl_for_BlockBuilder::ID,
sp_block_builder::runtime_decl_for_BlockBuilder::VERSION,
),
(
sp_transaction_pool::runtime_api::runtime_decl_for_TaggedTransactionQueue::ID,
sp_transaction_pool::runtime_api::runtime_decl_for_TaggedTransactionQueue::VERSION,
),
(
sp_offchain::runtime_decl_for_OffchainWorkerApi::ID,
sp_offchain::runtime_decl_for_OffchainWorkerApi::VERSION,
),
(
sp_consensus_aura::runtime_decl_for_AuraApi::ID,
sp_consensus_aura::runtime_decl_for_AuraApi::VERSION,
),
(
sp_session::runtime_decl_for_SessionKeys::ID,
sp_session::runtime_decl_for_SessionKeys::VERSION,
),
(
fg_primitives::runtime_decl_for_GrandpaApi::ID,
fg_primitives::runtime_decl_for_GrandpaApi::VERSION,
),
(
frame_system_rpc_runtime_api::runtime_decl_for_AccountNonceApi::ID,
frame_system_rpc_runtime_api::runtime_decl_for_AccountNonceApi::VERSION,
),
(
pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentApi::ID,
pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentApi::VERSION,
),
(
pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentCallApi::ID,
pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentCallApi::VERSION,
),
],
);
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
const _: () = {};
pub mod api {
use super::*;
#[cfg(feature = "std")]
pub fn dispatch(method: &str, mut __sp_api__input_data: &[u8]) -> Option<Vec<u8>> {
match method {
"Core_version" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"version"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_api::runtime_decl_for_Core::Core<Block>>::version()
}))
},
"Core_execute_block" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (block): (Block) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"execute_block"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_api::runtime_decl_for_Core::Core<Block>>::execute_block(block)
}))
},
"Core_initialize_block" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (header): (<Block as BlockT>::Header) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"initialize_block"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_api::runtime_decl_for_Core::Core<Block>>::initialize_block(
&header,
)
}))
},
"Metadata_metadata" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"metadata"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_api::runtime_decl_for_Metadata::Metadata<Block>>::metadata()
}))
},
"BlockBuilder_apply_extrinsic" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (extrinsic): (<Block as BlockT>::Extrinsic) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"apply_extrinsic"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_block_builder::runtime_decl_for_BlockBuilder::BlockBuilder<
Block,
>>::apply_extrinsic(extrinsic)
}))
},
"BlockBuilder_finalize_block" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"finalize_block"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_block_builder::runtime_decl_for_BlockBuilder::BlockBuilder<
Block,
>>::finalize_block()
}))
},
"BlockBuilder_inherent_extrinsics" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (data): (sp_inherents::InherentData) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"inherent_extrinsics",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_block_builder::runtime_decl_for_BlockBuilder::BlockBuilder<
Block,
>>::inherent_extrinsics(data)
}))
},
"BlockBuilder_check_inherents" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (block, data): (Block, sp_inherents::InherentData) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"check_inherents"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_block_builder::runtime_decl_for_BlockBuilder::BlockBuilder<
Block,
>>::check_inherents(block, data)
}))
},
"TaggedTransactionQueue_validate_transaction" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (
source,
tx,
block_hash,
): (
TransactionSource,
<Block as BlockT>::Extrinsic,
<Block as BlockT>::Hash,
) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"validate_transaction",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_transaction_pool::runtime_api::runtime_decl_for_TaggedTransactionQueue::TaggedTransactionQueue<
Block,
>>::validate_transaction(source, tx, block_hash)
}))
},
"OffchainWorkerApi_offchain_worker" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (header): (<Block as BlockT>::Header) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"offchain_worker"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_offchain::runtime_decl_for_OffchainWorkerApi::OffchainWorkerApi<
Block,
>>::offchain_worker(&header)
}))
},
"AuraApi_slot_duration" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"slot_duration"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_consensus_aura::runtime_decl_for_AuraApi::AuraApi<
Block,
AuraId,
>>::slot_duration()
}))
},
"AuraApi_authorities" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"authorities"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_consensus_aura::runtime_decl_for_AuraApi::AuraApi<
Block,
AuraId,
>>::authorities()
}))
},
"SessionKeys_generate_session_keys" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (seed): (Option<Vec<u8>>) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"generate_session_keys",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_session::runtime_decl_for_SessionKeys::SessionKeys<
Block,
>>::generate_session_keys(seed)
}))
},
"SessionKeys_decode_session_keys" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (encoded): (Vec<u8>) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"decode_session_keys",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as sp_session::runtime_decl_for_SessionKeys::SessionKeys<
Block,
>>::decode_session_keys(encoded)
}))
},
"GrandpaApi_grandpa_authorities" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"grandpa_authorities",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as fg_primitives::runtime_decl_for_GrandpaApi::GrandpaApi<
Block,
>>::grandpa_authorities()
}))
},
"GrandpaApi_current_set_id" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (): () = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"current_set_id"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as fg_primitives::runtime_decl_for_GrandpaApi::GrandpaApi<
Block,
>>::current_set_id()
}))
},
"GrandpaApi_submit_report_equivocation_unsigned_extrinsic" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (
_equivocation_proof,
_key_owner_proof,
): (
fg_primitives::EquivocationProof<
<Block as BlockT>::Hash,
NumberFor<Block>,
>,
fg_primitives::OpaqueKeyOwnershipProof,
) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"submit_report_equivocation_unsigned_extrinsic",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as fg_primitives::runtime_decl_for_GrandpaApi::GrandpaApi<
Block,
>>::submit_report_equivocation_unsigned_extrinsic(
_equivocation_proof,
_key_owner_proof,
)
}))
},
"GrandpaApi_generate_key_ownership_proof" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (
_set_id,
_authority_id,
): (fg_primitives::SetId, GrandpaId) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"generate_key_ownership_proof",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as fg_primitives::runtime_decl_for_GrandpaApi::GrandpaApi<
Block,
>>::generate_key_ownership_proof(_set_id, _authority_id)
}))
},
"AccountNonceApi_account_nonce" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (account): (AccountId) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"account_nonce"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as frame_system_rpc_runtime_api::runtime_decl_for_AccountNonceApi::AccountNonceApi<
Block,
AccountId,
Index,
>>::account_nonce(account)
}))
},
"TransactionPaymentApi_query_info" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (uxt, len): (<Block as BlockT>::Extrinsic, u32) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"query_info"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentApi::TransactionPaymentApi<
Block,
Balance,
>>::query_info(uxt, len)
}))
},
"TransactionPaymentApi_query_fee_details" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (uxt, len): (<Block as BlockT>::Extrinsic, u32) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"query_fee_details"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentApi::TransactionPaymentApi<
Block,
Balance,
>>::query_fee_details(uxt, len)
}))
},
"TransactionPaymentCallApi_query_call_info" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (call, len): (Call, u32) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(&"query_call_info"),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentCallApi::TransactionPaymentCallApi<
Block,
Balance,
Call,
>>::query_call_info(call, len)
}))
},
"TransactionPaymentCallApi_query_call_fee_details" => {
Some(self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::Encode::encode(&{
let (call, len): (Call, u32) = match self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::DecodeLimit::decode_all_with_depth_limit(
self::sp_api_hidden_includes_IMPL_RUNTIME_APIS::sp_api::MAX_EXTRINSIC_DEPTH,
&mut __sp_api__input_data,
) {
Ok(res) => res,
Err(e) => {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["Bad input data provided to ", ": "],
&[
::core::fmt::ArgumentV1::new_display(
&"query_call_fee_details",
),
::core::fmt::ArgumentV1::new_display(&e),
],
),
)
}
};
#[allow(deprecated)]
<Runtime as pallet_transaction_payment_rpc_runtime_api::runtime_decl_for_TransactionPaymentCallApi::TransactionPaymentCallApi<
Block,
Balance,
Call,
>>::query_call_fee_details(call, len)
}))
},
_ => None,
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment