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,83 @@
+// 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.
+
+//! This module provides the entry points to create dynamic
+//! transactions, storage and constant lookups.
+
+use crate::metadata::{DecodeWithMetadata, Metadata};
+use alloc::vec::Vec;
+use scale_decode::DecodeAsType;
+pub use scale_value::{At, Value};
+
+/// A [`scale_value::Value`] type endowed with contextual information
+/// regarding what type was used to decode each part of it. This implements
+/// [`crate::metadata::DecodeWithMetadata`], and is used as a return type
+/// for dynamic requests.
+pub type DecodedValue = scale_value::Value<u32>;
+
+// Submit dynamic transactions.
+pub use crate::tx::dynamic as tx;
+
+// Lookup constants dynamically.
+pub use crate::constants::dynamic as constant;
+
+// Lookup storage values dynamically.
+pub use crate::storage::dynamic as storage;
+
+// Execute runtime API function call dynamically.
+pub use crate::runtime_api::dynamic as runtime_api_call;
+
+/// This is the result of making a dynamic request to a node. From this,
+/// we can return the raw SCALE bytes that we were handed back, or we can
+/// complete the decoding of the bytes into a [`DecodedValue`] type.
+pub struct DecodedValueThunk {
+    type_id: u32,
+    metadata: Metadata,
+    scale_bytes: Vec<u8>,
+}
+
+impl DecodeWithMetadata for DecodedValueThunk {
+    fn decode_with_metadata(
+        bytes: &mut &[u8],
+        type_id: u32,
+        metadata: &Metadata,
+    ) -> Result<Self, scale_decode::Error> {
+        let mut v = Vec::with_capacity(bytes.len());
+        v.extend_from_slice(bytes);
+        *bytes = &[];
+        Ok(DecodedValueThunk {
+            type_id,
+            metadata: metadata.clone(),
+            scale_bytes: v,
+        })
+    }
+}
+
+impl DecodedValueThunk {
+    /// Return the SCALE encoded bytes handed back from the node.
+    pub fn into_encoded(self) -> Vec<u8> {
+        self.scale_bytes
+    }
+    /// Return the SCALE encoded bytes handed back from the node without taking ownership of them.
+    pub fn encoded(&self) -> &[u8] {
+        &self.scale_bytes
+    }
+    /// Decode the SCALE encoded storage entry into a dynamic [`DecodedValue`] type.
+    pub fn to_value(&self) -> Result<DecodedValue, scale_decode::Error> {
+        let val = scale_value::scale::decode_as_type(
+            &mut &*self.scale_bytes,
+            &self.type_id,
+            self.metadata.types(),
+        )?;
+        Ok(val)
+    }
+    /// decode the `DecodedValueThunk` into a concrete type.
+    pub fn as_type<T: DecodeAsType>(&self) -> Result<T, scale_decode::Error> {
+        T::decode_as_type(
+            &mut &self.scale_bytes[..],
+            &self.type_id,
+            self.metadata.types(),
+        )
+    }
+}