subxt-core crate (#1466)

* start migrating, broken * first iteration of updating * fmt and clippy * add Composite<u32> decoding via scale value patch * bump scale type gen versions * fix decoding with new scale decode * compiling with changed deps * core utils, condig, client, metadata * core crate compiling * signer crate no once lock * add core to no-std-tests, change imports * broken commit, start pulling everything together in subxt * port more things to subxt * events in core crate, extrinsics sadly much more difficult * almost all examples pass again * dynamic values fix in examples * fix no std issue and fmt * remove unused dependencies * fix lightclient impl * runtime version refactor * formatting and addressing nits * more comments addressed * update wasm example and no-std-signer tests * other nits and error impl on signer errors * fix feature flag * fix runtime version refactor * fix doc links * fix integration tests * fix feature flag gated client state * fix native feature in CI * fix lightclient utils * make imports more lean in subxt-core * integrate changes from subxt-core imports into subxt * other changes in subxt simplify imports more * fix and docs * doc false for cli * fix clippy * remove events block hash in tests * codegen no-std support in generated code * export alloc crate for no-std codegen * fix doc test * implement James comments * remove std traits, use core traits instead * address nits * remove unusued dep in no-std tests * fix Box import in no_std * sp-crypto-hashing instead of sp-core-hashing * bump scale-typegen, add no std codegen tests * fix some things * replace unmaintained derivative with derive_where to remove non-canonical warnings * fmt * remove unused dep * fix deps * update artifacts to fix type ID mismatches * bump to latest scale-typegen --------- Co-authored-by: James Wilson <james@jsdw.me>
2026-05-09 17:38:02 +00:00 · 2024-03-27 09:55:08 +01:00
parent 92c1ba7f66
commit a0cb14aa4f
106 changed files with 24329 additions and 26882 deletions
@@ -0,0 +1,76 @@
+use derive_where::derive_where;
+
+use crate::dynamic::DecodedValueThunk;
+use crate::metadata::DecodeWithMetadata;
+use crate::utils::Yes;
+
+/// This represents the address of a custom value in in the metadata.
+/// Anything, that implements the [CustomValueAddress] trait can be used, to fetch
+/// custom values from the metadata.
+/// The trait is implemented by [str] for dynamic loopup and [StaticAddress] for static queries.
+pub trait CustomValueAddress {
+    /// The type of the custom value.
+    type Target: DecodeWithMetadata;
+    /// Should be set to `Yes` for Dynamic values and static values that have a valid type.
+    /// Should be `()` for custom values, that have an invalid type id.
+    type IsDecodable;
+
+    /// the name (key) by which the custom value can be accessed in the metadata.
+    fn name(&self) -> &str;
+
+    /// An optional hash which, if present, can be checked against node metadata.
+    fn validation_hash(&self) -> Option<[u8; 32]> {
+        None
+    }
+}
+
+impl CustomValueAddress for str {
+    type Target = DecodedValueThunk;
+    type IsDecodable = Yes;
+
+    fn name(&self) -> &str {
+        self
+    }
+}
+
+/// A static address to a custom value.
+#[derive_where(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct StaticAddress<ReturnTy, IsDecodable> {
+    name: &'static str,
+    hash: Option<[u8; 32]>,
+    phantom: core::marker::PhantomData<(ReturnTy, IsDecodable)>,
+}
+
+impl<ReturnTy, IsDecodable> StaticAddress<ReturnTy, IsDecodable> {
+    #[doc(hidden)]
+    /// Creates a new StaticAddress.
+    pub fn new_static(name: &'static str, hash: [u8; 32]) -> StaticAddress<ReturnTy, IsDecodable> {
+        StaticAddress::<ReturnTy, IsDecodable> {
+            name,
+            hash: Some(hash),
+            phantom: core::marker::PhantomData,
+        }
+    }
+
+    /// Do not validate this custom value prior to accessing it.
+    pub fn unvalidated(self) -> Self {
+        Self {
+            name: self.name,
+            hash: None,
+            phantom: self.phantom,
+        }
+    }
+}
+
+impl<R: DecodeWithMetadata, Y> CustomValueAddress for StaticAddress<R, Y> {
+    type Target = R;
+    type IsDecodable = Y;
+
+    fn name(&self) -> &str {
+        self.name
+    }
+
+    fn validation_hash(&self) -> Option<[u8; 32]> {
+        self.hash
+    }
+}
@@ -0,0 +1,156 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! Types associated with accessing custom types
+
+mod custom_value_address;
+
+use crate::utils::Yes;
+pub use custom_value_address::{CustomValueAddress, StaticAddress};
+
+use crate::{
+    error::MetadataError,
+    metadata::{DecodeWithMetadata, MetadataExt},
+    Error, Metadata,
+};
+use alloc::vec::Vec;
+
+/// Run the validation logic against some custom value address you'd like to access. Returns `Ok(())`
+/// if the address is valid (or if it's not possible to check since the address has no validation hash).
+/// Returns an error if the address was not valid (wrong name, type or raw bytes)
+pub fn validate_custom_value<Address: CustomValueAddress + ?Sized>(
+    metadata: &Metadata,
+    address: &Address,
+) -> Result<(), Error> {
+    if let Some(actual_hash) = address.validation_hash() {
+        let custom = metadata.custom();
+        let custom_value = custom
+            .get(address.name())
+            .ok_or_else(|| MetadataError::CustomValueNameNotFound(address.name().into()))?;
+        let expected_hash = custom_value.hash();
+        if actual_hash != expected_hash {
+            return Err(MetadataError::IncompatibleCodegen.into());
+        }
+    }
+    if metadata.custom().get(address.name()).is_none() {
+        return Err(MetadataError::IncompatibleCodegen.into());
+    }
+    Ok(())
+}
+
+/// Access a custom value by the address it is registered under. This can be just a [str] to get back a dynamic value,
+/// or a static address from the generated static interface to get a value of a static type returned.
+pub fn get_custom_value<Address: CustomValueAddress<IsDecodable = Yes> + ?Sized>(
+    metadata: &Metadata,
+    address: &Address,
+) -> Result<Address::Target, Error> {
+    // 1. Validate custom value shape if hash given:
+    validate_custom_value(metadata, address)?;
+
+    // 2. Attempt to decode custom value:
+    let custom_value = metadata.custom_value_by_name_err(address.name())?;
+    let value = <Address::Target as DecodeWithMetadata>::decode_with_metadata(
+        &mut custom_value.bytes(),
+        custom_value.type_id(),
+        metadata,
+    )?;
+    Ok(value)
+}
+
+/// Access the bytes of a custom value by the address it is registered under.
+pub fn get_custom_value_bytes<Address: CustomValueAddress + ?Sized>(
+    metadata: &Metadata,
+    address: &Address,
+) -> Result<Vec<u8>, Error> {
+    // 1. Validate custom value shape if hash given:
+    validate_custom_value(metadata, address)?;
+
+    // 2. Return the underlying bytes:
+    let custom_value = metadata.custom_value_by_name_err(address.name())?;
+    Ok(custom_value.bytes().to_vec())
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::collections::BTreeMap;
+    use codec::Encode;
+    use scale_decode::DecodeAsType;
+    use scale_info::form::PortableForm;
+    use scale_info::TypeInfo;
+
+    use alloc::borrow::ToOwned;
+    use alloc::string::String;
+    use alloc::vec;
+
+    use crate::custom_values::get_custom_value;
+    use crate::Metadata;
+
+    #[derive(Debug, Clone, PartialEq, Eq, Encode, TypeInfo, DecodeAsType)]
+    pub struct Person {
+        age: u16,
+        name: String,
+    }
+
+    fn mock_metadata() -> Metadata {
+        let person_ty = scale_info::MetaType::new::<Person>();
+        let unit = scale_info::MetaType::new::<()>();
+        let mut types = scale_info::Registry::new();
+        let person_ty_id = types.register_type(&person_ty);
+        let unit_id = types.register_type(&unit);
+        let types: scale_info::PortableRegistry = types.into();
+
+        let person = Person {
+            age: 42,
+            name: "Neo".into(),
+        };
+
+        let person_value_metadata: frame_metadata::v15::CustomValueMetadata<PortableForm> =
+            frame_metadata::v15::CustomValueMetadata {
+                ty: person_ty_id,
+                value: person.encode(),
+            };
+
+        let frame_metadata = frame_metadata::v15::RuntimeMetadataV15 {
+            types,
+            pallets: vec![],
+            extrinsic: frame_metadata::v15::ExtrinsicMetadata {
+                version: 0,
+                address_ty: unit_id,
+                call_ty: unit_id,
+                signature_ty: unit_id,
+                extra_ty: unit_id,
+                signed_extensions: vec![],
+            },
+            ty: unit_id,
+            apis: vec![],
+            outer_enums: frame_metadata::v15::OuterEnums {
+                call_enum_ty: unit_id,
+                event_enum_ty: unit_id,
+                error_enum_ty: unit_id,
+            },
+            custom: frame_metadata::v15::CustomMetadata {
+                map: BTreeMap::from_iter([("Mr. Robot".to_owned(), person_value_metadata)]),
+            },
+        };
+
+        let metadata: subxt_metadata::Metadata = frame_metadata.try_into().unwrap();
+        Metadata::new(metadata)
+    }
+
+    #[test]
+    fn test_decoding() {
+        let metadata = mock_metadata();
+
+        assert!(get_custom_value(&metadata, "Invalid Address").is_err());
+        let person_decoded_value_thunk = get_custom_value(&metadata, "Mr. Robot").unwrap();
+        let person: Person = person_decoded_value_thunk.as_type().unwrap();
+        assert_eq!(
+            person,
+            Person {
+                age: 42,
+                name: "Neo".into()
+            }
+        )
+    }
+}