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-06-09 20:11:09 +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,100 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+use crate::dynamic::DecodedValueThunk;
+use crate::metadata::DecodeWithMetadata;
+use alloc::borrow::Cow;
+use alloc::string::String;
+use derive_where::derive_where;
+
+/// This represents a constant address. Anything implementing this trait
+/// can be used to fetch constants.
+pub trait ConstantAddress {
+    /// The target type of the value that lives at this address.
+    type Target: DecodeWithMetadata;
+
+    /// The name of the pallet that the constant lives under.
+    fn pallet_name(&self) -> &str;
+
+    /// The name of the constant in a given pallet.
+    fn constant_name(&self) -> &str;
+
+    /// An optional hash which, if present, will be checked against
+    /// the node metadata to confirm that the return type matches what
+    /// we are expecting.
+    fn validation_hash(&self) -> Option<[u8; 32]> {
+        None
+    }
+}
+
+/// This represents the address of a constant.
+#[derive_where(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct Address<ReturnTy> {
+    pallet_name: Cow<'static, str>,
+    constant_name: Cow<'static, str>,
+    constant_hash: Option<[u8; 32]>,
+    _marker: core::marker::PhantomData<ReturnTy>,
+}
+
+/// The type of address typically used to return dynamic constant values.
+pub type DynamicAddress = Address<DecodedValueThunk>;
+
+impl<ReturnTy> Address<ReturnTy> {
+    /// Create a new [`Address`] to use to look up a constant.
+    pub fn new(pallet_name: impl Into<String>, constant_name: impl Into<String>) -> Self {
+        Self {
+            pallet_name: Cow::Owned(pallet_name.into()),
+            constant_name: Cow::Owned(constant_name.into()),
+            constant_hash: None,
+            _marker: core::marker::PhantomData,
+        }
+    }
+
+    /// Create a new [`Address`] that will be validated
+    /// against node metadata using the hash given.
+    #[doc(hidden)]
+    pub fn new_static(
+        pallet_name: &'static str,
+        constant_name: &'static str,
+        hash: [u8; 32],
+    ) -> Self {
+        Self {
+            pallet_name: Cow::Borrowed(pallet_name),
+            constant_name: Cow::Borrowed(constant_name),
+            constant_hash: Some(hash),
+            _marker: core::marker::PhantomData,
+        }
+    }
+
+    /// Do not validate this constant prior to accessing it.
+    pub fn unvalidated(self) -> Self {
+        Self {
+            pallet_name: self.pallet_name,
+            constant_name: self.constant_name,
+            constant_hash: None,
+            _marker: self._marker,
+        }
+    }
+}
+
+impl<ReturnTy: DecodeWithMetadata> ConstantAddress for Address<ReturnTy> {
+    type Target = ReturnTy;
+
+    fn pallet_name(&self) -> &str {
+        &self.pallet_name
+    }
+
+    fn constant_name(&self) -> &str {
+        &self.constant_name
+    }
+
+    fn validation_hash(&self) -> Option<[u8; 32]> {
+        self.constant_hash
+    }
+}
+
+/// Construct a new dynamic constant lookup.
+pub fn dynamic(pallet_name: impl Into<String>, constant_name: impl Into<String>) -> DynamicAddress {
+    DynamicAddress::new(pallet_name, constant_name)
+}
@@ -0,0 +1,59 @@
+// 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 constants.
+
+mod constant_address;
+
+pub use constant_address::{dynamic, Address, ConstantAddress, DynamicAddress};
+
+use alloc::borrow::ToOwned;
+
+use crate::{
+    error::MetadataError,
+    metadata::{DecodeWithMetadata, MetadataExt},
+    Error, Metadata,
+};
+
+/// Run validation logic against some constant 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).
+/// Return an error if the address was not valid or something went wrong trying to validate it (ie
+/// the pallet or constant in question do not exist at all).
+pub fn validate_constant<Address: ConstantAddress>(
+    metadata: &subxt_metadata::Metadata,
+    address: &Address,
+) -> Result<(), Error> {
+    if let Some(actual_hash) = address.validation_hash() {
+        let expected_hash = metadata
+            .pallet_by_name_err(address.pallet_name())?
+            .constant_hash(address.constant_name())
+            .ok_or_else(|| {
+                MetadataError::ConstantNameNotFound(address.constant_name().to_owned())
+            })?;
+        if actual_hash != expected_hash {
+            return Err(MetadataError::IncompatibleCodegen.into());
+        }
+    }
+    Ok(())
+}
+
+pub fn get_constant<Address: ConstantAddress>(
+    metadata: &Metadata,
+    address: &Address,
+) -> Result<Address::Target, Error> {
+    // 1. Validate constant shape if hash given:
+    validate_constant(metadata, address)?;
+
+    // 2. Attempt to decode the constant into the type given:
+    let constant = metadata
+        .pallet_by_name_err(address.pallet_name())?
+        .constant_by_name(address.constant_name())
+        .ok_or_else(|| MetadataError::ConstantNameNotFound(address.constant_name().to_owned()))?;
+    let value = <Address::Target as DecodeWithMetadata>::decode_with_metadata(
+        &mut constant.value(),
+        constant.ty(),
+        metadata,
+    )?;
+    Ok(value)
+}