mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-07-15 21:55:47 +00:00
Introduce Metadata type (#974)
* WIP new Metadata type * Finish basic Metadata impl inc hashing and validation * remove caching from metadata; can add that higher up * remove caches * update retain to use Metadata * clippy fixes * update codegen to use Metadata * clippy * WIP fixing subxt lib * WIP fixing tests, rebuild artifacts, fix OrderedMap::retain * get --all-targets compiling * move DispatchError type lookup back to being optional * cargo clippy * fix docs * re-use VariantIndex to get variants * add docs and enforce docs on metadata crate * fix docs * add test and fix docs * cargo fmt * address review comments * update lockfiles * ExactSizeIter so we can ask for len() of things (and hopefully soon is_empty()
This commit is contained in:
James Wilson
@@ -0,0 +1,82 @@
|
||||
// Copyright 2019-2023 Parity Technologies (UK) Ltd.
|
||||
// This file is dual-licensed as Apache-2.0 or GPL-3.0.
|
||||
// see LICENSE for license details.
|
||||
|
||||
mod v14;
|
||||
mod v15;
|
||||
|
||||
/// An error emitted if something goes wrong converting [`frame_metadata`]
|
||||
/// types into [`crate::Metadata`].
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
#[non_exhaustive]
|
||||
pub enum TryFromError {
|
||||
/// Type missing from type registry
|
||||
#[error("Type {0} is expected but not found in the type registry")]
|
||||
TypeNotFound(u32),
|
||||
/// Type was not a variant/enum type
|
||||
#[error("Type {0} was not a variant/enum type, but is expected to be one")]
|
||||
VariantExpected(u32),
|
||||
/// An unsupported metadata version was provided.
|
||||
#[error("Cannot convert v{0} metadata into Metadata type")]
|
||||
UnsupportedMetadataVersion(u32),
|
||||
}
|
||||
|
||||
impl From<crate::Metadata> for frame_metadata::RuntimeMetadataPrefixed {
|
||||
fn from(value: crate::Metadata) -> Self {
|
||||
let m: frame_metadata::v15::RuntimeMetadataV15 = value.into();
|
||||
m.into()
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<frame_metadata::RuntimeMetadataPrefixed> for crate::Metadata {
|
||||
type Error = TryFromError;
|
||||
|
||||
fn try_from(value: frame_metadata::RuntimeMetadataPrefixed) -> Result<Self, Self::Error> {
|
||||
match value.1 {
|
||||
frame_metadata::RuntimeMetadata::V0(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(0))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V1(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(1))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V2(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(2))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V3(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(3))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V4(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(4))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V5(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(5))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V6(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(6))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V7(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(7))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V8(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(8))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V9(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(9))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V10(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(10))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V11(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(11))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V12(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(12))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V13(_) => {
|
||||
Err(TryFromError::UnsupportedMetadataVersion(13))
|
||||
}
|
||||
frame_metadata::RuntimeMetadata::V14(m) => m.try_into(),
|
||||
frame_metadata::RuntimeMetadata::V15(m) => m.try_into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
// Copyright 2019-2023 Parity Technologies (UK) Ltd.
|
||||
// This file is dual-licensed as Apache-2.0 or GPL-3.0.
|
||||
// see LICENSE for license details.
|
||||
|
||||
use super::TryFromError;
|
||||
use crate::Metadata;
|
||||
use frame_metadata::{v14, v15};
|
||||
|
||||
impl TryFrom<v14::RuntimeMetadataV14> for Metadata {
|
||||
type Error = TryFromError;
|
||||
fn try_from(value: v14::RuntimeMetadataV14) -> Result<Self, Self::Error> {
|
||||
// Convert to v15 and then convert that into Metadata.
|
||||
v14_to_v15(value).try_into()
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Metadata> for v14::RuntimeMetadataV14 {
|
||||
fn from(val: Metadata) -> Self {
|
||||
let v15 = val.into();
|
||||
v15_to_v14(v15)
|
||||
}
|
||||
}
|
||||
|
||||
fn v15_to_v14(metadata: v15::RuntimeMetadataV15) -> v14::RuntimeMetadataV14 {
|
||||
v14::RuntimeMetadataV14 {
|
||||
types: metadata.types,
|
||||
pallets: metadata
|
||||
.pallets
|
||||
.into_iter()
|
||||
.map(|pallet| frame_metadata::v14::PalletMetadata {
|
||||
name: pallet.name,
|
||||
storage: pallet
|
||||
.storage
|
||||
.map(|storage| frame_metadata::v14::PalletStorageMetadata {
|
||||
prefix: storage.prefix,
|
||||
entries: storage
|
||||
.entries
|
||||
.into_iter()
|
||||
.map(|entry| {
|
||||
let modifier = match entry.modifier {
|
||||
frame_metadata::v15::StorageEntryModifier::Optional => {
|
||||
frame_metadata::v14::StorageEntryModifier::Optional
|
||||
}
|
||||
frame_metadata::v15::StorageEntryModifier::Default => {
|
||||
frame_metadata::v14::StorageEntryModifier::Default
|
||||
}
|
||||
};
|
||||
|
||||
let ty = match entry.ty {
|
||||
frame_metadata::v15::StorageEntryType::Plain(ty) => {
|
||||
frame_metadata::v14::StorageEntryType::Plain(ty)
|
||||
},
|
||||
frame_metadata::v15::StorageEntryType::Map {
|
||||
hashers,
|
||||
key,
|
||||
value,
|
||||
} => frame_metadata::v14::StorageEntryType::Map {
|
||||
hashers: hashers.into_iter().map(|hasher| match hasher {
|
||||
frame_metadata::v15::StorageHasher::Blake2_128 => frame_metadata::v14::StorageHasher::Blake2_128,
|
||||
frame_metadata::v15::StorageHasher::Blake2_256 => frame_metadata::v14::StorageHasher::Blake2_256,
|
||||
frame_metadata::v15::StorageHasher::Blake2_128Concat => frame_metadata::v14::StorageHasher::Blake2_128Concat ,
|
||||
frame_metadata::v15::StorageHasher::Twox128 => frame_metadata::v14::StorageHasher::Twox128,
|
||||
frame_metadata::v15::StorageHasher::Twox256 => frame_metadata::v14::StorageHasher::Twox256,
|
||||
frame_metadata::v15::StorageHasher::Twox64Concat => frame_metadata::v14::StorageHasher::Twox64Concat,
|
||||
frame_metadata::v15::StorageHasher::Identity=> frame_metadata::v14::StorageHasher::Identity,
|
||||
}).collect(),
|
||||
key,
|
||||
value,
|
||||
},
|
||||
};
|
||||
|
||||
frame_metadata::v14::StorageEntryMetadata {
|
||||
name: entry.name,
|
||||
modifier,
|
||||
ty,
|
||||
default: entry.default,
|
||||
docs: entry.docs,
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
}),
|
||||
calls: pallet.calls.map(|calls| frame_metadata::v14::PalletCallMetadata { ty: calls.ty } ),
|
||||
event: pallet.event.map(|event| frame_metadata::v14::PalletEventMetadata { ty: event.ty } ),
|
||||
constants: pallet.constants.into_iter().map(|constant| frame_metadata::v14::PalletConstantMetadata {
|
||||
name: constant.name,
|
||||
ty: constant.ty,
|
||||
value: constant.value,
|
||||
docs: constant.docs,
|
||||
} ).collect(),
|
||||
error: pallet.error.map(|error| frame_metadata::v14::PalletErrorMetadata { ty: error.ty } ),
|
||||
index: pallet.index,
|
||||
})
|
||||
.collect(),
|
||||
extrinsic: frame_metadata::v14::ExtrinsicMetadata {
|
||||
ty: metadata.extrinsic.ty,
|
||||
version: metadata.extrinsic.version,
|
||||
signed_extensions: metadata.extrinsic.signed_extensions.into_iter().map(|ext| {
|
||||
frame_metadata::v14::SignedExtensionMetadata {
|
||||
identifier: ext.identifier,
|
||||
ty: ext.ty,
|
||||
additional_signed: ext.additional_signed,
|
||||
}
|
||||
}).collect()
|
||||
},
|
||||
ty: metadata.ty,
|
||||
}
|
||||
}
|
||||
|
||||
fn v14_to_v15(metadata: v14::RuntimeMetadataV14) -> v15::RuntimeMetadataV15 {
|
||||
v15::RuntimeMetadataV15 {
|
||||
types: metadata.types,
|
||||
pallets: metadata
|
||||
.pallets
|
||||
.into_iter()
|
||||
.map(|pallet| frame_metadata::v15::PalletMetadata {
|
||||
name: pallet.name,
|
||||
storage: pallet
|
||||
.storage
|
||||
.map(|storage| frame_metadata::v15::PalletStorageMetadata {
|
||||
prefix: storage.prefix,
|
||||
entries: storage
|
||||
.entries
|
||||
.into_iter()
|
||||
.map(|entry| {
|
||||
let modifier = match entry.modifier {
|
||||
frame_metadata::v14::StorageEntryModifier::Optional => {
|
||||
frame_metadata::v15::StorageEntryModifier::Optional
|
||||
}
|
||||
frame_metadata::v14::StorageEntryModifier::Default => {
|
||||
frame_metadata::v15::StorageEntryModifier::Default
|
||||
}
|
||||
};
|
||||
|
||||
let ty = match entry.ty {
|
||||
frame_metadata::v14::StorageEntryType::Plain(ty) => {
|
||||
frame_metadata::v15::StorageEntryType::Plain(ty)
|
||||
},
|
||||
frame_metadata::v14::StorageEntryType::Map {
|
||||
hashers,
|
||||
key,
|
||||
value,
|
||||
} => frame_metadata::v15::StorageEntryType::Map {
|
||||
hashers: hashers.into_iter().map(|hasher| match hasher {
|
||||
frame_metadata::v14::StorageHasher::Blake2_128 => frame_metadata::v15::StorageHasher::Blake2_128,
|
||||
frame_metadata::v14::StorageHasher::Blake2_256 => frame_metadata::v15::StorageHasher::Blake2_256,
|
||||
frame_metadata::v14::StorageHasher::Blake2_128Concat => frame_metadata::v15::StorageHasher::Blake2_128Concat ,
|
||||
frame_metadata::v14::StorageHasher::Twox128 => frame_metadata::v15::StorageHasher::Twox128,
|
||||
frame_metadata::v14::StorageHasher::Twox256 => frame_metadata::v15::StorageHasher::Twox256,
|
||||
frame_metadata::v14::StorageHasher::Twox64Concat => frame_metadata::v15::StorageHasher::Twox64Concat,
|
||||
frame_metadata::v14::StorageHasher::Identity=> frame_metadata::v15::StorageHasher::Identity,
|
||||
}).collect(),
|
||||
key,
|
||||
value,
|
||||
},
|
||||
};
|
||||
|
||||
frame_metadata::v15::StorageEntryMetadata {
|
||||
name: entry.name,
|
||||
modifier,
|
||||
ty,
|
||||
default: entry.default,
|
||||
docs: entry.docs,
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
}),
|
||||
calls: pallet.calls.map(|calls| frame_metadata::v15::PalletCallMetadata { ty: calls.ty } ),
|
||||
event: pallet.event.map(|event| frame_metadata::v15::PalletEventMetadata { ty: event.ty } ),
|
||||
constants: pallet.constants.into_iter().map(|constant| frame_metadata::v15::PalletConstantMetadata {
|
||||
name: constant.name,
|
||||
ty: constant.ty,
|
||||
value: constant.value,
|
||||
docs: constant.docs,
|
||||
} ).collect(),
|
||||
error: pallet.error.map(|error| frame_metadata::v15::PalletErrorMetadata { ty: error.ty } ),
|
||||
index: pallet.index,
|
||||
docs: Default::default(),
|
||||
})
|
||||
.collect(),
|
||||
extrinsic: frame_metadata::v15::ExtrinsicMetadata {
|
||||
ty: metadata.extrinsic.ty,
|
||||
version: metadata.extrinsic.version,
|
||||
signed_extensions: metadata.extrinsic.signed_extensions.into_iter().map(|ext| {
|
||||
frame_metadata::v15::SignedExtensionMetadata {
|
||||
identifier: ext.identifier,
|
||||
ty: ext.ty,
|
||||
additional_signed: ext.additional_signed,
|
||||
}
|
||||
}).collect()
|
||||
},
|
||||
ty: metadata.ty,
|
||||
apis: Default::default(),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,390 @@
|
||||
// Copyright 2019-2023 Parity Technologies (UK) Ltd.
|
||||
// This file is dual-licensed as Apache-2.0 or GPL-3.0.
|
||||
// see LICENSE for license details.
|
||||
|
||||
use super::TryFromError;
|
||||
use crate::utils::variant_index::VariantIndex;
|
||||
use crate::{
|
||||
utils::ordered_map::OrderedMap, ArcStr, ConstantMetadata, ExtrinsicMetadata, Metadata,
|
||||
PalletMetadataInner, RuntimeApiMetadataInner, RuntimeApiMethodMetadata,
|
||||
RuntimeApiMethodParamMetadata, SignedExtensionMetadata, StorageEntryMetadata,
|
||||
StorageEntryModifier, StorageEntryType, StorageHasher, StorageMetadata,
|
||||
};
|
||||
use frame_metadata::v15;
|
||||
use scale_info::form::PortableForm;
|
||||
use std::collections::HashMap;
|
||||
|
||||
// Converting from V15 metadata into our Subxt repr.
|
||||
mod from_v15 {
|
||||
use super::*;
|
||||
|
||||
impl TryFrom<v15::RuntimeMetadataV15> for Metadata {
|
||||
type Error = TryFromError;
|
||||
fn try_from(m: v15::RuntimeMetadataV15) -> Result<Self, TryFromError> {
|
||||
let mut pallets = OrderedMap::new();
|
||||
let mut pallets_by_index = HashMap::new();
|
||||
for (pos, p) in m.pallets.into_iter().enumerate() {
|
||||
let name: ArcStr = p.name.into();
|
||||
|
||||
let storage = p.storage.map(|s| StorageMetadata {
|
||||
prefix: s.prefix,
|
||||
entries: s
|
||||
.entries
|
||||
.into_iter()
|
||||
.map(|s| {
|
||||
let name: ArcStr = s.name.clone().into();
|
||||
(name.clone(), from_storage_entry_metadata(name, s))
|
||||
})
|
||||
.collect(),
|
||||
});
|
||||
let constants = p.constants.into_iter().map(|c| {
|
||||
let name: ArcStr = c.name.clone().into();
|
||||
(name.clone(), from_constant_metadata(name, c))
|
||||
});
|
||||
|
||||
let call_variant_index =
|
||||
VariantIndex::build(p.calls.as_ref().map(|c| c.ty.id), &m.types);
|
||||
let error_variant_index =
|
||||
VariantIndex::build(p.error.as_ref().map(|e| e.ty.id), &m.types);
|
||||
let event_variant_index =
|
||||
VariantIndex::build(p.event.as_ref().map(|e| e.ty.id), &m.types);
|
||||
|
||||
pallets_by_index.insert(p.index, pos);
|
||||
pallets.push_insert(
|
||||
name.clone(),
|
||||
PalletMetadataInner {
|
||||
name,
|
||||
index: p.index,
|
||||
storage,
|
||||
call_ty: p.calls.map(|c| c.ty.id),
|
||||
call_variant_index,
|
||||
event_ty: p.event.map(|e| e.ty.id),
|
||||
event_variant_index,
|
||||
error_ty: p.error.map(|e| e.ty.id),
|
||||
error_variant_index,
|
||||
constants: constants.collect(),
|
||||
docs: p.docs,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
let apis = m.apis.into_iter().map(|api| {
|
||||
let name: ArcStr = api.name.clone().into();
|
||||
(name.clone(), from_runtime_api_metadata(name, api))
|
||||
});
|
||||
|
||||
let dispatch_error_ty = m
|
||||
.types
|
||||
.types
|
||||
.iter()
|
||||
.find(|ty| ty.ty.path.segments == ["sp_runtime", "DispatchError"])
|
||||
.map(|ty| ty.id);
|
||||
|
||||
Ok(Metadata {
|
||||
types: m.types,
|
||||
pallets,
|
||||
pallets_by_index,
|
||||
extrinsic: from_extrinsic_metadata(m.extrinsic),
|
||||
runtime_ty: m.ty.id,
|
||||
dispatch_error_ty,
|
||||
apis: apis.collect(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn from_signed_extension_metadata(
|
||||
value: v15::SignedExtensionMetadata<PortableForm>,
|
||||
) -> SignedExtensionMetadata {
|
||||
SignedExtensionMetadata {
|
||||
identifier: value.identifier,
|
||||
extra_ty: value.ty.id,
|
||||
additional_ty: value.additional_signed.id,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_extrinsic_metadata(value: v15::ExtrinsicMetadata<PortableForm>) -> ExtrinsicMetadata {
|
||||
ExtrinsicMetadata {
|
||||
ty: value.ty.id,
|
||||
version: value.version,
|
||||
signed_extensions: value
|
||||
.signed_extensions
|
||||
.into_iter()
|
||||
.map(from_signed_extension_metadata)
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_hasher(value: v15::StorageHasher) -> StorageHasher {
|
||||
match value {
|
||||
v15::StorageHasher::Blake2_128 => StorageHasher::Blake2_128,
|
||||
v15::StorageHasher::Blake2_256 => StorageHasher::Blake2_256,
|
||||
v15::StorageHasher::Blake2_128Concat => StorageHasher::Blake2_128Concat,
|
||||
v15::StorageHasher::Twox128 => StorageHasher::Twox128,
|
||||
v15::StorageHasher::Twox256 => StorageHasher::Twox256,
|
||||
v15::StorageHasher::Twox64Concat => StorageHasher::Twox64Concat,
|
||||
v15::StorageHasher::Identity => StorageHasher::Identity,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_entry_type(value: v15::StorageEntryType<PortableForm>) -> StorageEntryType {
|
||||
match value {
|
||||
v15::StorageEntryType::Plain(ty) => StorageEntryType::Plain(ty.id),
|
||||
v15::StorageEntryType::Map {
|
||||
hashers,
|
||||
key,
|
||||
value,
|
||||
} => StorageEntryType::Map {
|
||||
hashers: hashers.into_iter().map(from_storage_hasher).collect(),
|
||||
key_ty: key.id,
|
||||
value_ty: value.id,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_entry_modifier(value: v15::StorageEntryModifier) -> StorageEntryModifier {
|
||||
match value {
|
||||
v15::StorageEntryModifier::Optional => StorageEntryModifier::Optional,
|
||||
v15::StorageEntryModifier::Default => StorageEntryModifier::Default,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_entry_metadata(
|
||||
name: ArcStr,
|
||||
s: v15::StorageEntryMetadata<PortableForm>,
|
||||
) -> StorageEntryMetadata {
|
||||
StorageEntryMetadata {
|
||||
name,
|
||||
modifier: from_storage_entry_modifier(s.modifier),
|
||||
entry_type: from_storage_entry_type(s.ty),
|
||||
default: s.default,
|
||||
docs: s.docs,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_constant_metadata(
|
||||
name: ArcStr,
|
||||
s: v15::PalletConstantMetadata<PortableForm>,
|
||||
) -> ConstantMetadata {
|
||||
ConstantMetadata {
|
||||
name,
|
||||
ty: s.ty.id,
|
||||
value: s.value,
|
||||
docs: s.docs,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_runtime_api_metadata(
|
||||
name: ArcStr,
|
||||
s: v15::RuntimeApiMetadata<PortableForm>,
|
||||
) -> RuntimeApiMetadataInner {
|
||||
RuntimeApiMetadataInner {
|
||||
name,
|
||||
docs: s.docs,
|
||||
methods: s
|
||||
.methods
|
||||
.into_iter()
|
||||
.map(|m| {
|
||||
let name: ArcStr = m.name.clone().into();
|
||||
(name.clone(), from_runtime_api_method_metadata(name, m))
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
fn from_runtime_api_method_metadata(
|
||||
name: ArcStr,
|
||||
s: v15::RuntimeApiMethodMetadata<PortableForm>,
|
||||
) -> RuntimeApiMethodMetadata {
|
||||
RuntimeApiMethodMetadata {
|
||||
name,
|
||||
inputs: s
|
||||
.inputs
|
||||
.into_iter()
|
||||
.map(from_runtime_api_method_param_metadata)
|
||||
.collect(),
|
||||
output_ty: s.output.id,
|
||||
docs: s.docs,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_runtime_api_method_param_metadata(
|
||||
s: v15::RuntimeApiMethodParamMetadata<PortableForm>,
|
||||
) -> RuntimeApiMethodParamMetadata {
|
||||
RuntimeApiMethodParamMetadata {
|
||||
name: s.name,
|
||||
ty: s.ty.id,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Converting from our metadata repr to V15 metadata.
|
||||
mod into_v15 {
|
||||
use super::*;
|
||||
|
||||
impl From<Metadata> for v15::RuntimeMetadataV15 {
|
||||
fn from(m: Metadata) -> Self {
|
||||
let pallets = m.pallets.into_values().into_iter().map(|p| {
|
||||
let storage = p.storage.map(|s| v15::PalletStorageMetadata {
|
||||
prefix: s.prefix,
|
||||
entries: s
|
||||
.entries
|
||||
.into_values()
|
||||
.into_iter()
|
||||
.map(from_storage_entry_metadata)
|
||||
.collect(),
|
||||
});
|
||||
|
||||
v15::PalletMetadata {
|
||||
name: (*p.name).to_owned(),
|
||||
calls: p
|
||||
.call_ty
|
||||
.map(|id| v15::PalletCallMetadata { ty: id.into() }),
|
||||
event: p
|
||||
.event_ty
|
||||
.map(|id| v15::PalletEventMetadata { ty: id.into() }),
|
||||
error: p
|
||||
.error_ty
|
||||
.map(|id| v15::PalletErrorMetadata { ty: id.into() }),
|
||||
storage,
|
||||
constants: p
|
||||
.constants
|
||||
.into_values()
|
||||
.into_iter()
|
||||
.map(from_constant_metadata)
|
||||
.collect(),
|
||||
index: p.index,
|
||||
docs: p.docs,
|
||||
}
|
||||
});
|
||||
|
||||
v15::RuntimeMetadataV15 {
|
||||
types: m.types,
|
||||
pallets: pallets.collect(),
|
||||
ty: m.runtime_ty.into(),
|
||||
extrinsic: from_extrinsic_metadata(m.extrinsic),
|
||||
apis: m
|
||||
.apis
|
||||
.into_values()
|
||||
.into_iter()
|
||||
.map(from_runtime_api_metadata)
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn from_runtime_api_metadata(
|
||||
r: RuntimeApiMetadataInner,
|
||||
) -> v15::RuntimeApiMetadata<PortableForm> {
|
||||
v15::RuntimeApiMetadata {
|
||||
name: (*r.name).to_owned(),
|
||||
methods: r
|
||||
.methods
|
||||
.into_values()
|
||||
.into_iter()
|
||||
.map(from_runtime_api_method_metadata)
|
||||
.collect(),
|
||||
docs: r.docs,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_runtime_api_method_metadata(
|
||||
m: RuntimeApiMethodMetadata,
|
||||
) -> v15::RuntimeApiMethodMetadata<PortableForm> {
|
||||
v15::RuntimeApiMethodMetadata {
|
||||
name: (*m.name).to_owned(),
|
||||
inputs: m
|
||||
.inputs
|
||||
.into_iter()
|
||||
.map(from_runtime_api_method_param_metadata)
|
||||
.collect(),
|
||||
output: m.output_ty.into(),
|
||||
docs: m.docs,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_runtime_api_method_param_metadata(
|
||||
p: RuntimeApiMethodParamMetadata,
|
||||
) -> v15::RuntimeApiMethodParamMetadata<PortableForm> {
|
||||
v15::RuntimeApiMethodParamMetadata {
|
||||
name: p.name,
|
||||
ty: p.ty.into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn from_extrinsic_metadata(e: ExtrinsicMetadata) -> v15::ExtrinsicMetadata<PortableForm> {
|
||||
v15::ExtrinsicMetadata {
|
||||
ty: e.ty.into(),
|
||||
version: e.version,
|
||||
signed_extensions: e
|
||||
.signed_extensions
|
||||
.into_iter()
|
||||
.map(from_signed_extension_metadata)
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
fn from_signed_extension_metadata(
|
||||
s: SignedExtensionMetadata,
|
||||
) -> v15::SignedExtensionMetadata<PortableForm> {
|
||||
v15::SignedExtensionMetadata {
|
||||
identifier: s.identifier,
|
||||
ty: s.extra_ty.into(),
|
||||
additional_signed: s.additional_ty.into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn from_constant_metadata(c: ConstantMetadata) -> v15::PalletConstantMetadata<PortableForm> {
|
||||
v15::PalletConstantMetadata {
|
||||
name: (*c.name).to_owned(),
|
||||
ty: c.ty.into(),
|
||||
value: c.value,
|
||||
docs: c.docs,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_entry_metadata(
|
||||
s: StorageEntryMetadata,
|
||||
) -> v15::StorageEntryMetadata<PortableForm> {
|
||||
v15::StorageEntryMetadata {
|
||||
docs: s.docs,
|
||||
default: s.default,
|
||||
name: (*s.name).to_owned(),
|
||||
ty: from_storage_entry_type(s.entry_type),
|
||||
modifier: from_storage_entry_modifier(s.modifier),
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_entry_modifier(s: StorageEntryModifier) -> v15::StorageEntryModifier {
|
||||
match s {
|
||||
StorageEntryModifier::Default => v15::StorageEntryModifier::Default,
|
||||
StorageEntryModifier::Optional => v15::StorageEntryModifier::Optional,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_entry_type(s: StorageEntryType) -> v15::StorageEntryType<PortableForm> {
|
||||
match s {
|
||||
StorageEntryType::Plain(ty) => v15::StorageEntryType::Plain(ty.into()),
|
||||
StorageEntryType::Map {
|
||||
hashers,
|
||||
key_ty,
|
||||
value_ty,
|
||||
} => v15::StorageEntryType::Map {
|
||||
hashers: hashers.into_iter().map(from_storage_hasher).collect(),
|
||||
key: key_ty.into(),
|
||||
value: value_ty.into(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn from_storage_hasher(s: StorageHasher) -> v15::StorageHasher {
|
||||
match s {
|
||||
StorageHasher::Blake2_128 => v15::StorageHasher::Blake2_128,
|
||||
StorageHasher::Blake2_256 => v15::StorageHasher::Blake2_256,
|
||||
StorageHasher::Blake2_128Concat => v15::StorageHasher::Blake2_128Concat,
|
||||
StorageHasher::Twox128 => v15::StorageHasher::Twox128,
|
||||
StorageHasher::Twox256 => v15::StorageHasher::Twox256,
|
||||
StorageHasher::Twox64Concat => v15::StorageHasher::Twox64Concat,
|
||||
StorageHasher::Identity => v15::StorageHasher::Identity,
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user