From dd44adad30ebb489674b2a0758c26320747ff3af Mon Sep 17 00:00:00 2001 From: James Wilson Date: Tue, 11 Nov 2025 16:50:32 +0000 Subject: [PATCH 01/14] First pass converting historic metadatas to our subxt::Metadata type --- Cargo.lock | 4 +- Cargo.toml | 3 + core/src/blocks/extrinsics.rs | 2 +- core/src/events.rs | 4 +- core/src/tx/payload.rs | 2 +- metadata/Cargo.toml | 7 +- metadata/src/from/legacy/mod.rs | 398 ++++++++++++++++++ .../from/legacy/portable_registry_builder.rs | 352 ++++++++++++++++ metadata/src/from/mod.rs | 4 + metadata/src/from/v14.rs | 8 +- metadata/src/from/v15.rs | 8 +- metadata/src/from/v16.rs | 8 +- metadata/src/lib.rs | 137 +++++- subxt/src/error/dispatch_error.rs | 2 +- 14 files changed, 913 insertions(+), 26 deletions(-) create mode 100644 metadata/src/from/legacy/mod.rs create mode 100644 metadata/src/from/legacy/portable_registry_builder.rs diff --git a/Cargo.lock b/Cargo.lock index 4aba7f6e1e..cc80aeeffa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1954,8 +1954,6 @@ dependencies = [ [[package]] name = "frame-decode" version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e5c3badfabd704dda4ddc7fafcd09127e8661d1cca2f16556c6826166932c87" dependencies = [ "frame-metadata 23.0.0", "parity-scale-codec", @@ -5800,6 +5798,8 @@ dependencies = [ "hashbrown 0.14.5", "parity-scale-codec", "scale-info", + "scale-info-legacy", + "scale-type-resolver", "sp-crypto-hashing", "subxt-utils-stripmetadata", "thiserror 2.0.12", diff --git a/Cargo.toml b/Cargo.toml index d31a168b40..f7054ff695 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -192,3 +192,6 @@ opt-level = 2 opt-level = 2 [profile.test.package.smoldot] opt-level = 2 + +[patch.crates-io] +frame-decode = { path = "../frame-decode" } \ No newline at end of file diff --git a/core/src/blocks/extrinsics.rs b/core/src/blocks/extrinsics.rs index 77f6f7c26d..94de10ade3 100644 --- a/core/src/blocks/extrinsics.rs +++ b/core/src/blocks/extrinsics.rs @@ -494,7 +494,7 @@ mod tests { let metadata = metadata(); // Except our metadata to contain the registered types. - let pallet = metadata.pallet_by_index(0).expect("pallet exists"); + let pallet = metadata.pallet_by_call_index(0).expect("pallet exists"); let extrinsic = pallet .call_variant_by_index(2) .expect("metadata contains the RuntimeCall enum with this pallet"); diff --git a/core/src/events.rs b/core/src/events.rs index e6246cbce3..9d38517910 100644 --- a/core/src/events.rs +++ b/core/src/events.rs @@ -262,7 +262,7 @@ impl EventDetails { // Get metadata for the event: let event_pallet = metadata - .pallet_by_index(pallet_index) + .pallet_by_event_index(pallet_index) .ok_or_else(|| EventsError::CannotFindPalletWithIndex(pallet_index))?; let event_variant = event_pallet .event_variant_by_index(variant_index) @@ -359,7 +359,7 @@ impl EventDetails { pub fn event_metadata(&self) -> EventMetadataDetails<'_> { let pallet = self .metadata - .pallet_by_index(self.pallet_index()) + .pallet_by_event_index(self.pallet_index()) .expect("event pallet to be found; we did this already during decoding"); let variant = pallet .event_variant_by_index(self.variant_index()) diff --git a/core/src/tx/payload.rs b/core/src/tx/payload.rs index 765ef64967..e87c38a98f 100644 --- a/core/src/tx/payload.rs +++ b/core/src/tx/payload.rs @@ -182,7 +182,7 @@ impl Payload for DefaultPayload { call_name: self.call_name.to_string(), })?; - let pallet_index = pallet.index(); + let pallet_index = pallet.call_index(); let call_index = call.index; pallet_index.encode_to(out); diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml index 425dc6698d..dc6d50ddb9 100644 --- a/metadata/Cargo.toml +++ b/metadata/Cargo.toml @@ -14,11 +14,16 @@ homepage.workspace = true description = "Command line utilities for checking metadata compatibility between nodes." [features] -default = ["std"] +default = ["std", "legacy"] std = ["scale-info/std", "frame-metadata/std"] +# Enable decoding of legacy metadata, too. +legacy = ["dep:scale-info-legacy", "dep:scale-type-resolver"] + [dependencies] scale-info = { workspace = true, default-features = false } +scale-info-legacy = { workspace = true, optional = true } +scale-type-resolver = { workspace = true, optional = true } frame-decode = { workspace = true } frame-metadata = { workspace = true, default-features = false, features = ["current", "decode"] } codec = { package = "parity-scale-codec", workspace = true, default-features = false, features = ["derive"] } diff --git a/metadata/src/from/legacy/mod.rs b/metadata/src/from/legacy/mod.rs new file mode 100644 index 0000000000..a66bc357b5 --- /dev/null +++ b/metadata/src/from/legacy/mod.rs @@ -0,0 +1,398 @@ +mod portable_registry_builder; + +use crate::Metadata; +use crate::utils::ordered_map::OrderedMap; +use crate::utils::variant_index::VariantIndex; +use portable_registry_builder::PortableRegistryBuilder; +use alloc::borrow::ToOwned; +use alloc::vec::Vec; +use alloc::string::ToString; +use alloc::format; +use alloc::collections::BTreeMap; +use scale_info_legacy::type_registry::RuntimeApiName; +use frame_metadata::v15; +use scale_info_legacy::TypeRegistrySet; +use frame_decode::storage::StorageTypeInfo; +use frame_decode::extrinsics::ExtrinsicTypeInfo; +use frame_decode::runtime_apis::RuntimeApiTypeInfo; +use frame_decode::constants::ConstantTypeInfo; + +macro_rules! from_vx_to_vx { + ($vis:vis fn $fn_name:ident($metadata:path $(, builtin_index: $builtin_index:ident)? )) => { + $vis fn $fn_name(metadata: &$metadata, mut types: TypeRegistrySet<'_>) -> Result { + // Extend the types with important information from the metadata: + { + let builtin_types = frame_decode::helpers::type_registry_from_metadata(metadata) + .map_err(Error::CannotEnhanceTypesFromMetadata)?; + types.prepend(builtin_types); + } + + // This will be used to construct our `PortableRegistry` from old-style types. + let mut portable_registry_builder = PortableRegistryBuilder::new(&types); + + // We use this type in a few places to denote that we don't know how to decode it. + let unknown_type_id = portable_registry_builder.add_type_str("special::Unknown", None) + .map_err(|e| Error::add_type("constructing 'Unknown' type", e))?; + + // Pallet metadata + let mut call_index = 0u8; + let mut error_index = 0u8; + let mut event_index = 0u8; + + let new_pallets = as_decoded(&metadata.modules).iter().map(|pallet| { + // In older metadatas, calls and event enums can have different indexes + // in a given pallet. Pallets without calls or events don't increment + // the respective index for them. + // + // We assume since errors are non optional, that the pallet index _always_ + // increments for errors (no `None`s to skip). + let (call_index, event_index, error_index) = { + let out = (call_index, event_index, error_index); + if pallet.calls.is_some() { + call_index += 1; + } + if pallet.event.is_some() { + event_index += 1; + } + error_index += 1; + + out + }; + + // For v12 and v13 metadata, there is a builtin index for everything in a pallet. + // We enable this logic for those metadatas to get the correct index. + $( + let $builtin_index = true; + let (call_index, event_index, error_index) = if $builtin_index { + (pallet.index, pallet.index, pallet.index) + } else { + (call_index, event_index, error_index) + }; + )? + + let pallet_name = as_decoded(&pallet.name).to_string(); + + // Storage entries: + let storage = pallet.storage.as_ref().map(|s| { + let storage = as_decoded(s); + let prefix = as_decoded(&storage.prefix); + let entries = metadata.storage_entries_in_pallet(&pallet_name).map(|entry_name| { + let info = metadata + .storage_info(&pallet_name, &entry_name) + .map_err(|e| Error::StorageInfoError(e.into_owned()))?; + let entry_name = entry_name.into_owned(); + + let info = info.map_ids(|old_id| { + portable_registry_builder.add_type(old_id) + }).map_err(|e| { + let ctx = format!("adding type used in storage entry {pallet_name}.{entry_name}"); + Error::add_type(ctx, e) + })?; + + let entry = crate::StorageEntryMetadata { + name: entry_name.clone(), + info: info.into_owned(), + // We don't expose docs via our storage info yet. + docs: Vec::new(), + }; + + Ok((entry_name, entry)) + }).collect::, _>>()?; + + Ok(crate::StorageMetadata { + prefix: prefix.clone(), + entries, + }) + }).transpose()?; + + // Pallet error type is just a builtin type: + let error_ty = portable_registry_builder.add_type_str(&format!("builtin::module::error::{pallet_name}"), None) + .map_err(|e| { + let ctx = format!("converting the error enum for pallet {pallet_name}"); + Error::add_type(ctx, e) + })?; + + // Pallet calls also just a builtin type: + let call_ty = pallet.calls.as_ref().map(|_| { + portable_registry_builder.add_type_str(&format!("builtin::module::call::{pallet_name}"), None) + .map_err(|e| { + let ctx = format!("converting the call enum for pallet {pallet_name}"); + Error::add_type(ctx, e) + }) + }).transpose()?; + + // Pallet events also just a builtin type: + let event_ty = pallet.event.as_ref().map(|_| { + portable_registry_builder.add_type_str(&format!("builtin::module::event::{pallet_name}"), None) + .map_err(|e| { + let ctx = format!("converting the event enum for pallet {pallet_name}"); + Error::add_type(ctx, e) + }) + }).transpose()?; + + let call_variant_index = + VariantIndex::build(call_ty, portable_registry_builder.types()); + let error_variant_index = + VariantIndex::build(Some(error_ty), portable_registry_builder.types()); + let event_variant_index = + VariantIndex::build(event_ty, portable_registry_builder.types()); + + let constants = metadata.constants_in_pallet(&pallet_name).map(|name| { + let name = name.into_owned(); + let info = metadata.constant_info(&pallet_name, &name) + .map_err(|e| Error::ConstantInfoError(e.into_owned()))?; + let new_type_id = portable_registry_builder.add_type(info.type_id) + .map_err(|e| { + let ctx = format!("converting the constant {name} for pallet {pallet_name}"); + Error::add_type(ctx, e) + })?; + + let constant = crate::ConstantMetadata { + name: name.clone(), + ty: new_type_id, + value: info.bytes.to_vec(), + // We don't expose docs via our constant info yet. + docs: Vec::new(), + }; + + Ok((name, constant)) + }).collect::>()?; + + let pallet_metadata = crate::PalletMetadataInner { + name: pallet_name.clone(), + call_index, + event_index, + error_index, + storage, + error_ty: Some(error_ty), + call_ty, + event_ty, + call_variant_index, + error_variant_index, + event_variant_index, + constants, + view_functions: Default::default(), + associated_types: Default::default(), + // Pallets did not have docs prior to V15. + docs: Default::default(), + }; + + Ok((pallet_name, pallet_metadata)) + }).collect::,Error>>()?; + + // Extrinsic metadata + let new_extrinsic = { + let signature_info = metadata + .extrinsic_signature_info() + .map_err(|e| Error::ExtrinsicInfoError(e.into_owned()))?; + + let address_ty_id = portable_registry_builder.add_type(signature_info.address_id) + .map_err(|_| Error::CannotFindAddressType)?; + + let signature_ty_id = portable_registry_builder.add_type(signature_info.signature_id) + .map_err(|_| Error::CannotFindCallType)?; + + let transaction_extensions = metadata + .extrinsic_extension_info(None) + .map_err(|e| Error::ExtrinsicInfoError(e.into_owned()))? + .extension_ids + .into_iter() + .map(|ext| { + let ext_name = ext.name.into_owned(); + let ext_type = portable_registry_builder.add_type(ext.id) + .map_err(|e| { + let ctx = format!("converting the signed extension {ext_name}"); + Error::add_type(ctx, e) + })?; + + Ok(crate::TransactionExtensionMetadataInner { + identifier: ext_name, + extra_ty: ext_type, + // This only started existing in V14+ metadata, but in any case, + // we don't need to know how to decode the signed payload for + // historic blocks (hopefully), so set to unknown. + additional_ty: unknown_type_id.into() + }) + }) + .collect::,Error>>()?; + + let transaction_extensions_by_version = BTreeMap::from_iter([( + 0, + (0..transaction_extensions.len() as u32).collect() + )]); + + crate::ExtrinsicMetadata { + address_ty: address_ty_id.into(), + signature_ty: signature_ty_id.into(), + supported_versions: Vec::from_iter([4]), + transaction_extensions, + transaction_extensions_by_version, + } + }; + + // Outer enum types + let outer_enums = crate::OuterEnumsMetadata { + call_enum_ty: portable_registry_builder.add_type_str("builtin::Call", None) + .map_err(|e| { + let ctx = format!("constructing the 'builtin::Call' type to put in the OuterEnums metadata"); + Error::add_type(ctx, e) + })?, + event_enum_ty: portable_registry_builder.add_type_str("builtin::Event", None) + .map_err(|e| { + let ctx = format!("constructing the 'builtin::Event' type to put in the OuterEnums metadata"); + Error::add_type(ctx, e) + })?, + error_enum_ty: portable_registry_builder.add_type_str("builtin::Error", None) + .map_err(|e| { + let ctx = format!("constructing the 'builtin::Error' type to put in the OuterEnums metadata"); + Error::add_type(ctx, e) + })?, + }; + + // These are all the same in V13, but be explicit anyway for clarity. + let pallets_by_call_index = new_pallets + .values() + .iter() + .enumerate() + .map(|(idx,p)| (p.call_index, idx)) + .collect(); + let pallets_by_error_index = new_pallets + .values() + .iter() + .enumerate() + .map(|(idx,p)| (p.error_index, idx)) + .collect(); + let pallets_by_event_index = new_pallets + .values() + .iter() + .enumerate() + .map(|(idx,p)| (p.event_index, idx)) + .collect(); + + // This is optional in the sense that Subxt will return an error if it needs to decode this type, + // and I think for historic metadata we wouldn't end up down that path anyway. Historic metadata + // tends to call it just "DispatchError" but search more specific paths first. + let dispatch_error_ty = portable_registry_builder + .try_add_type_str("hardcoded::DispatchError", None) + .or_else(|| portable_registry_builder.try_add_type_str("sp_runtime::DispatchError", None)) + .or_else(|| portable_registry_builder.try_add_type_str("DispatchError", None)) + .transpose() + .map_err(|e| Error::add_type("constructing DispatchError", e))?; + + // Runtime API definitions live with type definitions. + let apis = type_registry_to_runtime_apis(&types, &mut portable_registry_builder)?; + + Ok(crate::Metadata { + types: portable_registry_builder.finish(), + pallets: new_pallets, + pallets_by_call_index, + pallets_by_error_index, + pallets_by_event_index, + extrinsic: new_extrinsic, + outer_enums, + dispatch_error_ty, + apis, + // Nothing custom existed in V13 + custom: v15::CustomMetadata { map: Default::default() }, + }) + }} +} + +from_vx_to_vx!(pub fn from_v13(frame_metadata::v13::RuntimeMetadataV13, builtin_index: yes)); +from_vx_to_vx!(pub fn from_v12(frame_metadata::v12::RuntimeMetadataV12, builtin_index: yes)); +from_vx_to_vx!(pub fn from_v11(frame_metadata::v11::RuntimeMetadataV11)); +from_vx_to_vx!(pub fn from_v10(frame_metadata::v10::RuntimeMetadataV10)); +from_vx_to_vx!(pub fn from_v9(frame_metadata::v9::RuntimeMetadataV9)); +from_vx_to_vx!(pub fn from_v8(frame_metadata::v8::RuntimeMetadataV8)); + +fn as_decoded(item: &frame_metadata::decode_different::DecodeDifferent) -> &B { + match item { + frame_metadata::decode_different::DecodeDifferent::Encode(_a) => { + panic!("Expecting decoded data") + } + frame_metadata::decode_different::DecodeDifferent::Decoded(b) => b, + } +} + +// Obtain Runtime API information from some type registry. +pub fn type_registry_to_runtime_apis( + types: &TypeRegistrySet<'_>, + portable_registry_builder: &mut PortableRegistryBuilder +) -> Result, Error> { + let mut apis = OrderedMap::new(); + let mut trait_name = ""; + let mut trait_methods = OrderedMap::new(); + + for api in types.runtime_apis() { + match api { + RuntimeApiName::Trait(name) => { + if !trait_methods.is_empty() { + apis.push_insert(trait_name.into(), crate::RuntimeApiMetadataInner { + name: trait_name.into(), + methods: trait_methods, + docs: Vec::new() + }); + } + trait_methods = OrderedMap::new(); + trait_name = name; + }, + RuntimeApiName::Method(name) => { + let info = types + .runtime_api_info(trait_name, name) + .map_err(|e| Error::RuntimeApiInfoError(e.into_owned()))?; + + let info = info.map_ids(|id| { + portable_registry_builder + .add_type(id) + .map_err(|e| { + let c = format!("converting type for runtime API {trait_name}.{name}"); + Error::add_type(c, e) + }) + })?; + + trait_methods.push_insert(name.to_owned(), crate::RuntimeApiMethodMetadataInner { + name: name.into(), + info, + docs: Vec::new(), + }); + } + } + } + + Ok(apis) +} + +/// An error encountered converting some legacy metadata to our internal format. +#[allow(missing_docs)] +#[derive(Debug, thiserror::Error)] +pub enum Error { + /// Cannot add a type. + #[error("Cannot add type ({context}): {error}")] + AddTypeError { + context: String, + error: portable_registry_builder::PortableRegistryAddTypeError + }, + #[error("Cannot enhance the types with information from metadata: {0}")] + CannotEnhanceTypesFromMetadata(scale_info_legacy::lookup_name::ParseError), + #[error("Cannot find 'hardcoded::ExtrinsicAddress' type in legacy types")] + CannotFindAddressType, + #[error("Cannot find 'hardcoded::ExtrinsicSignature' type in legacy types")] + CannotFindSignatureType, + #[error("Cannot find 'builtin::Call' type in legacy types (this should have been automatically added)")] + CannotFindCallType, + #[error("Cannot obtain the storage information we need to convert storage entries")] + StorageInfoError(frame_decode::storage::StorageInfoError<'static>), + #[error("Cannot obtain the extrinsic information we need to convert transaction extensions")] + ExtrinsicInfoError(frame_decode::extrinsics::ExtrinsicInfoError<'static>), + #[error("Cannot obtain the Runtime API information we need")] + RuntimeApiInfoError(frame_decode::runtime_apis::RuntimeApiInfoError<'static>), + #[error("Cannot obtain the Constant information we need")] + ConstantInfoError(frame_decode::constants::ConstantInfoError<'static>), +} + +impl Error { + /// A shorthand for the [`Error::AddTypeError`] variant. + fn add_type(context: impl Into, error: impl Into) -> Self { + Error::AddTypeError { context: context.into(), error: error.into() } + } +} diff --git a/metadata/src/from/legacy/portable_registry_builder.rs b/metadata/src/from/legacy/portable_registry_builder.rs new file mode 100644 index 0000000000..938fcfb796 --- /dev/null +++ b/metadata/src/from/legacy/portable_registry_builder.rs @@ -0,0 +1,352 @@ +use alloc::vec::Vec; +use alloc::collections::BTreeMap; +use scale_info::PortableRegistry; +use scale_info_legacy::{ TypeRegistrySet, LookupName }; +use scale_type_resolver::{ + ResolvedTypeVisitor, + UnhandledKind, + PathIter, + FieldIter, + VariantIter, + Primitive, + BitsOrderFormat, + BitsStoreFormat, +}; +use scale_info::{ PortableType, form::PortableForm }; +use scale_info_legacy::type_registry::TypeRegistryResolveError; +use alloc::string::ToString; +use alloc::borrow::ToOwned; + +#[derive(thiserror::Error, Debug)] +pub enum PortableRegistryAddTypeError { + #[error("Error resolving type: {0}")] + ResolveError(#[from] TypeRegistryResolveError), + #[error("Cannot find type '{0}'")] + TypeNotFound(LookupName) +} + +/// the purpose of this is to convert a (subset of) [`scale_info_legacy::TypeRegistrySet`] +/// into a [`scale_info::PortableRegistry`]. Type IDs from the former are passed in, and +/// type IDs from the latter are handed back. Calling [`PortableRegistryBuilder::finish()`] +/// then hands back a [`scale_info::PortableRegistry`] which these Ids can be used with. +pub struct PortableRegistryBuilder<'info> { + legacy_types: &'info TypeRegistrySet<'info>, + scale_info_types: PortableRegistry, + old_to_new: BTreeMap +} + +impl <'info> PortableRegistryBuilder<'info> { + /// Instantiate a new [`PortableRegistryBuilder`], providing the set of + /// legacy types you wish to use to construct modern types from. + pub fn new(legacy_types: &'info TypeRegistrySet<'info>) -> Self { + PortableRegistryBuilder { + legacy_types, + scale_info_types: PortableRegistry { types: Default::default() }, + old_to_new: Default::default() + } + } + + /// Try adding a type, given its string name and optionally the pallet it's scoped to. + pub fn try_add_type_str(&mut self, id: &str, pallet: Option<&str>) -> Option> { + let mut id = match LookupName::parse(id) { + Ok(id) => id, + Err(e) => return Some(Err(TypeRegistryResolveError::LookupNameInvalid(id.to_owned(), e))) + }; + + if let Some(pallet) = pallet { + id = id.in_pallet(pallet); + } + + self.try_add_type(id) + } + + /// Try adding a type, returning `None` if the type doesn't exist. + pub fn try_add_type(&mut self, id: LookupName) -> Option> { + match self.add_type(id) { + Ok(id) => Some(Ok(id)), + Err(PortableRegistryAddTypeError::TypeNotFound(_)) => None, + Err(PortableRegistryAddTypeError::ResolveError(e)) => Some(Err(e)) + } + } + + /// Add a new legacy type, giving its string ID/name and, if applicable, the pallet that it's seen in, + /// returning the corresponding "modern" type ID to use in its place, or an error if something does wrong. + pub fn add_type_str(&mut self, id: &str, pallet: Option<&str>) -> Result { + let mut id = LookupName::parse(id) + .map_err(|e| TypeRegistryResolveError::LookupNameInvalid(id.to_owned(), e))?; + + if let Some(pallet) = pallet { + id = id.in_pallet(pallet); + } + + self.add_type(id) + } + + /// Add a new legacy type, returning the corresponding "modern" type ID to use in + /// its place, or an error if something does wrong. + pub fn add_type(&mut self, id: LookupName) -> Result { + if let Some(new_id) = self.old_to_new.get(&id) { + return Ok(*new_id) + } + + let visitor = PortableRegistryVisitor { + builder: &mut *self, + current_type: &id + }; + + match visitor.builder.legacy_types.resolve_type(id.clone(), visitor) { + Ok(Ok(new_id)) => { + self.old_to_new.insert(id, new_id); + Ok(new_id) + }, + Ok(Err(e)) => Err(e), + Err(e) => Err(e.into()) + } + } + + /// Return the current [`scale_info::PortableRegistry`]. + pub fn types(&self) -> &PortableRegistry { + &self.scale_info_types + } + + /// Finish adding types and return the modern type registry. + pub fn finish(self) -> PortableRegistry { + self.scale_info_types + } + + fn push_type(&mut self, ty: scale_info::Type) -> u32 { + let id = self.scale_info_types.types.len() as u32; + self.scale_info_types.types.push(PortableType { id, ty }); + id + } +} + +struct PortableRegistryVisitor<'a, 'info> { + builder: &'a mut PortableRegistryBuilder<'info>, + current_type: &'a LookupName, +} + +impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info> { + type TypeId = LookupName; + type Value = Result; + + fn visit_unhandled(self, kind: UnhandledKind) -> Self::Value { + panic!("A handler exists for every type, but visit_unhandled({kind:?}) was called"); + } + + fn visit_not_found(self) -> Self::Value { + Err(PortableRegistryAddTypeError::TypeNotFound(self.current_type.clone())) + } + + fn visit_primitive(self, primitive: Primitive) -> Self::Value { + let p = match primitive { + Primitive::Bool => scale_info::TypeDefPrimitive::Bool, + Primitive::Char => scale_info::TypeDefPrimitive::Char, + Primitive::Str => scale_info::TypeDefPrimitive::Str, + Primitive::U8 => scale_info::TypeDefPrimitive::U8, + Primitive::U16 => scale_info::TypeDefPrimitive::U16, + Primitive::U32 => scale_info::TypeDefPrimitive::U32, + Primitive::U64 => scale_info::TypeDefPrimitive::U64, + Primitive::U128 => scale_info::TypeDefPrimitive::U128, + Primitive::U256 => scale_info::TypeDefPrimitive::U256, + Primitive::I8 => scale_info::TypeDefPrimitive::I8, + Primitive::I16 => scale_info::TypeDefPrimitive::I16, + Primitive::I32 => scale_info::TypeDefPrimitive::I32, + Primitive::I64 => scale_info::TypeDefPrimitive::I64, + Primitive::I128 => scale_info::TypeDefPrimitive::I128, + Primitive::I256 => scale_info::TypeDefPrimitive::I256, + }; + + let primitive_type = scale_info::Type::new( + Default::default(), + core::iter::empty(), + scale_info::TypeDef::Primitive(p), + Default::default(), + ); + + Ok(self.builder.push_type(primitive_type)) + } + + fn visit_sequence>(self, path: Path, inner_type_id: Self::TypeId) -> Self::Value { + let inner_id = self.builder.add_type(inner_type_id)?; + let path = scale_info::Path { segments: path.map(Into::into).collect() }; + let sequence_type = scale_info::Type::new( + path, + core::iter::empty(), + scale_info::TypeDef::Sequence(scale_info::TypeDefSequence { type_param: inner_id.into() }), + Default::default(), + ); + + Ok(self.builder.push_type(sequence_type)) + } + + fn visit_composite(self, path: Path, fields: Fields) -> Self::Value + where + Path: PathIter<'info>, + Fields: FieldIter<'info, Self::TypeId> + { + let path = scale_info::Path { segments: path.map(Into::into).collect() }; + + let mut scale_info_fields = Vec::>::new(); + for field in fields { + let type_name = field.id.to_string(); + let id = self.builder.add_type(field.id)?; + scale_info_fields.push(scale_info::Field { + name: field.name.map(Into::into), + ty: id.into(), + type_name: Some(type_name), + docs: Default::default() + }); + } + + let composite_type = scale_info::Type::new( + path, + core::iter::empty(), + scale_info::TypeDef::Composite(scale_info::TypeDefComposite { fields: scale_info_fields }), + Default::default(), + ); + + Ok(self.builder.push_type(composite_type)) + } + + fn visit_array(self, inner_type_id: LookupName, len: usize) -> Self::Value { + let inner_id = self.builder.add_type(inner_type_id)?; + let array_type = scale_info::Type::new( + Default::default(), + core::iter::empty(), + scale_info::TypeDef::Array(scale_info::TypeDefArray { len: len as u32, type_param: inner_id.into() }), + Default::default(), + ); + + Ok(self.builder.push_type(array_type)) + } + + fn visit_tuple(self, type_ids: TypeIds) -> Self::Value + where + TypeIds: ExactSizeIterator + { + let mut scale_info_fields = Vec::new(); + for old_id in type_ids { + let new_id = self.builder.add_type(old_id)?; + scale_info_fields.push(new_id.into()); + } + + let tuple_type = scale_info::Type::new( + Default::default(), + core::iter::empty(), + scale_info::TypeDef::Tuple(scale_info::TypeDefTuple { fields: scale_info_fields }), + Default::default(), + ); + + Ok(self.builder.push_type(tuple_type)) + } + + fn visit_variant(self, path: Path, variants: Var) -> Self::Value + where + Path: PathIter<'info>, + Fields: FieldIter<'info, Self::TypeId>, + Var: VariantIter<'info, Fields> + { + let path = scale_info::Path { segments: path.map(Into::into).collect() }; + + let mut scale_info_variants = Vec::new(); + for variant in variants { + let mut scale_info_variant_fields = Vec::>::new(); + for field in variant.fields { + let type_name = field.id.to_string(); + let id = self.builder.add_type(field.id)?; + scale_info_variant_fields.push(scale_info::Field { + name: field.name.map(Into::into), + ty: id.into(), + type_name: Some(type_name), + docs: Default::default() + }); + } + + scale_info_variants.push(scale_info::Variant { + name: variant.name.to_owned(), + index: variant.index, + fields: scale_info_variant_fields, + docs: Default::default() + }) + } + + let variant_type = scale_info::Type::new( + path, + core::iter::empty(), + scale_info::TypeDef::Variant(scale_info::TypeDefVariant { variants: scale_info_variants }), + Default::default(), + ); + + Ok(self.builder.push_type(variant_type)) + } + + fn visit_compact(self, inner_type_id: Self::TypeId) -> Self::Value { + let inner_id = self.builder.add_type(inner_type_id)?; + + // Configure the path and type params to maximise compat. + let path = ["parity_scale_codec", "Compact"].into_iter().map(ToOwned::to_owned).collect(); + let type_params = [ + scale_info::TypeParameter { + name: "T".to_owned(), + ty: Some(inner_id.into()) + }, + ]; + + let compact_type = scale_info::Type::new( + scale_info::Path { segments: path }, + type_params, + scale_info::TypeDef::Compact(scale_info::TypeDefCompact { type_param: inner_id.into() }), + Default::default(), + ); + + Ok(self.builder.push_type(compact_type)) + } + + fn visit_bit_sequence(self, store_format: BitsStoreFormat, order_format: BitsOrderFormat) -> Self::Value { + // These order types are added by default into a `TypeRegistry`, so we + // expect them to exist. Parsing should always succeed. + let order_ty_str = match order_format { + BitsOrderFormat::Lsb0 => "bitvec::order::Lsb0", + BitsOrderFormat::Msb0 => "bitvec::order::Msb0", + }; + let order_ty = LookupName::parse(order_ty_str).unwrap(); + let new_order_ty = self.builder.add_type(order_ty)?; + + // The store types also exist by default. Parsing should always succeed. + let store_ty_str = match store_format { + BitsStoreFormat::U8 => "u8", + BitsStoreFormat::U16 => "u16", + BitsStoreFormat::U32 => "u32", + BitsStoreFormat::U64 => "u64", + }; + let store_ty = LookupName::parse(store_ty_str).unwrap(); + let new_store_ty = self.builder.add_type(store_ty)?; + + // Configure the path and type params to look like BitVec's to try + // and maximise compatibility. + let path = ["bitvec", "vec", "BitVec"].into_iter().map(ToOwned::to_owned).collect(); + let type_params = [ + scale_info::TypeParameter { + name: "Store".to_owned(), + ty: Some(new_store_ty.into()) + }, + scale_info::TypeParameter { + name: "Order".to_owned(), + ty: Some(new_order_ty.into()) + } + ]; + + let bitseq_type = scale_info::Type::new( + scale_info::Path { segments: path }, + type_params, + scale_info::TypeDef::BitSequence(scale_info::TypeDefBitSequence { + bit_order_type: new_order_ty.into(), + bit_store_type: new_store_ty.into(), + }), + Default::default(), + ); + + Ok(self.builder.push_type(bitseq_type)) + } +} diff --git a/metadata/src/from/mod.rs b/metadata/src/from/mod.rs index 16e0f816d1..5a5ed0c55b 100644 --- a/metadata/src/from/mod.rs +++ b/metadata/src/from/mod.rs @@ -8,6 +8,10 @@ mod v14; mod v15; mod v16; +/// Legacy translation hidden behind the corresponding feature flag. +#[cfg(feature = "legacy")] +pub mod legacy; + /// The metadata versions that we support converting into [`crate::Metadata`]. /// These are ordest from highest to lowest, so that the metadata we'd want to /// pick first is first in the array. diff --git a/metadata/src/from/v14.rs b/metadata/src/from/v14.rs index e8e3fd90a8..ee31cd8537 100644 --- a/metadata/src/from/v14.rs +++ b/metadata/src/from/v14.rs @@ -73,7 +73,9 @@ impl TryFrom for Metadata { name.clone(), PalletMetadataInner { name: name.clone(), - index: p.index, + call_index: p.index, + event_index: p.index, + error_index: p.index, storage, call_ty: p.calls.as_ref().map(|c| c.ty.id), call_variant_index, @@ -99,7 +101,9 @@ impl TryFrom for Metadata { Ok(Metadata { types: m.types, pallets, - pallets_by_index, + pallets_by_call_index: pallets_by_index.clone(), + pallets_by_error_index: pallets_by_index.clone(), + pallets_by_event_index: pallets_by_index, extrinsic: from_extrinsic_metadata(m.extrinsic, missing_extrinsic_type_ids), dispatch_error_ty, outer_enums: OuterEnumsMetadata { diff --git a/metadata/src/from/v15.rs b/metadata/src/from/v15.rs index 157c01a7a0..0a170c1cde 100644 --- a/metadata/src/from/v15.rs +++ b/metadata/src/from/v15.rs @@ -69,7 +69,9 @@ impl TryFrom for Metadata { name.clone(), PalletMetadataInner { name, - index: p.index, + call_index: p.index, + event_index: p.index, + error_index: p.index, storage, call_ty: p.calls.as_ref().map(|c| c.ty.id), call_variant_index, @@ -126,7 +128,9 @@ impl TryFrom for Metadata { Ok(Metadata { types: m.types, pallets, - pallets_by_index, + pallets_by_call_index: pallets_by_index.clone(), + pallets_by_error_index: pallets_by_index.clone(), + pallets_by_event_index: pallets_by_index, extrinsic: from_extrinsic_metadata(m.extrinsic), dispatch_error_ty, apis, diff --git a/metadata/src/from/v16.rs b/metadata/src/from/v16.rs index 83301f70b3..8369620264 100644 --- a/metadata/src/from/v16.rs +++ b/metadata/src/from/v16.rs @@ -88,7 +88,9 @@ impl TryFrom for Metadata { name.clone(), PalletMetadataInner { name, - index: p.index, + call_index: p.index, + event_index: p.index, + error_index: p.index, storage, call_ty: p.calls.as_ref().map(|c| c.ty.id), call_variant_index, @@ -157,7 +159,9 @@ impl TryFrom for Metadata { Ok(Metadata { types: m.types, pallets, - pallets_by_index, + pallets_by_call_index: pallets_by_index.clone(), + pallets_by_error_index: pallets_by_index.clone(), + pallets_by_event_index: pallets_by_index, extrinsic: from_extrinsic_metadata(m.extrinsic), dispatch_error_ty, apis, diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs index b317050afc..0cc17802ce 100644 --- a/metadata/src/lib.rs +++ b/metadata/src/lib.rs @@ -49,6 +49,9 @@ pub use from::SUPPORTED_METADATA_VERSIONS; pub use from::TryFromError; pub use utils::validation::MetadataHasher; +#[cfg(feature = "legacy")] +pub use from::legacy::Error as LegacyFromError; + type CustomMetadataInner = frame_metadata::v15::CustomMetadata; /// Node metadata. This can be constructed by providing some compatible [`frame_metadata`] @@ -60,8 +63,18 @@ pub struct Metadata { types: PortableRegistry, /// Metadata of all the pallets. pallets: OrderedMap, - /// Find the location in the pallet Vec by pallet index. - pallets_by_index: HashMap, + /// Find the pallet for a given call index. + pallets_by_call_index: HashMap, + /// Find the pallet for a given event index. + /// + /// for modern metadatas, this is the same as pallets_by_call_index, + /// but for old metadatas this can vary. + pallets_by_event_index: HashMap, + /// Find the pallet for a given error index. + /// + /// for modern metadatas, this is the same as pallets_by_call_index, + /// but for old metadatas this can vary. + pallets_by_error_index: HashMap, /// Metadata of the extrinsic. extrinsic: ExtrinsicMetadata, /// The types of the outer enums. @@ -84,7 +97,7 @@ impl frame_decode::extrinsics::ExtrinsicTypeInfo for Metadata { pallet_index: u8, call_index: u8, ) -> Result, ExtrinsicInfoError<'_>> { - let pallet = self.pallet_by_index(pallet_index).ok_or({ + let pallet = self.pallet_by_call_index(pallet_index).ok_or({ ExtrinsicInfoError::PalletNotFound { index: pallet_index, } @@ -347,11 +360,65 @@ impl frame_decode::custom_values::CustomValueTypeInfo for Metadata { } impl Metadata { - /// This is essentiall an alias for `::decode(&mut bytes)` + /// This is essentially an alias for `::decode(&mut bytes)` pub fn decode_from(mut bytes: &[u8]) -> Result { ::decode(&mut bytes) } + /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. + #[cfg(feature = "legacy")] + pub fn from_v13( + metadata: &frame_metadata::v13::RuntimeMetadataV13, + types: scale_info_legacy::TypeRegistrySet<'_>, + ) -> Result { + from::legacy::from_v13(metadata, types) + } + + /// Convert V12 metadata into [`Metadata`], given the necessary extra type information. + #[cfg(feature = "legacy")] + pub fn from_v12( + metadata: &frame_metadata::v12::RuntimeMetadataV12, + types: scale_info_legacy::TypeRegistrySet<'_>, + ) -> Result { + from::legacy::from_v12(metadata, types) + } + + /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. + #[cfg(feature = "legacy")] + pub fn from_v11( + metadata: &frame_metadata::v11::RuntimeMetadataV11, + types: scale_info_legacy::TypeRegistrySet<'_>, + ) -> Result { + from::legacy::from_v11(metadata, types) + } + + /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. + #[cfg(feature = "legacy")] + pub fn from_v10( + metadata: &frame_metadata::v10::RuntimeMetadataV10, + types: scale_info_legacy::TypeRegistrySet<'_>, + ) -> Result { + from::legacy::from_v10(metadata, types) + } + + /// Convert V9 metadata into [`Metadata`], given the necessary extra type information. + #[cfg(feature = "legacy")] + pub fn from_v9( + metadata: &frame_metadata::v9::RuntimeMetadataV9, + types: scale_info_legacy::TypeRegistrySet<'_>, + ) -> Result { + from::legacy::from_v9(metadata, types) + } + + /// Convert V8 metadata into [`Metadata`], given the necessary extra type information. + #[cfg(feature = "legacy")] + pub fn from_v8( + metadata: &frame_metadata::v8::RuntimeMetadataV8, + types: scale_info_legacy::TypeRegistrySet<'_>, + ) -> Result { + from::legacy::from_v8(metadata, types) + } + /// Access the underlying type registry. pub fn types(&self) -> &PortableRegistry { &self.types @@ -385,10 +452,36 @@ impl Metadata { }) } - /// Access a pallet given its encoded variant index. - pub fn pallet_by_index(&self, variant_index: u8) -> Option> { + /// Access a pallet given some call/extrinsic pallet index byte + pub fn pallet_by_call_index(&self, variant_index: u8) -> Option> { let inner = self - .pallets_by_index + .pallets_by_call_index + .get(&variant_index) + .and_then(|i| self.pallets.get_by_index(*i))?; + + Some(PalletMetadata { + inner, + types: self.types(), + }) + } + + /// Access a pallet given some event pallet index byte + pub fn pallet_by_event_index(&self, variant_index: u8) -> Option> { + let inner = self + .pallets_by_event_index + .get(&variant_index) + .and_then(|i| self.pallets.get_by_index(*i))?; + + Some(PalletMetadata { + inner, + types: self.types(), + }) + } + + /// Access a pallet given some error pallet index byte + pub fn pallet_by_error_index(&self, variant_index: u8) -> Option> { + let inner = self + .pallets_by_error_index .get(&variant_index) .and_then(|i| self.pallets.get_by_index(*i))?; @@ -458,9 +551,19 @@ impl<'a> PalletMetadata<'a> { &self.inner.name } - /// The pallet index. - pub fn index(&self) -> u8 { - self.inner.index + /// The index to use for calls in this pallet. + pub fn call_index(&self) -> u8 { + self.inner.call_index + } + + /// The index to use for events in this pallet. + pub fn event_index(&self) -> u8 { + self.inner.event_index + } + + /// The index to use for errors in this pallet. + pub fn error_index(&self) -> u8 { + self.inner.error_index } /// The pallet docs. @@ -613,8 +716,18 @@ impl<'a> PalletMetadata<'a> { struct PalletMetadataInner { /// Pallet name. name: String, - /// Pallet index. - index: u8, + /// The index for calls in the pallet. + call_index: u8, + /// The index for events in the pallet. + /// + /// This is the same as `call_index` for modern metadatas, + /// but can be different for older metadatas (pre-V12). + event_index: u8, + /// The index for errors in the pallet. + /// + /// This is the same as `call_index` for modern metadatas, + /// but can be different for older metadatas (pre-V12). + error_index: u8, /// Pallet storage metadata. storage: Option, /// Type ID for the pallet Call enum. diff --git a/subxt/src/error/dispatch_error.rs b/subxt/src/error/dispatch_error.rs index a98da908ff..5c083e0756 100644 --- a/subxt/src/error/dispatch_error.rs +++ b/subxt/src/error/dispatch_error.rs @@ -169,7 +169,7 @@ impl std::fmt::Display for ModuleError { impl ModuleError { /// Return more details about this error. pub fn details(&self) -> Result, ModuleErrorDetailsError> { - let pallet = self.metadata.pallet_by_index(self.pallet_index()).ok_or( + let pallet = self.metadata.pallet_by_error_index(self.pallet_index()).ok_or( ModuleErrorDetailsError::PalletNotFound { pallet_index: self.pallet_index(), }, From 4733a55d5792f53fc319fb0c3e653e4e601170d4 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Wed, 12 Nov 2025 15:06:24 +0000 Subject: [PATCH 02/14] use published frame-decode --- Cargo.lock | 4 +++- Cargo.toml | 5 +---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cc80aeeffa..f3d191e3b6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1953,7 +1953,9 @@ dependencies = [ [[package]] name = "frame-decode" -version = "0.12.0" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4d325134db7604b9649bc5428cbbc35e01f667ef684ccd3e5f4fc5d59938bdf" dependencies = [ "frame-metadata 23.0.0", "parity-scale-codec", diff --git a/Cargo.toml b/Cargo.toml index f7054ff695..fd836cd1af 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -81,7 +81,7 @@ darling = "0.20.10" derive-where = "1.2.7" either = { version = "1.13.0", default-features = false } finito = { version = "0.1.0", default-features = false } -frame-decode = { version = "0.12.0", default-features = false } +frame-decode = { version = "0.12.1", default-features = false } frame-metadata = { version = "23.0.0", default-features = false } futures = { version = "0.3.31", default-features = false, features = ["std"] } getrandom = { version = "0.2", default-features = false } @@ -192,6 +192,3 @@ opt-level = 2 opt-level = 2 [profile.test.package.smoldot] opt-level = 2 - -[patch.crates-io] -frame-decode = { path = "../frame-decode" } \ No newline at end of file From 9836a43af8bafc8aa7bf4ca68e6a83342d7003dc Mon Sep 17 00:00:00 2001 From: James Wilson Date: Wed, 12 Nov 2025 15:48:20 +0000 Subject: [PATCH 03/14] fmt and rename legacy metadata macro --- metadata/src/from/legacy/mod.rs | 96 ++++---- .../from/legacy/portable_registry_builder.rs | 227 +++++++++++------- metadata/src/lib.rs | 12 +- subxt/src/error/dispatch_error.rs | 9 +- 4 files changed, 203 insertions(+), 141 deletions(-) diff --git a/metadata/src/from/legacy/mod.rs b/metadata/src/from/legacy/mod.rs index a66bc357b5..c06999f7a0 100644 --- a/metadata/src/from/legacy/mod.rs +++ b/metadata/src/from/legacy/mod.rs @@ -3,21 +3,21 @@ mod portable_registry_builder; use crate::Metadata; use crate::utils::ordered_map::OrderedMap; use crate::utils::variant_index::VariantIndex; -use portable_registry_builder::PortableRegistryBuilder; use alloc::borrow::ToOwned; -use alloc::vec::Vec; -use alloc::string::ToString; -use alloc::format; use alloc::collections::BTreeMap; -use scale_info_legacy::type_registry::RuntimeApiName; -use frame_metadata::v15; -use scale_info_legacy::TypeRegistrySet; -use frame_decode::storage::StorageTypeInfo; +use alloc::format; +use alloc::string::ToString; +use alloc::vec::Vec; +use frame_decode::constants::ConstantTypeInfo; use frame_decode::extrinsics::ExtrinsicTypeInfo; use frame_decode::runtime_apis::RuntimeApiTypeInfo; -use frame_decode::constants::ConstantTypeInfo; +use frame_decode::storage::StorageTypeInfo; +use frame_metadata::v15; +use portable_registry_builder::PortableRegistryBuilder; +use scale_info_legacy::TypeRegistrySet; +use scale_info_legacy::type_registry::RuntimeApiName; -macro_rules! from_vx_to_vx { +macro_rules! from_historic { ($vis:vis fn $fn_name:ident($metadata:path $(, builtin_index: $builtin_index:ident)? )) => { $vis fn $fn_name(metadata: &$metadata, mut types: TypeRegistrySet<'_>) -> Result { // Extend the types with important information from the metadata: @@ -81,21 +81,21 @@ macro_rules! from_vx_to_vx { .storage_info(&pallet_name, &entry_name) .map_err(|e| Error::StorageInfoError(e.into_owned()))?; let entry_name = entry_name.into_owned(); - + let info = info.map_ids(|old_id| { portable_registry_builder.add_type(old_id) }).map_err(|e| { let ctx = format!("adding type used in storage entry {pallet_name}.{entry_name}"); Error::add_type(ctx, e) })?; - + let entry = crate::StorageEntryMetadata { name: entry_name.clone(), info: info.into_owned(), // We don't expose docs via our storage info yet. docs: Vec::new(), }; - + Ok((entry_name, entry)) }).collect::, _>>()?; @@ -298,12 +298,12 @@ macro_rules! from_vx_to_vx { }} } -from_vx_to_vx!(pub fn from_v13(frame_metadata::v13::RuntimeMetadataV13, builtin_index: yes)); -from_vx_to_vx!(pub fn from_v12(frame_metadata::v12::RuntimeMetadataV12, builtin_index: yes)); -from_vx_to_vx!(pub fn from_v11(frame_metadata::v11::RuntimeMetadataV11)); -from_vx_to_vx!(pub fn from_v10(frame_metadata::v10::RuntimeMetadataV10)); -from_vx_to_vx!(pub fn from_v9(frame_metadata::v9::RuntimeMetadataV9)); -from_vx_to_vx!(pub fn from_v8(frame_metadata::v8::RuntimeMetadataV8)); +from_historic!(pub fn from_v13(frame_metadata::v13::RuntimeMetadataV13, builtin_index: yes)); +from_historic!(pub fn from_v12(frame_metadata::v12::RuntimeMetadataV12, builtin_index: yes)); +from_historic!(pub fn from_v11(frame_metadata::v11::RuntimeMetadataV11)); +from_historic!(pub fn from_v10(frame_metadata::v10::RuntimeMetadataV10)); +from_historic!(pub fn from_v9(frame_metadata::v9::RuntimeMetadataV9)); +from_historic!(pub fn from_v8(frame_metadata::v8::RuntimeMetadataV8)); fn as_decoded(item: &frame_metadata::decode_different::DecodeDifferent) -> &B { match item { @@ -316,8 +316,8 @@ fn as_decoded(item: &frame_metadata::decode_different::DecodeDifferent, - portable_registry_builder: &mut PortableRegistryBuilder + types: &TypeRegistrySet<'_>, + portable_registry_builder: &mut PortableRegistryBuilder, ) -> Result, Error> { let mut apis = OrderedMap::new(); let mut trait_name = ""; @@ -327,34 +327,38 @@ pub fn type_registry_to_runtime_apis( match api { RuntimeApiName::Trait(name) => { if !trait_methods.is_empty() { - apis.push_insert(trait_name.into(), crate::RuntimeApiMetadataInner { - name: trait_name.into(), - methods: trait_methods, - docs: Vec::new() - }); + apis.push_insert( + trait_name.into(), + crate::RuntimeApiMetadataInner { + name: trait_name.into(), + methods: trait_methods, + docs: Vec::new(), + }, + ); } trait_methods = OrderedMap::new(); trait_name = name; - }, + } RuntimeApiName::Method(name) => { let info = types .runtime_api_info(trait_name, name) .map_err(|e| Error::RuntimeApiInfoError(e.into_owned()))?; let info = info.map_ids(|id| { - portable_registry_builder - .add_type(id) - .map_err(|e| { - let c = format!("converting type for runtime API {trait_name}.{name}"); - Error::add_type(c, e) - }) + portable_registry_builder.add_type(id).map_err(|e| { + let c = format!("converting type for runtime API {trait_name}.{name}"); + Error::add_type(c, e) + }) })?; - trait_methods.push_insert(name.to_owned(), crate::RuntimeApiMethodMetadataInner { - name: name.into(), - info, - docs: Vec::new(), - }); + trait_methods.push_insert( + name.to_owned(), + crate::RuntimeApiMethodMetadataInner { + name: name.into(), + info, + docs: Vec::new(), + }, + ); } } } @@ -370,7 +374,7 @@ pub enum Error { #[error("Cannot add type ({context}): {error}")] AddTypeError { context: String, - error: portable_registry_builder::PortableRegistryAddTypeError + error: portable_registry_builder::PortableRegistryAddTypeError, }, #[error("Cannot enhance the types with information from metadata: {0}")] CannotEnhanceTypesFromMetadata(scale_info_legacy::lookup_name::ParseError), @@ -378,7 +382,9 @@ pub enum Error { CannotFindAddressType, #[error("Cannot find 'hardcoded::ExtrinsicSignature' type in legacy types")] CannotFindSignatureType, - #[error("Cannot find 'builtin::Call' type in legacy types (this should have been automatically added)")] + #[error( + "Cannot find 'builtin::Call' type in legacy types (this should have been automatically added)" + )] CannotFindCallType, #[error("Cannot obtain the storage information we need to convert storage entries")] StorageInfoError(frame_decode::storage::StorageInfoError<'static>), @@ -392,7 +398,13 @@ pub enum Error { impl Error { /// A shorthand for the [`Error::AddTypeError`] variant. - fn add_type(context: impl Into, error: impl Into) -> Self { - Error::AddTypeError { context: context.into(), error: error.into() } + fn add_type( + context: impl Into, + error: impl Into, + ) -> Self { + Error::AddTypeError { + context: context.into(), + error: error.into(), + } } } diff --git a/metadata/src/from/legacy/portable_registry_builder.rs b/metadata/src/from/legacy/portable_registry_builder.rs index 938fcfb796..a44217413c 100644 --- a/metadata/src/from/legacy/portable_registry_builder.rs +++ b/metadata/src/from/legacy/portable_registry_builder.rs @@ -1,28 +1,22 @@ -use alloc::vec::Vec; +use alloc::borrow::ToOwned; use alloc::collections::BTreeMap; +use alloc::string::ToString; +use alloc::vec::Vec; use scale_info::PortableRegistry; -use scale_info_legacy::{ TypeRegistrySet, LookupName }; +use scale_info::{PortableType, form::PortableForm}; +use scale_info_legacy::type_registry::TypeRegistryResolveError; +use scale_info_legacy::{LookupName, TypeRegistrySet}; use scale_type_resolver::{ - ResolvedTypeVisitor, - UnhandledKind, - PathIter, - FieldIter, - VariantIter, - Primitive, - BitsOrderFormat, - BitsStoreFormat, + BitsOrderFormat, BitsStoreFormat, FieldIter, PathIter, Primitive, ResolvedTypeVisitor, + UnhandledKind, VariantIter, }; -use scale_info::{ PortableType, form::PortableForm }; -use scale_info_legacy::type_registry::TypeRegistryResolveError; -use alloc::string::ToString; -use alloc::borrow::ToOwned; #[derive(thiserror::Error, Debug)] pub enum PortableRegistryAddTypeError { #[error("Error resolving type: {0}")] ResolveError(#[from] TypeRegistryResolveError), #[error("Cannot find type '{0}'")] - TypeNotFound(LookupName) + TypeNotFound(LookupName), } /// the purpose of this is to convert a (subset of) [`scale_info_legacy::TypeRegistrySet`] @@ -32,25 +26,36 @@ pub enum PortableRegistryAddTypeError { pub struct PortableRegistryBuilder<'info> { legacy_types: &'info TypeRegistrySet<'info>, scale_info_types: PortableRegistry, - old_to_new: BTreeMap + old_to_new: BTreeMap, } -impl <'info> PortableRegistryBuilder<'info> { +impl<'info> PortableRegistryBuilder<'info> { /// Instantiate a new [`PortableRegistryBuilder`], providing the set of /// legacy types you wish to use to construct modern types from. pub fn new(legacy_types: &'info TypeRegistrySet<'info>) -> Self { - PortableRegistryBuilder { - legacy_types, - scale_info_types: PortableRegistry { types: Default::default() }, - old_to_new: Default::default() + PortableRegistryBuilder { + legacy_types, + scale_info_types: PortableRegistry { + types: Default::default(), + }, + old_to_new: Default::default(), } } /// Try adding a type, given its string name and optionally the pallet it's scoped to. - pub fn try_add_type_str(&mut self, id: &str, pallet: Option<&str>) -> Option> { + pub fn try_add_type_str( + &mut self, + id: &str, + pallet: Option<&str>, + ) -> Option> { let mut id = match LookupName::parse(id) { Ok(id) => id, - Err(e) => return Some(Err(TypeRegistryResolveError::LookupNameInvalid(id.to_owned(), e))) + Err(e) => { + return Some(Err(TypeRegistryResolveError::LookupNameInvalid( + id.to_owned(), + e, + ))); + } }; if let Some(pallet) = pallet { @@ -61,17 +66,24 @@ impl <'info> PortableRegistryBuilder<'info> { } /// Try adding a type, returning `None` if the type doesn't exist. - pub fn try_add_type(&mut self, id: LookupName) -> Option> { + pub fn try_add_type( + &mut self, + id: LookupName, + ) -> Option> { match self.add_type(id) { Ok(id) => Some(Ok(id)), Err(PortableRegistryAddTypeError::TypeNotFound(_)) => None, - Err(PortableRegistryAddTypeError::ResolveError(e)) => Some(Err(e)) + Err(PortableRegistryAddTypeError::ResolveError(e)) => Some(Err(e)), } } - /// Add a new legacy type, giving its string ID/name and, if applicable, the pallet that it's seen in, + /// Add a new legacy type, giving its string ID/name and, if applicable, the pallet that it's seen in, /// returning the corresponding "modern" type ID to use in its place, or an error if something does wrong. - pub fn add_type_str(&mut self, id: &str, pallet: Option<&str>) -> Result { + pub fn add_type_str( + &mut self, + id: &str, + pallet: Option<&str>, + ) -> Result { let mut id = LookupName::parse(id) .map_err(|e| TypeRegistryResolveError::LookupNameInvalid(id.to_owned(), e))?; @@ -86,21 +98,25 @@ impl <'info> PortableRegistryBuilder<'info> { /// its place, or an error if something does wrong. pub fn add_type(&mut self, id: LookupName) -> Result { if let Some(new_id) = self.old_to_new.get(&id) { - return Ok(*new_id) + return Ok(*new_id); } let visitor = PortableRegistryVisitor { builder: &mut *self, - current_type: &id + current_type: &id, }; - match visitor.builder.legacy_types.resolve_type(id.clone(), visitor) { + match visitor + .builder + .legacy_types + .resolve_type(id.clone(), visitor) + { Ok(Ok(new_id)) => { self.old_to_new.insert(id, new_id); - Ok(new_id) - }, + Ok(new_id) + } Ok(Err(e)) => Err(e), - Err(e) => Err(e.into()) + Err(e) => Err(e.into()), } } @@ -126,7 +142,7 @@ struct PortableRegistryVisitor<'a, 'info> { current_type: &'a LookupName, } -impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info> { +impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info> { type TypeId = LookupName; type Value = Result; @@ -135,7 +151,9 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf } fn visit_not_found(self) -> Self::Value { - Err(PortableRegistryAddTypeError::TypeNotFound(self.current_type.clone())) + Err(PortableRegistryAddTypeError::TypeNotFound( + self.current_type.clone(), + )) } fn visit_primitive(self, primitive: Primitive) -> Self::Value { @@ -167,45 +185,57 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf Ok(self.builder.push_type(primitive_type)) } - fn visit_sequence>(self, path: Path, inner_type_id: Self::TypeId) -> Self::Value { + fn visit_sequence>( + self, + path: Path, + inner_type_id: Self::TypeId, + ) -> Self::Value { let inner_id = self.builder.add_type(inner_type_id)?; - let path = scale_info::Path { segments: path.map(Into::into).collect() }; + let path = scale_info::Path { + segments: path.map(Into::into).collect(), + }; let sequence_type = scale_info::Type::new( path, - core::iter::empty(), - scale_info::TypeDef::Sequence(scale_info::TypeDefSequence { type_param: inner_id.into() }), + core::iter::empty(), + scale_info::TypeDef::Sequence(scale_info::TypeDefSequence { + type_param: inner_id.into(), + }), Default::default(), ); - Ok(self.builder.push_type(sequence_type)) + Ok(self.builder.push_type(sequence_type)) } fn visit_composite(self, path: Path, fields: Fields) -> Self::Value where Path: PathIter<'info>, - Fields: FieldIter<'info, Self::TypeId> + Fields: FieldIter<'info, Self::TypeId>, { - let path = scale_info::Path { segments: path.map(Into::into).collect() }; + let path = scale_info::Path { + segments: path.map(Into::into).collect(), + }; let mut scale_info_fields = Vec::>::new(); for field in fields { let type_name = field.id.to_string(); let id = self.builder.add_type(field.id)?; - scale_info_fields.push(scale_info::Field { - name: field.name.map(Into::into), - ty: id.into(), - type_name: Some(type_name), - docs: Default::default() + scale_info_fields.push(scale_info::Field { + name: field.name.map(Into::into), + ty: id.into(), + type_name: Some(type_name), + docs: Default::default(), }); } let composite_type = scale_info::Type::new( path, - core::iter::empty(), - scale_info::TypeDef::Composite(scale_info::TypeDefComposite { fields: scale_info_fields }), + core::iter::empty(), + scale_info::TypeDef::Composite(scale_info::TypeDefComposite { + fields: scale_info_fields, + }), Default::default(), ); - + Ok(self.builder.push_type(composite_type)) } @@ -213,17 +243,20 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf let inner_id = self.builder.add_type(inner_type_id)?; let array_type = scale_info::Type::new( Default::default(), - core::iter::empty(), - scale_info::TypeDef::Array(scale_info::TypeDefArray { len: len as u32, type_param: inner_id.into() }), + core::iter::empty(), + scale_info::TypeDef::Array(scale_info::TypeDefArray { + len: len as u32, + type_param: inner_id.into(), + }), Default::default(), ); - Ok(self.builder.push_type(array_type)) + Ok(self.builder.push_type(array_type)) } fn visit_tuple(self, type_ids: TypeIds) -> Self::Value where - TypeIds: ExactSizeIterator + TypeIds: ExactSizeIterator, { let mut scale_info_fields = Vec::new(); for old_id in type_ids { @@ -233,21 +266,25 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf let tuple_type = scale_info::Type::new( Default::default(), - core::iter::empty(), - scale_info::TypeDef::Tuple(scale_info::TypeDefTuple { fields: scale_info_fields }), + core::iter::empty(), + scale_info::TypeDef::Tuple(scale_info::TypeDefTuple { + fields: scale_info_fields, + }), Default::default(), ); - Ok(self.builder.push_type(tuple_type)) + Ok(self.builder.push_type(tuple_type)) } fn visit_variant(self, path: Path, variants: Var) -> Self::Value where Path: PathIter<'info>, Fields: FieldIter<'info, Self::TypeId>, - Var: VariantIter<'info, Fields> + Var: VariantIter<'info, Fields>, { - let path = scale_info::Path { segments: path.map(Into::into).collect() }; + let path = scale_info::Path { + segments: path.map(Into::into).collect(), + }; let mut scale_info_variants = Vec::new(); for variant in variants { @@ -255,11 +292,11 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf for field in variant.fields { let type_name = field.id.to_string(); let id = self.builder.add_type(field.id)?; - scale_info_variant_fields.push(scale_info::Field { - name: field.name.map(Into::into), - ty: id.into(), - type_name: Some(type_name), - docs: Default::default() + scale_info_variant_fields.push(scale_info::Field { + name: field.name.map(Into::into), + ty: id.into(), + type_name: Some(type_name), + docs: Default::default(), }); } @@ -267,44 +304,53 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf name: variant.name.to_owned(), index: variant.index, fields: scale_info_variant_fields, - docs: Default::default() + docs: Default::default(), }) } let variant_type = scale_info::Type::new( path, - core::iter::empty(), - scale_info::TypeDef::Variant(scale_info::TypeDefVariant { variants: scale_info_variants }), + core::iter::empty(), + scale_info::TypeDef::Variant(scale_info::TypeDefVariant { + variants: scale_info_variants, + }), Default::default(), ); - Ok(self.builder.push_type(variant_type)) + Ok(self.builder.push_type(variant_type)) } fn visit_compact(self, inner_type_id: Self::TypeId) -> Self::Value { let inner_id = self.builder.add_type(inner_type_id)?; // Configure the path and type params to maximise compat. - let path = ["parity_scale_codec", "Compact"].into_iter().map(ToOwned::to_owned).collect(); - let type_params = [ - scale_info::TypeParameter { - name: "T".to_owned(), - ty: Some(inner_id.into()) - }, - ]; + let path = ["parity_scale_codec", "Compact"] + .into_iter() + .map(ToOwned::to_owned) + .collect(); + let type_params = [scale_info::TypeParameter { + name: "T".to_owned(), + ty: Some(inner_id.into()), + }]; let compact_type = scale_info::Type::new( scale_info::Path { segments: path }, - type_params, - scale_info::TypeDef::Compact(scale_info::TypeDefCompact { type_param: inner_id.into() }), + type_params, + scale_info::TypeDef::Compact(scale_info::TypeDefCompact { + type_param: inner_id.into(), + }), Default::default(), ); - Ok(self.builder.push_type(compact_type)) + Ok(self.builder.push_type(compact_type)) } - fn visit_bit_sequence(self, store_format: BitsStoreFormat, order_format: BitsOrderFormat) -> Self::Value { - // These order types are added by default into a `TypeRegistry`, so we + fn visit_bit_sequence( + self, + store_format: BitsStoreFormat, + order_format: BitsOrderFormat, + ) -> Self::Value { + // These order types are added by default into a `TypeRegistry`, so we // expect them to exist. Parsing should always succeed. let order_ty_str = match order_format { BitsOrderFormat::Lsb0 => "bitvec::order::Lsb0", @@ -325,28 +371,31 @@ impl <'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'inf // Configure the path and type params to look like BitVec's to try // and maximise compatibility. - let path = ["bitvec", "vec", "BitVec"].into_iter().map(ToOwned::to_owned).collect(); + let path = ["bitvec", "vec", "BitVec"] + .into_iter() + .map(ToOwned::to_owned) + .collect(); let type_params = [ - scale_info::TypeParameter { + scale_info::TypeParameter { name: "Store".to_owned(), - ty: Some(new_store_ty.into()) + ty: Some(new_store_ty.into()), }, scale_info::TypeParameter { name: "Order".to_owned(), - ty: Some(new_order_ty.into()) - } + ty: Some(new_order_ty.into()), + }, ]; let bitseq_type = scale_info::Type::new( scale_info::Path { segments: path }, - type_params, - scale_info::TypeDef::BitSequence(scale_info::TypeDefBitSequence { + type_params, + scale_info::TypeDef::BitSequence(scale_info::TypeDefBitSequence { bit_order_type: new_order_ty.into(), bit_store_type: new_store_ty.into(), - }), + }), Default::default(), ); - Ok(self.builder.push_type(bitseq_type)) + Ok(self.builder.push_type(bitseq_type)) } } diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs index 0cc17802ce..d609dc5fa0 100644 --- a/metadata/src/lib.rs +++ b/metadata/src/lib.rs @@ -66,7 +66,7 @@ pub struct Metadata { /// Find the pallet for a given call index. pallets_by_call_index: HashMap, /// Find the pallet for a given event index. - /// + /// /// for modern metadatas, this is the same as pallets_by_call_index, /// but for old metadatas this can vary. pallets_by_event_index: HashMap, @@ -368,7 +368,7 @@ impl Metadata { /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. #[cfg(feature = "legacy")] pub fn from_v13( - metadata: &frame_metadata::v13::RuntimeMetadataV13, + metadata: &frame_metadata::v13::RuntimeMetadataV13, types: scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v13(metadata, types) @@ -377,7 +377,7 @@ impl Metadata { /// Convert V12 metadata into [`Metadata`], given the necessary extra type information. #[cfg(feature = "legacy")] pub fn from_v12( - metadata: &frame_metadata::v12::RuntimeMetadataV12, + metadata: &frame_metadata::v12::RuntimeMetadataV12, types: scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v12(metadata, types) @@ -386,7 +386,7 @@ impl Metadata { /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. #[cfg(feature = "legacy")] pub fn from_v11( - metadata: &frame_metadata::v11::RuntimeMetadataV11, + metadata: &frame_metadata::v11::RuntimeMetadataV11, types: scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v11(metadata, types) @@ -719,12 +719,12 @@ struct PalletMetadataInner { /// The index for calls in the pallet. call_index: u8, /// The index for events in the pallet. - /// + /// /// This is the same as `call_index` for modern metadatas, /// but can be different for older metadatas (pre-V12). event_index: u8, /// The index for errors in the pallet. - /// + /// /// This is the same as `call_index` for modern metadatas, /// but can be different for older metadatas (pre-V12). error_index: u8, diff --git a/subxt/src/error/dispatch_error.rs b/subxt/src/error/dispatch_error.rs index 5c083e0756..4b27e63dfd 100644 --- a/subxt/src/error/dispatch_error.rs +++ b/subxt/src/error/dispatch_error.rs @@ -169,11 +169,12 @@ impl std::fmt::Display for ModuleError { impl ModuleError { /// Return more details about this error. pub fn details(&self) -> Result, ModuleErrorDetailsError> { - let pallet = self.metadata.pallet_by_error_index(self.pallet_index()).ok_or( - ModuleErrorDetailsError::PalletNotFound { + let pallet = self + .metadata + .pallet_by_error_index(self.pallet_index()) + .ok_or(ModuleErrorDetailsError::PalletNotFound { pallet_index: self.pallet_index(), - }, - )?; + })?; let variant = pallet .error_variant_by_index(self.error_index()) From 99a8cb927aa52e5694ff48458b61238cdb77ff3e Mon Sep 17 00:00:00 2001 From: James Wilson Date: Wed, 12 Nov 2025 17:12:57 +0000 Subject: [PATCH 04/14] Enable legacy feature where needed in subxt_metadata so it compiles on its own --- .github/workflows/rust.yml | 1 + metadata/Cargo.toml | 7 ++++++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 054cfdd429..1cad71cda6 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -188,6 +188,7 @@ jobs: - name: Cargo hack; check each subxt feature run: cargo hack -p subxt --each-feature check --exclude-no-default-features --exclude-all-features --exclude-features web --features native + # Same with subxt-historic - name: Cargo hack; check each subxt feature run: cargo hack -p subxt-historic --each-feature check --exclude-no-default-features --exclude-all-features --exclude-features web --features native diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml index dc6d50ddb9..aedc948608 100644 --- a/metadata/Cargo.toml +++ b/metadata/Cargo.toml @@ -18,7 +18,12 @@ default = ["std", "legacy"] std = ["scale-info/std", "frame-metadata/std"] # Enable decoding of legacy metadata, too. -legacy = ["dep:scale-info-legacy", "dep:scale-type-resolver"] +legacy = [ + "dep:scale-info-legacy", + "dep:scale-type-resolver", + "frame-decode/legacy", + "frame-metadata/legacy" +] [dependencies] scale-info = { workspace = true, default-features = false } From d668fa46ff2bbc11b7865b724a78ac96123b1345 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Wed, 12 Nov 2025 17:39:05 +0000 Subject: [PATCH 05/14] Use cargo hack more in CI and fix subxt-metadata features --- .github/workflows/rust.yml | 39 +++++++++++++------------------------- metadata/Cargo.toml | 2 ++ 2 files changed, 15 insertions(+), 26 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 1cad71cda6..0330cebb3b 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -181,42 +181,29 @@ jobs: - name: Cargo check all targets. run: cargo check --all-targets - # Next, check subxt features. + # Next, check each subxt feature in isolation. # - `native` feature must always be enabled # - `web` feature is always ignored. - # - This means, don't check --no-default-features and don't try enabling --all-features; both will fail - name: Cargo hack; check each subxt feature - run: cargo hack -p subxt --each-feature check --exclude-no-default-features --exclude-all-features --exclude-features web --features native + run: cargo hack -p subxt --each-feature check --exclude-features web --features native # Same with subxt-historic - name: Cargo hack; check each subxt feature - run: cargo hack -p subxt-historic --each-feature check --exclude-no-default-features --exclude-all-features --exclude-features web --features native + run: cargo hack -p subxt-historic --each-feature check --exclude-features web --features native - # Subxt-signer has the "subxt" features enabled in the "check all targets" test. Run it on its own to - # check it without. We can't enable subxt or web features here, so no cargo hack. - - name: Cargo check subxt-signer - run: | - cargo check -p subxt-signer - cargo check -p subxt-signer --no-default-features --features sr25519 - cargo check -p subxt-signer --no-default-features --features ecdsa - cargo check -p subxt-signer --no-default-features --features unstable-eth + # And with subxt-rpcs + - name: Cargo hack; check each subxt-rpcs feature + run: cargo hack -p subxt-rpcs --each-feature check --exclude-features web --features native - # Subxt-rpcs has a bunch of clients that can be exposed. Check that they all stand on their own. - - name: Cargo check subxt-rpcs - run: | - cargo check -p subxt-rpcs - cargo check -p subxt-rpcs --no-default-features --features native - cargo check -p subxt-rpcs --no-default-features --features native,subxt - cargo check -p subxt-rpcs --no-default-features --features native,jsonrpsee - cargo check -p subxt-rpcs --no-default-features --features native,reconnecting-rpc-client - cargo check -p subxt-rpcs --no-default-features --features native,mock-rpc-client - cargo check -p subxt-rpcs --no-default-features --features native,unstable-light-client - - # We can't enable web features here, so no cargo hack. + # And with subxt-signer (seems to work with a more basic check here; disable web if it becomes an issue). + - name: Cargo hack; check each subxt-signer feature + run: cargo hack -p subxt-signer --each-feature check + + # And for subxt-lightclient. - name: Cargo check subxt-lightclient - run: cargo check -p subxt-lightclient + run: cargo hack -p subxt-lightclient --each-feature check --exclude-features web --features native - # Next, check each other package in isolation. + # Next, check all other crates. - name: Cargo hack; check each feature/crate on its own run: cargo hack --exclude subxt --exclude subxt-historic --exclude subxt-signer --exclude subxt-lightclient --exclude subxt-rpcs --exclude-all-features --each-feature check --workspace diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml index aedc948608..31a213bfdd 100644 --- a/metadata/Cargo.toml +++ b/metadata/Cargo.toml @@ -18,7 +18,9 @@ default = ["std", "legacy"] std = ["scale-info/std", "frame-metadata/std"] # Enable decoding of legacy metadata, too. +# std required by frame-metadata to decode Date: Fri, 14 Nov 2025 17:31:16 +0000 Subject: [PATCH 06/14] Add tests for metadata conversion (need to optimise; some too expensive right now --- Cargo.lock | 8 +- Cargo.toml | 4 +- artifacts/kusama/metadata_v10_1038.scale | Bin 0 -> 85190 bytes artifacts/kusama/metadata_v11_1045.scale | Bin 0 -> 113893 bytes artifacts/kusama/metadata_v12_2025.scale | Bin 0 -> 182290 bytes artifacts/kusama/metadata_v13_9030.scale | Bin 0 -> 234364 bytes artifacts/kusama/metadata_v14_9111.scale | Bin 0 -> 335369 bytes artifacts/kusama/metadata_v9_1021.scale | Bin 0 -> 61374 bytes historic/src/storage.rs | 7 +- .../src/storage/list_storage_entries_any.rs | 35 ++ metadata/Cargo.toml | 1 + metadata/src/from/legacy/mod.rs | 21 +- .../from/legacy/portable_registry_builder.rs | 129 +++--- metadata/src/from/legacy/tests.rs | 398 ++++++++++++++++++ metadata/src/lib.rs | 59 +-- 15 files changed, 565 insertions(+), 97 deletions(-) create mode 100644 artifacts/kusama/metadata_v10_1038.scale create mode 100644 artifacts/kusama/metadata_v11_1045.scale create mode 100644 artifacts/kusama/metadata_v12_2025.scale create mode 100644 artifacts/kusama/metadata_v13_9030.scale create mode 100644 artifacts/kusama/metadata_v14_9111.scale create mode 100644 artifacts/kusama/metadata_v9_1021.scale create mode 100644 historic/src/storage/list_storage_entries_any.rs create mode 100644 metadata/src/from/legacy/tests.rs diff --git a/Cargo.lock b/Cargo.lock index f3d191e3b6..225dfaeffe 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1953,9 +1953,9 @@ dependencies = [ [[package]] name = "frame-decode" -version = "0.12.1" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4d325134db7604b9649bc5428cbbc35e01f667ef684ccd3e5f4fc5d59938bdf" +checksum = "73d29c7f2987ea24ab2eaea315aadb9ba598188823181cdf0476049b625a5844" dependencies = [ "frame-metadata 23.0.0", "parity-scale-codec", @@ -4464,9 +4464,9 @@ dependencies = [ [[package]] name = "scale-info-legacy" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9d7e3c60aa5e479fe4cfba98a8e74f93b329f4ce0628f7a52f41768489bc418" +checksum = "909e47c92f7955ef5e44ec77ae6d7d62797e9b6ad3a508ed96f7ef97ca197495" dependencies = [ "hashbrown 0.15.3", "scale-type-resolver", diff --git a/Cargo.toml b/Cargo.toml index fd836cd1af..3f83e01afc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -81,7 +81,7 @@ darling = "0.20.10" derive-where = "1.2.7" either = { version = "1.13.0", default-features = false } finito = { version = "0.1.0", default-features = false } -frame-decode = { version = "0.12.1", default-features = false } +frame-decode = { version = "0.13.0", default-features = false } frame-metadata = { version = "23.0.0", default-features = false } futures = { version = "0.3.31", default-features = false, features = ["std"] } getrandom = { version = "0.2", default-features = false } @@ -103,7 +103,7 @@ scale-bits = { version = "0.7.0", default-features = false } scale-decode = { version = "0.16.0", default-features = false } scale-encode = { version = "0.10.0", default-features = false } scale-type-resolver = { version = "0.2.0" } -scale-info-legacy = { version = "0.3.0", default-features = false } +scale-info-legacy = { version = "0.3.1", default-features = false } scale-typegen = "0.11.1" scale-typegen-description = "0.11.0" serde = { version = "1.0.210", default-features = false, features = ["derive"] } diff --git a/artifacts/kusama/metadata_v10_1038.scale b/artifacts/kusama/metadata_v10_1038.scale new file mode 100644 index 0000000000000000000000000000000000000000..1e7837da77a283cebc357c01d34d9b25aab322b5 GIT binary patch literal 85190 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 z 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 ZdfF<>pL#Ek*SFYD1AXDF)Xr_n^9yKt2TlM0 literal 0 HcmV?d00001 diff --git a/artifacts/kusama/metadata_v13_9030.scale b/artifacts/kusama/metadata_v13_9030.scale new file mode 100644 index 0000000000000000000000000000000000000000..92dfaaca105fd0eba71c6fdbe2f6be6e1371c0de GIT binary patch literal 234364 zcmeFae{7ujo!>X(o6YeW9iU5``7oEzjbnLe>Bc^>*3$a zrxv!h29y4{UjM+^_4)bm*K+5r_^H1=xX2I7{Z961E-4;aY>(TQY76z+&-lN_d&&Av zmTXUYy`=4HOS&v#xZ56g2mORkNjuqV569iDNw3Wx;i2Wl^up4k@vz$;b+@i+Pqo^y z$;Uq0s5Rb6)(7KuFUjK1qr^6CgN>POYcd>W{c*C{8*JTA=dS3Vm$UA@opHT(;p(72 zn(SsB|Dtu&ejBgb!sAd6?e%;HANle^ua~cJw37AnB`(y%8hcs)-gqZzcKgZZ{x}=W z`i_A{Y4v-PaWWp<%UJtxE}tV#?Q@;BU0iFAcIx%#E^u)6_l?Q!W;Q&D&7wW)ENNFibW|&*$3`VlbmXf9j=d>*D0Xr5b1Osd|z>GDsPb5|f>*-N}aO$)yLZ zb5yUrA%NQ-x3aClup`Q~KaFy=tV^2gi;2IGbh5p{s5{O&ho42-wC9YN>NWqv7=gnW zvSNdd5n5MftKh6`<1L?q?X{9#cQj7t?2GlmUUzE*yNLk(yw=>Tp5dG?(B_&I`ZPaW z7as2E;5M`I!z}B=1;!dHX$~`hJOTpjgJTT1Jqr$Xc<4d4HHK%fK0~5x^wuG3b)bz{ zY+P;aH|h!08s_jpM#)b5K?c;u*>JbpXH!f+V)XXCEP-bjhXOydy{zBSQsGy^0b6GZ zw7R3EI%nA%JRAWN*vpx%UROsa)b0U48%eKh?X>$KN&-L2@+ro{_SSukyPN6v?r2wg z{JtQ*)gEQqSA1_f8*lB{rN#P+Pz7}-k46S-QUZS*5gj3#Tjh1 zC(PL0P9A0npE~Tdx1apxWHe?_4ddr;N7&LA{d}3cWb@eR#aTz~U3NX-5Cx6^xIR43 z38!99`UC!N+}-XvoRf!Lj%Sng4!ig6v7rv5LT4HpNW#r`1z|nW8?f1HEA7$v7Gj~h zo88{KH-vI(wO0;)xs0%ZMsC-WHBMGXpv{c-vaJoyXM_xD8D{xceU{x4cpqwqdbGzh z$Rodgyz-f54M zmYq<1x0Q59NegbrPIloq;<1-Znkw+ z-+m-~ePNW1H(=R&8+$N}QR9UDb8PaL&nG`I8KjjI?9_gZ-1Oyaa{*zsy9tqH{RiFQ zpuY=_BN{c}QPZ!mkaIcvcsPXBryah#BCx(}K$uU?rRUFnJo)|qX4JB$?J2?K+S0=6 z#_GbSm)0t~NVJQsK__b**Z)T7G(mv{r_YK9i+Wn2Vh}P=|x0p2b`j(F1>TGK^-PergV3Eeo8NB@d zydKj!n))3|8trX#2lMm0-O<+ke4yik@*nPW;j2(w_6UL=fi|=0oDFY0C;e;AQ3HY* z=JN3Nq`zg_E1z9Dh(84;7v`8tHqq+t!6k+)WFNHTVg3)M!;#0?(l0fGou>#{LtTnDUYVl+hhy_3S>LJ*Ua?{Cr=p-e)hxN>+->ss3 zQ1&)@gL|#{B)-tiwX(bD*%X5-1Vp<0n#3#~^p1U9hah?GeuSCZ2@IntXty2+vC z*vOS_oxLxy6!&%fezreK!nQ6YkCGQ9fl6E29u9WnimIFXN!ZkjN9{^O2j=)X?GWs|@Uin?=c=&t zHRg*1SYT&32_)>f3XU$iwqk-{!vt0%Xgg7ipZxOCN{*?$*=~32`gL{V@A$?y^Nnvx zcnNNWSl3@cUn=wS$`b1*FXw)OwaJ!D^v2o6pwXFb{!X$`at;LLK(^n=AD0~5Pm?>Z z%58M#?!|n#7uwxk)|ojUM_U>W2gB;vZ&k9 zds^D`YrM5555_H1S=n4M)$wbX`;G4;H~Z7dYGI8qp3~1d;A)h_(w-~5L=zxRu+|Ku0= z;}ie%cYpG^zxjvX*8(s9i}~-=fBd)pV=eL@z5Dj>{@>sJ8-G?W{`24Ywcq*Q|H{&e zKL7o>5B%=mxwQK!J-_^a{{6qO{vRCssy_eC|MefA{OUjYpM+AifA)L-!&m;Rf9Ie5 zp`QPT|Ko@M>3??OL;t=$?|k+n0Z(A2{Lo z!Vz`v^+mAB+S-MWM`;q(eH$&UeNuWVOc4K6uMHzJZur5`=;Ie&Fn9I`c~6IdS%bNP zFPq_l^UOv_OehA-0{O%t%}MwWF(>x1RKSmG#~S@MYm zi(0_-;%Au0)_SRvzgw+fyUVk0KvyT8Qw!Y)mpb;(1YDR!u;xhHDU}u$X@7m z_v%Of(zxL7T!+er-FB~DJ1cEEICt@4A8X5C#nvz@H1JgOhhuL`xz-t&Gw#AUXSpIk z$cKYtTacx#33mn{18;2>chWMlc0S|@mak{q32`M{&y#IH;0j#JrrZc@{=>&{F9fb<-$WB1 zcikW7ulVUzIM7_!>R}5g0m2sHXOK1vEUVXE8Ex(K2gBk0tT#Vj{P0@b#8Lk?J*wfG za1;^R<^huD14Db>_vuRT8vaa4#M*O#7XESI4Ryc-!b<_8D-N0vXz}&ONCe6p;hYi! zw)jP$Ra}OBhyqHupcxC4e0E%I+(|T4SYLsxaCE+oB>%K*p;aEV%oEP8W%uNC&Uw?v zK5Bu$)1OO<-ME!4Z`No$oS4@$t^G)*yJ;WWxY_ZXb}>WX(v9_vm8Bb>Ucc5#Yd^qPLb|o%07$$xj!uyU80)Kn!d7R~&4Rz6cA(XJmFN@RY^d@>GD6IS4~Qy(i{=IAgOQ zJ5;;=^37Myn8PG#mCwt;#7n;hJ4@27LieWVFo=(E_jwTsu= z`ZpY?6agRj^-~7w~H0l4_WiEyHCGnV@?39H$mYC z39{s+TQ4Li*~-6gPd)TZpx927z1d!Zq(iAjF%SBAyZ5k-=Lc@TH`p_mQYYykGB^d_ zKYU8quP-M39-sbv9TWn`I|4EGgU}j*E42is+;4A6(`&ly?F{j-;Rn8K^ zm#VNPCtJPt+JUHUHSRu}M6q~6;9|qRI%nJ1-jyJy=rkUNGdbhn=FrQ~J0J#>cBy)( z0j(QnP>^`#1Rq=Ja$VwaXg^acB$=eyOXJBlru3TF70^E%<4$Qr%Z zMQCaA$1G>&%;T1062jIp7w3la31@uyAO}8j=|3PP_QrcjbAK=~rqpzvt?jxI|Qao%B5>ppbzrYqZnd^GCta_C1&$%7TsMb~)&af`P_IZd9@i zst*)$fNz>U?F4HNK=E48dEtda4)qMP_5chwCd7L0K^H%JU?zW}fyn_mFN&#`$u22E zf_ISU5wLdXZc-@NEk)T;TX{tYL+3+|ZVI7*MjAn!y&23TW7e43@>{_)Z-*mm&6>d_ zV}Wr3?UjcU+snCqNEl&(@hdpRG@dpiwhYs2$mV_s3KLit1vgGQWglu;9G6|eE9|#o zR|M)8wFEH~`GXItMGh^gk8O%T3eqTxxrO zZjd!{1f?9mD;-zeje=U@7$@$FNjd7GRcUwmLL(&5)m$+(ko>9xnx~i-FHYg(SQrz| zCJ8{Y5ntp$F?BzvVHZB`SO*901j}e~Dd74Q#aq_d%W0VHbu?u8*ZvLP^9l1Ru#`v_ zBq3U&pbsYq6n>a13s;t+fEAUYLu)zEp*@Y(;hK&;#~HGi%{IAHp3GQ)gPep1m;l;_ z$yg-%WXwVyMi2DkRuh2E{E9dTrHq86{lN7LV1mXXEfigIpGY^szYNlmq(eqdNDVqi zXpuj`Fqv1R2Y%7s%2)1bL0D~aNVyA6hp<1J9%}_R_5pF%_&AwjP+&=D1>wW63L~4_ zFX~F7)$)@rAw-fyOvG-|I8l_75>cy?t2U8EyQf5#rhA5oURj*rWY~gIZ%V{%k;^A( z)d05_f;xP}Qf;A@WE3qcIdJ7?f)0E~NWc1NVIeyF?q2ER%&{AThxJ+sIUO}|O1_zU z5e*S#q3KMc7G_wNo?h&BJYbrq95%j2a)_V5UbGp}zQ!?v>beaewh{hHy>SfFx^WB* z{+gWM@GGe-PAZo!zJf2eVdr+`;S+l@erPV1*3JHUJV8#O z2N8nTgCgP!Oe7DR3f-y$6yb@=j=T@J#yPC*+Xfbjsijy z{;$(j7(weZNtz|kM`rqb7>2RK8_~3cTLhtz;AVtRj`0r%76McM%wU3N#NDPyTiE1? z-$z#L;}R&(EX-iygW-L?MJqPkm8c3i?O+(}7|ltN(DslR;wD*o&z-yrh(h!5Mg^oZ zzy+)wlB5x#0K<>LCV(vgG)ik9IECl1i<_e!KQxk%=rF3)KOk}rf0~E!bvY~I7Z%1q zo7jTwk)=12`UU<#9d+rEa%?7g)1y=1k$FXSg{bP>Kw?S%Q&B$sd`5U-DcCt#?+Yg|F? z+fPA}8*652Y{+j43EJFb?1`(|XKhWQU0ccnD@M-JWB3J5qAF+(4q!|u>G+Uuf`HT7^2x#UQG2}|s+TrKBippIau!As)KnZ1wySN@=hbGJc zk_y(w^Rv_2Y#RcGjT--ZSLB>Q&C$&j*JkAi9{W?EJC5^=cra_c_$WjeW@jRzMq@j$ zwnKK80t}FfMFo`7@=P_6%O=OMFi<&hS&`r~gFRtSu+x5v2%nJAk^PSg-;|Ike2bud zI)oEW76|u!Phl0(kx>Mhh&|;@DbHdJh^SJdt?r&Gc4ptJCci$-s}*cMzD@naQH<&B zQ4GO>w;;NXdp*eQ=l-0 zV@<_lb&1HiOtP0oGv>s~OZZj8B6$pR6I5c%IBF_~ZvFKNj}y55m1l4lIHs+P#ByhI z$DWYQofOPIn^{HAI>+{cMkx@-xLVGLU}#cA$lH;^I+V$PmeP(0g9cn;24Zr7Vg7)6 zlb-v$B`%e@y!>qfzIT^~}V=@VzsEZqaNo(JH8X>6cUPR!RABQE-C&nfqR7*XVxMxAb*tqUf{Tle>i1`ZX=iDi6R{SxR|AK-)~!)liWJb zB%-Sv^T$ugF`Zu^CkzK>fAX|!bL#yH?+h4!1ovD-i55TjY>5c`MC`OeNN$g$fm{!t z(%PIzq)t=+?Owou?rAN=$DWlhqT$I&6xgg=Ocp((*jfo!D3YHg>=}O#N?=-30Z91c zphg&8f|DD+Pit>XF-ML0vsVAc6$~5UXruNSW61QQKOz;de(XE~w@_(IY0qbathV3r zF)ZXTbfKp(V9qhff3|NG*(0yJX)g(9I*sZ$?;RLNZa=g0MfD1oCC$QKAf6aTCRscT zD%j6dMlEu+8z^|w3oT7xs4&G+BWBR{AkGzb(Kr=Mle1S`VKs~C^7+60_x?e2+UVcL zSDYIM{vGmhq#-z$F!T&sM|xro4}j~?z~)VRvw)|}j;K%3ckUXI4xvuzW z($hFf$dy8kYka3P6Kex+{Rh)vVi*_JZKwPZ_X~H@Um&N>Y=Kcd|8)GkHJMl*jV3Zv zsh7um4Ub(e1KxoDw#_@XwiFX`ALJJpO+cimhMDD_9@U=XPQY?CTaY;$=DAd>*Qcj? z+P{zWY-yXp*uf}3_Y8ncYYWkZZu$cdv$Ai?@d_*7!sCk!j42U&O5CtaF?)zJ_e7pB z{wO`Mg6CTe0VIZ<2Ud7_ks&Y7_wJ!o)z{dXt72?51)3Z3AM0hgA`uLCV&WzIf@myb+IWDArLoirz zKL^Z*ln&Yt_}`c2=hut^PT=I7WGf{HX@KFS9zMZ9GY%pLoox;;y<4`2P-N|w>e6yt z6{T8NijJ)uZ$wM1GE87a@FkUBAu6n;jO>qL`m1$iE84qxezu-<{1@hnWFn}7*D82C zTXEShWLYaEw;^bzF00Aek7o@?H#73UO#!nI6a=miMpRM7`NiA_W_>Nr6?f)A;W(77 z6zsrDsq&f{&h>Sc`((ntp3ZvuxfdVP(eVI_V6BxhWa0< z6j)r9bVLrh-J6SPZvc~!Io>ae_!FzXK{_jXkH4e-n>Sa4A%1OjYoTVWF|;;*q++axP9&!itH5@-H$ z09nM;4b=&45OjKg^V?X3VVU*MAjwRLEd{-LQMmyQ^yb6x_e6FEfs!!mFfd6{S&6J8M&7R1&rGbp(j z>i}$Kj$D7u^S*bh@d2x04rg@i7|P?5FlX`i4GELO`14u)7@aYPJ#g(UXxT$tVPXru z#2mPIHZ^#yNtj^dSTME1r$w}_Tft+Ub8o;99KD_`$I-+2Er|2vEW6pN=s?th+9E2H*1q-x zJe+m3h}ura!c=7|H9qIn?i|Vab@~k+xcW3)G=1f88oJ0pWwO~ZX2jsIVTDoVlaGFa z>U7ajC;X&}QTyd%A5YJn(=Tr`$N@^3gJRsT4w7=XFPlDG!1MTD_ zf?+AdVy75b_Gl~H^YadDDEb3+P)7gaUeN*wOv7_DA!#ogLx`7Sn+swIYbs@9vdCDS zR~AgtBwr!;Kv3^_bjWPo(VHBGSSH4edc_6d5L9B=*RV%kb;WtH66Y;3^q+;IHwP&5 ztpS)<3u$oIqSU_6P=^1+GT?How9gsMyU8a%`QcoTA{3P7^) z55G}?K)PxcLb@~F?S05IiqZ(0@|nFS5>vAqWF~SPUvgAuhZ$l8$on;mQ0#1O8AjB#?wrH@0s##iSvBvdqO2-Os zNAW3#3RY1(O^ZybHb?_Xb3!#A%z2doE}8&GL}6*fI8OW*ufRfOhmshmxswh+@V1himPK= zDIbo+oyC@$rUtn(X&3?@k3SX@nE?o#Zs(Dm!zP*y`zcRUiUpOYic^TCY1#u*T?;!R z5vdJ6Naa6X9C7g}9?nTwu9ML*@hQQyyoS;i#b(3Yk;!P~W73RESi$D*SDw(t(ciDfCJU#?(V_-U@JPtw~(>%MchaqS>=l$|}dzxb1S+3OOV zOfgX;r0|58i-`&={fD69*3duu>8T4ZnJeqw6*pxXU!b3i=T+t_9}JQmC{Sl3{^V4$ zz7oA6oD3&o_&92OGsZPbUK0SEKVVTqS)yV@vdG%Km1XR-Z948L46w$FTV0a;?_+FaGQQ_ItmaBhusC zPCPVIp5zLhV;Q^Z0RA(7?zwz0eQ1z)z7CPWs04c49eZs|WAQOc^~B}dWrp_aMr}yn zGwMrAx-1=d2mN%;3yRkV%=aZZ?Mi=N9grH~$a67ZkNKi6UAoh#EQLS*?*H*0)ob;* zroBOLzdzWu1XS7VI+0LZDd`)V8jxZGUf2%I#`dlkY3)}-0kpC(>!r`fPTr=POJ&mU zX{q+dlB#5uN!v9Squhu$tVne(HWIZD0SA^l)k7*iZr|@nyOsaPVR34HS|wjsiX0Xv%o> z&oB+Ik_U0K;U!i=8mje0Qeu}?{`iAbo}aoF(qnIHnANsY(!g>dg*_80icGP!=}9_L z&U1R%UKlO-^4JcoH2kZBOAcvdDem#Xbt1<8Tw{@b$LdOf6W8V%rDsFQxjoQ$rL+uo z9m{gg^42vto}+WLX~`K!c%Nfm=&NLD*aGAZuUAp!8?^F zJyedz0_TzYcbsnW7oR(YY!m6!3mwGdIyquBhK#om`OBpS7Mc((OwK(GzILD3EGZlH0DcYZx$pMJbchG$#J z{9b^8&jZ4b$)<(F&jzOdRC^!Y2BitdwmY(sw!?>A63dch)zpc{L42B3Jn)n97Q`yY z(jNTbmOpK4yi{J)^om3F=w@~{xi=xr5oaT+;05G|iaG{V#gfq%;3ysvqf4C(p6 z6ad+z$k}sJb>^R`nPC_0Rht!C;?eU{dQ$ppSz{B z;Lf6{BNnTyEX@}4eTf7kQ7OWD9DZ!sr=|LiUATOjP<0S!Rq#riIf4^ct4>@H(kks- zMzt9zh+VI^>Qz5W!*;Ef@W1lt zJ!;gB-?8mSF)e;(vFfyDi-9WmKW$mj3|MC@YT`lJ2l5F@S;FL_zlJ@y7C2^zeg4)Y zn*{SCU)pOD#+F8%cc~8i6#B-IlwvoDz1m{W=bt4ESTV6Y))QXv1sf$xBeOwwXfY#4 z1sgPS2S`IItKc)!FZ$LrhF8u6Fu+_K=fqxebc!0pSRqWk6I^j$QF#n(1KfDE6?VU@ zFwr(?hx7CKu1BrA={j2)t!X{^gRBxP$&Z9S6DD!&eBchp&-t=P0jyzL7%Endt)tOe zY>y@y{jfNy*0tre^_#aov$43eN{0uNnI;2oP|q+AEOfGJs_sy*5pm516B<^=g52h`P#p=3?ax5J5K2@s9v=pTKeb10`^jiR8_tN5~ao zXBEW}N9e@^i3f=KhB;JNGN`>d>D>q6 z3Fphd5u`}S8a4J1Od=)iEwg*&6}mxhRda`*1`?M50g%_W72?YaXpFvx7WK14n>ZM& zqZ~^GUJ_9T3{j}}*Z^IxmEd@l9#cece+J;3dpik(y$@K8##j&kH=-k z*8{wHhtizOK~>rkhhaOS;)9RQasR*~g>)AT{BtmL8IpBYvtdr5M4c5@1os0-Q+%9O zzT@d)-j$+dfp=@iKxxcFa>Bq6JM{=qfNc@sNk8Pg%%(qbdSPKPlf#0=_FnfRiUKn$ zY{tBfVe zNdREZ%XKbsp$FZelIX+6`+V*vXMJabWUes13tG7a zUrmCP*In@f)h^pIOaC+TgVGVi@|~b3rE(v(y;=A z^ZZo96sU!S9^9WqJ)FyiBG@7H^nH6@R!!wio&!sDKZj(MY76t?p_Z+xm9AV>E)zf4 z-)R4EKbjYoG5_EhkfR_v2;gU}u7+V&dg}|gV!k*nNX5=l$gQ#}=s^S}exPJ?n_QHS zgK^l#SB3(OzjCWP+?wnn6?lN==N7ZLr#Mz$-^|LV6I^VzaBS5Q?!W8qvho8J^q*2d zOqKtJ-Je5JY;fG!icJrOOl2aQUhG&V)q0pV-C7hX*K1=<+2pgSft2EultQ&HJP!3N z$Y`-kfz17fbG+9(vuP%$>3TtQ2F<3b#~DIIUFe(c6_Jf+VowHLbh=2SW#TXTAU2Fs z;$AlYE}j=x`-0=e5|hBsjac9Q>p??z-^)tQ7Y)A4eYRFRO3k~|4A@)+?Cf)7J}$9u ztQ-TUlvTq4OMT24C^OHaOJnntA?WPu)i1*ZTxGJq^#0ea&3sCob#!%?tcL;zi`Kre zRkh6)Sb?ovQ5)QDfinm(w70o;l;ZF(17Y}A2I{VwCKfUWvk!IJJpWSDURi1n>0vm+ zL0u;Hiox9Yi7_kMz1fo{twkGdj^R1-LI(UxW*N`n;H~h0bUoNatGHh%zYLTOlPuG? z^YQm=Dh{x)yCWIL7*5WC;}0>__FSP8(S|~4lvuTZXtdwo@@TuLSzn7ja>ErTH3DNe zKQE_x7!$koG4Yq@j(>~Dl;7GE@^=e;Bfq}M)Oh3uELZ;2^chlx|MC&3!gmNG^gGA6 z_a^$qo+NL_lZDq~vTy}extj>L)%&@rUXh0cRl(R|HAztDW;VHq3g#j|nyMsPM#pAw zDC>RGU2v(c{E2J#EaT5BBBcWgBlih7yNM2fkFar6BkWydw$*p zCDm);Z#(i9{#;};sjlGZMr;R%mF{f`?L=CB)apyEE0a89WaE(7?S>saO+93u2Uh@E z7tw;0tEmqBcb;y5$|sq(ZO)Z)*f?n=*S0(Ji34;lagXj?@@h!!41V3axmQJs`&@F( zLn%tM9`Ep$$^^d0V3rD3jE0_;(MRauVD>_st&+gi6#UpVN><|nY%mVhD15o)q9~`g(S%P4gB`6}<-{KnrDI#^Kt0ga`6$B_^)M{BZDklT3C*is)t0`%j{)0%wMDwJ|7G@S%rdv? zQjZ;4ECgIo!3G@(yf_CRl99J{G+7DcO%eoT&nj``xKaC45#*fBuW1VQBAooOyi@4P zn#@W;LdLl{_g-y*IZM{1e9&LBqz`rqBwJTWbfUia{m5IXYL6#x@+wpTsJjdaCLTuP zml;DTwURC)Ti=jiZLYrQb83@Lk1`P^c#

Mb%aNyC#N2^`JxTKtk}2*iL4o2*zAL?7P34Z6Vdy7`dlGe^Lb-Z9HXK3KAOp=( zjX5aFame)Gprb|QiaO$7Z!tQdIP(|u#q$dxpljc(n@bcJO)~qKj50V2j}cpAU2@Nv zFemfCt|>MQPHSZ9TmN9K&i4^l$CBvL3V#tv3GGbjXvIVu<@?*Ztf+vsdgpX8%&!}b zco~8Ak6up99A<7E!VUt-ZcMsS4%r=6)8VU=j<~fm>Erz-nE+{dec_dj+c#EjUVU-- z#-}%~Ub}tc#kJNfDyc1b;2AD})w6M};=r53EQ^%+dJEXVL|a#p3-j{_w|AEm_^k7j zaMpq5-0ciNT|_v04E9G{9y|=UsCA_wlN)SW2gc7Ps0&6=FbCtZDfuu9edy$;V-44$ z1#h=!Frf#mp*djr_4+VYfmi_*fc zMho{av=BOt#O2Q z!BeSeDMD3%bQg;&LjNQSb0G?QG8vcO-rH`c1%Snm_c8HXN%R!70P#XxBtFm_U{2y!sz8 z3z^K}LRwuO%j`j{m7AzY>(mwYW3+$xt%GYTkfb7M568>6Msg<5mWII-WvdfK|t% zZTmLxyp)_p0gHNTu+d)1v!v#d+%-9x`zkX}gX9qA>7rguD*_%!(#RVGauG#M@gF2h)_^Q@MTS3YXFW7!Cy>f56Na2vo^sj!ob$`+ z(w}Fvr=C#fc?Q04w#*lfmiKQ45;O8XXq!21zZTJPzKqdD-p#0rOu=)WHBOO6Bk#%= z6)RCd=6%`&Tw3{+`Vp8G$E0}J$Hco6;vI+J93=c~NatFB?1|WcAy@&jyx+idIKTv_ zP4Ay;DPP9gb7FJrhyxr%{gH<$b;V#IJ76Y7493%^M4?fp6(`ZWF^j1iMJ#%`#de@@ z2_i=J&MekC032ApzPz3^Wz5~Ud42iDf-bvR^Xs6ms1v^CFje2Qgy0n1CY_S#0502* zjX*Jvs_)Zgf#+o`zcKsyAogw?6ng=M%1#PV*e%%?k0peP^X~JJDtPB`re7h86I(lk z|7wfh%rTtQ)q<5~=w0Y8IY$M#BhLT-JQVdAkJS-AsddgF*U7M*40)bKl{%fHQW=xZ zA>xZ_<<|qAJVqTVamyz_i__$hZJ28t+503xjmz&O&0F-9Q~sGqg_q3P;z(^=v0ZW} z{`?_NrOU{B!1L!$c9wXG3f{|Jf83lUY*<05OLB~GVHv**9(>aZD~#ZRPQ1{N8c!J( zyZmPL{ELxfXoQ&7zpPU?^|f$Z6>F>7i$9mA{$vi4ALYj#O$|SGZl!x@Y{(P;qgkL@ zozmAo7CNa~XVun>}M2?3~`CUrpI`thw2|VYHqsJ{+A>KAI zN^iaNwD5n*#h*u8rhi6%plqK}?etee|5Yg+X3Algp^uoqQ^`a)Np!&&n961KPmLTn zC9o9mVT6WJ=`a*ZIzP)zO}T+HSlkYmo=sJNWuy&&32sN!ii zc8Yc1Y`!#mC$3*zsY}&Xm0g5GNcz#KU1|0eyI;Vaylz&M)v%UZ>#l`E9P_w032M z9H_qV3?8PbDSD6bAXScOHLwP!HClJ6O0t$b7ti2HNG?#?Ps=x+mQAdK+vJl{OiE)g z+7^4DVCEP+L%v8UmXFRG)n_J?P z3z99UcGWZ}@g98dTkwMSRno@7ccI~=w!)yE)z)Vs;pkk*Q)h0b=sUDtR(MaHQN?Q1 zX8nz_cLKC@H`bxT~() z!J=w@EWGAzJw0UN+|k2p)(p*$3$%&{tH7Jemc@<%2?6FRk7)XF&8E;;$YDcDL^x zHD(qu;WjE?Ek<_$Bx@ScrE4;(Hk4U1;w=hhvrfhAUOz`Z9L7Ye%q3dlXcMaWEm0!R zqBQB|gBU7@sR1pz&8|fyU(*>9<*ts#d7`nYf;6q2E$d9iD_RG(!NnE`W3y1>93&c` z1X&)aMb<6%6BNgKQeRq^s?~kQQF4B6P;ebAn1xiX^K|A zs1aN8*jT>aA%l1VKw4XmeP<)RTLZd^fA)Jok!#Qk`B#B`o;Qu6_Z)KU2nH1%Jv3Zirp!ev2Oxkb!Dc4Z<- z=`_(4K3C*dRa*UfaWtQ+80Ua!JVN*t^^GnJnX=kNphCMOuC@1E8+{7X_+q=rdqSZj zNkblAHL9fOUT*&_f?|?L<_Ko@9~oKsjkTaHRWyj5BJ`xFgq%|Kh&I&bmvS1EUDt_2 zi$q{hvUMOsi?#*c0u}908f3*%Lb#zS{@BEY<_bZImMtpu(y?+Jd{3T5+RL`p$7 zNY#3ZM4Fg8?w#4vvWg}hCIlMS>|{bZN|6U`CYFvcq^_7!^q-5JMIt!d$M7sJgQ+Fh zRO5W6sAk1dGbNu?aQL`7{4~^H`iVpQ=fBVPEpJb!>*b>%&`IJWdUd>_PzH;jfYkA> zL;td38fCRdwvX0rm?atW(`V$GR4e9qJ2%G)5hFJxOF8fN?3bFHA31zS*)PkKVUrgT)5v;B)&Zv0`=Su7ouvHv>MG8Q@Rf;w+@_? z!?dq3Z$3^j_YTpp$lh*ov(Iq6*d?k$zeH{{S}Rph&tQBnkc30<%%%||2#SpJeKJ$J zV7ZRfy4}WM5FMVoEomgB@J;hqAe2aD@w-$ECO(&+#htqs*8nGTMAco_wl0{eDJ;d& z;oydh2#ugHZ=q?$=3$3G^7wbO_$YU1JP_+Tj5dxunNo3_NK-bYIb4j6GIHsq-E;V#6)O@K)(0 zxo-eSaRmB=hitm>2h*F5Wh2gMj@<=h^5d0(B)Wn` zMQoYMR&u_W*18sBnfls&5YjSQr{8ZW2l^?Ql5AHm|ElijF8s{FZnwe(!1gq~kuDUg zkmR-PpA=Gkjdp~O>~`@3Ti1gsFDpQiuAYY@UCkYtjU90)xK^S2M3#vSJQ%NuE*k6M zA)}J~_w%7;s&F3B(eauSvuQ%JRACG}IzG7CCS$qNcvMQoC_hbq0e();E~#zTx+j=2 zYWO6W=A4rU(hG|dDiXG^$IYM8Sftf`_ySZyx~GdoMWw45?f65ldshb#Lj4o`ISX!p zFV>r5q_>KG)-TE1()gA|pKNw^WEd<2qL{y+kYK>&#p-8o46aj4bk%C-8gJzzL^q(9 zG&s`>%rWI`Zd*l#z18?q{*wD2bJ8hTrE}Hv>|a! zb6Oh|E-8KpbnYv(sNw{JMt6}HhfH@?FBzQz~=kfcTn@um_H z`_!}|T!0>YHDz5pT_>w$K)`Zq9Q+yP>u7v~9fa@IOzS~+Fu^ArD#YE{<#%YI%cy5^ zCw(PE&WZDZTOB_ap;cC&LB~JFF zj7Z*!QRNpBMN$z>cl!cgXsaBF>g}Sha$u62T|g7ego!ufNl&w)fKm%3=~_H%npk|? z@k+Xxb)RNo@Y=l8!4$x<{QXnOO)3)blyE&_{B-P;>!WJaa^62KcdQ%ux5FcgRsvM* z2|B0h+-2R5X0_51AM0>}%o+?~9j*f#6xCfdI4Zm}UQUm03*O_=|9!3pe-LAgw&|1P!_X#`Q`WsRsDwIMsC7rl+zJ8&Z&6-Wi(*br*tM{XEBl(?7gP7eoU%~+1;OIv zuaJ-rRYEAb=|HGLTGoooSE8@Cw7fp!9Kv> zz(L%&-GyX$ikrKr!7)XMzHJ^Kr2J4Tp`w#E^4-sx(w3^n{HcI&Glw1NF|RLR=PV6x zTY)@bV%t=7th98FtsH>y49Rx04yJDYSf9mD(uPqFp9vjEwr2eR?2uhK%k2>{O1RNr zgqz#-nochM%vz(-$0|y$#siL=qei)NmzM6o*mQ=cZZ~KUwb}bcN>PMf$EsL_z}#W4Lk~#{daYRL zmyE%NCYCHk7#};2C+ib%rX_Fj4o8($V_ zCtoWYNQ}_P!=cOKYsef=&fyTTVeR1(j6!)X#LhW`_7*<@^E|4=eS~4U4R7ewg16ue zxBDWM&ls?yI2MIi9*qSlnEiz+5Kr-^{Q{DG!5~-xOAg1fJV|)Lt`cUr)h2(e!(Em^ z{lH9Sr{+*c@n7=ev0KN5yYN7YIc-8dXqSR%D<7;y+K;|LY|(PCV^7y-v^VbO+8@mv z*Z;=FQ^YqIY)Afk;XT<(K49r!n)q@8vp^5CE`>;MYg&%J)zWw^-Hf`R!W-i?(Fo^f zI|;@tjTbyJ{0PUCTBaC8j>05ktjnnp+gi$fm2mwAQV1fVF`n(N4C}P!mmf!`M)33d zni(lybPQg3uzEUsO0^+H`bbL+idq)AUvNoaZDHYN>d=AZ<;%#UgM>Zq;WPkF%J!MooI2{-|2NE8i`(}1)KeHT%&^(A{by7&)y zJAd-?#WZGOu^^bvykU#sVM~c7i<=>iB`fUUBNab>b8kYSo?%k$?6**G<)GJ@7uPE= z!qFJ>FX?o@#x@V0uDEDn0chub*X$q9sXz9NIqxZ~m^$_Rj1NBf#`~Npf~b0BB6qOd z$R4h_RGo6KX1HvOHTvBdQu3psXU2C~V+u*!ktg9$E^80mAa4q`n3HMWuSejUlZk<( zYIzs=(ZqT`r?nGjgQ>PEMunvvEjQzbx)w+7+QD{u=f;5I!2wqqp=y+9r}0Jn0`zc; zKNXB7Szh!czz};opPS~L7qfkw4!4kOM9Q)E>GTz?cCaKpd1Js6BW~Z zg3QidyM8fzup7hhRh>LxMq0hrQ#uQc31y&3Il9uL#f6*1QjXq~I|QXSaQCPswI_JL zNIJGfrsr2(TDpc)tG(f4R=z!C>~AFD2^7sugrQ>|z3IZBz_hCskN(JT5n7cc}gdEW9Wm7>}oKc5SBc`ZX>@0d(7t|H#V z4h5DRP`;sFme$@$)?dE)${EkHYuP$2$yV5J(2&|VjLyEaer(0fxDCrM7;KsSGjpx{ z*M{+cFE7#G=RtVD_=V8&8qUG#1HW_;_-_~s@mDYNAVg_0(cV06-Wyp;$pg$n9I~ac zKeF2$g_@6H@Rs_0pRV}QS){vdmk<27@|trhbA<$L$Ms>4hq0n$imCl1Y2Rz3T)Tw` zai~W$o4EYhYbu%ttZYeaw4Kt25@6sR?v z7N)c6h&V4yyQpf05LAS)9lj?=)7#3TgU}Zq2Sx7wd_4xTjsHSBGNUwt!g9@sGx7-I zesD84yB*H1MFJ#pluJi<7zZYni`m54xui0|6^t-NYIDqpUj-RlM)PKHy?|(EAx7?H;${mbFovrY3|;?RsTD`{JZr zKw2^jU$VKdewQPDW@3{J%RP+)H1T+8t76+`b zc52RMd4c9l+;@!89l{ejem|BRqBe{B6a>iXTDo@ci?p~e)0^H~HTbeHOYvut%SSs% z8Ic0E{W6=L^#zB?L7$^1_XR(GcAxJ{`TUlfe#q=T)@*wIs%ca?QMNAr zoT&|^r|{yh4F>(j*A*8Mt_I*$F&X`K#8ZKMh{=xAR?zID7?y5tqPRiX%YxaZQ{qwb z)Pfsge7YY`^ot%?=3#+_iTQOsPLxk{KwGehre0?X27R`PUdauL;HSN1vbO<$UI_VY zM=aG?y>&y(;TwWH&|NOe|FvX!7fOVq6N?F-j$gP&g6nvb!VfEDtxqe`){T4)1}q*? z(WRZ0MHLR?V{qS)A5^8>APg!n8v6(w`*h@!)^&QpSxe4Rbs!eWj@}_I1d># zQd)Fju0{KtWvUf3Cq5iZ?(MMKFx_sq!yOfoLC4|pD8KCnza5wF*ub8r^{|bg1MvX3 z2sH>$YO^#qXR4fX*5FX6?kjG~OtBaf_;LXUyF-njNWa3A`{=}@5iuOQ@X}NQ-=Ohc z%g%{jQBYPT-M!u>w{``iV;kn9rAfGvgvPA~D4t=jx0%Xsj-jCG z-wN%$@E4gt*9GbEX_SK~l|%R*vN+)JV-3r-8pf?j&nAI$w5nLuN{>UPIA^2N zeIZ(m?sWgQoku_sJ8=*J1y`;`lpPhXbrFC9evVlR5N&1f%}zeosP=*9DkjTm&10VW z=(5y35V$toPS&v}|v~*1G-qc@K)+$i`#<-CvVw z+#;-Nd&@dkOyUzjt1PK#fVSMZxPD0~56>Bm&A`T=Ze1@Gkqbt$lzh(Rny6VnSZ9il1z@Mm_2!0gX=R4LtKUk;DLlF*zw2(cu(!85*(9Ce5(TX? z<@NmOa&Zn3*aLpH7x70gnFmys;EN*AlCM-~)JmH9a?^rHH+W3lq7qY@m!@7U-Ut^J zNIM;8DXN=pg6XM=xrn8uMt)>_-)z1(O9CtfI|GxvAVOG1>qRoW!ZR$ic;+MKLYJ5> zJ-pQVls1_=Z~cyj7+A>la+nM>IQ?T#Mht`H(zV^sS!33N$lr4BZSLnix+LH7tg@d`M7S*#(ao9Tq|vhw_*!NvI0zbFZu7 z(WbKBd6hM2A_Wv@nuUIW8}SC5JNEfc_6)1Vpwg9GW*5}L70$)C1?|M5a58EA!N&3 z%Hs5}xtkO*rCBAHlCvx|K8w157QU0RTMPHz+{Wot?C$eTEk>Lr=0aX7wfBYF&EkzZ z_IY+MiKSi?wnK4TOdOR<+Nf#myJhFm8n%=Px~{h~7pW>iPpRl8ZR8e_!IiR-43Wuw zg0=deIu*P^@5L|0=_k|q8hNizR(HUE#A;{Se#b7TubmSF0qe>j0X9A-ODqx=v^Or; zjgDm$l#m)jop;=&-`Q1B&H}joJMcfMX+~b*J-y-o8(tfeJFlXDmm{dRqs)JHIk`h?YUhFR?oOqKD3@q;VlPF+!d_Frn01 z__YG!iU;;_1=?t(2h#+VokWQ7fGZ@YHfnxbmdk;=1=c=nfXl^Ox`5V@bb7JhsXj9$ zDoa#UMi8a098)S4+NPH>%72+xSP>m_86815*-dNMm?cN(+QJJd;OMI9yu(1II6p4_a zw;|9WT*&Y3^Sp7%B2}5*Ge5BAz7U%t$n==lbbIl|Kzp5g{~a=wYlh_ z{0yz$a{YGF^%Z3By5(TJ+#W3j#jD7G`3wjiE|anaNMaWRKq{Y7JwkfkW++;S>Kk2o zk{1v`kn^^=DdsI~QQ*vgN=h0OWCLOT-!fb-Slo#nu zTyF$9ckq}g6Iz%-FkxQd-qxW2wv%XKI*zi|uj5qO(UT>~Z@=5M!X!ub;2A3UDv3S2 z1I~;Y4+MJlNkukG8qa`c3v5HAr*%qjJ;=rb9T`Skste{r+gEf2BN9Q1Lkjm>6#7+J zlD(I37rnAL3{HqYp<(XR98CfuaCs9TD$PlO{dqh}^zgwb6{PBgAh(n&maKe5G~cjb zZ0r1#4ya8`^qa~kVa4=}!;#wOib{fr`S{bdgqjDP}$7+s7h^!-$WhdahK7|eUU6Qa$C+y7d?S9rz zYj{9}{6}TTSd1ZtEMm)-sF-MI)vf9G&pSi5bZo)SlwM=uQFlQ@105@S36=EPmLWU~ ziNEu~b)=LP@}BXs@O+t_oA#G9;}T(PZUD5d`!zR`5@4fSjxNT&DzXFj zW?Ls+hRo#axTfR~0C!O@nVxisrimiU(FU2CTp(tN_m$oU&3Cx)SOIN_7Qc*NWMfBM zk$-Wk*6``4Jp_CT1_Kj|N1pxeJ^AHu>l&xLmb)C*qOEdp85~rwb#g~GSehP}7BX|1fkWPF#Ex6Jmh3oU z4|al#l*Fm%TbEAb$JDoy+hvJhaod(ANxP#B8rqN{=7C#%XUl~xso9u;F|P5~-z}x8 z!#RNj4phCtA(@{`K$jbYVu0V84AR=So}TK{ni@H@ioJV*d<8l95k;C00io;%XlT28FO-_uO^2mJx|JW&t%HYD%;Kh|hVwdBeUki4FXy~_!+Ce3IJ9ZK zK0%%pS9c-F4`utp|LReNFouhFq;+@8;BBBL0bZ9_M`)xqFS&gpHrpyovztULyShl_ zJIR@+fxYiq*SM9SO5P%niGDE0o~&`Wd^wFJSU{z;7oBXOuY{%$IwWb<=B17aJR<%$ zTNN5Vcyjb>LHp*n%OP>39El>sRSs!TC4pk1t^|vhgkfrc_fpA?YHAEofZ+1qj7pLY zKN4H|F06^WEZkf8AluT9!DIMRnh-Iw=qqYzDC)y#4xYyV@r~W~Z(0`B5ul$#BQ1eG zK7EENXWf8#tXpn^@&{1Z(D3l!w9yQ zLth*o?knG6NcS}{A})t27&Jw^1e_L1&KEeT>`cT#;_?TEwrx$xen{iMgX#&{p7h2? z9n*50Zjy$Vr;(6>@E&3MzgdJ6L8(n!r zSx@(m9nQYaBMQKq4OEZrpfhEJADX6eu`C8kN(!OIh(W#mGl7I{Cp3aOv z6pLPv9WN;7`150l^2iF!APF+Pti(t4E^e;iow!C_6)4Uoyzd7E+d+jFWvgTWSuRJA zA7xYxi^1@!6_-`M4OedE>wU>if7K4(J%9uCB6*l%l(PU&)d}6e@=X2UL$$=6FsIm# zj2ug?B2q|R0WwZ($M|C&Hu(}QTF3bkm)5YYcW5&)}pze#8|zx zUC^;|M6^}Q9jyDYAvh?nwMZMdb7xy=^xI~~X2yexdsR1IJm{KZqj@#|cq;gj&z8O1 ztHcf$-T&*(=0M|nFq&b~G-c3Ss_v052F{C|5!~&Jl>V@Ad(IQq)yO#1Jx}w`1qmzq|RA^25_8HF(iWrDGRv#-t zARLdJgm}Qhas;~;yp|Li)L=hAAQ*mi9I!R{HBoBK%9sVT!`Q_atV?e67(P%CX2*A< zsq!P%3>35GHIg_>$XoFFg(eE)SWH6qSL;o8-o$ZBSfn3uc;LCF2Eda9O}+)07LYK) zz*;p$r%kcnh^lVHDSJ}JPI0b5ddZjcO%@vbuXceY`*rV4FCL<67_yBo>U3H?72KP zl%J6TLSiIJlftgYLYZw=7?F4toskf);lrf_t|M{8Z;sK}1dFUi#PIp;1 zE{77^d=)V%tqBIj;xR+J_=-nIH zSz_|lEFq@+Hr&>MnUW?j8++vhiRbdw*?y_f^BBNv+Nm7VM&5Fy-8=fo8kDB2sh@@P zk;?m|`l}I?Iq1ZES~roz7J_Q`;(ns?{EEGaAxP3upUc|b7gNq6C!PsYDtDPjEOHcq zP7g&9m1{;IX(N)#imAWsxu21X@GnIq%46N0^t@Z|Cp~{QZYOwYREB`9NoC}KCg`el zK&=6Qs5+!TASD?{&0r!pa%7*oER%SftP|#+QdWI-%8lHSy)4=yW_o0l!FVDc*wVRruqCW zRC#0c@09s`VJ$9-0~El{0e#XnuEt5%{+9w7^}sW-m3Pg` za1)|xX`q$5{bJy?H4ua%ai%21Oz)KtyHyT2a5$!`*{JE9k77nn5Ev?aZYkxwf;Km;s;N-^-Km~#9;W^!Dj$Fma0%f54?5ofx;uEibAGnj}7~M zHYw#%m5m5y+A3{^=xd}z1o`eg9}-Ij@476=??OH{0AfOqBLzx|aCp2hJ2Z=4dp*9E z8&sC`O3njC`Cgxk!j+~efCyC#S|581)~5A=QOTNQlZpc6b(H#LYBTd2iS{+}n zWT@<+JHb-h%uIuRfLm3$KxvH&2e;=Ex|}I%$ZfjPAr$aq&Uv-_kWUuxAeo}N_@iv! zg^eEqRI}T^7fvSvI&OZ<$TW;}^e`);0H(e8_3)x0s=E*3p%qV>CV*F2*~_qzG8FB- zXrZ?6k>fy49jhl3%}-YE$nYqROt0u74jM$8@kGtlp!YzDe9!A){R|kN#|>ki0%5N5 zpY%Np3A8{j-b8r{lW@d5PTh|!#R#2K)my>ndrup(3TS;9j4?gT2s&(=K<&YJjROe3 zpr_zYz=gHWOHXA|RUIiIDaKtQ9*TbhoXeAY<>o2jM9U~0wb#7s{>PN-u=I2gK86** z8@EirX7fjtIgWc!lP9vcmD7tqBX^MqPc?;^*na?_`M`n~#Nib{?w&6}eTuWCi-Dh6 zBR%74Gly~R!#Ul>_vds7O@x*fkguEdRZ?73zY@q$EP$VJuy`Vr9({zHN)a9v@y8nq z(5_k~MvVKBNf4ut9oQUApdXGCKlY&gD3}|nJ!2a?j9?;}J;z3V2l7dBpoa zX=s1JEa}|(KSHBE9P1lE-qfg)p&a`^7oZ~t78cT{lO~0ezbQbgNxmV;Lvx^uEeK@- zJ4{dK!J#8oa}k%;W~RtV=xBbE4y=RzwEA)BA`U0CJ6aE7$U-?G>Ru@Mxe&-_3_c9> zQuRkRerxrKmQ`!w^Ky7y%vp^s>{cm=PGZ;lNb81H$LT1aNm3($#7)L(>CJi3KF> zbz>9l(V%bH)t1#an_hI7=4927!)MR2^^i2pQ!9m{9C!0{sg@xTYc;qM^CKY@%K>zB zlrK)GbBU3$_om_Gs!nTLDajNe)G`XM~8BG zEIbjTjlq3(y%RgFf}$HJ+CIVK28>h& z!1Ply8vw&YckZ5z3%CuE9yPz}+Kc(Cvj?GTrk4dBkrBDu&rJRpikMB`I=C7Zr+yw- z)A^D}$aiOAsNS71s7#aP4Bq?Fn!qJ`??{zLL}vk|`5f)GYLr4kH_gn57h}m2WKz5;A4RRoGK)G)r{1UHU zZWpp4_=_x;j5UZLBcH4x$d{?>^KKmK*e5TF-{(yK$MG14M>P~r`!H*R8>WL95}j5Z zo{af!T`W?ovWJL(MrUaG_7dLlgO(1vJIe6Nlw8XrzehL3jkc(A!ij?z`+}bK3w|sa zSDqN_5;cNO1rYaoq-R&!nAZ8fMIZth+v`B3%9_P|{df?FfQy z5hW)V6tT6QjYxp%EW(`KJ!b58ju=~7*-l2;qm&a(BvCR-FI=w_4OOy-E}#F~fA1fZ z>tEFrXk8XoC9}^I@zCE|s%&If!A(20A?hR|-%ZyKO(v%-0VWIJS!|{VG zdD3JXJt;3_hybLz`25wuphx?I$3P7^;=jt(8Db5tt7_1ok>v|FcV1wrO1zGRdLeY- z=pMw}N@P%1_Q%xiXNga!*h$(kb!`7P+fpW#QX^fh6JlJs6wj79kw5XlA#3~W8;V8#pMvLXYCp$##nXz z$Woh@{f(yGL_%%}JUV~)bpCN#F=(t5lQ9X{MM~1*t=udK0BXGMwPB&x9vmv@A@J#F zLF7ZncNTN-Mxpd9&YW^| z6jobgx8Y?Y`WlylA!yXsIT}FMQORC#rX&MgLd3)mtkydv9l%RLC=I_)c9KQyddKI%vwc+EJd6x(HO{W8d*P@ z%XBP`&FqgK=wMY!jO-06A!VdE!Z5k=+{}=SNl>nwr)kh495rTt3oe|v<4>5T=CyoZ zLTO%Ashb5D{8|mDiWp1~YC;z-0OkK+j1g9TxZpWzi}L++PbjfNdn~>9@(@4QZB?Jz z4et;^WI?5jf>8iWA)V!PlA3pElzwYKD@x#@V^JF2CMYE8e`g zdfdBd=}(iO<|QL?P#Y1VrzeDz-!Cnp4-kO?ADtc%VTM`y}y6AdLC1 zv8Q!_WiXI9p5Xds6|RCXy!FRvn$I53T<~q4SmlbRtX8WeG%!!*^XLL7G)-F)G>77| zll5q_P`y4Sl&d+*jBTi;!z4mCLbad69A2f_+g zLrkF365=#|u?=(5%sI>qy!0refwzf-0vh-v!gRFojA`4Yd4p$L3VGP8I#i^|6*}IO zs%xz$pD`~^Tl`fK+|Z8d`|g`%vALVP1iCyU98D_TXA+>6a-_I*^UZ|UOPs<`d2ECp z+(Jd&c-WSJt%IhY6nFJb{U_gvjS(U=q5Yy{QSB9c)t0S@)lDTy;Dr_j@pkBo%HR}h z&eTarmBuUtN$PIE78LHlr)Qqu%NXTxo(CS5NPuxN{;=|u^q)pKupC+b@Lom$t_bqj zCo+$Sn^)dntKOB;OgSjr*PiOlFZi6Rt=wc8Rc4GcoMdH-SLP>P&2TOrBsPYV zj4yD@cEyI^&qQn4qV0}L5wcl3U44&ewtYP0Ykd}&!)AYIt0_j;TXIs@_9N}EW z9T9so__3FOX8G#4OF;08%kx1ddmX4fEWl-$EMAGR92i)88nalD7M+zwqZG|YlNOYZ z#`!4-B0{sRLQnZ`B4C7ar3vAw;BG5gYkcm?;L*jS#mS|!At%qyr`llSN6BK$cQ1KX z!nMv0=u*?_)^%f?sv41op$r|5<>clg^?A-)4>Istxs7EBzkl1<1qcp)b7<}rG0YAJ zeJG9@s9GE!=`5I4k5nJSoH5lzM+H#*v|B1B10gw@DI~eB6ZuR0CUsJp2169DHSIJl z)>=IQA2>U9I*(_p#*#RPka6xyIc7Zj0rh^8EOeAnB}|C>F;?PgBc_3{QMo137;{f- zhkQ}xW2Cj$3x+5PP$`DgO|vQ-z-euXJdJ!StwI=Dt0mq-6^(Oy>!axKjngE};{D`e z^3m4pD_RbB3X}I~#LOx=lOvhjR{=E~;0lLfcmSzrfbv%#jkpnc-xXU+X=RquE>8n+t;gDocm2md}0I`MQ`yZ{me>l&roWP||=?DTFe#cf(a3v#w7O^AWKT+li zyZh0hkFN$&y16|+j|n&?wP2(xs>*MRy-8M!)&f0o3`c@#o`{0}JCiIeuU}ibl`~=| zMPBW|`V@369q|D$sa{xP+`Ltg2W!iQ7Q?MPZa`52mi{aA>0BOdc1Nt zUYWCuOH7NlOtOB=rFQ95h__l$^1_dt31J-U<3hmEi{nUaCs*VOt|A^&H6YU3n~z~Z zQDAtoAoMkIuY!sfU_YTK5H|~5t3%m-6fw}Ca}_Z^U5};)^`RwVBsM(vlG9q1H!Qad z?`W=D%7{#gyc#1-)+Xroq{v`W|9|YgO^jUGmFE}P4vpCZwkKzX1F&t59nx^RGd0O4 zvWn7B6h$z}WHmV=iz#MSsiuoWMldr-W>{QIAC?tS+~L?)B0s#dFqM7Js<;=TKE z?z!jt!?uWwOxMX+il@avj#*u`4?hE~U0_S}%6QpR(wn%u@5P}e8O86e^Oy#X3IlW% z#-sIkjM z5{RT~{8Bq^{D7LQU(|5K>O52})NcT#2Yu6pq0HnrZL+?F=u8%Eoj2JdO-e6QsH7wi z21~?lq#&mdRp*u#`)Cy_o6ACCvmuMt;Nvh%chB@CrMm)WTO+121$_R+1oB8X9d`q% zL#tg616S=;2_+CFX>Cu$zhWh!Js1G$T%HQhFi9z*AD}V&V`)ceWu>;{=5e_qrC{YQ=PB+zsvKP_#-;V)2P|Kiki=ZjzLoJ9>*^oM9DCo1UB zpAz4pHRIe@o_p*xu$Jf8qxh&x_rD1VPMOZo<#`vz?35dtLq29{x9-TOz7y{>1+cOD zNDyqoRG8(3EXxSQh@zo54LI2>RzR}Rdgo2?E54S*pmRIbd9hSUBXMcm0IuX9LKLGQ zLfGJ;?v_89IP()tAQG5lpOCi5E5J2gBWwYcDZy@fj`tAhxhOBXs4-}$MmO@6RTi($ zzE8oGvwKvL$Yi|mKM@ou9^i=p;ZX-eO)1s6xhGxm4-ZJrFbc&DS2}gFB4QCIHm>#O zotp~ig*wz^UjwMb2$bGc*wdZ)-Zm+KxK9S>KS>rvap7fV1$2wNqd!Nkow27}x~61G z&5QAqMrYJpQ}ffI<<9HgX-S0vtoIlMjB}fjDD7^kPrPURd^Z7F^EwxzA9YJFp(WW@LaOIKc7=F;6;2GgSAM@ex#zZAF1`)81XIE4B<=CYdjz>b2tH)ewBBhjM?Rv>ayQt$= zMCl?Butd)CZ}}sONG!{8vDX^$cKLK82+$mCQr27^6nRX&oa~9+t!ix)S{cb&Q}Ss$ z%!t954QDds%J3j`urdxHi2Yl2Cy#u8<0bc7jzoCOXOiV+M2qg2GM}T7qV^n7Is;F5 zSJoOK9(5z(SGl6?JH?#3Egj@~HRZh)p6TlwSdR&rplPCTub@05RLt-r49opvoRt$cC@aJ2*AaO!u z60aINmOPP&-=Ml-ut`riduV$ZIwv+EgPOfJ>%ZxJJAEx*Rot3G-7ul9F;obghZyR= zxVG3|eu#Uiw}!%J#pe69r}c&Bp4R7{*5{s9)BB!#T9K-rds+|h(LVRIx~tbE=;xl+ z=bqLq-ahxVW>7r$v|2Fzb5AQqdTbBRJ+03@t@0wF>H1isZSc)t$c2 zJ*~-||J>6`0{C-JYbw%w2v6%jxHSKe%((Ub##I&mCd6@KyIkn^cCL|X z)ZZS;2EFWA*0=6cEbSsWtw(nn37KRnS$(WfsjJraEccgIIvYDwz+0nVyHY(Z7xNxP zO)Oj{0(d&qoj-YdcZ2FHgIBgDT2Hr-$*(mQLL5hbTS4I4KHw<=7}PdM8N>&#hM3Ve zD2GcOG@SGbq#f)`SDjbr{X%dE-KwZ8fzuriyu}5W`tyB)9*G>ATCGStUD6v%(=jpg z=75xFmAFz(T_NOWl@zi5V50Rk!CP(8BWU6}*=;41r-AZuR<5uzLJgHks#pMjpQJ-2 zYR=|ZHeZzjIeg=qUy%deN}YEtG!vu8n;g{U_6KI?;A78^Muj9+mseF_(rW{zHbK35 z&ZQg_L5c9SwGXRr1MR?XXzOzZxR1x-OMhMyy@igj} z@^X6=jP#bUD(2dMyu7ySEs9xJ?(RW`NJ@L2nD|5^>Gx}|5(#o3wzt04sE{)5!_n_W zX0$@ORGt9@^g=;~GDXILHbBTQt$Ov!Yq~J|(p3xg%9vo8Jb-?CZwpjZd>84% z-VFJe86d`F3|nUNVhW-!G3nwR%06qG7UZE0<-|3r*k?k<9Q=_1W+2u>cCjHHkytI1 zsskl=Hh*e^2?ruH#-rI(%N*zn({oJ+i`P-$y=}nSXW8W{UgTH8QEek#qRJJF#1guM z?RQCKPK6%8+5oYjU03{x;Of-@=>drhXxSM*W%J9#M{BObDQ!)5Ct`=bc*qoqu~zTD zYR%hNU3-*xXe%0Z{+g-33U&f4{q?P#J$15D*estTEItCF>)DX=2CLLAFOI;fb0|6p zoF-0i=w5SAH&!V3rhheIv!Hx(=&8!GyR%8;lY(lv!D9~A+Mn8?TCW#^>=T%QNnPS9 zf!eQK0NhBO$8;CbM}nU!hV#A(%so|KA5W;LT7;V_f4R4{^NK3120b)mPuhM2PJwWsvrg+pR)%loyy5ne)x)0gzYVs+Q=tvjMF)eb5oCMX zBbTjK_jc>p7M6MIjM(+SW5T*PdwUtG@qI85c>60J5p1XO%&Qde(rp5?u^%ECGm@+t(4OyLV4DXCF}btxg) zs)PvA`E9YR`>T&3k98_UtX7yrHmXuw40ipQ%oS%o5N%RiuE*j3Rrin>R-utR#C+PG_L%Eh47G0CL$d35hW++h;**$ezn z%fCmZzN&M>%fty_+$ipslHf8~cNryw0Dxj_9}b~yH!s8QIYX|ASc;-AjwqoLF@#=* z2jne_voulv+URE5Q}G?Zn7ZwI<k@q# zn;?n#UFJOWe8wf6lEt2rV6B`ePpyQPIcN2|kuj}#!Y-?jr6O9Z=8T;VMbzjH zVvOSTZctbse$c&ZrD{SZHz_tasv`l>^V}7$v`7WA{))PRuI+&toT3JSAE2bQhC)mGT=?wJv_*;`N9J`ILL0A% zua-s$II>5aw;z(hsA7#(V|ZCIy@`xg_dORrq{=+w^;{C{3&I2Sz z$!A*ul(H;6?e5lMwGtjE+1O+p^Xfdgu|y#ubrx~aX>ep_iLJ#4>5-@Hb3CLkrnqhD zObG*Id=qa}xdQ2#DEoLWba_BSEwoLeK4wn<)kqxQ-9~a}*CwK499VqVe=jM&=_)1^ ziSaddBKT1aKfr=nK?!ELJBryHjKp}jzsXHnu85z`D$>;?1U?m_lp-xsh~6HjR;ytr zXiYBx89+=ADd6&StbO9diI@A27Lm%@D`w`%nr*gmOkX_4ZJf26A@NOug7R{xV3NvW z-MO0x00QT-tR}uL$py4K$m}54Hz*Dax!Q~?cqPuSbSPa0jxF8{qd^qz4}NaP2~uK) z@+x7OM$)uqU9FJ7A03L_wZH|*v)$P0)ScJw+$DFF)RS_xrfw8#ePD|*MFq0OT7xl*B47cpDaJNlV{kZ)M5*e2f@*a#zuP+U*$I{Z zoU(hB05UypjJ(wloDwOnd)0|l|8RKwlt!SRq~H(fS>9f?t|q!12~6GU?A5SGUR5?$ zi&FmAWuMx>(qs8q*`8y2XRz%(y8}>*{x-{6&qrIGzG>FDFRjYtQWUm60`-~&o1CeX z^{C^124+Q8W(dIWLvKkYYME7uyl{l2v*kHpwG45*oSM?93&@l@NZ22j-z9e4EFF5B z*79C;=?eGFtbq%zWfXP!Q;qpan5FiS&zP+!xhUZbt0WQ9YL4;C%C4?<=RU2`0$`i> zRD(ry8pE#mba2^CO1oz!Shaqpf~#@sRcOkea)J=jkqn9=W@c~5%NbO2waIw@ZM5yG z-+A3up~enYkbM7*uq{`JIPGP~ysR3Dur>q)QdA-4{hjM8=Wbwj^P08ySGmG47Q5K( z52BK-ed|bF(}uyR#DFLZqJdB?#3s+i*(~o}=8`r`CXW=R#w($c+Ux4iSEu=E81M+N zaR9ksgsan`!~__@g>$c3TCOI$j0(}5aPt3p{eSugh1qfP9Sp?~>7-&{vE5vjn7ZOb z6xPG>TQNJkwDp=WBFpf!=e1Ko6`6BsfGp+=zNb>=h=m3WA*&1E@I3mhYd`n)-oY*j zHVMO21@ZwV{?+ASTUvFg-qA~>rfqIF_w?4kef{qhTWYCugE&)d7BHdCsCLn{K7guY zw4!R_vYn|HUtn3Vhw19v9P$n+eNGmcKD@pt=3UgS0TrmOhvY2y93AoZ}hj4 zfQ#?}e{tK5Nn{OCjf?Aj{0hAtvfyfuNv3Z9HqAt~T^9Fe{cRd@z#MFYs?%YYw{O-= zj6hUs;4GcrtH%AxF4jnmH80~22)hMRN!;eAel>Uc73&PNxXGdR>Egoe5MCJc39iP? z&|pKHPJ*#CSx&if>%lT?+Wqy88 z&65kM60-Kf)yK=$Q5i}+{>5a+1Ibmty_%xJco@v7ja|)imW+mXc z-cFB(1|l3;k@e!1T=QDfSx!JQg#_(HT|ag2V>BIvRTh9*JZY>qg_6>1>R~8Rjn86r zC8Pn4*-BKis6ycm!$)}Xbosnaai?3qMop1aWFqerT%hHKx!W}AJok3hoVg6H!WKfR zLN$v#ZohucGZCv;t`|j~ypgkS9l!%B!`A7yXX-DH)Slr{XA_ljy@q%)0{VO!4D}CU zul-4UaK^_cw18^AqPyQVpr@hA5~t#45RT9sDecF;MoJ=SItMOU8Km6cm&AxB1aaby3fRISV`^$9oKPgT?( z!G1yI%Y)|g5z>@1gGarsWMVn)^EbE0-Wy*Wd%v^5JF-0(0ZrTXce|#o^dQt$nvs|3 zc>3)F7o^eBa$0a?D?5{DIfpAm`ZNRLcd`Ci0lG9FknU<4J2qMtAQ=dd@T8>DwNC`5 zjN;TJGU64hqGrccW0VfiEhr3RHN9%g*TEWY=o-|o)Fq6$`D?b=PB(tG!ab*=d~xeL z2g2jF)}8<|#vO}V#q2Glj^LG;}@5aem;IAzYtFtD@u(Fbm?$wwN$AehpI0Kf-Nh6 zNCLkdyr@uu2ZpV!_V2qS9pmWMO3|`wc;Gm8?Z66AN-lae^`-uvUr5&W_0BEGFes=~ ziJ|`x8J4gfzZNUivANy#^}Y7@2U|;not5+F*L&M<^tY*3&!xsaEna=liqmC&A}Ru@u5jIg+v@yH4pslrE9_XB86e4;tjH|L`;(f+YiGaX9$tC0U!b9Iw_ zrkRZ*c|^&4=dxT`{S{f((iFCKE834FoS#+mfnVj3-7=M|X!SloF&uU#qrzi+mBd0pp zMLnT64uMxv5o}gSsZ4E2B{*K4qId-wf6m)F zqB&XMK{C|BOugd!qQpvz%GKiuB#j_}8@T5L3okBxzH@8p%=CBpZtmV~ufo+$N947u z2ykf<&j%E2_<;)i15C>{G$@%ILY z2+6d*z_BMV58#Gzw|aa3Bk-}X0Cw-xAV1&f*55aPS`?6LHz^~^>dQr?@?ewKLI#sg&sR>?=K-%HPG!q}tu(-R+H?8h-Ej9$?~lXGgYj zPY*kswl}m;dfq7dEx&){3_yrOG1Imezm;@iE)giC&^Ro3X1T*7O^X+e5)N>)ZaH~b z9DgKp-lZU`Y4RK2{_jdda2tgZN!!E$^eG(8yzlcd()W`-~UN;*ij z(oTmp$Vdr2r|`CAoB-eo+$W$BM6(kzYM0BuWkL#p#01Le;CAjM$xoOl)T8Y9Zom3R zR0ZsSzsKUg^mV#$mB+UGyX)vX$U=jL=^bgab!<^_)f27850@nQHvXM>RdN`i znWIC#H&r0##q8C!`~VX}i{4SwOgZ@&6Oawo8K|e1?9FBXriv@Os0c56X>}Vza0yZN z>YnP7rquV7o=kqGbWk;q$4}8xacCgOMo&17<>9DjCU?mbdYP%c`l0D@4YND%nrT}Q zj|mcOu%Hc^o`X2!p>uXYrDYZJ@+A&f^8NcZfw}N4=7?J-k05BU9xAlQUz$eFsY|cu z8)ybVzhP<^K3xqjAsPd&y#S)8^G`L)32MTnrk#ZT1)lrteCM%F>D8UhYT_8R-8qya zlelnq8gpOk2WBmKSP3*2X`gb~z)C*LOQ&fcWzbk%e&ubN3&ilc62^jf(PgS8ez*H@FK%{ zb`@w#Ly9*9X1okC1nQIx4&qF_IC^4HtGI@TxFIp2akQ!4eeC~R1itxNMKv`#$Hdx! zvHbh@*s+D5Rjreq3myn`5kvJN4@R6c!`G+E;jE@yoQSUH$<+-tfyvhILG{z9XUs3k z=m1P>n-6d^vQIlyt`{OjoK)BLOOqeOv8r_k(y6SGVaax?bKx_wzA0QdJ4^P~q^!up zSITwVCUp!Nu$0Kx2hp7EX$axPlbHf6#_J7Aaq+^}#n7cc$PnY`T-=~%xID_O=JGTU z>X*U`*~T58YHH!AX|gkZvGVTv0UD{6j@C7SDc-LgEm|LE4RRzc$F_iw27T9CPN*{s z835U7(_%z8u}o%54gtm?Lix@=N({qtT1WRQ?MtE7DfH*_jOBjcTtzpEM4DYEauwTX4 zr=>CdO_Jgt9F7!EWjIVLS$a;N{s#$&kZ|#CqvL_~4_Ao+SsnZUr$n?06oGax z9rxHcAfaQJOu@9?HaUk6OiUQMpuZ&)f7LE^4G$+LG>9Z3q)yt&zavjMc;W*2WpFwZ zqHX3$A1yb5AAQBT$~*--$vAvyu5#Qr)E>R5bHBnUq?<32T3kb!y8F^G`5JB7YEK)I z8MUx}#_Bg$wSe?jW^ccI{pCM8Pq5sekGI9TJ@ca@6&M8wGqc2s*iU@YXGY+VN4C>l zFzMwgZRKH~n;W>G#tT-BYwbJRSF(~h#ydeXK@wcmvhe|F6=)(Wzp_gfa+fV5V}+W1 z1X|=vV^dw`6-9L zJGb83yQjVzu3wC8GTWMHpSU7!Pu2O_3^qJcHd_5Whdc(q_geVIv^%dOX^@!7u1E34+oc+&rf4QvKW@HudVX`~72T`*1SuUM4QNpS z#O9#Ls|c3~s;Rs#prtS)X#nPEra?ILM#8y)x$688X2@*>lyNc;`sh2pb~K;`RdCP^(JXw6D><5im|>;YGmNi}GH#}t61ouvBt3Wz1j$rlz% zdi9S_yh3ga45Kx1^w>QqMeSpvxr46coU&mli6vL~;o`NoQ1sEI)cl>tWlhSeq`j$B zbp>7w#dye?;s*7q^$W?PK8>?2`&(e-r8FAgtHVuu*niX8Jxh-8Pojzz$`6LC_cO@_ zvS6h#EGAROf>66`#oMsr>7dO!i*%&I8`_aQZn4HHp3AcX(Umbp4uOd)bb1gx~pr|-z zA+T9WWJT3k%a@IYM42(Ra8QcKLWbv|b^Y=xN4bvdrz{)UH0*JsE50+*DYfkRf5IBFt zWTQJm%N&%9Qfbyu7YR7 zBxUg02X6d>XcH_@K~!zKVD<7FhJhL&GJ+lv&ww*QTd{{Q=V0rxpgg-t7;K@k46pSP ze|aj%;9xosLJR70*6XyKSzXG7nwQRW-%7LJ)K737&Ou@6d<`-0p=%#8AF{_vc8rukxUb#JWm^ztJ4@$) zWI}-+>sjx(s$c7w%R`&yO^{H zD2FAL80|t*^HE!^9@J$7;`{dMa;F+L4@IL)b~;&}Xj>94b>o}<{9u5Y-x zR9DnJKB#r-JG>#*$NhD6`M#UyLvy~@r+u_IUlMz(*863}m|I`!{J(GgFF4+v7+$A8 zBljM~(iKC*tcSQKc9};@{+-5>=Z9(zDK1MMnj^?Gx_kq@cB)k3wG4?WGCAYp`xJ!a zQ?YEc{GClaor*9uSjwxm0m&zCjm$G6rM(?kDE9FkB0`N*@^so)BHKl5WDrXPU6IbT zj-Z@>B7;j;4uNiUe1RUkx9*P=^cgb9N{B40EM1&#%{9DS`f%)fgq7{HMTyFZSH0@G$5b?UXvKU?6_ertjSgN?cO#L+{;ohlKlz{RcQ&h4B|BW$assiRS%&?fjZ*An|hITnvNomyLc!+P0)0c7h!v%Lo$LhH0I!0s{pjfsqV5v=cWyIV`T#jYS2 z#iHJUBs?h7>WdxOoU<=^)H#%3Tl|rAtJkG2D%5}y;p5@4akbO)oO?|kCFmndDRj@lCdW52nS4EQtxRG?LM)+L zDwpHN^{W^I*fqsJ2}y$vlY1|%SsvNNun;IG{!u;MGl@&IGUtS}weXOPTb3G+#^EP$ z0j2{_{+b{BYjnwd?GO1Mjs^~+VpG=PqSJj1Bj3sjJ?b{GC7vSVacw1`L+n2t{U|Q{ zv>XV8`V)mq2{O4re#ToLGYvKUwLp&Kbx&uQyEjX&I}p!K5wn4?dTT0ei{`H2>GG*Z z+t60~!MA%LCMs}QQtqHVssFY3*m2D6;^Nzek#_M5@jTtnLOH@1B@oC>g`51r13(~b z9NMX63u8}vb9Hl94U%ISZpT9&kM{H_Wbce?l)4aRo9T4nWV6o7=REugqiB99Vp&Cl zEP>Fu4c0iB-K_DramNUPF;sr(k;x0M%&i{*%v6ncDUER z&iu1DYBpghhz|MqGJ+1O=Dza1W%j{z0V>vn4mwGY3Z!eal z)KGft^YfypKNxwzaeeF?KyAAE(eN9mJQaez(TRZEqARx~tsd&4@>F=MVaqw^nHGs0 zwXP9TsgfAP(q>U}m^#}@pjkD}*S-u}kbVp5!nyx~$c1!g_#tRP4#`23@*t+f6J={i z7vpaXm%lkoc?}3p;JfN+Ew(G%;QwEn?tWk=614YlJXo!Zp9zN{p~ZV2hR|1k&PIf( zLB&qx;#74dJOZNF>a4EameDTW)DaK+rgM);GIkgwYOtO@@%8`?h84p># zBejjd%nP@Z_-4A{#S`S|F5U0<_bFvBw8djTEx6wC?*t)OnI#md*TSN z@1m(QQUZaKb3R#8Gw?>b!q~R%_VcYC<#}N+3=olbrh{Q5SJBB+Tbo>3m)uWB$gT_L+u4EHllozRwE_PT|jY&Hx@4K@h5D_-Hi06g>_??{g?E%l$R< z4@1ayjoasLH*k86uq1mFoXrA5yj8V+UC_?_GkR7gqJ0? znc%S*)Hq2R!|=JkLeV^f=SO|=i2x4s_Y!|jgB>E0rtvhG=n2VppljIY_oH4%_oZBC zl}&&~q#LX2rd_INMFhmwmloxedzOJPp0<5NvL6#^J;9d0on+yBcV(1?qJ*}Nlxu$> ze*Q}L&Of-e>yLz;WB7gT7gFLo1CZ5gdYx}WRhII_r>4d`rDsgxt-cz^GWO`W_CMqI z%l(bzhsr)Y-}#r-i)TIyzq;M|bmw&S;tQYe{N=w#io-Y68T{!kvWIwDZ*6a|I+$)8 z@;M!H00ZszNoUQno0f+6%UtFx>kJiY8D>+z}R^Q0|dWsYMY4b$S zRp(xKu{hDg9_W#~7`p)VLZbEIjkZ$&O>@Yoe*g+8o z>K|M>5Ur^1Haf>L_F=QouT!D~55L)epZU;7uJPH=oh=UivxhzPxd=I`<<6ruZ{Ck` zAEzcGV#=YiS2MA`lf{*W<@Mr??-QAC;pR;-RTwi)=Q4TqV<80JeKJkwL|r6@uA9xK zTYqy1;+}ya67NB>mLu)*rb9JwDG`R?Dk)@8Xw?{Hmnz^Pex`hY8f=eIiQM}fxTsLG zT4Kh+4MEDo#mxEhC^+C*&b*3kE4ZEDjc%;IFxmdAB%l5fUXhIh4R=Gb>DO6TseqZM z^FHEGEu4OXM_#cyQ=14O0j*POUT?L2?65MdlvYW_2iS4XzJbN5Hsn6VCAe|5uIM@r zrA=+bRFnMR4bmx<(lQoJ{HW~+Shcd&c01*BhsKJNm(qi!q0JOiQTSxqzz~XIA?1GS zXQ~ja$R&Pn5An6Tp!~^hMN-oCD%t9uOc9b+wr1EEiYiFLwnYHr)3@6H?xm32&#+%Z zU)tEk6tYL;gZ!A?rb@tt`t@PWbRJMF@4`zef0sQAzoBbXJ1G)J{1TY*1eyGru3p1f zatMvg1c)K?Lbkmfgu5r?`~ky`9OZuwL$@c%9_mfX^?Bkws~IH1;{`zyWlEkQvyZwr z67v>L(u|guBg-tSXT;hUYTb|>*ra=1W|ml3cc~|D9*&g@$=Z<2&)k5Ih!2d|b??|B z(p?cD?6RtErSj_*arR80oczF@sIExVvaW_q#MWWVWQiDjtTw*`_G$I3Sx5V@D0AWm z*qf~4(j)+P2_Mo<)?ZKV}WY=uxYmCv>~RRy4trHQD4>=aU~lnlE}bz+isM3LZA zL_y2YuLOI^4VJ){C>H}TEG1a*Mw#^}Md6Pg$;8x5BI*nMouYuQ^0f*6)y=gst(Ys2 zSVigRcjW>59+MSC&@lC9!HPPZ#OEN{-MM=qjUEQ}F(qyl&|S=A9twd%JiESWwa3ky zC&Ubt19OKN5kP4w=T75h`n|?XQKV^~i9&Q3o#$GX`)()eR590(y-ywMW^2e8EPDgh zQ8kiL>WmIDwTFlphA@ubozD{%2C)OC{6%BNB-3~eC?rkwY0JABne1Gi%%s`_rup5` zojGwgE|>?_R4zM@*;)-P3wvnSpRdcT-F}y?a?144?zeyg0q43qh#bC5+)|=tDD5BX1sfEhMTs!QDEVBrG{#E%&#H&#&$PkSDL^%}o&RK&TwSGC2k+``pO{56Vv_A;!^~ zYfF%dAX5O*{o9#Nmpcx^rDGkpi{m8X4px`v{H8ava*y2jzyFf*68T^IM8>~CrF{0V z>%Y0bhnMgEMLGM?;9UF6KC(gJnW0;E?te`np|9y0sg;~ki@#ynK zWJRj;T%Ehwdt3v~%RH}eMs04B&L%mt>da)|kR(oSx!3)*@*;liI3_$;j-u5KMu&n# z7>!{@J%uuH_}zSE_3+S*c-&81Td93$GFCG_*8w153Z?i_%KGy@p4#{I&)oV6#4cO` zB0-dtA-%7lL@pmhfE@0l9pVoju0D83S;F4q+lg=ZT8{yaBVV?)t`99Xlg=6vA!kGw z+}QQiF%Mrw-XQR{dQeeUMNR&s@7CPEx^ykdHy20L?$!lOIEz6(3=21WNd@iNi#aW7 zb+GY=DhbE8_WR4oA)~)bI-z*8H8*g6aTXsET@u`iQ%$|p?_aTsqATr79X?33B2g00 z6R*9zc|9n9`-Y0NWcusVURa>2`5Swg9a4DEzo~ax4Kd61Tqi#szTr!eQ|Q`LTe#qb<2?bsd>u9IfW!*&1~y zXqk{ZC=8-yfiK*A<>ptZDm8cyg3_r>t(VS4WyVMxZ13drq}m8eOo4iSZpR5T1wnXf z!9$RELPBvTraV-wl?O-1%zUR`MfFEBYP1q{_*0<&baVP;Pqvg5kh->#il> zJ{}L;w3FMyxx1JUVn5ZWdJS|q2gaPN|oP?mlgBVyhX^R1x4dV|TFZ>6ko9+&@ z?w@vIXQ|3DuzWL~lJ%MEe4S^9ILIuQV^7hOAZF2&Kq=l9=bd;{=HQMZA}W1 zRs0u_5f!niJ6TH>Yu>-n%g$p5phA`t4L{E6n2OgATEEl0oef$ysYgBmfIsNWZSJb? z?0Rp@!I%k7=hVe$TEHJuHyXrcO!QivIQ`RIKcAAW7LR+JU#;dt3m{7gLXsD0K+9JLI-k6Q_@Y zq-`(vGfZo~_7f;SW*N*YU<2YovSFr?B#2Qz4`M1*H<|(g*xs`^oNOiTW*CQhu}{od zuEb~8rdg2o7YgupQ;=pNsnNPtrV7Z`Zkf=uxOA5MM})@i1`p$Sc(xe!M#Ug^J=pEW zjW!FOB6|SA6g{7(ezduZZ(K`D*=Ex}j7m<)>GPe-ohi^o z&}RKgn!J*~s2K!b-^^dfS@Yd%ovB3l!z@3oxXp!7XKpKu@%+y_zuOE)x7aV%Ybn}x zkYjifE&T}f{mIk3>+A9t|9Za{k>k;afD*SP-5uMx-n%^g%cpv;29VyqGW}PFdOP5! zS8h(rb(7!~MRotp#PBc?9w#+LBA_Kr2sQaaSQyDpT0i;ix8`o0r|oJqy;ixW_0>Of zm)oPyfF!+@=?R;m_IQfDDD>KlbQo{JZicVGi>Yaf{M?*wjVxC>t)EcHCtp4GrW)0SHIRz^>Ne>%o6qaiU`ZWN78~f zjH$wQlLIIYLLY&pzIm+~e|5}=SNkYfqg2xyKZfWqDWZ^sL`MsYSX0Aq79)Yqh%br| zXPV9nw7RTLj-opQs*r%2dv1_0pBNwOmTYyF5yMA|-p%c=74J|}L*j_O;WhhPN%Te7 z=Aw%|+2901v3Ei50xir7-X}$@6>rQ0Ic==Dkj1h#5m-Wl8lk2d1d$9^aZB!46c% zNfM$+$5jn-l{`}MU^q@5K83C$?Az9KLnI;Up)45=kr1a6%>W4MI*!BAarkJ%9vx{p zGhTE!y0f}9EKa<~Ze~$}bC(0hB_Xb|UyY+~cEltT_Da%I-CiNDix{3eA(ZbUQ{9gi zZ>R@SuZgNncFxj_R8NzswA+!=O6)?JlA0gAOFvscsf&fU)H7C}Q+M@kErE<-lvo5f zQ0f;D$e`TMT=w|h-mI5R@RzJ?LAHW$eritd*?P{9lIidO$=|}I46L?zfy&>Vv62s> z6;_4EHbMWIR4E|zOfySF>E;MC;^=H%6n|o3O_VoJrrK{Qi92r0cHi0+=suT=O%jie zb*#YiiD&ler}G-B6=#_m++D7^sE_e6U1b%lXi8)Gcq{fsct#TE^xBRQ>$EA0JGQN- z8qXR{$Ey8i86&_c|D^;{$pHb2WKRq+kBA%Q1F|ggUrR|}#?Kjm^qFHZk|&Y2YjL-j zOE#{RUAeD}#^W~BViKkAEUs=*Bvi&RS+qI#G-S%88>qUIr79?>EM{twIM~I9lt4#? z&1aCnaIGCEpe7)P!7QYebOD^u{U;>jjuBX4KSL1AY$rsu1T731vOgrj)j{hZ{5K*{2(8lkYdz6;j!I|>LcnHt2R|Pgq9z$nmUrKY zck`Hs5n*uzjZw5NH`S?0*$5jvFzVW80z4SVUor#Y4;%x`Ma%BkReAk%_vJt8O94 zC!dJNkBioi9iJ*uK0bfcwhcFm8K~<9sSpox--*58ravz zqHh=m^q(tDOg@`z!AlyGIxpVe$dL5XpN~gU-P!co$AG0D4#B=%`-`3iryg>ICaaEG zK|eC|QFg(HI9mKrV<=NP+UBtycfr3kkCwbhS?qz*A#`rxpS8-Y6f$)6Ai3{Sq$!ue zqxpy`sl9UOVz{Tgda@VIvj`Z|2I&+g;fj|3T)=X!fVjsDYx}S!-ShPhH?tW?oS9@TGoClsbMTwa)AgpXEc-UqU_P8kxlV%rxQyE^ zA*PT;I>Kwy|8RJVPX5sTljWMjER0*eD4fl)R*f=0O^U@qR|P7liX_7(QVSb6dLp6+ z8ZN&Xd||2QuI#7BENUS&4!CinV^I;d^`t;kxx=mpQVpd-;Te){z%`=1py6R?L$5cF zuP_)G&|4?2A{NK!w!|-7r&Jx-&9TJ3?QWR!2VWp#h|9o1T)yOKn^3V4xv<*dkUTr! zmux@%?S<5?cev$+TSNm?U64sPsf_)wH9f@apX?G?!V!M`4O#Oo&ZFWEB25&~O=EG7 zc2xK5P)A(hy~TqRr4ZHt}BYl4BjJ;cVxOQC0)L>_&`;MqD0qu$uqg%D~Qg?Y(v7Y3m;O$#fePU&!{ z;B}31++p4HBH~U{_Mkd@;LX&;86E~5`^JD3>QO3_ZITasMFlZZERP{<^2xgSRd*(c zf0LYwQET zJ|AG3)ulIocVV-Y29W2<+Xukc)vbE?7pY7!Er#Al2#o?VDkh>L@Lz}5sl01#mY_j` zLc;Ffr+6YL@38B4#|cQHwFS8Td>bBAlw+ML^Nmcqu+ z^yac=L@WeDA?t;K2N`#~OJlG`Q{k{w%9)`@i4gP7-RxGbr>cc1eDToOT@$(mJ6M^{ z|5eIA^#s9TiuYY`t1G*((2t2m&cX?`o#jgPS)*%lHhQI2lL+sYE1jMm+);3z-MDDx zBaXG=!}**4Vq|JBjOb1JF4U$mDAT-4-yW;Cj|&C(6?-VDn+XhT*|ix5j4ANLaB<@J zr-DcA|4ew`G*Vu2d<3)z%Bt8sx_1x}R%=b}7Iz$Uv@R&97UzS%IR5JEswwJz1K9zf zIAW!MvI-eFy)UXWyf{45vABkhIb?3wI?-6=$_QWn+Cml*v6BI%!ilfU>;PHpXvf< z&=Hhe*N_rtm6Z~)--8g59(%m<- zK|EsYg^-KGieB(sSlh^c>+Z~Es5D{H!hsm|Sy`OI%9{7bS=JSG@>z_U^6XHikAqu|^F-3C?<&C~VJ-Z8g3#XTDn3LCpivWn^MaF)oUHfEEXJ2Rbs+hA8f5eJ>pvf5iyqUdwYD`&%iuqbmV5_y63vd%DcN7y&Om zD#s5f?7|d0oaS-o^~T_5U+zDGwK%K>ZE>ykw-{0p#dltZECU{gQ?Q)8ZkXQ5SKKm4 zo?pGs_Sb1E=;?J}T-Xjp8Vdq@B9bcFiF~zxWxWW&zzr_0HROt@NbX5=nWz<F(W&~JN#P@{80xuaDLIkmq%)uV`(!g6+4aTMt|BFi)Mh=i zrP}yfbRMfS#dK!yGk*^1b7Z|Bb}DBvt#SG>R~|^3*ps3UYtm57%v05Cb7cWex-tUD zxBs7i^m|{Mu;fAepP_tyjtwiHtXJ$-()w$ca zJavG+gmcZ@v&r}Whl!R-tLWrv;8=2*$k@&!5#LN5KjZghATez_#*HNmstcL0959uq z{_HzbF@7dIs5A4TSUcBO>OZ#jK4bDv`=Kq}Wg!~lz!bvmv$}GP+n?{wb&Alx(Kmz; ztlMwryyCn&-A10VEPR*|sovLSF85YaygIMUiV@+%#f^$ZB*n3dWv2o;)k#u5oaD4$ z>%8J|OA({wo2$-7R&qS`Fh7;jk#n@f$(q97$WLW1P@QI~`iVRF2_bC#6gepK<{GxF za$$~T*t$NKQ=~EaOM+~#WD1v7aHPVD~=xs;l54xv=eTD!Zj<{29736pVXY z<4koS_G|JTv$yFIZv0F9IL(r!D=ysrX_eIsQ|58H#W>n?8p9K2X%@=i>-(@X>SmYz zG!P8yOiIUYTOsVB$3twcreX^S&!mUjsft;o#TTg)m*UBccj@_JuVsjm&ai%VrE!Mk zb48w^a+Npb_)wa=XWoL9E)RxNkXiyeexloSgVo)(Xab86(-sAaw6_yHD=(8W^T$3Y zm{tEJ`uQ>yV73vI(_cqt;xCy>hSO<(mY%v|O+uA}yK) zZu{J3k_iq8^s}B3KU>oK{nZBws)pcImuBHyZ}wv$5QhVkQh(NXdhcl#Oe*W-Luv~c ziO!3OjCR63usFT6x=p5RtUU>$>7#Src(E)s745p>xp&ihW=tTjGp=&HXr~&FR>!FE z`j`f`%~op-mpouT`nExNjgD~wGgNl-5mE`n?6C|h>X5a=`hNwjjQm_-j!iFVAIhnx zR1^e}f?ep>yp1$KHF5GZT_5xJN5;0odO}ChZ(C6YIIa+xd7`7}nAtu=REpP?uzEN< zn?Hm7QEOF^H{oT})YdMOzJOmn+SW&)eR;hiKR+=x~3G2rrZ$%&b>Du^&cbqvrbNck@Y9t6XioOCC zx7o(lgq`)i&<)Kd?Y56bDf6>3D&;4SOp;N))4Qn6zqr ziOVw}Jt>*qAr2xQ!cbOa!zEa&kc$)u&6~c%sn3cimQc0+%I?JBEKFmKOW%`mNrT5B zeX5-3Q?~NrnpEtI=VOiOm7yhn3dvJF>2>4m2EcuEz~#tIBmK%))0Es``!^D}ph8MJ z{d6{agz}IGjM_3Mg}p(ePv$1EY6pCpo-4h*B^O4AM9ejuQdewTI|*kZDo;{VYC8|G zIM>REfCu^Z2SV@sLqag!%c^yzsD0XXJ`*aEI#PE*;qFVef%x_%Y{i?~T}to&v!%`Z zOR+iRjWxBvxITgTn(M^12l{II=5`Djk&V*U#BG?MGb#+2hi}>y=UvNB4s#xacXu@g2soJ459MJmo>{hG0{D(H39g^T_%`JL=t+ zU3zrEqJt59MJ2Kobr-Xps&PH5+C+(Cb+x{@|BhNEvCi?eFXbu&0Z6$$hJ6C1Pt9g8 zh_ocYB)SH)?LL{0sZzecY*2Q4Q!qKlqgc8JsWPQ!ty@Ju`i8ABF;Jd3sN?||K@8y$2_SpIR%BY&BQ |AJE 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 literal 0 HcmV?d00001 diff --git a/artifacts/kusama/metadata_v14_9111.scale b/artifacts/kusama/metadata_v14_9111.scale new file mode 100644 index 0000000000000000000000000000000000000000..ec79100675b1b9d15d7d43f73d4ae39ddc1e0474 GIT binary patch literal 335369 zcmeFa4QQm-c`ts>=+$~Q87JdbzE{3i`QJBG{&&TyPR|Sh{xeT+@~0Z{l~Q^9KQ%g{3i;`sZf!r<>K*p_!G8E{ zd#95hTWL3fySnHeF4p=rJ*LL=Si94%2SsffC_P#4w0nd7pxY~I|5~tffy3kRLAP_e z*+@Sw_XayV&3ZFv_ml054Gb`*-&r3T&kbSJiF^xymL}A84YjAMT z>Gmh?1kK&Oe(&6B&|Pfy4r=}S-i21J*Ymt}?W=+wZ+E);wU)2Fb*0OlgP>dMH#=?j zWOBdO#-cmjLusL~Goz=}Bo^Ck?l=3*+rd`<@F3_Fm!E$2xy)Xcl*;8*xmd#fcLDL{ zelW2cw1aN5KHg~V2EG3HqWt3(mutN}Jqc7OwmQ4LX}x|usLz|1E7sC+9U)Za)G2nW)8C>gh`ktE9GN#I@(rP!jW@eXHvwHCYa3uh`^p@JY z&33TTP^zRSIG@4n3ks_b8=RoIr;2Mqt#yKyqiQiW$+hM#Ho;T#m`^ly^He>e#;*4F zg02^zm{JY9ilz4LX1CMc2mWpxVE2Ls&(bUo77iEwoIeJ7Lq^lyxhugPEPAK8J22?s zsdM`Es|UoCIAjxTuvto-^Ttgx;@hIm7q4{M0iGAvI{SgA7M0RUErtYQx^C9G)yFjlr}^w=u@Px;PrVlQ-ZPIftxqZc>dsC;66UGb^$pv5$3C;|frArkL9Yi4 z@YEOdx^2}nk6fd?n)q}V6y%`hsW-w#yXKK=^daT1>|brSaMnEa2l{ol`u(krJj~4S z!)kId*zeT4wfdo_z8!wia1S$IJgO#0^6O2UsPE~Y+Y#y=5bQdMSn7kaKcvM<8xR9j z&c2{NqL$Z#`d+(PueC08_CW~y0p|XLU$Ez=Ur--a=T`T+wOyRuC7Bz+`$PRzJDunv_R;ii40CsdKoZIDKe;dqguX*69ABU6M51*z!4woHo5nJ|S%3tpWwcel$u>T~) zyS{yv>g@&fD{36PrnwJ1`kB5_mp?O&epO9u^qZ|_AAOGM5Jv{)nQad4=C3qx2&LI+ z9gYp=Ee|u@J^}RXfQ7T$M|Fhs=2@ose^C$%>YdvGm-blHf7d?DeDGftI6|*4XX^2& z|J&wSrul@LT&wQ|jX{f4`w1Q5Y|lN-eDX0hw%YC7#eAOB`oJOp1eUvpnWq1b@-Gis z{bsL;6Mi-zrCo0g3_aV>`ppA80yk>5d*CtlP3F^Qu}5eJxcs)( zH)EghPX`=u-onN{j^OVIdWYQ(_77}_>XWLt++~yBlf4L=?BQW%(0Mg^E!f3Mx;5a^ z@7phWTV3}s^TkCqw$|$OG0i{36ngwK)8^C4Ul@QGLiq92A8B2!*A{8h+1wvNLG44lDl6SDR>l zb8|lI@?x#o3L1IU&@-;brEa&=Rhcog_hw>@9r==d2K=Dxo36_jI*q^yVL5NLI#}w-n-iNJMA-aAfT=ABY&@UZ~$Q* zz1)1Y(``alF56dIIKq23H@yQ9bNro7*N3?38)?Y$*2;||RF%|TLPaq;jIYOE7G(wk z8F)#rcQe`~QE8M$*N43==tosuT*aSC-8^EDaC_~Sh4Cw*2SE}mUyYO?NT-vRodyI| zK~<0F&kU#Yg;xTMs`6Jl6l@#$nC24>X)sFrMutc0=?k@XyVJka>D(F|aLDtu##I3* zh8(}#A=k+3F^Ge~-Mr2ZW+{>q%gm1vC=OP=<#smPU`kM<%U3#%0{0XY)b-A-0Oxg2 zm*g)qi&Lt!&~5hj_Je-2?x~iZkA9jKk0`YlUq<|EJuz{mb8*maaLxY9ok6Ry*o45W zrq2hh&YjDc%Kl&YQP0N?C>w*`d}G14rxWKMkK}{`MWqu%Xz;Y`-`NAXDajBQVFPGDJIr>c zy&tB#!+G+zgP`rxa?k+f@JoZX>whX7;O1u8_D!Qfepu(3bDr~_)W;0Rj{JVdZ}xkB zebDVf+zOYvvKWqRm*)Mk{?O^ur`K`VUlpZkv$WUmLri$;sor3l9IGEx8o}+S8l8IY zsi6H7u>jO-H`oT#f6Cejo{~>{Q+^84|d_LDD6)y zwHuu~LpO6Ahhc8cDpT0Uk899Mx09sNmdg5fa7O$dbXM5`f7@7dxP05XEH9k#2Q+$d z(8G!D^@mW_rIEV%BygnD9EZvffV6Eo4w6`yjc3oc9&? zvEi^m!*B%{ulCEpp0W=OeGmZkEvVOm{*Ymky{hET5%1lF1Smi`d|*Wv)*P+~urhl< zCSH#a9NMDDo>p7$|LlZ0Q}rwA;tZWw4{A4)-Gw_?~Bfm9PQ$p@e5$=Q>kZEFDX znjQY0gO0jE?Iy^mZt{M~-~eH0kPfHNy^Mx+fZb@jclR9j6i&RXH9qVh{5~y#vb zv?nw0@-?&CYXNMF-6lm67(`P-O!h%?Z`EBr4huzp&{K~TE@vkfg9POWJ1M`jBVxr) zv)hY^5+=$vJt%JNhC9oZ?_F%trdjLm!U~N21(k;K-Vb`xxFK4b7(PQ3qgk`^)tj$I zIBdaH_G8VrU=zT!A?rL$%6E4xY2_UUVFiJPZ3-;DSES*1#+@_+R#@K1aL6O=hBd&Z z)oVq^5v?`IQqTk;6}fwQVyRnOtu-43a1|ea3!_muq|To9+ zNYV}N)Vhtz*C?CUpv?&@4tw7+y&Kt8`jRuuPmbUj$rWpFRC9st&OUGqrt)ZgW?&Ey z$Gr@7A-Mv)dwXR&Nf4?vNVKpI3_ZNb@pAc(>#OY;c>EG1RAJEJ6u>(pAe)}e90GqA z<}UCAA#;`Wo3Dm&h$gdlwbhXMfPvs#!;JuCs4noJz%p&^eg*?Z@=uU`bz0D_I1-so zS3WXZf?e-60Tk{(Icmdo1@=|14Zz=;eQ0P99p8WqjE897pyF zCM~fsKtlAq&l~lK+yGlmG{$QgNsMLaW&AuS!HGaST6{0Y{{@2bDeww7dF1B7CUNEJ z`qG@g&SoOK`1k|X%R?u^fR$5vqo@ob1fFjCz1^(&HG)JOGqvqjQ1P#H`uO9p{BaGy z+<|fj%o4a*X-N2xJ+2nDv0io$>_3#=YYnWIBwN5y@i*FLyc1y8DerqJ5De_c_W;7= z%Mg(o-P#?j+}>oT{2`tbUiF}XVfnXxvg)85xfKLlN&ulUZCaHS)PKMxMD=>T3uD%%qm_C(>& znhHJy!jRg#9=sLM^FesK(C?bSGQtDU4gh5k&00iceVoy7%9TkAtecy#jge?$>Rs@5 z>J%~RpN7+iy~l+X3f^^lzaHWzaeg=G%kT%_A_UM-Vr)V6P}%A0p(5d&90~rXv^QZr zB6;DW8s1P+JPVNs>cK5s9s|yEFy|Es=B#bq;!! zOE+I-caY1`3p=^FS@EXDQUktAsps?X6herDr|=7*#%!mR1`KUimK|hSgUYXHyoW3% zej+(FZoNY10xa3CJCe){^9TN!uN>ts3mF86zOv18?Y9T?Z4j3UHqP7M7Zs;B*rjK= z@=#IejSx`Qxs?J`VU|X|L4Oa1GGldrQ_r~Hhcs40`+T3ks@X<|09#B{0-Cg%h9!nA zw$S3{=J+bPD8xDMtqV>;AKu4-G^|WO0)!OYP|(}%@dYGpwtTp-d=t*vFR3p9Ao;g^ z^;Y2$q6c;;zQg&mWx-njJjPcC+rVwKQ(w{ZLF4IXpFR8h+?;#*mC&m^Vc*3*@ZupS ze^5B*>_X1xnAkoMfD4Pu0Z8CBtgi4B1(2d(z4@x1r7_5Xo1p@pCa1tg?z!extux;k zR#A<8QUxiDwzS!RFu2faeY(@(mcF-O$U*=XXvv2?7d#Iki4jwUbwoBQWombzSjMCJ zb={(;+PKd^K19t~2U!RpufG5!cwQef2##k9EDHc9pE z@X&;A_w1or^kISqK#brp$sd>pO{QsyPtR6e+yLwT=IASiB7nIH~VJ>zwH$*fkis#_wfUs=XD?%mCj9FnEhZDo*5yxf+ zw=n&#p1F=$tnYzr??EAh^XOX(@j06Ab_Z=v6mxfA>$@+6n^5%H{n6W}*C^hHJqnY-FUZzIueF$t+xgHVlP^WyfGmmf8Z_MhHtQ*rmN}h`yAT ztMjlFrbPRO`<(Jmvn%*Vm9GXFP(*vmtH~Kod_L*Z1X(jxGN&YsSkONa)HO3 zfZNh>xEu#=aW$5G#xk_1taO9ser-1Zws96QA7*w&X%h5dZ2A;; zbfGs+Ro;w|OKd8PPnfa03bw)tJ$?CgGk&59Q8eK+%N!m8uj}KAZ_S; z{^~7Hy^nrW0q%28K_P&d9S=ZizgJka!eSJ7m=Kwq$8sW+nxKWJT`5HkB4@+{%l2b? z2FhACL4PK~T@_YHb!-- z@_xuKgrmXmR(_dJ>S>G?M|nqG7C#BR2N3?wNN4il&Chv zl*BsA)NpR&$Um;JR+u3V{n8;kL;Qe-oCY;5^TT`xXuuT1xKT6(jZJ|AeumH~oLauj zq3ok~s&6<=7V(lNFPDedW;cyAJT73FWB!>zlT;#vW@RyT>m362_Kfi*NBY>|i#+t?2D32_WHY}~%I7#vjgGEfXr@}ZLN?<1W=sUQ3Y zVT_LQe-Ot1AdHO)N5ufaO@jQ|K&W^iZAut?ahtk0<# zi=cs#IB0hUyL+^$fQd?AO(1b;VjxCb--f2-;uhnaInjrEwc9~t?vi#iovh=dCj6eT zZ_ohg?<1;?F#^He8lo+N#*#L{#dMGky0jHm`~|;i!BM*T>dnn5NEFGr3X6};bQcm3 zW(Ok*-Q*iu;uyd}jpzrv_Z>R*?3@_s*lb}I)usJ|{vn}Wh5Uf9F!X`-Kvs-(9RZ=d zjqv=oK(sO$ehORTSq(>TNxZKPj8nt92p8I=-QDd111jKWl(!ak#(OLHpQWI@W(4a7@{cu|= z(?$j}esx-x-Z~i`s*(Ilz`L8T8Z3*enO6C=>xEqtks^MrbqC?yM1&pWa51=(QoVI* zhbw~&G#%Te%H%a-DNI=qw@*Gb&wGph6#74C3j?H09~NcoX4elZ=Po$pj|KCb6aX26 z_-GL!5`ajEOaKa%0f(GeFZ2uvFx~xu-l59(sK-TNc2{SpIgvr2+x#fh2TbYf^!N@Q*%RbHtBej`%0_PvRXKS3eHrS_@Ys;w6Z;Q~1ZN z(!RjB9en%)l0Bnq+FcVhkZ(VU{WRwpF@I4gD#!;cj+L3qqR3n`fPnw-M?-tEfI7Y} zD>n4j?(q22Tl~HCJDm_kgeLaPyW=~uM4<;`NzjK+!i0!KAhFyTFOTgmjvW|GIxG0Fgk>3NpVNm9fRa{{A6ySz5?NYxfZ?Xxf1nA!Ms7 z_S1)pEk6n4PFxD*Q0$1zLG*8=tv}xDV0NL7Nc*_c7hU9pzlJoO2F?odEcARVTC?o0 zz}W@=@5>}@;J;`_w&%mV0jme7d$VJ>pbbMqbONX?<7Q1L8%Nt7AbP)#>B1EnXTA)F*B5oAEFZl=jk>9 z{@?AJJ+G_|-Oxqj9vC`-Q+6@wRalpT@qdN>g@{a^kp&B<)QgAq;U*!#r3&*Yit&Wj7e?gHXeAg{-HHW#9X;6Bc9$94C=B7q6}( z@1km4ae?h+3vrt42FNRXe6#vc!SnONJ;0M)uBWuNkuy(EqgacEaeD+NT!e~^>M#V# z=58mTt90Sqc~&10*|Ix0fH9V*($r_j=3Bz@CCzzATzo97v9!?9VChmiad;$^Q%vD( zYmxz+9OS+<%oK3$y>SPgVv0jN6~?3pA_fJ4=~?m{-gy}riTx&P6eRN9VRLbFKqvqw zVU#6^|EAX&mMw|;$kBuA%#BUFlI9|y4eOhdX4JoAAB80bP z$@yymNM6QgLFcaDMiCz)&@oh-u@hwECFm6OJpco{V#E^i82>lPRhX#}X4t?F=mxm} zdp*qGL;U9HC%jF$7lQU^=(tkVahBnEzCm1gqqSvH)L$M)5C;tIS3H47=;!BQNUj7A=cSNDu=n^;h5nQCpN5x zV>7qten$7ae~J%oKep@?Vylaa5Ey61oejtRG*cB$wBAwVV8n-{xNP^9fkWXKT&)R& zpx?me(7OdkKomKg!dCRi!1a{(HRq;9^1T5orE>P0>F?ayVB6u1^f)9cB6C#I82pGw z#TdzxXPUOuMKr1j_wd6P4y!GcWFeFE6h4%=8?( zOE7+|ee@J1pS5xWdfz?gcpJ%0!`SjYL3o-ODp?R7K@1%5ki+5<+RUK=!+25?im}xg zM=AG#>?8pO>jETZ3|renCE|}pyt!uzpd@IxQ$x>9T%>8qm`9Rj2$c83b*|8SO{r3% zKaJgmYd5FOp(0mp8bFILoNo@JT0;b5oo572Of%dDyZ=p^{G18OSOm>r7Q#-%4GkrT z+*w(4lom!k#^HD0vVyQlALIPO_FGNp4bn(_FN6BtkdrWEwi!N`E8J`Pv{K#fU<7Dm z_qCK2nor$Y+=|^=xHGO-N%c5%EuaD*@oo5G%O&>>g3%C<+(DL5Q!Hc2t*631%n;Q; z6asTgO4jy-V;?6e$#2&>@hVt5>0i(uGy9>kY0T&-)R?n!_ zqP#-Hls?V2Z&MVO5Hp0Up}3yKP9wdFsT=tjd%=6sj)0_y=~}scr>ZZXmt#ZT+^nt* zM1c<)m&F*nUU1p{F_tD!t6Js~fz^`-cRMK~0zZ{=nT*xcWST6G|M>_@%t4}n8C zcqsIfKqWCanP2#LB#zp8dD-)npS9)nZ1Joi`;=CdZ2qOQb+T)$J)E8^w*{Xvh?ZoW zhmK(oRO2QvtX8tLZ^M@+8QD*23RuoaU4P5Hp(QWBzlT_PM!GWw z8~OJ3L@{LDGy@LUrH0m`Ea)}pb^@e!U9b_+7Ekk&>FwcqFrI)_&m};)LWbGBEQGZW z#pIWc{dc@cd2hNJiPmb0wCP)9D$H(YMKu`dz_K88Al-u}C7Va!`qJJTu9-2w4($r1 zf=wa^$=AoUMmkRKmbLA&%2O;u;RU5WuJydFdCL$B6a&V?Y_wy}`&!g(a&S%p>wvle zgJZ9dnnX}EKFPIgPYtv%tF3Mr^nqx7Zd3XnXdAF zBrcD;FknI~bD^0yASm`!M?g0M9*`_fY1ArtGjrd1lhmQ3`2iVnO0yU!>P?l`wCTH@rhPAi0zl|crrjm=` zi|B!-spK}3vAQ`+(JBd9zI!NTtjjl&T{z3o zS>yDw$QwJ60yKoR6&4}w>?4bWG>E28t2ONmkhmckWr);o*;!K1Z?$ZBJ=Cqn-il@E z!N8t9J|o`G;>b{Qwk@0M!@7npc_>H#j*n~bxII*}#*|K1US_V}-9tetJyBR_AHp?( zI(ThYo(iX?^l5s&+N2=};&+9SQIl@b+3G@l2|@d1Lq()pgsM*15}B+_cLpbLl;u`K z1Gy`=I^-OdDURdBvqbAjaLCgja|VY%5@^37%DVxgge!YGY)YSr_l8mcbDte7fidUY z6c!}k0addzHVpMF>UpxH!9fRdc$NrePIG*wI{z-rH+JOAB$0AwCTJuQ`o$1bQ+XRF zQl=yGW>Eqe`d&+LG;K%%!7s9eArvwvp()2L%MnfTs{2^WqT3FGWMF9@@P3R)M%!^S zug7yB?T-`f!$Upj&+71Y1-F>V5Jx>^FolVPx`^8F<1m$>*d2oFV{eedEDXW99G{QQ zt*d&RJ+~9HQYQHj=by2KQ0mwzb>+hqN+UR%cX6^2H^@g}(E3h}4@Hm>5dnc1Mwn*IEYG9H(tfZY$ts!2=e!@Fq+W9BROqRdSnMqw!vZXGT!&!8D2+_9LE?uii4V;GCXh3Ga>{!v z>>{{(&@{F|=EbskIKhX^X+Nb4Wh-g2>UZ{_jE&e(?~HdntTi2z_=)7SrX~} z$Qx!!Bb*kra8eC=p=u5)l<3Tyiy=KhJd%W$C=G^)D|;-xB)bRQknSn*#}kCo2%CxQ z$kC}eWO%V-TJ=7*5GPwo@g$i2FzmI!`aTou8le&KsD9y*j@+ea6oZisy1dU-c;Xm7 zYPgsm+6{)9n#5cY{A`Z!LnZwSx`0ybiAeaN1>>_QIX=7AX(1G)(_TYSKB|jLP~cpw zGj(m`_$%d%xoZ4vSitQULT^z#i%E7V?T1kr_^^UX_$#LVWcU$q&Q$!R?H)g3QQ=5v zgCU~*>wV<@F@PPi&_Pt@&U7@Y<2?;f;+!RjkLn9y5(vmm^`xW%m0xAfB*Na2n%M6S zSZYXt@Gtv2l5T9~qc z#)jBTpruRhLZri)IzH&YYL!)*fva?yMEa$Hu;_5`%b{{$i$wyZMK$cv6iF-lRY>_t71WdhfDBhsFMhx_qdVWl85xL|HNZNY-)yXk zyJ?6*nGuMb*qgr#@d93T9{l)i2-X-;Y2AF4UQvWdNk}5}eU~~4CWaA1CUzf#>O7-! zhK}lN#-;55XA4$VIYc;s0RsdXr&oj3snwr4c48%74YJbf4X8muHZ=0?3iuWz^sJR5 zBOPX$J)&x(8E2>CoVaq+8>~05NFgW@=_p+gC{!{>H4cfaH4SA*N>w7gMvSb%@pqq~!J;wjVf% zcoUp`4+ zto@SU1XCgSQkNp6K#A|ckde9naP90HxE3!H${bxcGa24clLb&=9_ot8$vY2%L;`54 zp(-SM6zZ!{giV>n@ETjl3#@Hc7sH|D#vN!iALxt_tec*ZKu5Hvd(Vkxg~rtZ%G3V> zP|7i)C4vfVT1dzrAgKSS2|QHJ_lhoD3b84?$g!8deKtyAvuNRY%X$(fm6FRI>~uG^ zz7cNWqD?C7bmx~L_nm|6hC3T1a94B{cgv#MJaWuSLpn3VLO&ypBR;DJK8fOrdK&b# zc8H4I%y*pB-m=ngRJ2+wyBz>CFWA4?_Ac^QdQ#SAOG+7uKq)wwn3?tuI=7Qgrcs%e zHT<@Cw}4xLo+Niiv3FGF(Yz$mj7s(|4;5|`_(D-xeeTHiNy->*)Ndb8y~l_*Nt+6cmCLp?YwQ9k4=AEh?iI!N8?Zcn z*A;IiWIny8+Kc;MLMIo`zwGvt^{YU?y+?y3p%zUPA@KN&HcM;oM~0jU!J>H-H!#KE{7~un?;MX`1za?jkPDQa zz%@rgnlAFzE2M0Adh#+tH&Ho{sFlCFaX@t%77TetOM=rYZ(O)caR^>)2!zYfdE9MH z*GX=9U1g##oqs#q7qmk66~Y$eGisZOu2CY>RADrq=ab#4-_?2oY#RIqZoK?AQ)4)X zOxkz@9?UNoha+xy`x`5nH$vjl-8~dZ1_BjQ<3+cRL5y@4k&WbkOeNRePuAj%$bxvt zFKtL3Htrp2#{p?BCa@OEO5e@`N)QOWxLp{VDy5xnZr(6!vfF~}SyMo`kV0F-3oK7y zWRL{bWe1M(3*pw6^2K7{m&6+=E|E3rCT2y%hv$&iZbVMO;KRMXimftBU22=NP)y7v zvG0J=eDr}879+@wj-M6_kp-PeA{FtGF~qz-$edu>GhF#wKfS1mqM1nyZ3ayta#0C` zIDpVKxbo#z1$2elbSR&T7#ZB}h=|E5uLr_qyIb@Gn;BHY<_!6H%d~^&4-J%TAAMA# z#wIMFT2ZLyJ9ntQ z58c7OAQ;_&RA1D3Y)Nix)XMzf#h&F9ex$~7&G(|q;F!vc}u8W54d-EW`Vcn;Va43fb6t>Q7)fc??{*f_F5XK(`p`#UPkZ^@6#Y&s}HGV z*Ab*{a7q?%P#;$7OLFRZ5-}`iX$^;771Rv~__(w|mKvk=>QOZ*gK@RE4!MLBG0;*O zQq z(n`$k)&ygfNZ{fsE|8>s5JfgxT$;ooCP`&d z@<@QT^PmY7b!8WW#ulQwx9YWnS{+p_ zQ;#h(-y%KVtX_)E61ZR^>f#goveq-amDVnWIu&Dzhfj_1wXlFmss^Sj9L6NbfhbGo zd}%ARfW7n&D+kqAw?&sTiVpaVff@9@7L7{X_5-gD~pAxk*_DqGO2$Ma@#t9i8W_3$&@6kz4JydZ2;nAQOllzsk0Lk+T zkV~` zX8Z-|2fFwyEaIU;bO#PEibv*FNeSb?eS6>(1C|D7VmIV@S%57g0z*D+`RoA4yxFcS z>5Fo2pNp%87*}h9Lg3bB+=(U52hb67kt3_N;wB^Kkzyyvos!yGl;>>fNaY)A;4chX zF}HJ4YvCN_zJ+v`l@$=ua5jl`8Ppo6BY_%u=o>|& zh(Km8kZ!+H#hoew11H!@7xpxv(t{}O-~x8(h70gWCV`OGpNsJI3Vpp~6M0gY-S79hrEu zXhw!2Y*yWUqf*NdmlBGq9_QT|BA5oTR~U$nOgB%hk4hZkX#@!~NJgL`j2!=itFiq4 z9q5S`*detr-akvDFz>wprPF}D7ASA=ZeFY>qX}f3M&NT#ZtsKxWm3_3)ygmLORWq87qXVShol{ z6xGJ9LGmX~*~Ne+2ks8Ti1CjGBRRKnvp$h z+!Jhtm^1ck2iOkmDEG2z$F71xb-FNc!5VN-c`bEH5pPJ^v}JA;d&rdhkB_G0ll5-r zPNUVSwX>wWG!dp6#&N-W*E|Nd<-Ud;kWL_&6Gb6*abZRERT3~m95<_F94Fk~3&b7j zM~!!%Mm6pIAoejRIL4JRaf*1IrA3u!G#6R`!f15U;LZ@jc-)XVgvh#2L5D$%9mj{z zfzjPsI&j<`GyLKzI2LZrZXM!M3tRUfHtYyu0EmGEzT~pkgy!Rrpi-KNyK>*tc!ZED z+<}Aao(dKX!~<`Gm&)Y-FfHuIv>yR?o1hg^mrj@#lxs}C%}d<@IoPgl$>olj{Q<`r zI!O;XrRd=3IpQ7-Sz5Zs$wfEiguFfKef}calNyI>N`E@PO!H;{>IBAyVE?3A_Fm?C zoKxOU2uDyyG#2h177#U|OBPc}f$X7O0|h~T4E6>U9LJXsiICC@9syrwr`YQqB>doB zdDvoN$VY%g>lKrL*3F z25_y`>;(y!pZ5O1NY)}4N8OrYmVgKgn#yMnw?5dP=t9YcUcx$;r9bB;7aaTaXpdh- ztGPKEUwi$zIcJ<#g|8V)J~xQxvrRjH=vg2^54mtf&Cn=mjPx)$7uR4^D5yV$AtGTh zQ^OwpH9P_^0nL|C##k3_E@XxQ)96>!7dQgc7E=u;G;Sf?#QHkKtAW@Vgf5D;?*N`1 zWa%hc&aC?9fIBA~7s(U_U7R0F;k3US3e!J+vH* z!9<_~?sDYX25QdW15$5kCM?iYtc-d9*L3C-itpQB^7U&c};t$INd&w<3T^~TZ7J$8;Wz;PES zK&K6uBFH#U5_U|v#of3#e(1u};KMP#A}~xbHgXRbYX^ay0%3&Bz#Fieih4p@TsR7x zkVoR)5mw5&8x3N{2jX8cAYZgzC2=wwgG#508@~X2f#yOOac45*?XVCxkHr@p^hgo7 zT);Yw{-kmDz@TNj9I?n7`}{Ghd1UORUtl#M9>}5wZMq4Jxbuo`$ONc9iR4&i)??My zE;aZ05|2!EYqxUBVWQhp79$vH61Xg3I0#-vJ;5&lEr^3v)Kxd6UXJw&PL(52Q}ExN z08Zzu|HXU;MRh1Uic^%2<@CA@j88DF7gQchg02iQ7T=H%N8KW>AJRr@k=$Rif{+e7 z^GEn48Ow&8IKx>)u5|p%5GFSk-OQx6EPMx2>Y^lCJbEZl!uAA-4TC_nF zGEP$wmm>j61J4DKhzMw~^mu4i)Pfcz6v#I~OTKikL1G@tX)~qL2DREpTfFpr~6~$BqM`Fq%?K^1Q+*~#6ZCx%s zg%;5ui@PW3{vrfe?1Kp)_=sGe-yWVYk!b z_9Yjp5I=1n{iUt$ZEP+lWW|#ZbXXg!ozo^o1rX92cDtggL)VH$K2(3+pSrM+vorgo z2X5ABy)!Q%$smJ0qcLcMlc2+YhB*2EVdWAO2LH1oI*hf^lf`9lVTQlnIP0nZ1>|!b zAmSu{>Zw0xO`T_+26iDGO1zgV zjc1+){ir9Grc6 z7J*VF`vOBHBDznh$*b)aE(d|F74cG&t1TD^TL_3jkIlw+5JP>w)1cKx7vaI^{}txJ z2Q&vGnhKCp>Qqtvg@g5U2K03hQp4&YC!VTI~1 z*|V>{lkGX2(L@oUXMOD2(0<1(4BY1CkXCYyK)bg9rqA3|F(l?S)B9z(l$Y5yaDDfs!z)Zt<6a+(sO8H@V_3>U6f$ZIHJ>>nt6#9LG&z|SV0>JAFei>vru5xp#YySyy+5S zz>M9(9m^3l1Hri6Lm^}t6Tv?<5pgrK#5HB%1u9u7&{M0fpZKy1M|M}FjG zz|63OFj1%^X4`@J4Ffpv@;vmts|1I4nS8=~?#!Z98+7rvS18y98go<5>3 z#iHdv1toKFil6T-DgJjzF@bcJLBm;55h-x)m7FCDkGX+d}ks zG^b4oDtUYnd8vrMH27-J(LqQbkA{z`OSb$NM9Ad}e(yyrL^8;JKP`F2N2Z6!=fMmaj4kPBn(7P?k!FVF4%P&i0v4sC3 zh!|cAx_Z~KychhhGlPbxf zGm7GW<}X|tWHI9?$~q3!_Es>27>>J`W=F)HP`o;V%H(!nRk{2T;64s=|3yi9PO>BQ zUlmxBje$Q~5@kouUXrbO>hDo3h0HU8GPvg7lWYEiR{t=phxmq2cxyKP5fomaLRqVT z9r$M)3HXA5QFpZS_rT%$XzlouB z-ZwL8p>HQsLRdyUk?8rq!1HJpV5L$B#_C^&^_^}uf%@5~(ak$bDa@s0SFOeuy4~90 zjHhPxgb2aNhlH#sPiH;#Q$S80&r&p=kjH1A^VH|9$b9y>O$a#V`7=*5=gNrEl-);F z5p~bD6Ci=i_ft%L1mZ13+IOgryk4cS^gEBG%owGVMAov zdx>(_jpdvv;X+P!vK#D8z9>-IwnAk`03yzpKv?!bb{dOJg{F#v0(p% zkYNhNj>6&7kLBVeZgIHNg;4$!jqu;cb9r*(;r3dc&tISR)RU0+NULs7&&@?p1ie!E z>#(c<^7FUP#$WZ=^OHcV+*D3YIY3O8g&b}PJ&aQ`JzZp(A@nEU)=;TiEk`AQRkQdR zqZ>f5OL*dFlWXXaB*w7FQ#WF*V&7BSLiAiO)^=2Sbi^>x>3a0IQz*X z>Rfudf=sa~K)RBsY)32en3AQwu_5x=xzk2wbowkgJ+02UdAdc(xY-$|hyRee0qg~>eO8l}$yTr3(i{vkBv^#P8)7OXxW{jy2l-(#J`T3Wj?&M6J+}6f^Xen9vV{GKkAC^Brl; z{hRMdlI&OaWxgAEQ1cz+nBnHT(WA_Fr;aq=!D1Jg@ACI&zB{ep01<|9loQ0V3=oLL zkX=L`62maSjTS?O5xxY=cs`e(-s!^Nw`DFh8k1sbkZot7Dzu=bAcz);iuI^igqpTB z^Tb61wliz=vsUx7<_Vb4r^tvV)dK%P3HYVdAU7_-es;|Sxonu~2`jjA10DsAYW*wxH^kEI=iscuQgG?bxS~xa zhz+j6ttW5}(HUmEZPH(5oN4jhTb{Om#97hU-ep!yX9;QK2AzRsF5&lVUs0uB^XE;^ zFZgHt>ebTOscIR|p0W>T;k{*ILViT zZA!@d^nM5J+s$sL%{*abB(c-s<1e4_&xYRqJ6#BbmFgM)Jd(lC9g7vu`DZIL)6e?< z-=FnvvaPfsSeBO-R<~9cKE1Ry&*zOMri{owzGZ000m|mToUzn;+RnDd0RVncS?)pX;=w(gswZ%WItWU4>j&rHtZ{(EG z8i<@$#ucNjofZ-W5SL@avVZ{cA=={%9=^kv51C#CyJ~U~c(XUL2~8vc&V;K&xVTk` z@83-axGlzbA&O%QHErv+fSl>=^d@mTwnNa=equ=Z7?l#}eq}zL>Ba>One%0~F|qk? zn7u!C-+wWPZ|Dbv`0=n@7D`g_W9QqzQjB%IEl{=q2ZK@K9>`<%={fzn)n927#^GAW z7mzHYu<{qwXz43)klS7m0n$uGpeJA&5}&VUQ58`Qyhs7@M-kG3OifkZXWQ`D01IIp z?r*g^yVW^=qlXaUD&t$)jjF$}x`Nsq9bf2Mik5t$^7PqR(vs;j{^EH@V!rC*|IYX? zll=7Ne7jy4-kZ40VeJqxVf+4~(3d!BmWi4+cLubQl&7}=or4M&Ja5-)twHbt+**4C zkx*o5LX@*#C7|-AVA@KAX)6f|Bi~l^T13k#!XMe&%xT}Q>ILtL!#i+-_-X|)z|VV?R%)G5m~m=ybGs~`J&3;IQPQ@CGtW{9JMN9I$SFHP^D*^*Zy0bmkif`p?w z^3xE*h+%MY>I23zN`FVt_XIwEPxfv#+PYQjlu17Z-Vi)ynRfW9`M1hFLrVvyXwR~^ zIs42EaC4Qo`PwktbZhG7`~DGCXr4p@}PFuk~B^tLQ} zJ6!fQgZc>Oh}-j*nM0g&#;52#sX;0G5>-lEzFq4!YhanMw}sN53HBw@Kn7qeC5fAf z-o|exnu^3+c_~+zfgFGy`g{8UY~>~NvIWN3-tEN%OV|=kSi=UTj0hV=#p_9WwTy5YM$MzJA7&yJnINY>4)FatJv^7+FgpcUi&Ya$eB6Y=#NN5|#}KD=6J|+0-ex>htC`cVI>G~rAw@q3 zA7N%~6wvG-cS_o*=J184rvo#io|UzRu#T;FhU*Pq?86dinW2Fcl?S$vH1}a|>4K*B zyD{XY+E1AH{EUUq7X#mChOfii-Em1|PwcQRU>*a6R;M9obR0FfFOU}_h!-;eH%}sX z%Wrjf)By8ViCWw?Fr!{pWJXI2%wtBJ4^c|}RxV!xwp-0@)^>5-makD0Nu6!RzPEZB zJjD>ax2!^!ez}N1$~}0{+q*NghArb{%MA;6hoT_bvGqJKh375-QwqpA#gNFH>;fMBFWsk#Hm|sEY za&NtZvQpT(UVu_J4CaQ4nHbQ5iL{cD;h#1I0r=1ckf5N%UQDBpMF@-xMn3 z3jbspa1b6;G?9haMTAkPBAldGs7~u8&{HO!Vyz~g(uNzO27eFj3KU2YY~=lXZGdsoMV&A?k3=USNCWdCwB$&^oCs0l@7upT&ES7=*3B2}4<%{elBaAi51Ob;Ah& zO#SeK0Sc}+Dqc%aD@+WsBCbKZFXoCV8f|&`xjRAa))sGZfkz0Cs?WZR2fX4w1a}>VJ%| zni2x`a1G^iGgC^>SX7pT{obGCkf3jHTQYI!E%{?vp6{za$>p=FOEoV{ubP{w&F4xX z{!4DEUVsxG_y$haJw);PX501O8q(nUwTtF8hW^u|wyPZ5sZw&6JhMrE7TcshBZv`e zo8U}v%sBr}k>USvrwV8K^Ie`l)@pxr`EK?pSR z*};j}i9L8z!AyaX1W_>fP*QnMW}`HCs_>k`o)pdl|yf$jh* ziRkoEk=o;*QQU`2O;RigC{9c_RtYK>GPB+ut_zZ;kLubkg-b*6EcFAuMKK5(XD~Ky zPT59@c2NnW&$19lX#j%3=}b$?jLCDTfOhb&1U$D;j#O$q{?Y-f{r_tL`zS~^$Ts&# zi{DmEa4y$PaXdhQWECGU!(D}wC=Yr2(XWNfvq6$yqp znu(x`fsDaO^hd}g8cJ((NPq^3lZ+vB1QVwDz~=Js++e)y3r-XfWSuV9jX=vyHE4tP z6Z_jQ$wPhZa_OyCwbEDVmIFH>&G}BHV4jjs3XsYdZ+UtGuGccMg-T^a_B` zD394d9ShGkV8T==OpIA-$RniWK=80eYGQ%-7D^vdW!5PwN&d520q#Jme2}{1Uk+uM ziy2y&A7>@$psT-wvPup8N~k2g?lTZO^C6$S;wt}?81JZA2-G+gxxG7eN6vVPK{~Yu|`**twul1 z7g9(8H7OM|M6r&*%VR%Px&%8+-<7FPHJ=ZUBFgkh9s5*+aU&^|^{TP?p{z$V9ORk5 z$`xX(7>DGEf?m+d;CNZT(~;CVgkBpx28Ky`pyqA3I0(4qBn23m%)4}fZC#@IbgK=M zJq>Tu6r=e6 zEpr0jp+yQOkM&2oQm=$|iWpnP=_Fm?Ic=IM+7&mFjC5ns zm2*HbB?`sYWHJzH9>+L_lO8cy0janzYAx!gysy&S2L{8LrF9UR|6G6Q^y$+VK)!Je z*sEdAb-=2+z0J~Izkkr1d+I4ztr&U-M^+=a{Zyk!Z?pSsoV+<|px7k9Gsf~V{W zc*=Y`#eTv6g{BxGyuwF+n+q=yX9_EDIxMRixg5O$%+Rm`pnn7rO+se53`vb{^K<#|-Gs=w5hSsg9ms5qHW{wZk7kr9ec*OQ2(u#?A{;Fa3_DVYIbDgS*573!N#Uw)6FLH$Lqt-4B3TY>Z zkL#f7sKYKQe|52GuPT_EV?_{D!fc=OQIEU5W%nhhPKnz@)Ix9^iRhIEA-w5)1V6lN zg%aaPNO<5rNPhHp)RhWq{QK(fbA?%h>MXT|q#Ae6LxkC54EAd7)3pMb_HI#AVvk2} zD7E|+9L|t(z;)wi7L^oSb#nQ%qQ1XcJLIW=ht&qiOWjasq>HMDn^XsM5MCT+9fd})(X*LdeRLmnW!k(jR`E+`vj6vH+-(Mgy#{jm zl=#j3lHHo#RNNBIY;Z}hVLDWB2Lb7^O+@hXk$bCGH+8hR27-<}lVjL2Cs?d#JcMoy zfTT&s8a|95=_;U^#mcFA2ZufYlc2yy--w$c3qOcxXRKkan+L;zCmA(x6cTiUGY&(Y znrIK;kfl{N*%g3iv5A&C;hCg2A$r+<;;wp{iq4=qEHK9^7AOrWLa~9_!$37S9f@iV z#P@@1K*q>L`vdXN65ZgS#mOMW@Eyj5PFnlGFNLW^Q$I|&cJJrQI2spsx&c(1Be6BN z{H2R%feIibMFv}kZ6&UI3MtV7G=-3*S%l^wadyEiANLieUVgG5-rzB;w{9p#Q7z4>HMg_z|Y=qb!vHGf5eaIdUU3;TNH}|&( zU0%nCvB+$kgeY{SqP~3}sB{fF6nNfOk0EzBj%TJqg7-@!XA8ts16`0x@=JyT!2}?8 z{qka6m;}uG2*DXC0_qr*v~e2?ZtyS&BqBOCB+QRihX>%u2`c%M`=gRZ5(Z0; zcGR5-+);QR7;NRXh!{eSqxHrL07itDk~g&$oiA{xe3sWnTX&A-@)d<}rXxAN{RXsK z%tR=$l_ZGl@dK6d4&rzvw<6yU@4at1?}OA5{^2OyAZEiDL&goSa}kjnO2r%8Z^JEF zVum8MlNLk5vQ+35U21Pap$1DxA)`6?NeQ ze3xx|DC;70y#eAI)){hmgHh?xV<;sH6I3Rlt|F9ys=MdC7mbDKK@B%=1Vv-F>XMi> zo-&5l{~Z>Je>}?hbP`|TKU-hnPh)PVf6nD`gNEE{Zv}T)*37L12sgjw;c^*{1~^}zu5)rk;pmvZ`ny8`CLLr7U2xeFWMi`0`*VB zg#ikZ6a*+_+YJMR(j%Duzva~ENCwW(<)i>RQo!=#*UxTEZ%t$Uqg!DeqnBIP0k5)K^Wo&!8^Ky z#&(~TI(Xk5D-&_pYQo}(0)4>zu)4JfOiA5OjcTxcqk1AzS^^eraB!7u$Mz3Lzmc9C zZ-G2)v(&q|Qpg#-!XSn|jhrZh zQV!)QD&*Se{8?ZAvX(ZK#s&T-hn>S^^Nb6I3rTLhWvo6UJ9%rEn2)TGLIWZu5gUo2 z@GyO1>#P&r4T_Y2%9M2K5QOna4w1#PWKn|x4NQ!BWObt?!Ex7dP_1t$=dm5hugcSu0EBOwUe zR!#bVzzm~@SFD>b{qJ*?0uDKU_E?)!O{`-qubd!j+O_LOD#X41k19hV+2j+?RGyn* zL@Lw;nDwa`z}m{fAqc?i_$Avl5S?{-p)u+XDm>^eR<-aUayROzftdLiICeKKNrx88#1b}$W`A>fWX$CwqRr7|i^77)DXDesV^2L{i9Evgy zhp`+}MF)B&bJ2j)2`kIEk)}_K!@s!bksH6Pm#jA|MXLhb3VC3*+L9dSKjJ3IaVHu$ z1;8qbrVc%P#}cXuCLMDyUB>xeV=N~|iWofkNQ@Ygxk=|HYS#IJh71LK0bzX2r)C2d zEp{Go0BbsAEeKo}pCA_|juiogF|z$Z2yi3i%Q{>bVDf52^EbuyW+=Z+q>!vE93ksp zbdboB`uP;8SMNOk{F6==qj$?c>xLi|t@jyUEZ$B=S9A@1~B4ApBV5 zLx;Apx10zhcY8~Y!2!n{%1fFkYAXJ^i*6W(N3#Gy=a2|Pif|z&DJ(J-_KVPXNCoB! zr*l?qz>}a~uT+5M>*y)XTSSq-G!ve0qXSgbA3)%xfC3XLzYRSp;o-74fUqdEi~(@Y zUx2vVff9)mK_Lg+eIIpxXo=-|09>Pw5h0;?;rJLQw{`gwu^Bl|q1&oDfHI`{I4~d~ z^2&$k9%`q!SsIIhLFX)_OFNJe0&Hie`wBXB<1_20dx&TYNZyu`gWgd2H6(qA9tMn% zWLuG2b_b{?ipp_R1>f}%!xF%Niv^~pB9gC*$oE$raOSlV#(KSe(GTtgynfCqY)Xy8f8M=$$cD*0TFSMP+b@0)`H^PhU zj1rzW<~5lkPlk+*`qLMH0dk~6rGsy;UA?;gfkwAIIuZ}WnwIh;;FdUZy=jTq!{tK! zk)K>J*n!Ztu#N)-r@Q)nJ%-peMm0xmVD)fisU90aytn<9?G+3`*J^jXcu`Z78nxr3 z>rJ8VsD1M^YVjnhx?;q~V2U~QzIyyftBSF9Im30R?GOVY)iN6}AxPBA}62l=40fza2nGUd!{^&Z5J@GG$N)?hld$+}q!#MdO zPTT_ZN?1zYShrN=sRI+@0ljU&tHh`iS`vCwW`GlA0k#G)qcOm>-=n;<>b8L^lsxm) zF;l}hoOT6rX?rU#;&@unsZ-t;&PRnoT@&Ln05Lx!)1T+9-r!GwKXbx*>JjhjCd!e7 zjww8}I+=Guk?{L+?XGM7@FUNj7)j+EmXRilqz`e&OkU*Q8!R=fJlxA^st&72!QyU-RC!cog#e;TJseVm5LCr8wi7Rw%&n7?Lr6P z8wLsE7U80vsq+mYiuwTz7I6zOvdQ@dUDx9UIW$z=U2vh>p+8oSHv&YS1u(4g{-Y_* z>&%EcGm>AltFuAah-94IXxCXvwU4W=ko{dSsd>rx)yeS%NfppAt0If5jxvh?%d*tA zU^SHZH>5n$C5pS?mIj2KqDan2n0jbBLb3v%#*2iZ>r|cwdP1vbM+(_V$8ENfT;@Tf z>?776OF>zM5_Np@<9Q4%Nj!6NCbk#BuU-}5o06K0yJcWd1^$}GA1Gyio>2czPJQZ_ z1;m^|6U#QBRe~~PI+&~o0@n6n6{7yZH$0M zdcwUZ=F5jqcos(TE-Vn?uD3w4XW%U0zn2(1+fA@?=ikxe2oWDcdz_azAJ=1Is(&Z+ zm(V35L0|DllY=(Z1`M$@qM64wj}m=&aA9xIzBO-|oTLcZ&^=hd?$o-C-sKTf>tU%| z6JY|UV~KdXGNM*8%P7Y>jngcYg|l7{w;B{pf?$kjc2tZs9V>O2{T9_rnQr0s;anDl zg^4unMS=`S&e%A?2P^?)!CwRrin78c)a^hYW#PvO%gItQ(1YKnN+Pk=U z=3PUP?3`B`AcoTjxP})1##qpOq%DL{Llyv%%)wU?=MoNI%M3fSASfZ9nc`6{$}83t zv8&rhE_d0cfg?K*`yF60D8Z>zGt=!nIy9TJ${2>!im>g1o1p)(Mo3(M3%d#Oia5Rf z5&io4b#S7~wS)O^!Mvx7J1(7K2KytP?^@-(7q#-P>mu0lXD~DQpWI+X;Xh1M71d#8 zniCgcX9Mn|%qat#-7keY_B6mqMZg8sm^l8Jkrm*NHN?LI;c@9t4}Y0!f{S{R zkA(e=)ObKrrVA_GgSAIFi;PckuZ2XT&j#+Pv3i@qxl=}_3Kcj*=^0)IcOrajbL8FeL-im>&)4r;V|My zG{@k}Du^qyB9L?~Arz?5;tbK$&gn$FAh(&<58-9_xTd6#HXQAUqbY4Ua)Iy0I0ie2 zS*Dq31+|e)Jo|a<48lI+R`2)j;lS`OBMXYTG;#mwgf*Waw0M0F^br~p6b_nCfi*~- z>Q&&kwN}PExLe6O_>G0kxrIyBwV<^#H%D~Aq{_biEt_4%RdE0ve5f!KZ6RbICas|H zDGf;h+{8fB>@RBpuu_}x5TRg5sOiG~WlB`Zev@}W#WOb-0~Z>w{8W~+-j;X_U5Rs( z8YDGO&$8MGj2m#Tci_!_N2joKzNTSoFxD9Z51SbywsaG`hWc1omSl+%AJ>AG81t&UJ1T6 zx&x~`1m6@>GeZxI{nD0jiUS;mf7&52d&Xj?tO+eU+|U4rf5apgb-a6KX&( zDvQ5~+b%}+sA+c8EeY?Lv7 zOMnJlXxK@z4l)`9L6mV?$YN9Fc1l@)4%@mY>jo@S)2nH2Z=J z!|8l5lLIYbHo06CDgkBS$oQm*q(_6G;(w^9Ma#i9++J4Hml&ud5eUaXrLvd-m8X{x ztYpMLOnHk^q^mPGGC!rS36H>;p)J84K?^O3%^}W!Xz>j`uk!vQSW)E_sbYjd6?ImN zkBs_{#FPQ;xJcxZaFy6qN8;^?XF31`0gjO1;M~JTXZa33AwQG=47fkQW*^504=N-? zXAPlO7QQcALvtGf2&yKg0BlZDbu$r@HmX^A#}-??isGrn2=I+H9!xGJ3Jr6zJmenn z8am88ZG{D6UgP^xgLX8h z;TVnC8~fp60DA&v%1OfCCa%;@_^pfSadKoFT;E%gt+QPg&%M>#G1_eb;}(2#P1s87@oEkCMi6e(B28&t27DP(5Dg%YEk& z0BbSf@Dh-TXxo*`E9-uVl>f@r%PUtF)>p1xS(7@d=Yh9^cI55k&tb6S4y-~5M&-5P z`v`3BLS=+urQ1&6_n6R7b*lVrw`~YWi!eCAAqJJODm}L<#E^>m_l3IgO?q%SY&8~T zWs-OhU-E5N&{CvW7pDqJ%8ji$<-v)sDDjg3@gyzsqKc4)oK*jOs!J5P1 zLy;xS>5;QjO9P%`QOquOZL}cMqjNA4_} z2)JuFSaZHHS=&bv>Ne-Eax>%HLW-_ObPNud=*LM-7x{B&8av*m{;-dkg1BW6p6*AWn>v|WP%$s}6b zAM_t!4Kom)5K`OjY(X0Aslxo%FY*Cd1;tPaoB}5Y;y|~8jS8*^dq-F6@I=Tl`D^~m zwJv2(^@Jua!H_IL0F-W!ua6>Rw2Gr{7GmO>ET<*TAzIHcH6sZ#2Fwbslv$rgKeh&T zrZW>xi$J4YDe7;_Y(kd8e^mD9`V<9Lev5S}_;Q-HP$WU=L9(SOW4#E z6L%lqDO>=AP&kVR(ely6CZ8~>lQK=Xe-5Q=Hsl*(;@784O+-0Wk4RnCT0@9-_?sYa3XZvy`VngzY8)fs|e``bhtfaB#F*R zgQ0cX_$63IU;}_rVNh7A@7)8bQSr>Cdi zqcPzq+Z!bcsoP^@4Fgs%*M<|M!*~H-78~^TLOPat6+a_z4%4eor#r|`FCVXxIGn7d z_wHBL9|b5;XP2%Gn@nhXBfrGNsYXGvfzT2XZ-Hp|7*MUK6~@Ge4LG6Ro@5q~cge5N zWo4zDurX5_XnM9*FH#HZ3H000n6k4_ z%6hEmW#V7azjF;kQo%^h+<~1J1jp>~fpfDVX94BQ;r{CzKM#ZTXiu?#vfGis*q_6& z##|r6W_aP&97QHxd=CV^7r>_OKS8b>sfA~r&{v$1`AT>{i@`*9*y6~7&>n`>0f)FL z5f)8NSpD+zJO+&IL6UV;Enfo1LQr?vLKoXdZE8Lt`*hC;` zOH!Db2%zPr%s2a}#7f!#J?C~BVM}HzQ*f*LWOeL7c8s-%keC+f_9B7X1SvD_8L^V{ z(i=F-P{ydiYHgCrA{idkKoa^EuC}8K<|seruTFmdnl!+v9O}e$vD_~4&G}M}s0Hbi zTvJZOQQc@k38X{NLI&xsmM$@CNHnQSTz=@Hv5vSmk@#gQ<+JzU4!H^}3Trk@!PN8s zQ3u5byqxX~8q(>)M~IXbrc8y|uLuB%6GV|v6K6NC7b!v{o+V-oVT141w&YeLoOa&8 z)o{A_*o`xql52I@Py+<<_d(S_xd!kNij&EmVMBrJ4PM+~J0KPS_OmZ;mDfa5OLYd2 zfwc~xpj1>j#?++xSZ3xnH;G!38$c+ON&1ucf0I_jJcPcnNwk=M0g0z%B+w0*d}6U?BvwFpvLqXJ zfjSOyrtu=~JC@?fuxlYW0XSLBc(&n@H(Al(-em9zAr_V zpC>wQlvdfC&DosIxjSu@J1JK>wG*e;QI%lXa%$iDk7CQIvnJ>qOUJerSyFYR*d85p z&_M?s^g;(2bdW*|DRj_52N|T${pg^BUg)5M4LazcgI?$$gAQ8A;P-leKHu;6d7g8Q zWXZAGbvGlcbJMb>Yn4k~@ zS27!a*QH(1{({BHC9QBX#nkjs<%h>x(Eq_Z&`2-UyVqcIt;VTtrG8OkZ`yVlK-=L5Opq16)#Zs>k_0(;%XA%xsev} z=~&>#9*J3TvnC6I(`kQ*5cG8YMq(@6hb0W0*i^Vqo4zGUoZ#*D1X*Jiwrp~>fahYu zbtoamSJIR%8CP*~9smP#G&mRYD_{X(3?c#BTDfVKG!xaXY^-r2Nj=dyHBR!rDP5e= zoVSzPm!E`;U}UzK0Q?aWWg5j)en#VW0@Ww+_zsP%%*dhlbY) z6NOJNEqrMpp9}%~XihTMKb`&h;ny#&s$oWe1W{dBoH;myr0^jYGjY(k6JWs zX?5CVkS78aRjij}X#HZ*QO?UbMwR6a&}pQhiaqRXsPrCExmMK+v$(9*&63+kS;fir zDBLP7O6)*fg8s4uSG@u*3QHjQ6f9|@WC|x0{3y=RmRKjDEzO=5J&m!_&lMkVw?%gU>=dH9hYq!> zapJ54^?(*Z2pwcc61!pipHuRXj8=)x6j2!}@^z|M{oBB)^bgy;$$Twkb)j3ua7mV}(HxEg)W zgC4`(Az$5G9_k`9@f4SLs@^=V=tKpz8?_385lEsNs8!o`KtYcI@)kXGS0`j=eu=Ck|Nk_as*Ji?*y-llLVa$w2v+xhLBn^w|>0EC4l;)nAkeY zmKAgKHf?!LzJD&dNW=GWm)b%KU1BcNY*LMg&(=%32%T)hW)ks6F7?S5m(NB5dQ5aT z%)Pjr=Jv14Q|vpanJssG~`6kiybc)#-=;gdPk)1O*qwF%rQs z8t~J4kJg>|hmy@Gwiol+k_1bA=2b$MHM22^@SJ4`g4c(i+N-lWN89je{qyudd&k_2@;46*R-2Qeu{! zt+e$-<4EdWV`?Hvy+_kG=7_)9m<~D4W*YaW-c|dQed3(e7Rw)u!Q@tXu+uo&9XU<$ zfo~t@mfQU73MPkvAEt*JJO$)OT`*!0TRFRO1}D8`#dfm6+Gpb!(bVRV>2CLecqsb3 z!698Nl4-O1YOlt(+`eaX%jVu~E^8coMr?G!;g!9cIt^YO$Y?86&Opj>`$3w`2Ae7D zh5|9JLN;PjIEwfz%`|0M&E8YH6u=n0AZzwR<68LI%^c^h1PUWDHyf(mj4!#-q$K0J z94rJQdb7PSwM?ot)im1K{k2c3CV=rCznS)c-Q^8?q;Vvm-SH)B36lL%OR%=% zfs;e#)^P=2aR-O7u`*V_u__~$=$`mlQ7S0h8(nh6Z8VOARQ!0wex>%gl#3tOA14&h zMNRNLAGI;engVY9YVE0fiW4%Cym*+}Va4;TLPkNYRgw2B4ThSczwLNS!d2raSkCn_ zZhlUDGuu}a?T4fzciWz0q=GJ>Zxf{>>`qc)U^OOPE58MAjbtR{x;glqMKz`a01`*+ zWDgFW(OfVPF%gv!u+ju!hvNU_JqWBFD_Ps9e^^z-mgSx_79+)v%q5G+u*X~#`WhTu z0;T;NY986gPU{LG=;mC6<0z7b)RDNZ#F9JNuk~M7!rY(9x_=e29Lb7fh^sMP58!wb&>{cq&1T+e3dM(h1J$8`FAEi z?0+hEb$DJ`n3QFf4+CoIr#!W~Ipz+&i)5!*wt6osEGn7(Yfrs=pq{zfai}(k78hG4SndFzQ`1m{*6FT=q8u`J0pS zP9&S|6|Txows_jB$Ka`)Lv5PZ&Aaut1NmE%UfhN6r{mW<8aVswfxV|!SC(FCEzpjG zRB{w_%nzNxmk%CJz?j2@f16gzf3w*zhmI6r*v2@2J1}&KR*!vlyN!O&|Hlya?*>M) zzZ)1jU>%>=+WY6%Zqcim;!n3`sTEB}%B+?h$q#&N(;46*-2xFRtq+Y{~3 zcu64`;UTz+EU|J0%aP(%1lx%TfHJqZ&>5kDUeW@src~oc_=PTq*sP{o@gu;Lmdyx> zhn!kCcSYZwg$ruf=Bs))n#KFPoF4pSnnb#t4w23aG=pOl>j=@r`5s5wTQiDji1Azs(O3xp-L7g&Q5R%h1hp+)?c)GjXOT;El-wH?!txY zS*MfjeQ;+-c{dxE{NrX6sHC{=I~a6{84(+3STpJt)`X|%@!fdg>@5u3G9TR)+Ws!5`Z7b;la|EVZg5=50T#Y|9RM*2jpb~fKj>)_MOM**CJGtejq z>Wq434pJ&8l=xeiYf+q~c9!ZMc=%hl{O@ePJ%<4xI~-m-Pvr3R+rA0A`sbcyo%Usg zfsSJ-yxJbr^7fq;b5;$R+pOoPV!aa!rLe`n4CG58iX@2(r#a3^80?zX^Ia}t1867uZ0j6?02b|H&WT68_|AT zeoLw`d{p{ckg42hFK8{5LDcYflK?(Pq)PxFLDKX%2OFv@(=fnR60Zh9?lectOoE)u=qnzZ98icM8 zBql5fPOzI4($Tq^l|X@659YyfYNa28AIW@CyfG4S$11Tj17&Yt3DwAK8qva6*l7Q6pOGh!8V6)_Ekimw^;s8qKFLxGJQJ^4LzA zVn1kn7q&K#M19B`m(Z|pnG4eEN)wT(=&!pe6aDMJ;Au3tc-V7+WlZ-F{K4AEd|3Pu zqsM*@7ImSX@4L`mN7Ks>mht)D2J(~T*C$VsX91u4xBgQdEI*rO$p;S*_$7$evVR}Q zpUlI;CML>{7izhx%%w-dn?CW_yAw0Mpfgth7OTmId5XYfczq4acRsb#8T{R?=D=n0 z?*oHJyJ1_|@DTN_^H-<}_|t*fh5SFL>zE&06UPtNxlWGg2M=d?=tQ@E>y?~05R5EB zWDhBhBhS%acNF2G!*-SzN?&C^?K67>Yl1ZAIp+5IIjp_chV$CVEI%B+i8KXSEc=gv zp?;_$gTZiutb~!ADk|-T$DVlN(39jvM4013swHc|f$)3v#g9`})9eKwl)+#R#Vu=t zKOF!l_tmxw#`|k`0LBM;!C3kVUqSEe1@`P5kPq0#?ys@22WzROVO3ZwsU!yoxJ5pG z216u1t!!{l9-J+rmQKbJ30k%8^C8y~^PVxdNQxJ&MXhB0FOGzm1AE@g<_J z_RDDFpo`dH@_g`tEhfh=E<(HI>^|YEaej+qN1N!L-G>@&9CpDxNa<)uKiqupiFC`n zL1IGJn2iJ2;xDYMETcoc;U0hpy(;ZT4eIb%U^glY*@#MD6k#Pox)@ul9m=Pq8FkB+ z$xkC`K_MTqNy$S{5_5y#D3M`t*~E@CQ<=*7OnWp_*ZVH;^1tR0+SyE(lJaQ=?fJIb zs41ELAUkr#w8>&^sn%33!5CVtz%1BR5{7^Fw)}@`Z$p#%qH9tQLknbJq_$-CFc~b#-7f9eL>VOuM~yYT*RlJ>5iCM=zz03Dxh9OnDQ9b|PtR09_w7UjKzXO~z&%$X51l;5ph2 z$OAjjbO-%>MvCJZe>=mC!YIV74wcUPkj{IwmOW7$>N&6;CAv0D3eDR3W!h{F=EdJn z*760)vHK6wl8=>?<18OGf-M>3Of7#yzbEPB6t2cjy^rsv#6pKl$+mqgh94m(@PyfL zq3ZggWz^V5pZ z#~A&QQNjwzeKGVE*$ZoEex&)8@Cb`69{GT($r;lrJ$s_5Ml8wn9PUrFHbu3JrDJjK z{xKvhSQLf~(vWQ)Bb>Tt+< zUw*Kv=9Pa(V5^+XQ%GRFl!d1P{9<9`gBRQ!?(r)5WRe%+1H;13@avH(y6pApCD~Jj zR42;`TzGN0-{i=dkupuy@`JuSCq{kA&xu+-BSP#C8kG@gf{aYn2BX)hIt>fIy z>wKz~o$9l~?qNj=%I}`3?d>4}2Rdse)Q&;$=fdAr0rq;HpA0`#B;RK@CnzOBZ*U~o zn!#7rqkvul3Su&KHNBHo4E-Hb>5T^!~!e^;1M<_isp2?3rDj^Xe(JY_XPqwRqb>HCdXO#4NMM z9`j1UQgG|fP^Yy+(;T7{z*zR(PKEZ#j$dBr-WqlCH(mPC?#XYrcnDU%IS#W9Al+ID z%BHtb$%`C-Z_~8_tv^NC7CwM73h=G0WVfzUdU;lV5YAv_v)TCdO*gU69xaz*AIkSq z@vBol_Pxtga43Iq0B%kHjWTXzAMZ2AURf*lvv|;Qs5r$kK9{#3EZ#p&9OC@?5cPn0 zx3j?^i{y58+TPgJZv&2C_;k098eM*;`lrG4b)o)2F+?LF%~>vf?Vm~^FgInEiVwvN2q~-{|B{vuO6Zseeb5#o&#?jg5D75QijG5 z*i!zSWq+{QQha#$%pjNZ5BogjM1uZR=}1c}hJ8AclxI6Ykx9y2FO|N_{;1E$wnI!7 z;qV8mcv#>nOY0&Eia83{k!63}XXw(&SC0KaYc;WBIZ_=eA z{C)T)&|I&*zwNY#zn%SwAN#kmKkdU#h}0tC6gdZuIQZNlK%M^{VJ2+_ zhAeMZlGjY($m-^Thz^aIkYQ4}?8s^v*QSOrc?qAikW*qsi11*1i&HXNb6{iS(Ibgh zNNvdUk%>=q=a;i6bjzp$C13*JP(3^dL!Rwfl3_3U|L4_FW6TLe{+(>xaA6Udg zQBP2B)K4T=8W`y1An9%UP!9v1*x6_LGL0s zqHr$BLI+Ydj6|VGGq5Wk95!K-mdRuClJ$4Ar+yz5yF}I_qqBw}PiOZGAIe3@6*{BZ zVsQlX<~Bv@8;hMe$T-1H?#|VBwqCW0<(Sm z4nI1L=F!mlOX$@&%2mS^wmg4pj$ml2F4am0wzv1Z2I^-@4Gqv{;_Hf~=Jh38q>#UQ zQo%fXO_nt%=ncve#XF@;v$0~SjqE4ehBx)`i%C5r5yJGH@tuI)*Gyp@cQjc; z9J|}poQrrKMBT(jYQq%lNZl+;D5^aYPOvU-pWw}|9pxkt7*&Z8GP?S4#tJlkxP54F z@y+6wAh8+Gi0na;@jc8#Jgo$a=Y(O(Sb45=^ zDG}^IFSqA~6v1xvT!Vhz$|x}d8QF8{lLI*j2Fn2Ox$CXph2XB=+5+->#x9m2AKw_C zZ>^~_&8A0TPU@}BO;zw?pWJYEWU!=dh4#UI7WlBlh8$?-|*Imnxg*Ui3VtGHorYJ#KMG z@1pf~>3YNtpyNRe8^65BstXEGy)>Jh)FwBx-3wfPI%pq3Yi9hU6)&7?@&_2 z2gwnl0`cC*$&r*wJ$ycg**q=wIeTNqPM^Yg?2P;+25da5=`lvMZiQ(J!OzUr!J8Up z6y1?FVuaTMe1J>@Q?LB{SvM?{qduVCpDivsx9Qd4Fl~iL3dX2qVNTI>u+0AK}c<8Dc1?jTP z*H1{l@4!r~d{iN@1l4a>2Rl!g)0``@%n8H}UZslgfiOvYl_|n;f)Fy#1}5D$7>W>C~FjscNN{ zFbk4Z(r|5~R0xSRK)G+tX{vr5I!K-f*Hkvc_E0{!zS3R5!WtZGV#+HlV^sslduE=@ zgVjoLcErj$VOfRJtkp+M9#r~hh$<*-g(*=-whdvO)K2ndV(rSyZhlNFhF;*&#C#bD z7~4|)9r;Zyay{-WB;~UdYA9ILpvWB`zoqO)w}xXARd9XyL5b;M*F?Zu6rK}Km6+H* z;>s*R30kiSAV|pFTiTe1t9tOw#JZfJ$opZ{_L%3he+bioip){r)9V*Rh{~q)vf_DE zf!ekQL`;jd_G=!tNM*Vp6nQCvg%7Z~&WiPLZ7)F2>%2;k+0|>(Iw^9-akXi3xu(`t z_BSS+6Cz9NDx9R!A}n0RSw@)+oWsz?7pzKY zydkKX);5&C@U3X3bhes+E|OOMMlhHHP;q^rhoa>jzrg~%=w`AwYzcexqh(NcR|V!WET(XwSQSP{yS+l@;1mrxFH}ZQNUxvX z_ri=Nyt2nUuT21t5J2ux&Nz<54Py7f_*wn9NPhe}byrrl;NZQs*?!mja(gz3m}ycq z>6}Ro>%vluQ~zf;*h^OPa?YL2%HA+vT_?ML-|BJIaWwfc`l8d%cft(24Jd~#_C3lx zwfv|Bg+NQ=EF~}QFO8_UqGw7O#>Ll+nwwRW=v=$d(F6UqXT-KH&B_==_oHZq%f=Bk&vA{-EZAC#TZ*#sC3_Q%j}-J}rBS=vV(Y2*9-O)} zWC{hCrf;Eq>PYEsI?R9JZ!R5Jj1Qrh=sa`g|nZ7>sKbOgrXejqKZyo;XF>{E%jgc8EeVa-&0f$<4Lp{Xn{m8gr!!A62mG z1~whvt~#QSNp2+FWt*<3Gw^Q^-UK~mdDRtC8|)6v=PHH^Gf9*RnVMW-(r4uwA{{)R z3(Jrsk%3Ib&;#;8M6nH?B1S`nZ&{!05m-YiK^KI(B%=Q|_g{Lf$szgE(73+-@P_r8E~f-v2uB_|Q^8bde^D*n_3calne z^}wqbjwMO0yJ%(*aZ^iyhI-)62+HeVSWp+LS_N{bYbu7twgS1X-YD(P1YP+R&X@fP z9F2+OR&J_+BSejxO`So}_C*tKYan^+fRuBywjcn-Dm5EP}+iHrhO;~h8 z0`3{v3_sEH2!Ia_uk<@r<%KS#AqvBn5(xRVwf>gWJUu40rc1$a`II)ut0roMZ~`Aw zJ(Hv-emA@iXOJ`tVfxkBcJ7+Wz`uaUiW>dKhP z462KGuI~#Od z-PN-U;D%Yom+^$RfPMG{fdpH@seG1kcBDB~EhHhV#jPFgU;i`^l9ngVCmT%(7n*jn zA%C)%``=Dal5Mc`a9}fr4S*W$JD{*^Ol1P&w$b{wG-?|3$W#%jnaOLK!E|V%=Y3p( ziu<5o6#Wz}O;MFDEaZB%F&(Ivg&PRDzbY(+M! za0PYw`8idk(W5spLdk8TM5b79emrl6G)d-&71P`U#p$TO>%+}MOnvd)K`N_o`H%iQ;U~UtyVlw zW!LQ@+%QQ~q@hF(8^g)%v(>65q0E=t@{YKdg1GP(LR|RyBv71Eh!>^ICr{)^c9i== zd*ucN*Ltz�=8Z!F-4ePVXh^Qis2oSuNL= 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 literal 0 HcmV?d00001 diff --git a/historic/src/storage.rs b/historic/src/storage.rs index d34ddf1e97..9beb2d3c7d 100644 --- a/historic/src/storage.rs +++ b/historic/src/storage.rs @@ -2,6 +2,7 @@ mod storage_entry; mod storage_info; mod storage_key; mod storage_value; +mod list_storage_entries_any; use crate::client::{OfflineClientAtBlockT, OnlineClientAtBlockT}; use crate::config::Config; @@ -71,14 +72,14 @@ where let metadata = client.metadata(); let mut pallet_name = Cow::Borrowed(""); - frame_decode::helpers::list_storage_entries_any(metadata).filter_map(move |entry| { + list_storage_entries_any::list_storage_entries_any(metadata).filter_map(move |entry| { match entry { - frame_decode::storage::Entry::In(name) => { + frame_decode::storage::StorageEntry::In(name) => { // Set the pallet name for upcoming entries: pallet_name = name; None } - frame_decode::storage::Entry::Name(entry_name) => { + frame_decode::storage::StorageEntry::Name(entry_name) => { // Output each entry with the last seen pallet name: Some(StorageEntriesItem { pallet_name: pallet_name.clone(), diff --git a/historic/src/storage/list_storage_entries_any.rs b/historic/src/storage/list_storage_entries_any.rs new file mode 100644 index 0000000000..7bf4bb65eb --- /dev/null +++ b/historic/src/storage/list_storage_entries_any.rs @@ -0,0 +1,35 @@ +use frame_decode::storage::StorageEntryInfo; +use frame_metadata::RuntimeMetadata; + +pub use frame_decode::storage::StorageEntry; + +/// Returns an iterator listing the available storage entries in some metadata. +/// +/// This basically calls [`StorageTypeInfo::storage_entries()`] for each metadata version, +/// returning an empty iterator where applicable (ie when passing legacy metadata and the +/// `legacy` features flag is not enabled). +pub fn list_storage_entries_any( + metadata: &RuntimeMetadata, +) -> impl Iterator> { + match metadata { + RuntimeMetadata::V0(_deprecated_metadata) + | RuntimeMetadata::V1(_deprecated_metadata) + | RuntimeMetadata::V2(_deprecated_metadata) + | RuntimeMetadata::V3(_deprecated_metadata) + | RuntimeMetadata::V4(_deprecated_metadata) + | RuntimeMetadata::V5(_deprecated_metadata) + | RuntimeMetadata::V6(_deprecated_metadata) + | RuntimeMetadata::V7(_deprecated_metadata) => { + Box::new(core::iter::empty()) as Box>> + } + RuntimeMetadata::V8(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V9(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V10(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V11(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V12(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V13(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V14(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V15(m) => Box::new(m.storage_entries()), + RuntimeMetadata::V16(m) => Box::new(m.storage_entries()), + } +} \ No newline at end of file diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml index 31a213bfdd..ad950f1e43 100644 --- a/metadata/Cargo.toml +++ b/metadata/Cargo.toml @@ -43,6 +43,7 @@ bitvec = { workspace = true, features = ["alloc"] } criterion = { workspace = true } scale-info = { workspace = true, features = ["bit-vec"] } subxt-utils-stripmetadata = { workspace = true } +frame-decode = { workspace = true, features = ["legacy-types"] } [lib] # Without this, libtest cli opts interfere with criterion benches: diff --git a/metadata/src/from/legacy/mod.rs b/metadata/src/from/legacy/mod.rs index c06999f7a0..cbfba0ced7 100644 --- a/metadata/src/from/legacy/mod.rs +++ b/metadata/src/from/legacy/mod.rs @@ -1,4 +1,6 @@ mod portable_registry_builder; +#[cfg(test)] +mod tests; use crate::Metadata; use crate::utils::ordered_map::OrderedMap; @@ -8,10 +10,10 @@ use alloc::collections::BTreeMap; use alloc::format; use alloc::string::ToString; use alloc::vec::Vec; -use frame_decode::constants::ConstantTypeInfo; +use frame_decode::constants::{ConstantEntryInfo,ConstantTypeInfo}; use frame_decode::extrinsics::ExtrinsicTypeInfo; use frame_decode::runtime_apis::RuntimeApiTypeInfo; -use frame_decode::storage::StorageTypeInfo; +use frame_decode::storage::{StorageEntryInfo,StorageTypeInfo}; use frame_metadata::v15; use portable_registry_builder::PortableRegistryBuilder; use scale_info_legacy::TypeRegistrySet; @@ -19,16 +21,10 @@ use scale_info_legacy::type_registry::RuntimeApiName; macro_rules! from_historic { ($vis:vis fn $fn_name:ident($metadata:path $(, builtin_index: $builtin_index:ident)? )) => { - $vis fn $fn_name(metadata: &$metadata, mut types: TypeRegistrySet<'_>) -> Result { - // Extend the types with important information from the metadata: - { - let builtin_types = frame_decode::helpers::type_registry_from_metadata(metadata) - .map_err(Error::CannotEnhanceTypesFromMetadata)?; - types.prepend(builtin_types); - } - + $vis fn $fn_name(metadata: &$metadata, types: &TypeRegistrySet<'_>) -> Result { // This will be used to construct our `PortableRegistry` from old-style types. let mut portable_registry_builder = PortableRegistryBuilder::new(&types); + portable_registry_builder.ignore_not_found(true); // We use this type in a few places to denote that we don't know how to decode it. let unknown_type_id = portable_registry_builder.add_type_str("special::Unknown", None) @@ -76,7 +72,7 @@ macro_rules! from_historic { let storage = pallet.storage.as_ref().map(|s| { let storage = as_decoded(s); let prefix = as_decoded(&storage.prefix); - let entries = metadata.storage_entries_in_pallet(&pallet_name).map(|entry_name| { + let entries = metadata.storage_in_pallet(&pallet_name).map(|entry_name| { let info = metadata .storage_info(&pallet_name, &entry_name) .map_err(|e| Error::StorageInfoError(e.into_owned()))?; @@ -98,7 +94,6 @@ macro_rules! from_historic { Ok((entry_name, entry)) }).collect::, _>>()?; - Ok(crate::StorageMetadata { prefix: prefix.clone(), entries, @@ -376,8 +371,6 @@ pub enum Error { context: String, error: portable_registry_builder::PortableRegistryAddTypeError, }, - #[error("Cannot enhance the types with information from metadata: {0}")] - CannotEnhanceTypesFromMetadata(scale_info_legacy::lookup_name::ParseError), #[error("Cannot find 'hardcoded::ExtrinsicAddress' type in legacy types")] CannotFindAddressType, #[error("Cannot find 'hardcoded::ExtrinsicSignature' type in legacy types")] diff --git a/metadata/src/from/legacy/portable_registry_builder.rs b/metadata/src/from/legacy/portable_registry_builder.rs index a44217413c..3334fceb0a 100644 --- a/metadata/src/from/legacy/portable_registry_builder.rs +++ b/metadata/src/from/legacy/portable_registry_builder.rs @@ -27,6 +27,7 @@ pub struct PortableRegistryBuilder<'info> { legacy_types: &'info TypeRegistrySet<'info>, scale_info_types: PortableRegistry, old_to_new: BTreeMap, + ignore_not_found: bool, } impl<'info> PortableRegistryBuilder<'info> { @@ -39,9 +40,16 @@ impl<'info> PortableRegistryBuilder<'info> { types: Default::default(), }, old_to_new: Default::default(), + ignore_not_found: false, } } + /// If this is enabled, any type that isn't found will be replaced by a "special::Unknown" type + /// instead of a "type not found" error being emitted. + pub fn ignore_not_found(&mut self, ignore: bool) { + self.ignore_not_found = ignore; + } + /// Try adding a type, given its string name and optionally the pallet it's scoped to. pub fn try_add_type_str( &mut self, @@ -101,6 +109,25 @@ impl<'info> PortableRegistryBuilder<'info> { return Ok(*new_id); } + // Assign a new ID immediately to prevent any recursion. If we don't do this, then + // recursive types (ie types that contain themselves) will lead to a stack overflow. + // with this, we assign IDs up front, so the ID is returned immediately on recursing. + let new_id = self.scale_info_types.types.len() as u32; + + // Add a placeholder type to "reserve" this ID. + self.scale_info_types.types.push(PortableType { + id: new_id, + ty: scale_info::Type::new( + scale_info::Path { segments: vec![] }, + core::iter::empty(), + scale_info::TypeDef::Variant(scale_info::TypeDefVariant { variants: vec![] }), + Default::default(), + ), + }); + + // Cache the ID so that recursing calls bail early. + self.old_to_new.insert(id.clone(), new_id); + let visitor = PortableRegistryVisitor { builder: &mut *self, current_type: &id, @@ -111,12 +138,18 @@ impl<'info> PortableRegistryBuilder<'info> { .legacy_types .resolve_type(id.clone(), visitor) { - Ok(Ok(new_id)) => { - self.old_to_new.insert(id, new_id); + Ok(Ok(ty)) => { + self.scale_info_types.types[new_id as usize].ty = ty; Ok(new_id) - } - Ok(Err(e)) => Err(e), - Err(e) => Err(e.into()), + }, + Ok(Err(e)) => { + self.old_to_new.remove(&id); + Err(e) + }, + Err(e) => { + self.old_to_new.remove(&id); + Err(e.into()) + }, } } @@ -129,12 +162,6 @@ impl<'info> PortableRegistryBuilder<'info> { pub fn finish(self) -> PortableRegistry { self.scale_info_types } - - fn push_type(&mut self, ty: scale_info::Type) -> u32 { - let id = self.scale_info_types.types.len() as u32; - self.scale_info_types.types.push(PortableType { id, ty }); - id - } } struct PortableRegistryVisitor<'a, 'info> { @@ -144,16 +171,22 @@ struct PortableRegistryVisitor<'a, 'info> { impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info> { type TypeId = LookupName; - type Value = Result; + type Value = Result, PortableRegistryAddTypeError>; fn visit_unhandled(self, kind: UnhandledKind) -> Self::Value { panic!("A handler exists for every type, but visit_unhandled({kind:?}) was called"); } fn visit_not_found(self) -> Self::Value { - Err(PortableRegistryAddTypeError::TypeNotFound( - self.current_type.clone(), - )) + if self.builder.ignore_not_found { + // Return the "unknown" type if we're ignoring not found types: + Ok(unknown_type()) + } else { + // Otherwise just return an error at this point: + Err(PortableRegistryAddTypeError::TypeNotFound( + self.current_type.clone(), + )) + } } fn visit_primitive(self, primitive: Primitive) -> Self::Value { @@ -175,14 +208,12 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info Primitive::I256 => scale_info::TypeDefPrimitive::I256, }; - let primitive_type = scale_info::Type::new( + Ok(scale_info::Type::new( Default::default(), core::iter::empty(), scale_info::TypeDef::Primitive(p), Default::default(), - ); - - Ok(self.builder.push_type(primitive_type)) + )) } fn visit_sequence>( @@ -194,16 +225,15 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info let path = scale_info::Path { segments: path.map(Into::into).collect(), }; - let sequence_type = scale_info::Type::new( + + Ok(scale_info::Type::new( path, core::iter::empty(), scale_info::TypeDef::Sequence(scale_info::TypeDefSequence { type_param: inner_id.into(), }), Default::default(), - ); - - Ok(self.builder.push_type(sequence_type)) + )) } fn visit_composite(self, path: Path, fields: Fields) -> Self::Value @@ -227,21 +257,20 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info }); } - let composite_type = scale_info::Type::new( + Ok(scale_info::Type::new( path, core::iter::empty(), scale_info::TypeDef::Composite(scale_info::TypeDefComposite { fields: scale_info_fields, }), Default::default(), - ); - - Ok(self.builder.push_type(composite_type)) + )) } fn visit_array(self, inner_type_id: LookupName, len: usize) -> Self::Value { let inner_id = self.builder.add_type(inner_type_id)?; - let array_type = scale_info::Type::new( + + Ok(scale_info::Type::new( Default::default(), core::iter::empty(), scale_info::TypeDef::Array(scale_info::TypeDefArray { @@ -249,9 +278,7 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info type_param: inner_id.into(), }), Default::default(), - ); - - Ok(self.builder.push_type(array_type)) + )) } fn visit_tuple(self, type_ids: TypeIds) -> Self::Value @@ -264,16 +291,14 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info scale_info_fields.push(new_id.into()); } - let tuple_type = scale_info::Type::new( + Ok(scale_info::Type::new( Default::default(), core::iter::empty(), scale_info::TypeDef::Tuple(scale_info::TypeDefTuple { fields: scale_info_fields, }), Default::default(), - ); - - Ok(self.builder.push_type(tuple_type)) + )) } fn visit_variant(self, path: Path, variants: Var) -> Self::Value @@ -308,16 +333,14 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info }) } - let variant_type = scale_info::Type::new( + Ok(scale_info::Type::new( path, core::iter::empty(), scale_info::TypeDef::Variant(scale_info::TypeDefVariant { variants: scale_info_variants, }), Default::default(), - ); - - Ok(self.builder.push_type(variant_type)) + )) } fn visit_compact(self, inner_type_id: Self::TypeId) -> Self::Value { @@ -333,16 +356,14 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info ty: Some(inner_id.into()), }]; - let compact_type = scale_info::Type::new( + Ok(scale_info::Type::new( scale_info::Path { segments: path }, type_params, scale_info::TypeDef::Compact(scale_info::TypeDefCompact { type_param: inner_id.into(), }), Default::default(), - ); - - Ok(self.builder.push_type(compact_type)) + )) } fn visit_bit_sequence( @@ -386,7 +407,7 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info }, ]; - let bitseq_type = scale_info::Type::new( + Ok(scale_info::Type::new( scale_info::Path { segments: path }, type_params, scale_info::TypeDef::BitSequence(scale_info::TypeDefBitSequence { @@ -394,8 +415,22 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info bit_store_type: new_store_ty.into(), }), Default::default(), - ); - - Ok(self.builder.push_type(bitseq_type)) + )) } } + +fn unknown_type() -> scale_info::Type { + scale_info::Type::new( + scale_info::Path { + segments: Vec::from_iter([ + "special".to_owned(), + "Unknown".to_owned() + ]) + }, + core::iter::empty(), + scale_info::TypeDef::Variant(scale_info::TypeDefVariant { + variants: Vec::new(), + }), + Default::default(), + ) +} \ No newline at end of file diff --git a/metadata/src/from/legacy/tests.rs b/metadata/src/from/legacy/tests.rs new file mode 100644 index 0000000000..b23a76c336 --- /dev/null +++ b/metadata/src/from/legacy/tests.rs @@ -0,0 +1,398 @@ +use super::*; +use codec::Decode; +use frame_metadata::RuntimeMetadata; +use scale_info_legacy::LookupName; +use core::str::FromStr; +use scale_type_resolver::TypeResolver; +use frame_decode::constants::ConstantTypeInfo; +use frame_decode::runtime_apis::RuntimeApiEntryInfo; + +/// Load some legacy kusama metadata from our artifacts. +fn legacy_kusama_metadata(version: u8) -> (u64, RuntimeMetadata) { + const VERSIONS: [(u8, u64, &'static str); 5] = [ + (9, 1021, "metadata_v9_1021.scale"), + (10, 1038, "metadata_v10_1038.scale"), + (11, 1045, "metadata_v11_1045.scale"), + (12, 2025, "metadata_v12_2025.scale"), + (13, 9030, "metadata_v13_9030.scale"), + ]; + + let (spec_version, filename) = VERSIONS + .iter() + .find(|(v, _spec_version, _filename)| *v == version) + .map(|(_, spec_version, name)| (*spec_version, *name)) + .unwrap_or_else(|| panic!("v{version} metadata artifact does not exist")); + + let mut path = std::path::PathBuf::from_str("../artifacts/kusama/").unwrap(); + path.push(filename); + + let bytes = std::fs::read(path).expect("Could not read file"); + let metadata = RuntimeMetadata::decode(&mut &*bytes).expect("Could not SCALE decode metadata"); + + (spec_version, metadata) +} + +/// Load our kusama types. +/// TODO: This is WRONG at the moment; change to point to kusama types when they exist: +fn kusama_types() -> scale_info_legacy::ChainTypeRegistry { + frame_decode::legacy_types::polkadot::relay_chain() +} + +/// Return a pair of original metadata + converted subxt_metadata::Metadata +fn metadata_pair(version: u8) -> (TypeRegistrySet<'static>, RuntimeMetadata, crate::Metadata) { + let (spec_version, metadata) = legacy_kusama_metadata(version); + let types = kusama_types(); + + // Extend the types with builtins. + let types_for_spec = { + let mut types_for_spec = types.for_spec_version(spec_version).to_owned(); + let extended_types = frame_decode::helpers::type_registry_from_metadata_any(&metadata).unwrap(); + types_for_spec.prepend(extended_types); + types_for_spec + }; + + let subxt_metadata = match &metadata { + RuntimeMetadata::V9(m) => crate::Metadata::from_v9(m, &types_for_spec), + RuntimeMetadata::V10(m) => crate::Metadata::from_v10(m, &types_for_spec), + RuntimeMetadata::V11(m) => crate::Metadata::from_v11(m, &types_for_spec), + RuntimeMetadata::V12(m) => crate::Metadata::from_v12(m, &types_for_spec), + RuntimeMetadata::V13(m) => crate::Metadata::from_v13(m, &types_for_spec), + _ => panic!("Metadata version {} not expected", metadata.version()) + }.expect("Could not convert to subxt_metadata::Metadata"); + + (types_for_spec, metadata, subxt_metadata) +} + +/// A representation of the shape of some type that we can compare across metadatas. +#[derive(PartialEq, Debug, Clone)] +enum Shape { + Array(Box, usize), + BitSequence(scale_type_resolver::BitsStoreFormat, scale_type_resolver::BitsOrderFormat), + Compact(Box), + Composite(Vec, Vec<(Option, Shape)>), + Primitive(scale_type_resolver::Primitive), + Sequence(Vec, Box), + Tuple(Vec), + Variant(Vec, Vec), + // To avoid recursion we return this if we spot it: + Recursive, +} + +#[derive(PartialEq, Debug, Clone)] +struct Variant { + index: u8, + name: String, + fields: Vec<(Option, Shape)> +} + + +/// A dumb immutable stack to help prevent type recursion in our tests below. +mod stack { + pub struct Stack { + items: Vec + } + + impl Stack { + /// Create a new stack with a single item. + pub fn new(item: T) -> Self { + Stack { items: vec![item] } + } + /// Fetch the current top item of the stack. + pub fn current(&self) -> &T { + self.items.last().unwrap() + } + /// Push an item to the stack, returning a new stack. + pub fn push(&self, t: T) -> Self { + let mut items = self.items.clone(); + items.push(t); + Stack { items } + } + /// Return true if the item at the top of the stack is equal to any of the others. + pub fn has_recursed(&self) -> bool { + if self.items.len() <= 1 { + return false + } + + let last_item = self.items.last().unwrap(); + (0..self.items.len() - 1).any(|idx| &self.items[idx] == last_item) + } + } +} + +impl Shape { + /// convert some modern type definition into a [`Shape`]. + fn from_modern_type(id: u32, types: &scale_info::PortableRegistry) -> Shape { + Shape::from_modern_type_inner(stack::Stack::new(id), types) + } + + fn from_modern_type_inner(ids: stack::Stack, types: &scale_info::PortableRegistry) -> Shape { + if ids.has_recursed() { + return Shape::Recursive + } + + let id = *ids.current(); + let visitor = scale_type_resolver::visitor::new((ids, types), |_, _| panic!("Unhandled")) + .visit_array(|(ids, types), type_id, len| { + let inner = Shape::from_modern_type_inner(ids.push(type_id), types); + Shape::Array(Box::new(inner), len) + }) + .visit_bit_sequence(|_, store, order| { + Shape::BitSequence(store, order) + }) + .visit_compact(|(ids, types), type_id| { + let inner = Shape::from_modern_type_inner(ids.push(type_id), types); + Shape::Compact(Box::new(inner)) + }) + .visit_composite(|(ids, types), path, fields| { + let path = path.map(|p| p.to_owned()).collect(); + let inners = fields.map(|field| { + let name = field.name.map(|n| n.to_owned()); + let inner = Shape::from_modern_type_inner(ids.push(field.id), types); + (name, inner) + }).collect(); + Shape::Composite(path, inners) + }) + .visit_primitive(|_types, prim| { + Shape::Primitive(prim) + }) + .visit_sequence(|(ids, types), path, type_id| { + let path = path.map(|p| p.to_owned()).collect(); + let inner = Shape::from_modern_type_inner(ids.push(type_id), types); + Shape::Sequence(path, Box::new(inner)) + }) + .visit_tuple(|(ids, types), fields| { + let inners = fields.map(|field| { + Shape::from_modern_type_inner(ids.push(field), types) + }).collect(); + Shape::Tuple(inners) + }) + .visit_variant(|(ids, types), path, variants| { + let path = path.map(|p| p.to_owned()).collect(); + let variants = variants.map(|v| { + Variant { + index: v.index, + name: v.name.to_owned(), + fields: v.fields.map(|field| { + let name = field.name.map(|n| n.to_owned()); + let inner = Shape::from_modern_type_inner(ids.push(field.id), types); + (name, inner) + }).collect() + } + }).collect(); + Shape::Variant(path, variants) + }) + .visit_not_found(|_types| { + panic!("PortableRegistry should not have a type which can't be found") + }); + + types.resolve_type(id, visitor).unwrap() + } + + /// convert some historic type definition into a [`Shape`]. + fn from_legacy_type(name: &scale_info_legacy::LookupName, types: &TypeRegistrySet<'_>) -> Shape { + Shape::from_legacy_type_inner(stack::Stack::new(name.clone()), types) + } + + fn from_legacy_type_inner(ids: stack::Stack, types: &TypeRegistrySet<'_>) -> Shape { + if ids.has_recursed() { + return Shape::Recursive + } + + let id = ids.current().clone(); + let visitor = scale_type_resolver::visitor::new(types, |_, _| panic!("Unhandled")) + .visit_array(|types, type_id, len| { + let inner = Shape::from_legacy_type_inner(ids.push(type_id), types); + Shape::Array(Box::new(inner), len) + }) + .visit_bit_sequence(|_types, store, order| { + Shape::BitSequence(store, order) + }) + .visit_compact(|types, type_id| { + let inner = Shape::from_legacy_type_inner(ids.push(type_id), types); + Shape::Compact(Box::new(inner)) + }) + .visit_composite(|types, path, fields| { + let path = path.map(|p| p.to_owned()).collect(); + let inners = fields.map(|field| { + let name = field.name.map(|n| n.to_owned()); + let inner = Shape::from_legacy_type_inner(ids.push(field.id), types); + (name, inner) + }).collect(); + Shape::Composite(path, inners) + }) + .visit_primitive(|_types, prim| { + Shape::Primitive(prim) + }) + .visit_sequence(|types, path, type_id| { + let path = path.map(|p| p.to_owned()).collect(); + let inner = Shape::from_legacy_type_inner(ids.push(type_id), types); + Shape::Sequence(path, Box::new(inner)) + }) + .visit_tuple(|types, fields| { + let inners = fields.map(|field| { + Shape::from_legacy_type_inner(ids.push(field), types) + }).collect(); + Shape::Tuple(inners) + }) + .visit_variant(|types, path, variants| { + let path = path.map(|p| p.to_owned()).collect(); + let variants = variants.map(|v| { + Variant { + index: v.index, + name: v.name.to_owned(), + fields: v.fields.map(|field| { + let name = field.name.map(|n| n.to_owned()); + let inner = Shape::from_legacy_type_inner(ids.push(field.id), types); + (name, inner) + }).collect() + } + }).collect(); + Shape::Variant(path, variants) + }) + .visit_not_found(|types| { + // When we convert legacy to modern types, any types we don't find + // are replaced with empty variants (since we can't have dangling types + // in our new PortableRegistry). Do the same here so they compare equal. + Shape::from_legacy_type_inner(ids.push(LookupName::parse("special::Unknown").unwrap()), types) + }); + + types.resolve_type(id, visitor).unwrap() + } +} + +// Go over all of the constants listed via frame-decode and check that our old +// and new metadatas both have identical output. +macro_rules! constants_eq { + ($name:ident, $version:literal, $version_path:ident) => { + #[test] + fn $name() { + let (old_types, old_md, new_md) = metadata_pair($version); + let RuntimeMetadata::$version_path(old_md) = old_md else { panic!("Wrong version") }; + + let old: Vec<_> = old_md.constant_tuples() + .map(|(p,n)| { + old_md.constant_info(&p, &n).unwrap() + }) + .map(|c| { + (c.bytes.to_owned(), Shape::from_legacy_type(&c.type_id, &old_types)) + }) + .collect(); + let new: Vec<_> = new_md.constant_tuples() + .map(|(p,n)| { + new_md.constant_info(&p, &n).unwrap() + }) + .map(|c| { + (c.bytes.to_owned(), Shape::from_modern_type(c.type_id, new_md.types())) + }) + .collect(); + + assert_eq!(old, new); + } + } +} + +constants_eq!(v9_constants_eq, 9, V9); +constants_eq!(v10_constants_eq, 10, V10); +constants_eq!(v11_constants_eq, 11, V11); +constants_eq!(v12_constants_eq, 12, V12); +constants_eq!(v13_constants_eq, 13, V13); + +/// Make sure all Runtime APIs are the same once translated. +#[test] +fn runtime_apis() { + for version in 9..=13 { + let (old_types, _old_md, new_md) = metadata_pair(version); + + let old: Vec<_> = old_types.runtime_api_tuples() + .map(|(p,n)| { + old_types.runtime_api_info(&p, &n).unwrap().map_ids(|id| { + Ok::<_,()>(Shape::from_legacy_type(&id, &old_types)) + }).unwrap() + }) + .collect(); + let new: Vec<_> = new_md.runtime_api_tuples() + .map(|(p,n)| { + new_md.runtime_api_info(&p, &n).unwrap().map_ids(|id| { + Ok::<_,()>(Shape::from_modern_type(id, new_md.types())) + }).unwrap() + }) + .collect(); + + assert_eq!(old, new); + } +} + +macro_rules! storage_eq { + ($name:ident, $version:literal, $version_path:ident) => { + #[test] + fn $name() { + let (old_types, old_md, new_md) = metadata_pair($version); + let RuntimeMetadata::$version_path(old_md) = old_md else { panic!("Wrong version") }; + + let old: Vec<_> = old_md.storage_tuples() + .map(|(p,n)| { + let info = old_md.storage_info(&p, &n).unwrap().map_ids(|id| { + Ok::<_,()>(Shape::from_legacy_type(&id, &old_types)) + }).unwrap(); + (p.into_owned(), n.into_owned(), info) + }) + .collect(); + let new: Vec<_> = new_md.storage_tuples() + .map(|(p,n)| { + let info = new_md.storage_info(&p, &n).unwrap().map_ids(|id| { + Ok::<_,()>(Shape::from_modern_type(id, new_md.types())) + }).unwrap(); + (p.into_owned(), n.into_owned(), info) + }) + .collect(); + + if old.len() != new.len() { + panic!("Storage entries for version 9 metadata differ in length"); + } + + for (old, new) in old.into_iter().zip(new.into_iter()) { + assert_eq!((&old.0, &old.1), (&new.0, &new.1), "Storage entry mismatch"); + assert_eq!(old.2, new.2, "Storage entry {}.{} does not match!", old.0, old.1); + } + } + } +} + +storage_eq!(v9_storage_eq, 9, V9); +storage_eq!(v10_storage_eq, 10, V10); +storage_eq!(v11_storage_eq, 11, V11); +storage_eq!(v12_storage_eq, 12, V12); +storage_eq!(v13_storage_eq, 13, V13); + +#[test] +fn builtin_call() { + for version in 9..=13 { + let (old_types, _old_md, new_md) = metadata_pair(version); + + let old = Shape::from_legacy_type(&LookupName::parse("builtin::Call").unwrap(), &old_types); + let new = Shape::from_modern_type(new_md.outer_enums.call_enum_ty, new_md.types()); + assert_eq!(old, new, "Call types do not match in metadata V{version}!"); + } +} + +#[test] +fn builtin_error() { + for version in 9..=13 { + let (old_types, _old_md, new_md) = metadata_pair(version); + + let old = Shape::from_legacy_type(&LookupName::parse("builtin::Error").unwrap(), &old_types); + let new = Shape::from_modern_type(new_md.outer_enums.error_enum_ty, new_md.types()); + assert_eq!(old, new, "Error types do not match in metadata V{version}!"); + } +} + +#[test] +fn builtin_event() { + for version in 9..=13 { + let (old_types, _old_md, new_md) = metadata_pair(version); + + let old = Shape::from_legacy_type(&LookupName::parse("builtin::Event").unwrap(), &old_types); + let new = Shape::from_modern_type(new_md.outer_enums.event_enum_ty, new_md.types()); + assert_eq!(old, new, "Event types do not match in metadata V{version}!"); + } +} \ No newline at end of file diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs index d609dc5fa0..5222670f7d 100644 --- a/metadata/src/lib.rs +++ b/metadata/src/lib.rs @@ -26,15 +26,15 @@ use alloc::borrow::Cow; use alloc::collections::BTreeMap; use alloc::string::{String, ToString}; use alloc::vec::Vec; -use frame_decode::constants::{ConstantInfo, ConstantInfoError, Entry}; +use frame_decode::constants::{ConstantInfo, ConstantInfoError, ConstantEntry}; use frame_decode::custom_values::{CustomValue, CustomValueInfo, CustomValueInfoError}; use frame_decode::extrinsics::{ ExtrinsicCallInfo, ExtrinsicExtensionInfo, ExtrinsicInfoArg, ExtrinsicInfoError, ExtrinsicSignatureInfo, }; -use frame_decode::runtime_apis::{RuntimeApiInfo, RuntimeApiInfoError, RuntimeApiInput}; -use frame_decode::storage::{StorageInfo, StorageInfoError, StorageKeyInfo}; -use frame_decode::view_functions::{ViewFunctionInfo, ViewFunctionInfoError, ViewFunctionInput}; +use frame_decode::runtime_apis::{RuntimeApiInfo, RuntimeApiInfoError, RuntimeApiInput, RuntimeApiEntry}; +use frame_decode::storage::{StorageInfo, StorageInfoError, StorageKeyInfo, StorageEntry}; +use frame_decode::view_functions::{ViewFunctionInfo, ViewFunctionInfoError, ViewFunctionInput, ViewFunctionEntry}; use hashbrown::HashMap; use scale_info::{PortableRegistry, Variant, form::PortableForm}; @@ -192,16 +192,17 @@ impl frame_decode::storage::StorageTypeInfo for Metadata { Ok(info) } - - fn storage_entries(&self) -> impl Iterator> { +} +impl frame_decode::storage::StorageEntryInfo for Metadata { + fn storage_entries(&self) -> impl Iterator> { self.pallets().flat_map(|pallet| { let pallet_name = pallet.name(); - let pallet_iter = core::iter::once(Entry::In(pallet_name.into())); + let pallet_iter = core::iter::once(StorageEntry::In(pallet_name.into())); let entries_iter = pallet.storage().into_iter().flat_map(|storage| { storage .entries() .iter() - .map(|entry| Entry::Name(entry.name().into())) + .map(|entry| StorageEntry::Name(entry.name().into())) }); pallet_iter.chain(entries_iter) @@ -236,14 +237,15 @@ impl frame_decode::runtime_apis::RuntimeApiTypeInfo for Metadata { Ok(info) } - - fn runtime_apis(&self) -> impl Iterator> { +} +impl frame_decode::runtime_apis::RuntimeApiEntryInfo for Metadata { + fn runtime_api_entries(&self) -> impl Iterator> { self.runtime_api_traits().flat_map(|api_trait| { let trait_name = api_trait.name(); - let trait_iter = core::iter::once(Entry::In(trait_name.into())); + let trait_iter = core::iter::once(RuntimeApiEntry::In(trait_name.into())); let method_iter = api_trait .methods() - .map(|method| Entry::Name(method.name().into())); + .map(|method| RuntimeApiEntry::Name(method.name().into())); trait_iter.chain(method_iter) }) @@ -277,14 +279,15 @@ impl frame_decode::view_functions::ViewFunctionTypeInfo for Metadata { Ok(info) } - - fn view_functions(&self) -> impl Iterator> { +} +impl frame_decode::view_functions::ViewFunctionEntryInfo for Metadata { + fn view_function_entries(&self) -> impl Iterator> { self.pallets().flat_map(|pallet| { let pallet_name = pallet.name(); - let pallet_iter = core::iter::once(Entry::In(pallet_name.into())); + let pallet_iter = core::iter::once(ViewFunctionEntry::In(pallet_name.into())); let fn_iter = pallet .view_functions() - .map(|function| Entry::Name(function.name().into())); + .map(|function| ViewFunctionEntry::Name(function.name().into())); pallet_iter.chain(fn_iter) }) @@ -317,14 +320,15 @@ impl frame_decode::constants::ConstantTypeInfo for Metadata { Ok(info) } - - fn constants(&self) -> impl Iterator> { +} +impl frame_decode::constants::ConstantEntryInfo for Metadata { + fn constant_entries(&self) -> impl Iterator> { self.pallets().flat_map(|pallet| { let pallet_name = pallet.name(); - let pallet_iter = core::iter::once(Entry::In(pallet_name.into())); + let pallet_iter = core::iter::once(ConstantEntry::In(pallet_name.into())); let constant_iter = pallet .constants() - .map(|constant| Entry::Name(constant.name().into())); + .map(|constant| ConstantEntry::Name(constant.name().into())); pallet_iter.chain(constant_iter) }) @@ -351,7 +355,8 @@ impl frame_decode::custom_values::CustomValueTypeInfo for Metadata { Ok(info) } - +} +impl frame_decode::custom_values::CustomValueEntryInfo for Metadata { fn custom_values(&self) -> impl Iterator> { self.custom.map.keys().map(|name| CustomValue { name: Cow::Borrowed(name), @@ -369,7 +374,7 @@ impl Metadata { #[cfg(feature = "legacy")] pub fn from_v13( metadata: &frame_metadata::v13::RuntimeMetadataV13, - types: scale_info_legacy::TypeRegistrySet<'_>, + types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v13(metadata, types) } @@ -378,7 +383,7 @@ impl Metadata { #[cfg(feature = "legacy")] pub fn from_v12( metadata: &frame_metadata::v12::RuntimeMetadataV12, - types: scale_info_legacy::TypeRegistrySet<'_>, + types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v12(metadata, types) } @@ -387,7 +392,7 @@ impl Metadata { #[cfg(feature = "legacy")] pub fn from_v11( metadata: &frame_metadata::v11::RuntimeMetadataV11, - types: scale_info_legacy::TypeRegistrySet<'_>, + types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v11(metadata, types) } @@ -396,7 +401,7 @@ impl Metadata { #[cfg(feature = "legacy")] pub fn from_v10( metadata: &frame_metadata::v10::RuntimeMetadataV10, - types: scale_info_legacy::TypeRegistrySet<'_>, + types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v10(metadata, types) } @@ -405,7 +410,7 @@ impl Metadata { #[cfg(feature = "legacy")] pub fn from_v9( metadata: &frame_metadata::v9::RuntimeMetadataV9, - types: scale_info_legacy::TypeRegistrySet<'_>, + types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v9(metadata, types) } @@ -414,7 +419,7 @@ impl Metadata { #[cfg(feature = "legacy")] pub fn from_v8( metadata: &frame_metadata::v8::RuntimeMetadataV8, - types: scale_info_legacy::TypeRegistrySet<'_>, + types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { from::legacy::from_v8(metadata, types) } From 1ffac6ed692bb161badf50588ab8b9604b467cec Mon Sep 17 00:00:00 2001 From: James Wilson Date: Mon, 17 Nov 2025 11:50:38 +0000 Subject: [PATCH 07/14] Address performance and equality issues in metadata conversion testing --- metadata/src/from/legacy/tests.rs | 132 ++++++++++++------------------ 1 file changed, 51 insertions(+), 81 deletions(-) diff --git a/metadata/src/from/legacy/tests.rs b/metadata/src/from/legacy/tests.rs index b23a76c336..f1051204b7 100644 --- a/metadata/src/from/legacy/tests.rs +++ b/metadata/src/from/legacy/tests.rs @@ -6,6 +6,7 @@ use core::str::FromStr; use scale_type_resolver::TypeResolver; use frame_decode::constants::ConstantTypeInfo; use frame_decode::runtime_apis::RuntimeApiEntryInfo; +use alloc::collections::BTreeSet; /// Load some legacy kusama metadata from our artifacts. fn legacy_kusama_metadata(version: u8) -> (u64, RuntimeMetadata) { @@ -74,8 +75,10 @@ enum Shape { Sequence(Vec, Box), Tuple(Vec), Variant(Vec, Vec), - // To avoid recursion we return this if we spot it: - Recursive, + // This is very important for performance; if we've already seen a variant at some path, + // we'll return just the variant path next time in this, to avoid duplicating lots of variants. + // This also eliminates recursion, since variants allow for it. + SeenVariant(Vec), } #[derive(PartialEq, Debug, Clone)] @@ -85,69 +88,31 @@ struct Variant { fields: Vec<(Option, Shape)> } - -/// A dumb immutable stack to help prevent type recursion in our tests below. -mod stack { - pub struct Stack { - items: Vec - } - - impl Stack { - /// Create a new stack with a single item. - pub fn new(item: T) -> Self { - Stack { items: vec![item] } - } - /// Fetch the current top item of the stack. - pub fn current(&self) -> &T { - self.items.last().unwrap() - } - /// Push an item to the stack, returning a new stack. - pub fn push(&self, t: T) -> Self { - let mut items = self.items.clone(); - items.push(t); - Stack { items } - } - /// Return true if the item at the top of the stack is equal to any of the others. - pub fn has_recursed(&self) -> bool { - if self.items.len() <= 1 { - return false - } - - let last_item = self.items.last().unwrap(); - (0..self.items.len() - 1).any(|idx| &self.items[idx] == last_item) - } - } -} - impl Shape { /// convert some modern type definition into a [`Shape`]. fn from_modern_type(id: u32, types: &scale_info::PortableRegistry) -> Shape { - Shape::from_modern_type_inner(stack::Stack::new(id), types) + let mut seen_variants = BTreeSet::new(); + Shape::from_modern_type_inner(id, &mut seen_variants, types) } - fn from_modern_type_inner(ids: stack::Stack, types: &scale_info::PortableRegistry) -> Shape { - if ids.has_recursed() { - return Shape::Recursive - } - - let id = *ids.current(); - let visitor = scale_type_resolver::visitor::new((ids, types), |_, _| panic!("Unhandled")) - .visit_array(|(ids, types), type_id, len| { - let inner = Shape::from_modern_type_inner(ids.push(type_id), types); + fn from_modern_type_inner(id: u32, seen_variants: &mut BTreeSet>, types: &scale_info::PortableRegistry) -> Shape { + let visitor = scale_type_resolver::visitor::new((seen_variants, types), |_, _| panic!("Unhandled")) + .visit_array(|(seen_variants, types), type_id, len| { + let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); Shape::Array(Box::new(inner), len) }) .visit_bit_sequence(|_, store, order| { Shape::BitSequence(store, order) }) - .visit_compact(|(ids, types), type_id| { - let inner = Shape::from_modern_type_inner(ids.push(type_id), types); + .visit_compact(|(seen_variants, types), type_id| { + let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); Shape::Compact(Box::new(inner)) }) - .visit_composite(|(ids, types), path, fields| { + .visit_composite(|(seen_variants, types), path, fields| { let path = path.map(|p| p.to_owned()).collect(); let inners = fields.map(|field| { let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_modern_type_inner(ids.push(field.id), types); + let inner = Shape::from_modern_type_inner(field.id, seen_variants, types); (name, inner) }).collect(); Shape::Composite(path, inners) @@ -155,26 +120,30 @@ impl Shape { .visit_primitive(|_types, prim| { Shape::Primitive(prim) }) - .visit_sequence(|(ids, types), path, type_id| { + .visit_sequence(|(seen_variants, types), path, type_id| { let path = path.map(|p| p.to_owned()).collect(); - let inner = Shape::from_modern_type_inner(ids.push(type_id), types); + let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); Shape::Sequence(path, Box::new(inner)) }) - .visit_tuple(|(ids, types), fields| { + .visit_tuple(|(seen_variants, types), fields| { let inners = fields.map(|field| { - Shape::from_modern_type_inner(ids.push(field), types) + Shape::from_modern_type_inner(field, seen_variants, types) }).collect(); Shape::Tuple(inners) }) - .visit_variant(|(ids, types), path, variants| { - let path = path.map(|p| p.to_owned()).collect(); + .visit_variant(|(seen_variants, types), path, variants| { + let path: Vec = path.map(|p| p.to_owned()).collect(); + // very important to avoid recursion and performance costs: + if !seen_variants.insert(path.clone()) { + return Shape::SeenVariant(path); + } let variants = variants.map(|v| { Variant { index: v.index, name: v.name.to_owned(), fields: v.fields.map(|field| { let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_modern_type_inner(ids.push(field.id), types); + let inner = Shape::from_modern_type_inner(field.id, seen_variants, types); (name, inner) }).collect() } @@ -189,33 +158,29 @@ impl Shape { } /// convert some historic type definition into a [`Shape`]. - fn from_legacy_type(name: &scale_info_legacy::LookupName, types: &TypeRegistrySet<'_>) -> Shape { - Shape::from_legacy_type_inner(stack::Stack::new(name.clone()), types) + fn from_legacy_type(name: &LookupName, types: &TypeRegistrySet<'_>) -> Shape { + let mut seen_variants = BTreeSet::new(); + Shape::from_legacy_type_inner(name.clone(), &mut seen_variants, types) } - fn from_legacy_type_inner(ids: stack::Stack, types: &TypeRegistrySet<'_>) -> Shape { - if ids.has_recursed() { - return Shape::Recursive - } - - let id = ids.current().clone(); - let visitor = scale_type_resolver::visitor::new(types, |_, _| panic!("Unhandled")) - .visit_array(|types, type_id, len| { - let inner = Shape::from_legacy_type_inner(ids.push(type_id), types); + fn from_legacy_type_inner(id: LookupName, seen_variants: &mut BTreeSet>, types: &TypeRegistrySet<'_>) -> Shape { + let visitor = scale_type_resolver::visitor::new((seen_variants, types), |_, _| panic!("Unhandled")) + .visit_array(|(seen_variants, types), type_id, len| { + let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); Shape::Array(Box::new(inner), len) }) .visit_bit_sequence(|_types, store, order| { Shape::BitSequence(store, order) }) - .visit_compact(|types, type_id| { - let inner = Shape::from_legacy_type_inner(ids.push(type_id), types); + .visit_compact(|(seen_variants, types), type_id| { + let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); Shape::Compact(Box::new(inner)) }) - .visit_composite(|types, path, fields| { + .visit_composite(|(seen_variants, types), path, fields| { let path = path.map(|p| p.to_owned()).collect(); let inners = fields.map(|field| { let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_legacy_type_inner(ids.push(field.id), types); + let inner = Shape::from_legacy_type_inner(field.id, seen_variants, types); (name, inner) }).collect(); Shape::Composite(path, inners) @@ -223,37 +188,41 @@ impl Shape { .visit_primitive(|_types, prim| { Shape::Primitive(prim) }) - .visit_sequence(|types, path, type_id| { + .visit_sequence(|(seen_variants, types), path, type_id| { let path = path.map(|p| p.to_owned()).collect(); - let inner = Shape::from_legacy_type_inner(ids.push(type_id), types); + let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); Shape::Sequence(path, Box::new(inner)) }) - .visit_tuple(|types, fields| { + .visit_tuple(|(seen_variants, types), fields| { let inners = fields.map(|field| { - Shape::from_legacy_type_inner(ids.push(field), types) + Shape::from_legacy_type_inner(field, seen_variants, types) }).collect(); Shape::Tuple(inners) }) - .visit_variant(|types, path, variants| { - let path = path.map(|p| p.to_owned()).collect(); + .visit_variant(|(seen_variants, types), path, variants| { + let path: Vec = path.map(|p| p.to_owned()).collect(); + // very important to avoid recursion and performance costs: + if !seen_variants.insert(path.clone()) { + return Shape::SeenVariant(path); + } let variants = variants.map(|v| { Variant { index: v.index, name: v.name.to_owned(), fields: v.fields.map(|field| { let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_legacy_type_inner(ids.push(field.id), types); + let inner = Shape::from_legacy_type_inner(field.id, seen_variants, types); (name, inner) }).collect() } }).collect(); Shape::Variant(path, variants) }) - .visit_not_found(|types| { + .visit_not_found(|(seen_variants,_)| { // When we convert legacy to modern types, any types we don't find // are replaced with empty variants (since we can't have dangling types // in our new PortableRegistry). Do the same here so they compare equal. - Shape::from_legacy_type_inner(ids.push(LookupName::parse("special::Unknown").unwrap()), types) + Shape::from_legacy_type_inner(LookupName::parse("special::Unknown").unwrap(), seen_variants, types) }); types.resolve_type(id, visitor).unwrap() @@ -337,6 +306,7 @@ macro_rules! storage_eq { (p.into_owned(), n.into_owned(), info) }) .collect(); + let new: Vec<_> = new_md.storage_tuples() .map(|(p,n)| { let info = new_md.storage_info(&p, &n).unwrap().map_ids(|id| { From 5d6281266303dd968cf1922cc5ab97d5be6c5003 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Mon, 17 Nov 2025 11:54:30 +0000 Subject: [PATCH 08/14] fmt --- metadata/src/from/legacy/mod.rs | 4 +- .../from/legacy/portable_registry_builder.rs | 19 +- metadata/src/from/legacy/tests.rs | 395 ++++++++++-------- metadata/src/lib.rs | 12 +- 4 files changed, 244 insertions(+), 186 deletions(-) diff --git a/metadata/src/from/legacy/mod.rs b/metadata/src/from/legacy/mod.rs index cbfba0ced7..3569b67a78 100644 --- a/metadata/src/from/legacy/mod.rs +++ b/metadata/src/from/legacy/mod.rs @@ -10,10 +10,10 @@ use alloc::collections::BTreeMap; use alloc::format; use alloc::string::ToString; use alloc::vec::Vec; -use frame_decode::constants::{ConstantEntryInfo,ConstantTypeInfo}; +use frame_decode::constants::{ConstantEntryInfo, ConstantTypeInfo}; use frame_decode::extrinsics::ExtrinsicTypeInfo; use frame_decode::runtime_apis::RuntimeApiTypeInfo; -use frame_decode::storage::{StorageEntryInfo,StorageTypeInfo}; +use frame_decode::storage::{StorageEntryInfo, StorageTypeInfo}; use frame_metadata::v15; use portable_registry_builder::PortableRegistryBuilder; use scale_info_legacy::TypeRegistrySet; diff --git a/metadata/src/from/legacy/portable_registry_builder.rs b/metadata/src/from/legacy/portable_registry_builder.rs index 3334fceb0a..09d63129a7 100644 --- a/metadata/src/from/legacy/portable_registry_builder.rs +++ b/metadata/src/from/legacy/portable_registry_builder.rs @@ -115,8 +115,8 @@ impl<'info> PortableRegistryBuilder<'info> { let new_id = self.scale_info_types.types.len() as u32; // Add a placeholder type to "reserve" this ID. - self.scale_info_types.types.push(PortableType { - id: new_id, + self.scale_info_types.types.push(PortableType { + id: new_id, ty: scale_info::Type::new( scale_info::Path { segments: vec![] }, core::iter::empty(), @@ -141,15 +141,15 @@ impl<'info> PortableRegistryBuilder<'info> { Ok(Ok(ty)) => { self.scale_info_types.types[new_id as usize].ty = ty; Ok(new_id) - }, + } Ok(Err(e)) => { self.old_to_new.remove(&id); Err(e) - }, + } Err(e) => { self.old_to_new.remove(&id); Err(e.into()) - }, + } } } @@ -421,11 +421,8 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info fn unknown_type() -> scale_info::Type { scale_info::Type::new( - scale_info::Path { - segments: Vec::from_iter([ - "special".to_owned(), - "Unknown".to_owned() - ]) + scale_info::Path { + segments: Vec::from_iter(["special".to_owned(), "Unknown".to_owned()]), }, core::iter::empty(), scale_info::TypeDef::Variant(scale_info::TypeDefVariant { @@ -433,4 +430,4 @@ fn unknown_type() -> scale_info::Type { }), Default::default(), ) -} \ No newline at end of file +} diff --git a/metadata/src/from/legacy/tests.rs b/metadata/src/from/legacy/tests.rs index f1051204b7..facf039efd 100644 --- a/metadata/src/from/legacy/tests.rs +++ b/metadata/src/from/legacy/tests.rs @@ -1,12 +1,12 @@ use super::*; +use alloc::collections::BTreeSet; use codec::Decode; -use frame_metadata::RuntimeMetadata; -use scale_info_legacy::LookupName; use core::str::FromStr; -use scale_type_resolver::TypeResolver; use frame_decode::constants::ConstantTypeInfo; use frame_decode::runtime_apis::RuntimeApiEntryInfo; -use alloc::collections::BTreeSet; +use frame_metadata::RuntimeMetadata; +use scale_info_legacy::LookupName; +use scale_type_resolver::TypeResolver; /// Load some legacy kusama metadata from our artifacts. fn legacy_kusama_metadata(version: u8) -> (u64, RuntimeMetadata) { @@ -26,7 +26,7 @@ fn legacy_kusama_metadata(version: u8) -> (u64, RuntimeMetadata) { let mut path = std::path::PathBuf::from_str("../artifacts/kusama/").unwrap(); path.push(filename); - + let bytes = std::fs::read(path).expect("Could not read file"); let metadata = RuntimeMetadata::decode(&mut &*bytes).expect("Could not SCALE decode metadata"); @@ -47,7 +47,8 @@ fn metadata_pair(version: u8) -> (TypeRegistrySet<'static>, RuntimeMetadata, cra // Extend the types with builtins. let types_for_spec = { let mut types_for_spec = types.for_spec_version(spec_version).to_owned(); - let extended_types = frame_decode::helpers::type_registry_from_metadata_any(&metadata).unwrap(); + let extended_types = + frame_decode::helpers::type_registry_from_metadata_any(&metadata).unwrap(); types_for_spec.prepend(extended_types); types_for_spec }; @@ -58,8 +59,9 @@ fn metadata_pair(version: u8) -> (TypeRegistrySet<'static>, RuntimeMetadata, cra RuntimeMetadata::V11(m) => crate::Metadata::from_v11(m, &types_for_spec), RuntimeMetadata::V12(m) => crate::Metadata::from_v12(m, &types_for_spec), RuntimeMetadata::V13(m) => crate::Metadata::from_v13(m, &types_for_spec), - _ => panic!("Metadata version {} not expected", metadata.version()) - }.expect("Could not convert to subxt_metadata::Metadata"); + _ => panic!("Metadata version {} not expected", metadata.version()), + } + .expect("Could not convert to subxt_metadata::Metadata"); (types_for_spec, metadata, subxt_metadata) } @@ -68,7 +70,10 @@ fn metadata_pair(version: u8) -> (TypeRegistrySet<'static>, RuntimeMetadata, cra #[derive(PartialEq, Debug, Clone)] enum Shape { Array(Box, usize), - BitSequence(scale_type_resolver::BitsStoreFormat, scale_type_resolver::BitsOrderFormat), + BitSequence( + scale_type_resolver::BitsStoreFormat, + scale_type_resolver::BitsOrderFormat, + ), Compact(Box), Composite(Vec, Vec<(Option, Shape)>), Primitive(scale_type_resolver::Primitive), @@ -85,7 +90,7 @@ enum Shape { struct Variant { index: u8, name: String, - fields: Vec<(Option, Shape)> + fields: Vec<(Option, Shape)>, } impl Shape { @@ -95,136 +100,162 @@ impl Shape { Shape::from_modern_type_inner(id, &mut seen_variants, types) } - fn from_modern_type_inner(id: u32, seen_variants: &mut BTreeSet>, types: &scale_info::PortableRegistry) -> Shape { - let visitor = scale_type_resolver::visitor::new((seen_variants, types), |_, _| panic!("Unhandled")) - .visit_array(|(seen_variants, types), type_id, len| { - let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); - Shape::Array(Box::new(inner), len) - }) - .visit_bit_sequence(|_, store, order| { - Shape::BitSequence(store, order) - }) - .visit_compact(|(seen_variants, types), type_id| { - let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); - Shape::Compact(Box::new(inner)) - }) - .visit_composite(|(seen_variants, types), path, fields| { - let path = path.map(|p| p.to_owned()).collect(); - let inners = fields.map(|field| { - let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_modern_type_inner(field.id, seen_variants, types); - (name, inner) - }).collect(); - Shape::Composite(path, inners) - }) - .visit_primitive(|_types, prim| { - Shape::Primitive(prim) - }) - .visit_sequence(|(seen_variants, types), path, type_id| { - let path = path.map(|p| p.to_owned()).collect(); - let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); - Shape::Sequence(path, Box::new(inner)) - }) - .visit_tuple(|(seen_variants, types), fields| { - let inners = fields.map(|field| { - Shape::from_modern_type_inner(field, seen_variants, types) - }).collect(); - Shape::Tuple(inners) - }) - .visit_variant(|(seen_variants, types), path, variants| { - let path: Vec = path.map(|p| p.to_owned()).collect(); - // very important to avoid recursion and performance costs: - if !seen_variants.insert(path.clone()) { - return Shape::SeenVariant(path); - } - let variants = variants.map(|v| { - Variant { - index: v.index, - name: v.name.to_owned(), - fields: v.fields.map(|field| { + fn from_modern_type_inner( + id: u32, + seen_variants: &mut BTreeSet>, + types: &scale_info::PortableRegistry, + ) -> Shape { + let visitor = + scale_type_resolver::visitor::new((seen_variants, types), |_, _| panic!("Unhandled")) + .visit_array(|(seen_variants, types), type_id, len| { + let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); + Shape::Array(Box::new(inner), len) + }) + .visit_bit_sequence(|_, store, order| Shape::BitSequence(store, order)) + .visit_compact(|(seen_variants, types), type_id| { + let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); + Shape::Compact(Box::new(inner)) + }) + .visit_composite(|(seen_variants, types), path, fields| { + let path = path.map(|p| p.to_owned()).collect(); + let inners = fields + .map(|field| { let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_modern_type_inner(field.id, seen_variants, types); + let inner = + Shape::from_modern_type_inner(field.id, seen_variants, types); (name, inner) - }).collect() + }) + .collect(); + Shape::Composite(path, inners) + }) + .visit_primitive(|_types, prim| Shape::Primitive(prim)) + .visit_sequence(|(seen_variants, types), path, type_id| { + let path = path.map(|p| p.to_owned()).collect(); + let inner = Shape::from_modern_type_inner(type_id, seen_variants, types); + Shape::Sequence(path, Box::new(inner)) + }) + .visit_tuple(|(seen_variants, types), fields| { + let inners = fields + .map(|field| Shape::from_modern_type_inner(field, seen_variants, types)) + .collect(); + Shape::Tuple(inners) + }) + .visit_variant(|(seen_variants, types), path, variants| { + let path: Vec = path.map(|p| p.to_owned()).collect(); + // very important to avoid recursion and performance costs: + if !seen_variants.insert(path.clone()) { + return Shape::SeenVariant(path); } - }).collect(); - Shape::Variant(path, variants) - }) - .visit_not_found(|_types| { - panic!("PortableRegistry should not have a type which can't be found") - }); - + let variants = variants + .map(|v| Variant { + index: v.index, + name: v.name.to_owned(), + fields: v + .fields + .map(|field| { + let name = field.name.map(|n| n.to_owned()); + let inner = Shape::from_modern_type_inner( + field.id, + seen_variants, + types, + ); + (name, inner) + }) + .collect(), + }) + .collect(); + Shape::Variant(path, variants) + }) + .visit_not_found(|_types| { + panic!("PortableRegistry should not have a type which can't be found") + }); + types.resolve_type(id, visitor).unwrap() } - + /// convert some historic type definition into a [`Shape`]. fn from_legacy_type(name: &LookupName, types: &TypeRegistrySet<'_>) -> Shape { let mut seen_variants = BTreeSet::new(); Shape::from_legacy_type_inner(name.clone(), &mut seen_variants, types) } - fn from_legacy_type_inner(id: LookupName, seen_variants: &mut BTreeSet>, types: &TypeRegistrySet<'_>) -> Shape { - let visitor = scale_type_resolver::visitor::new((seen_variants, types), |_, _| panic!("Unhandled")) - .visit_array(|(seen_variants, types), type_id, len| { - let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); - Shape::Array(Box::new(inner), len) - }) - .visit_bit_sequence(|_types, store, order| { - Shape::BitSequence(store, order) - }) - .visit_compact(|(seen_variants, types), type_id| { - let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); - Shape::Compact(Box::new(inner)) - }) - .visit_composite(|(seen_variants, types), path, fields| { - let path = path.map(|p| p.to_owned()).collect(); - let inners = fields.map(|field| { - let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_legacy_type_inner(field.id, seen_variants, types); - (name, inner) - }).collect(); - Shape::Composite(path, inners) - }) - .visit_primitive(|_types, prim| { - Shape::Primitive(prim) - }) - .visit_sequence(|(seen_variants, types), path, type_id| { - let path = path.map(|p| p.to_owned()).collect(); - let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); - Shape::Sequence(path, Box::new(inner)) - }) - .visit_tuple(|(seen_variants, types), fields| { - let inners = fields.map(|field| { - Shape::from_legacy_type_inner(field, seen_variants, types) - }).collect(); - Shape::Tuple(inners) - }) - .visit_variant(|(seen_variants, types), path, variants| { - let path: Vec = path.map(|p| p.to_owned()).collect(); - // very important to avoid recursion and performance costs: - if !seen_variants.insert(path.clone()) { - return Shape::SeenVariant(path); - } - let variants = variants.map(|v| { - Variant { - index: v.index, - name: v.name.to_owned(), - fields: v.fields.map(|field| { + fn from_legacy_type_inner( + id: LookupName, + seen_variants: &mut BTreeSet>, + types: &TypeRegistrySet<'_>, + ) -> Shape { + let visitor = + scale_type_resolver::visitor::new((seen_variants, types), |_, _| panic!("Unhandled")) + .visit_array(|(seen_variants, types), type_id, len| { + let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); + Shape::Array(Box::new(inner), len) + }) + .visit_bit_sequence(|_types, store, order| Shape::BitSequence(store, order)) + .visit_compact(|(seen_variants, types), type_id| { + let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); + Shape::Compact(Box::new(inner)) + }) + .visit_composite(|(seen_variants, types), path, fields| { + let path = path.map(|p| p.to_owned()).collect(); + let inners = fields + .map(|field| { let name = field.name.map(|n| n.to_owned()); - let inner = Shape::from_legacy_type_inner(field.id, seen_variants, types); + let inner = + Shape::from_legacy_type_inner(field.id, seen_variants, types); (name, inner) - }).collect() + }) + .collect(); + Shape::Composite(path, inners) + }) + .visit_primitive(|_types, prim| Shape::Primitive(prim)) + .visit_sequence(|(seen_variants, types), path, type_id| { + let path = path.map(|p| p.to_owned()).collect(); + let inner = Shape::from_legacy_type_inner(type_id, seen_variants, types); + Shape::Sequence(path, Box::new(inner)) + }) + .visit_tuple(|(seen_variants, types), fields| { + let inners = fields + .map(|field| Shape::from_legacy_type_inner(field, seen_variants, types)) + .collect(); + Shape::Tuple(inners) + }) + .visit_variant(|(seen_variants, types), path, variants| { + let path: Vec = path.map(|p| p.to_owned()).collect(); + // very important to avoid recursion and performance costs: + if !seen_variants.insert(path.clone()) { + return Shape::SeenVariant(path); } - }).collect(); - Shape::Variant(path, variants) - }) - .visit_not_found(|(seen_variants,_)| { - // When we convert legacy to modern types, any types we don't find - // are replaced with empty variants (since we can't have dangling types - // in our new PortableRegistry). Do the same here so they compare equal. - Shape::from_legacy_type_inner(LookupName::parse("special::Unknown").unwrap(), seen_variants, types) - }); - + let variants = variants + .map(|v| Variant { + index: v.index, + name: v.name.to_owned(), + fields: v + .fields + .map(|field| { + let name = field.name.map(|n| n.to_owned()); + let inner = Shape::from_legacy_type_inner( + field.id, + seen_variants, + types, + ); + (name, inner) + }) + .collect(), + }) + .collect(); + Shape::Variant(path, variants) + }) + .visit_not_found(|(seen_variants, _)| { + // When we convert legacy to modern types, any types we don't find + // are replaced with empty variants (since we can't have dangling types + // in our new PortableRegistry). Do the same here so they compare equal. + Shape::from_legacy_type_inner( + LookupName::parse("special::Unknown").unwrap(), + seen_variants, + types, + ) + }); + types.resolve_type(id, visitor).unwrap() } } @@ -236,28 +267,34 @@ macro_rules! constants_eq { #[test] fn $name() { let (old_types, old_md, new_md) = metadata_pair($version); - let RuntimeMetadata::$version_path(old_md) = old_md else { panic!("Wrong version") }; + let RuntimeMetadata::$version_path(old_md) = old_md else { + panic!("Wrong version") + }; - let old: Vec<_> = old_md.constant_tuples() - .map(|(p,n)| { - old_md.constant_info(&p, &n).unwrap() - }) + let old: Vec<_> = old_md + .constant_tuples() + .map(|(p, n)| old_md.constant_info(&p, &n).unwrap()) .map(|c| { - (c.bytes.to_owned(), Shape::from_legacy_type(&c.type_id, &old_types)) + ( + c.bytes.to_owned(), + Shape::from_legacy_type(&c.type_id, &old_types), + ) }) .collect(); - let new: Vec<_> = new_md.constant_tuples() - .map(|(p,n)| { - new_md.constant_info(&p, &n).unwrap() - }) + let new: Vec<_> = new_md + .constant_tuples() + .map(|(p, n)| new_md.constant_info(&p, &n).unwrap()) .map(|c| { - (c.bytes.to_owned(), Shape::from_modern_type(c.type_id, new_md.types())) + ( + c.bytes.to_owned(), + Shape::from_modern_type(c.type_id, new_md.types()), + ) }) .collect(); assert_eq!(old, new); } - } + }; } constants_eq!(v9_constants_eq, 9, V9); @@ -271,22 +308,28 @@ constants_eq!(v13_constants_eq, 13, V13); fn runtime_apis() { for version in 9..=13 { let (old_types, _old_md, new_md) = metadata_pair(version); - - let old: Vec<_> = old_types.runtime_api_tuples() - .map(|(p,n)| { - old_types.runtime_api_info(&p, &n).unwrap().map_ids(|id| { - Ok::<_,()>(Shape::from_legacy_type(&id, &old_types)) - }).unwrap() + + let old: Vec<_> = old_types + .runtime_api_tuples() + .map(|(p, n)| { + old_types + .runtime_api_info(&p, &n) + .unwrap() + .map_ids(|id| Ok::<_, ()>(Shape::from_legacy_type(&id, &old_types))) + .unwrap() }) .collect(); - let new: Vec<_> = new_md.runtime_api_tuples() - .map(|(p,n)| { - new_md.runtime_api_info(&p, &n).unwrap().map_ids(|id| { - Ok::<_,()>(Shape::from_modern_type(id, new_md.types())) - }).unwrap() + let new: Vec<_> = new_md + .runtime_api_tuples() + .map(|(p, n)| { + new_md + .runtime_api_info(&p, &n) + .unwrap() + .map_ids(|id| Ok::<_, ()>(Shape::from_modern_type(id, new_md.types()))) + .unwrap() }) .collect(); - + assert_eq!(old, new); } } @@ -296,22 +339,30 @@ macro_rules! storage_eq { #[test] fn $name() { let (old_types, old_md, new_md) = metadata_pair($version); - let RuntimeMetadata::$version_path(old_md) = old_md else { panic!("Wrong version") }; + let RuntimeMetadata::$version_path(old_md) = old_md else { + panic!("Wrong version") + }; - let old: Vec<_> = old_md.storage_tuples() - .map(|(p,n)| { - let info = old_md.storage_info(&p, &n).unwrap().map_ids(|id| { - Ok::<_,()>(Shape::from_legacy_type(&id, &old_types)) - }).unwrap(); + let old: Vec<_> = old_md + .storage_tuples() + .map(|(p, n)| { + let info = old_md + .storage_info(&p, &n) + .unwrap() + .map_ids(|id| Ok::<_, ()>(Shape::from_legacy_type(&id, &old_types))) + .unwrap(); (p.into_owned(), n.into_owned(), info) }) .collect(); - let new: Vec<_> = new_md.storage_tuples() - .map(|(p,n)| { - let info = new_md.storage_info(&p, &n).unwrap().map_ids(|id| { - Ok::<_,()>(Shape::from_modern_type(id, new_md.types())) - }).unwrap(); + let new: Vec<_> = new_md + .storage_tuples() + .map(|(p, n)| { + let info = new_md + .storage_info(&p, &n) + .unwrap() + .map_ids(|id| Ok::<_, ()>(Shape::from_modern_type(id, new_md.types()))) + .unwrap(); (p.into_owned(), n.into_owned(), info) }) .collect(); @@ -322,10 +373,14 @@ macro_rules! storage_eq { for (old, new) in old.into_iter().zip(new.into_iter()) { assert_eq!((&old.0, &old.1), (&new.0, &new.1), "Storage entry mismatch"); - assert_eq!(old.2, new.2, "Storage entry {}.{} does not match!", old.0, old.1); + assert_eq!( + old.2, new.2, + "Storage entry {}.{} does not match!", + old.0, old.1 + ); } } - } + }; } storage_eq!(v9_storage_eq, 9, V9); @@ -338,7 +393,7 @@ storage_eq!(v13_storage_eq, 13, V13); fn builtin_call() { for version in 9..=13 { let (old_types, _old_md, new_md) = metadata_pair(version); - + let old = Shape::from_legacy_type(&LookupName::parse("builtin::Call").unwrap(), &old_types); let new = Shape::from_modern_type(new_md.outer_enums.call_enum_ty, new_md.types()); assert_eq!(old, new, "Call types do not match in metadata V{version}!"); @@ -349,8 +404,9 @@ fn builtin_call() { fn builtin_error() { for version in 9..=13 { let (old_types, _old_md, new_md) = metadata_pair(version); - - let old = Shape::from_legacy_type(&LookupName::parse("builtin::Error").unwrap(), &old_types); + + let old = + Shape::from_legacy_type(&LookupName::parse("builtin::Error").unwrap(), &old_types); let new = Shape::from_modern_type(new_md.outer_enums.error_enum_ty, new_md.types()); assert_eq!(old, new, "Error types do not match in metadata V{version}!"); } @@ -360,9 +416,10 @@ fn builtin_error() { fn builtin_event() { for version in 9..=13 { let (old_types, _old_md, new_md) = metadata_pair(version); - - let old = Shape::from_legacy_type(&LookupName::parse("builtin::Event").unwrap(), &old_types); + + let old = + Shape::from_legacy_type(&LookupName::parse("builtin::Event").unwrap(), &old_types); let new = Shape::from_modern_type(new_md.outer_enums.event_enum_ty, new_md.types()); assert_eq!(old, new, "Event types do not match in metadata V{version}!"); } -} \ No newline at end of file +} diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs index 5222670f7d..5151b52b1a 100644 --- a/metadata/src/lib.rs +++ b/metadata/src/lib.rs @@ -26,15 +26,19 @@ use alloc::borrow::Cow; use alloc::collections::BTreeMap; use alloc::string::{String, ToString}; use alloc::vec::Vec; -use frame_decode::constants::{ConstantInfo, ConstantInfoError, ConstantEntry}; +use frame_decode::constants::{ConstantEntry, ConstantInfo, ConstantInfoError}; use frame_decode::custom_values::{CustomValue, CustomValueInfo, CustomValueInfoError}; use frame_decode::extrinsics::{ ExtrinsicCallInfo, ExtrinsicExtensionInfo, ExtrinsicInfoArg, ExtrinsicInfoError, ExtrinsicSignatureInfo, }; -use frame_decode::runtime_apis::{RuntimeApiInfo, RuntimeApiInfoError, RuntimeApiInput, RuntimeApiEntry}; -use frame_decode::storage::{StorageInfo, StorageInfoError, StorageKeyInfo, StorageEntry}; -use frame_decode::view_functions::{ViewFunctionInfo, ViewFunctionInfoError, ViewFunctionInput, ViewFunctionEntry}; +use frame_decode::runtime_apis::{ + RuntimeApiEntry, RuntimeApiInfo, RuntimeApiInfoError, RuntimeApiInput, +}; +use frame_decode::storage::{StorageEntry, StorageInfo, StorageInfoError, StorageKeyInfo}; +use frame_decode::view_functions::{ + ViewFunctionEntry, ViewFunctionInfo, ViewFunctionInfoError, ViewFunctionInput, +}; use hashbrown::HashMap; use scale_info::{PortableRegistry, Variant, form::PortableForm}; From 33d86e291202b755ec104e9615fcfc6f62454e09 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Mon, 17 Nov 2025 11:55:40 +0000 Subject: [PATCH 09/14] fmt all --- historic/src/storage.rs | 2 +- historic/src/storage/list_storage_entries_any.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/historic/src/storage.rs b/historic/src/storage.rs index 9beb2d3c7d..2d818b9b4e 100644 --- a/historic/src/storage.rs +++ b/historic/src/storage.rs @@ -1,8 +1,8 @@ +mod list_storage_entries_any; mod storage_entry; mod storage_info; mod storage_key; mod storage_value; -mod list_storage_entries_any; use crate::client::{OfflineClientAtBlockT, OnlineClientAtBlockT}; use crate::config::Config; diff --git a/historic/src/storage/list_storage_entries_any.rs b/historic/src/storage/list_storage_entries_any.rs index 7bf4bb65eb..2f4f015e0d 100644 --- a/historic/src/storage/list_storage_entries_any.rs +++ b/historic/src/storage/list_storage_entries_any.rs @@ -32,4 +32,4 @@ pub fn list_storage_entries_any( RuntimeMetadata::V15(m) => Box::new(m.storage_entries()), RuntimeMetadata::V16(m) => Box::new(m.storage_entries()), } -} \ No newline at end of file +} From f7994fa018085a4d7f778c5ae80f58eef7d446dd Mon Sep 17 00:00:00 2001 From: James Wilson Date: Mon, 17 Nov 2025 12:02:37 +0000 Subject: [PATCH 10/14] clippy --- metadata/src/from/legacy/tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/metadata/src/from/legacy/tests.rs b/metadata/src/from/legacy/tests.rs index facf039efd..229aff57fd 100644 --- a/metadata/src/from/legacy/tests.rs +++ b/metadata/src/from/legacy/tests.rs @@ -10,7 +10,7 @@ use scale_type_resolver::TypeResolver; /// Load some legacy kusama metadata from our artifacts. fn legacy_kusama_metadata(version: u8) -> (u64, RuntimeMetadata) { - const VERSIONS: [(u8, u64, &'static str); 5] = [ + const VERSIONS: [(u8, u64, &str); 5] = [ (9, 1021, "metadata_v9_1021.scale"), (10, 1038, "metadata_v10_1038.scale"), (11, 1045, "metadata_v11_1045.scale"), From 9a4c7597a533037aa482a54e9cdcb2791fe952e4 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Mon, 17 Nov 2025 13:02:54 +0000 Subject: [PATCH 11/14] Fix a doc link --- historic/src/storage/list_storage_entries_any.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/historic/src/storage/list_storage_entries_any.rs b/historic/src/storage/list_storage_entries_any.rs index 2f4f015e0d..e97bafd748 100644 --- a/historic/src/storage/list_storage_entries_any.rs +++ b/historic/src/storage/list_storage_entries_any.rs @@ -5,7 +5,7 @@ pub use frame_decode::storage::StorageEntry; /// Returns an iterator listing the available storage entries in some metadata. /// -/// This basically calls [`StorageTypeInfo::storage_entries()`] for each metadata version, +/// This basically calls [`StorageEntryInfo::storage_entries()`] for each metadata version, /// returning an empty iterator where applicable (ie when passing legacy metadata and the /// `legacy` features flag is not enabled). pub fn list_storage_entries_any( From 374e0729b9eab7502b9267c2f23a77958089bcc8 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Tue, 18 Nov 2025 16:21:03 +0000 Subject: [PATCH 12/14] Test codegen and fixes to make it work --- Cargo.lock | 28 +++-- Cargo.toml | 7 +- metadata/Cargo.toml | 3 +- metadata/src/from/legacy/mod.rs | 22 +++- .../from/legacy/portable_registry_builder.rs | 116 +++++++++++++++++- metadata/src/from/legacy/tests.rs | 76 ++++++++++-- metadata/src/lib.rs | 12 +- 7 files changed, 229 insertions(+), 35 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 225dfaeffe..bcaef6c1a7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1954,8 +1954,6 @@ dependencies = [ [[package]] name = "frame-decode" version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73d29c7f2987ea24ab2eaea315aadb9ba598188823181cdf0476049b625a5844" dependencies = [ "frame-metadata 23.0.0", "parity-scale-codec", @@ -4464,9 +4462,9 @@ dependencies = [ [[package]] name = "scale-info-legacy" -version = "0.3.1" +version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "909e47c92f7955ef5e44ec77ae6d7d62797e9b6ad3a508ed96f7ef97ca197495" +checksum = "06423f0d7ea951547143aff4695c4c3e821e66c9b80729a3ff55fa93d23e93e6" dependencies = [ "hashbrown 0.15.3", "scale-type-resolver", @@ -4500,6 +4498,19 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "scale-typegen" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "642d2f13f3fc9a34ea2c1e36142984eba78cd2405a61632492f8b52993e98879" +dependencies = [ + "proc-macro2", + "quote", + "scale-info", + "syn 2.0.101", + "thiserror 2.0.12", +] + [[package]] name = "scale-typegen-description" version = "0.11.1" @@ -4513,7 +4524,7 @@ dependencies = [ "rand", "rand_chacha", "scale-info", - "scale-typegen", + "scale-typegen 0.11.1", "scale-value", "smallvec", ] @@ -5654,7 +5665,7 @@ dependencies = [ "pretty_assertions", "quote", "scale-info", - "scale-typegen", + "scale-typegen 0.12.0", "scale-typegen-description", "scale-value", "serde", @@ -5682,7 +5693,7 @@ dependencies = [ "proc-macro2", "quote", "scale-info", - "scale-typegen", + "scale-typegen 0.12.0", "subxt-metadata", "syn 2.0.101", "thiserror 2.0.12", @@ -5779,7 +5790,7 @@ dependencies = [ "quote", "sc-executor", "sc-executor-common", - "scale-typegen", + "scale-typegen 0.12.0", "sp-io", "sp-maybe-compressed-blob", "sp-state-machine", @@ -5803,6 +5814,7 @@ dependencies = [ "scale-info-legacy", "scale-type-resolver", "sp-crypto-hashing", + "subxt-codegen", "subxt-utils-stripmetadata", "thiserror 2.0.12", ] diff --git a/Cargo.toml b/Cargo.toml index 3f83e01afc..cb31ab5ebd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -103,8 +103,8 @@ scale-bits = { version = "0.7.0", default-features = false } scale-decode = { version = "0.16.0", default-features = false } scale-encode = { version = "0.10.0", default-features = false } scale-type-resolver = { version = "0.2.0" } -scale-info-legacy = { version = "0.3.1", default-features = false } -scale-typegen = "0.11.1" +scale-info-legacy = { version = "0.3.2", default-features = false } +scale-typegen = "0.12.0" scale-typegen-description = "0.11.0" serde = { version = "1.0.210", default-features = false, features = ["derive"] } serde_json = { version = "1.0.128", default-features = false } @@ -192,3 +192,6 @@ opt-level = 2 opt-level = 2 [profile.test.package.smoldot] opt-level = 2 + +[patch.crates-io] +frame-decode = { path = "../frame-decode" } \ No newline at end of file diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml index ad950f1e43..dd68a34b45 100644 --- a/metadata/Cargo.toml +++ b/metadata/Cargo.toml @@ -21,7 +21,7 @@ std = ["scale-info/std", "frame-metadata/std"] # std required by frame-metadata to decode Self { + Opts { + sanitize_paths: true, + ignore_not_found: true, + } + } +} + macro_rules! from_historic { ($vis:vis fn $fn_name:ident($metadata:path $(, builtin_index: $builtin_index:ident)? )) => { - $vis fn $fn_name(metadata: &$metadata, types: &TypeRegistrySet<'_>) -> Result { + $vis fn $fn_name(metadata: &$metadata, types: &TypeRegistrySet<'_>, opts: Opts) -> Result { // This will be used to construct our `PortableRegistry` from old-style types. let mut portable_registry_builder = PortableRegistryBuilder::new(&types); - portable_registry_builder.ignore_not_found(true); + portable_registry_builder.ignore_not_found(opts.ignore_not_found); + portable_registry_builder.sanitize_paths(opts.sanitize_paths); + // We use this type in a few places to denote that we don't know how to decode it. let unknown_type_id = portable_registry_builder.add_type_str("special::Unknown", None) diff --git a/metadata/src/from/legacy/portable_registry_builder.rs b/metadata/src/from/legacy/portable_registry_builder.rs index 09d63129a7..b681d69160 100644 --- a/metadata/src/from/legacy/portable_registry_builder.rs +++ b/metadata/src/from/legacy/portable_registry_builder.rs @@ -1,5 +1,5 @@ use alloc::borrow::ToOwned; -use alloc::collections::BTreeMap; +use alloc::collections::{BTreeMap, BTreeSet}; use alloc::string::ToString; use alloc::vec::Vec; use scale_info::PortableRegistry; @@ -28,6 +28,8 @@ pub struct PortableRegistryBuilder<'info> { scale_info_types: PortableRegistry, old_to_new: BTreeMap, ignore_not_found: bool, + sanitize_paths: bool, + seen_names_in_default_path: BTreeSet, } impl<'info> PortableRegistryBuilder<'info> { @@ -41,15 +43,26 @@ impl<'info> PortableRegistryBuilder<'info> { }, old_to_new: Default::default(), ignore_not_found: false, + sanitize_paths: false, + seen_names_in_default_path: Default::default(), } } /// If this is enabled, any type that isn't found will be replaced by a "special::Unknown" type /// instead of a "type not found" error being emitted. + /// + /// Default: false pub fn ignore_not_found(&mut self, ignore: bool) { self.ignore_not_found = ignore; } + /// Should type paths be sanitized to make them more amenable to things like codegen? + /// + /// Default: false + pub fn sanitize_paths(&mut self, sanitize: bool) { + self.sanitize_paths = sanitize; + } + /// Try adding a type, given its string name and optionally the pallet it's scoped to. pub fn try_add_type_str( &mut self, @@ -223,7 +236,7 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info ) -> Self::Value { let inner_id = self.builder.add_type(inner_type_id)?; let path = scale_info::Path { - segments: path.map(Into::into).collect(), + segments: prepare_path(path, self.builder), }; Ok(scale_info::Type::new( @@ -242,7 +255,7 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info Fields: FieldIter<'info, Self::TypeId>, { let path = scale_info::Path { - segments: path.map(Into::into).collect(), + segments: prepare_path(path, self.builder), }; let mut scale_info_fields = Vec::>::new(); @@ -308,7 +321,7 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info Var: VariantIter<'info, Fields>, { let path = scale_info::Path { - segments: path.map(Into::into).collect(), + segments: prepare_path(path, self.builder), }; let mut scale_info_variants = Vec::new(); @@ -419,6 +432,101 @@ impl<'a, 'info> ResolvedTypeVisitor<'info> for PortableRegistryVisitor<'a, 'info } } +fn prepare_path<'info, Path: PathIter<'info>>( + path: Path, + builder: &mut PortableRegistryBuilder<'_>, +) -> Vec { + // If no sanitizint, just return the path as-is. + if !builder.sanitize_paths { + return path.map(|p| p.to_owned()).collect(); + } + + /// Names of prelude types. For codegen to work, any type that _isn't_ one of these must + /// have a path that is sensible and can be converted to module names. + static PRELUDE_TYPE_NAMES: [&str; 24] = [ + "Vec", + "Option", + "Result", + "Cow", + "BTreeMap", + "BTreeSet", + "BinaryHeap", + "VecDeque", + "LinkedList", + "Range", + "RangeInclusive", + "NonZeroI8", + "NonZeroU8", + "NonZeroI16", + "NonZeroU16", + "NonZeroI32", + "NonZeroU32", + "NonZeroI64", + "NonZeroU64", + "NonZeroI128", + "NonZeroU128", + "NonZeroIsize", + "NonZeroUsize", + "Duration", + ]; + + let path: Vec<&str> = path.collect(); + + // No path should be empty; at least the type name should be present. + if path.is_empty() { + panic!( + "Empty path is not expected when converting legacy type; type name expected at least" + ); + } + + // The special::Unknown type can be returned as is; dupe paths allowed. + if path.len() == 2 && path[0] == "special" && path[1] == "Unknown" { + return vec!["special".to_owned(), "Unknown".to_owned()]; + } + + // If non-prelude type has no path, give it one. + if path.len() == 1 && !PRELUDE_TYPE_NAMES.contains(&path[0]) { + return vec![ + "other".to_owned(), + prepare_ident(path[0], &mut builder.seen_names_in_default_path), + ]; + } + + // Non-compliant paths are converted to our default path + let non_compliant_path = path[0..path.len() - 1].iter().any(|&p| { + p.is_empty() + || p.starts_with(|c: char| !c.is_ascii_alphabetic()) + || p.contains(|c: char| !c.is_ascii_alphanumeric() || c.is_ascii_uppercase()) + }); + if non_compliant_path { + let last = *path.last().unwrap(); + return vec![ + "other".to_owned(), + prepare_ident(last, &mut builder.seen_names_in_default_path), + ]; + } + + // If path happens by chance to be ["other", Foo] then ensure Foo isn't duped + if path.len() == 2 && path[0] == "other" { + return vec![ + "other".to_owned(), + prepare_ident(path[1], &mut builder.seen_names_in_default_path), + ]; + } + + path.iter().map(|&p| p.to_owned()).collect() +} + +fn prepare_ident(base_ident: &str, seen: &mut BTreeSet) -> String { + let mut n = 1; + let mut ident = base_ident.to_owned(); + while !seen.insert(ident.clone()) { + ident = format!("{base_ident}{n}"); + n += 1; + } + ident +} + fn unknown_type() -> scale_info::Type { scale_info::Type::new( scale_info::Path { diff --git a/metadata/src/from/legacy/tests.rs b/metadata/src/from/legacy/tests.rs index 229aff57fd..c4589d5ef2 100644 --- a/metadata/src/from/legacy/tests.rs +++ b/metadata/src/from/legacy/tests.rs @@ -39,8 +39,22 @@ fn kusama_types() -> scale_info_legacy::ChainTypeRegistry { frame_decode::legacy_types::polkadot::relay_chain() } +/// Sanitizing paths changes things between old and new, so disable this in tests by default +/// so that we can compare paths and check that by default things translate identically. +/// Tests assume that ignore_not_found is enabled, which converts not found types to +/// special::Unknown instead of returning an error. +fn test_opts() -> super::Opts { + super::Opts { + sanitize_paths: false, + ignore_not_found: true, + } +} + /// Return a pair of original metadata + converted subxt_metadata::Metadata -fn metadata_pair(version: u8) -> (TypeRegistrySet<'static>, RuntimeMetadata, crate::Metadata) { +fn metadata_pair( + version: u8, + opts: super::Opts, +) -> (TypeRegistrySet<'static>, RuntimeMetadata, crate::Metadata) { let (spec_version, metadata) = legacy_kusama_metadata(version); let types = kusama_types(); @@ -54,11 +68,11 @@ fn metadata_pair(version: u8) -> (TypeRegistrySet<'static>, RuntimeMetadata, cra }; let subxt_metadata = match &metadata { - RuntimeMetadata::V9(m) => crate::Metadata::from_v9(m, &types_for_spec), - RuntimeMetadata::V10(m) => crate::Metadata::from_v10(m, &types_for_spec), - RuntimeMetadata::V11(m) => crate::Metadata::from_v11(m, &types_for_spec), - RuntimeMetadata::V12(m) => crate::Metadata::from_v12(m, &types_for_spec), - RuntimeMetadata::V13(m) => crate::Metadata::from_v13(m, &types_for_spec), + RuntimeMetadata::V9(m) => super::from_v9(m, &types_for_spec, opts), + RuntimeMetadata::V10(m) => super::from_v10(m, &types_for_spec, opts), + RuntimeMetadata::V11(m) => super::from_v11(m, &types_for_spec, opts), + RuntimeMetadata::V12(m) => super::from_v12(m, &types_for_spec, opts), + RuntimeMetadata::V13(m) => super::from_v13(m, &types_for_spec, opts), _ => panic!("Metadata version {} not expected", metadata.version()), } .expect("Could not convert to subxt_metadata::Metadata"); @@ -266,7 +280,7 @@ macro_rules! constants_eq { ($name:ident, $version:literal, $version_path:ident) => { #[test] fn $name() { - let (old_types, old_md, new_md) = metadata_pair($version); + let (old_types, old_md, new_md) = metadata_pair($version, test_opts()); let RuntimeMetadata::$version_path(old_md) = old_md else { panic!("Wrong version") }; @@ -307,7 +321,7 @@ constants_eq!(v13_constants_eq, 13, V13); #[test] fn runtime_apis() { for version in 9..=13 { - let (old_types, _old_md, new_md) = metadata_pair(version); + let (old_types, _old_md, new_md) = metadata_pair(version, test_opts()); let old: Vec<_> = old_types .runtime_api_tuples() @@ -338,7 +352,7 @@ macro_rules! storage_eq { ($name:ident, $version:literal, $version_path:ident) => { #[test] fn $name() { - let (old_types, old_md, new_md) = metadata_pair($version); + let (old_types, old_md, new_md) = metadata_pair($version, test_opts()); let RuntimeMetadata::$version_path(old_md) = old_md else { panic!("Wrong version") }; @@ -392,7 +406,7 @@ storage_eq!(v13_storage_eq, 13, V13); #[test] fn builtin_call() { for version in 9..=13 { - let (old_types, _old_md, new_md) = metadata_pair(version); + let (old_types, _old_md, new_md) = metadata_pair(version, test_opts()); let old = Shape::from_legacy_type(&LookupName::parse("builtin::Call").unwrap(), &old_types); let new = Shape::from_modern_type(new_md.outer_enums.call_enum_ty, new_md.types()); @@ -403,7 +417,7 @@ fn builtin_call() { #[test] fn builtin_error() { for version in 9..=13 { - let (old_types, _old_md, new_md) = metadata_pair(version); + let (old_types, _old_md, new_md) = metadata_pair(version, test_opts()); let old = Shape::from_legacy_type(&LookupName::parse("builtin::Error").unwrap(), &old_types); @@ -415,7 +429,7 @@ fn builtin_error() { #[test] fn builtin_event() { for version in 9..=13 { - let (old_types, _old_md, new_md) = metadata_pair(version); + let (old_types, _old_md, new_md) = metadata_pair(version, test_opts()); let old = Shape::from_legacy_type(&LookupName::parse("builtin::Event").unwrap(), &old_types); @@ -423,3 +437,41 @@ fn builtin_event() { assert_eq!(old, new, "Event types do not match in metadata V{version}!"); } } + +#[test] +fn codegen_works() { + for version in 9..=13 { + // We need to do this against `subxt_codegen::Metadata` and so cannot re-use our + // test functions for it. This is because the compiler sees some difference between + // `subxct_codegen::Metadata` and `crate::Metadata` even though they should be identical. + let new_md = { + let (spec_version, metadata) = legacy_kusama_metadata(version); + let types = kusama_types(); + + let types_for_spec = { + let mut types_for_spec = types.for_spec_version(spec_version).to_owned(); + let extended_types = + frame_decode::helpers::type_registry_from_metadata_any(&metadata).unwrap(); + types_for_spec.prepend(extended_types); + types_for_spec + }; + + match &metadata { + RuntimeMetadata::V9(m) => subxt_codegen::Metadata::from_v9(m, &types_for_spec), + RuntimeMetadata::V10(m) => subxt_codegen::Metadata::from_v10(m, &types_for_spec), + RuntimeMetadata::V11(m) => subxt_codegen::Metadata::from_v11(m, &types_for_spec), + RuntimeMetadata::V12(m) => subxt_codegen::Metadata::from_v12(m, &types_for_spec), + RuntimeMetadata::V13(m) => subxt_codegen::Metadata::from_v13(m, &types_for_spec), + _ => panic!("Metadata version {} not expected", metadata.version()), + } + .expect("Could not convert to subxt_metadata::Metadata") + }; + + // We only test that generation succeeds without any errors, not necessarily that it's 100% useful: + let codegen = subxt_codegen::CodegenBuilder::new(); + let _ = codegen + .generate(new_md) + .map_err(|e| e.into_compile_error()) + .unwrap_or_else(|e| panic!("Codegen failed for metadata V{version}: {e}")); + } +} diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs index 5151b52b1a..53b1402e08 100644 --- a/metadata/src/lib.rs +++ b/metadata/src/lib.rs @@ -380,7 +380,7 @@ impl Metadata { metadata: &frame_metadata::v13::RuntimeMetadataV13, types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { - from::legacy::from_v13(metadata, types) + from::legacy::from_v13(metadata, types, from::legacy::Opts::compat()) } /// Convert V12 metadata into [`Metadata`], given the necessary extra type information. @@ -389,7 +389,7 @@ impl Metadata { metadata: &frame_metadata::v12::RuntimeMetadataV12, types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { - from::legacy::from_v12(metadata, types) + from::legacy::from_v12(metadata, types, from::legacy::Opts::compat()) } /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. @@ -398,7 +398,7 @@ impl Metadata { metadata: &frame_metadata::v11::RuntimeMetadataV11, types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { - from::legacy::from_v11(metadata, types) + from::legacy::from_v11(metadata, types, from::legacy::Opts::compat()) } /// Convert V13 metadata into [`Metadata`], given the necessary extra type information. @@ -407,7 +407,7 @@ impl Metadata { metadata: &frame_metadata::v10::RuntimeMetadataV10, types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { - from::legacy::from_v10(metadata, types) + from::legacy::from_v10(metadata, types, from::legacy::Opts::compat()) } /// Convert V9 metadata into [`Metadata`], given the necessary extra type information. @@ -416,7 +416,7 @@ impl Metadata { metadata: &frame_metadata::v9::RuntimeMetadataV9, types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { - from::legacy::from_v9(metadata, types) + from::legacy::from_v9(metadata, types, from::legacy::Opts::compat()) } /// Convert V8 metadata into [`Metadata`], given the necessary extra type information. @@ -425,7 +425,7 @@ impl Metadata { metadata: &frame_metadata::v8::RuntimeMetadataV8, types: &scale_info_legacy::TypeRegistrySet<'_>, ) -> Result { - from::legacy::from_v8(metadata, types) + from::legacy::from_v8(metadata, types, from::legacy::Opts::compat()) } /// Access the underlying type registry. From ad4cd917deb33bf42d420f5b1a52f70e888880c8 Mon Sep 17 00:00:00 2001 From: James Wilson Date: Tue, 18 Nov 2025 16:38:31 +0000 Subject: [PATCH 13/14] Remove local frame-decode patch --- Cargo.lock | 2 ++ Cargo.toml | 3 --- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bcaef6c1a7..91c0c41824 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1954,6 +1954,8 @@ dependencies = [ [[package]] name = "frame-decode" version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73d29c7f2987ea24ab2eaea315aadb9ba598188823181cdf0476049b625a5844" dependencies = [ "frame-metadata 23.0.0", "parity-scale-codec", diff --git a/Cargo.toml b/Cargo.toml index cb31ab5ebd..d6dc5f4961 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -192,6 +192,3 @@ opt-level = 2 opt-level = 2 [profile.test.package.smoldot] opt-level = 2 - -[patch.crates-io] -frame-decode = { path = "../frame-decode" } \ No newline at end of file From 70d3f7aa445757d780f30bdc1586cf681bb4e35e Mon Sep 17 00:00:00 2001 From: James Wilson Date: Wed, 19 Nov 2025 10:54:11 +0000 Subject: [PATCH 14/14] bump frame-decode to latest --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index d6dc5f4961..4acf44b7dc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -81,7 +81,7 @@ darling = "0.20.10" derive-where = "1.2.7" either = { version = "1.13.0", default-features = false } finito = { version = "0.1.0", default-features = false } -frame-decode = { version = "0.13.0", default-features = false } +frame-decode = { version = "0.14.0", default-features = false } frame-metadata = { version = "23.0.0", default-features = false } futures = { version = "0.3.31", default-features = false, features = ["std"] } getrandom = { version = "0.2", default-features = false }