Make subxt-core ready for publishing (#1508)

* Move Extrinsic decoding things to subxt_core and various tidy-ups * A couple more fixes and fmt * first pass moving tx logic to subxt_core * cargo fmt * fix wasm example * clippy * more clippy * WIP Adding examples and such * Move storage functionality more fully to subxt_core and nice examples for storage and txs * Add example for events * consistify how addresses/payloads are exposed in subxt-core and add runtime API fns * Add runtime API core example * fmt * remove scale-info patch * Add a little to the top level docs * swap args around * clippy * cargo fmt and fix wasm-example * doc fixes * no-std-ise new subxt-core additions * alloc, not core * more no-std fixes * A couple more fixes * Add back extrinsic decode test
2026-04-30 17:47:56 +00:00 · 2024-04-15 15:20:11 +01:00
parent b527c857ea
commit 1e111ea9db
89 changed files with 4459 additions and 3500 deletions
@@ -0,0 +1,82 @@
+// Copyright 2019-2024 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! Construct addresses to access custom values with.
+
+use crate::dynamic::DecodedValueThunk;
+use crate::metadata::DecodeWithMetadata;
+use derive_where::derive_where;
+
+/// Use this with [`AddressT::IsDecodable`].
+pub use crate::utils::Yes;
+
+/// This represents the address of a custom value in in the metadata.
+/// Anything that implements it can be used to fetch custom values from the metadata.
+/// The trait is implemented by [`str`] for dynamic lookup and [`StaticAddress`] for static queries.
+pub trait AddressT {
+    /// 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 AddressT 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> AddressT 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
+    }
+}