core integration into subxt, except for examples

subxt/src/constants/constant_address.rs

@@ -1,100 +0,0 @@
-// 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 derivative::Derivative;
-use std::borrow::Cow;
-use subxt_core::metadata::DecodeWithMetadata;
-
-/// 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(Derivative)]
-#[derivative(Clone(bound = ""), Debug(bound = ""))]
-pub struct Address<ReturnTy> {
-    pallet_name: Cow<'static, str>,
-    constant_name: Cow<'static, str>,
-    constant_hash: Option<[u8; 32]>,
-    _marker: std::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: std::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: std::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)
-}

subxt/src/constants/constants_client.rs

@@ -36,19 +36,7 @@ impl<T: Config, Client: OfflineClientT<T>> ConstantsClient<T, Client> {
     /// 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<Address: ConstantAddress>(&self, address: &Address) -> Result<(), Error> {
-        if let Some(actual_hash) = address.validation_hash() {
-            let expected_hash = self
-                .client
-                .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());
-            }
-        }
+        subxt_core::constants::validate_constant(&self.client.metadata(), address)?;
         Ok(())
     }
 
@@ -59,23 +47,7 @@ impl<T: Config, Client: OfflineClientT<T>> ConstantsClient<T, Client> {
         &self,
         address: &Address,
     ) -> Result<Address::Target, Error> {
-        let metadata = self.client.metadata();
-
-        // 1. Validate constant shape if hash given:
-        self.validate(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,
-        )?;
+        let value = subxt_core::constants::get_constant(&self.client.metadata(), address)?;
         Ok(value)
     }
 }

subxt/src/constants/mod.rs

@@ -4,8 +4,7 @@
 
 //! Types associated with accessing constants.
 
-mod constant_address;
 mod constants_client;
 
-pub use constant_address::{dynamic, Address, ConstantAddress, DynamicAddress};
 pub use constants_client::ConstantsClient;
+pub use subxt_core::constants::{dynamic, Address, ConstantAddress, DynamicAddress};