Merge v0.50.x to master (#2127)

* v0.50.0: Integrate frame-decode, redo storage APIs and break up Error. (#2100) * WIP integrating new frame-decode and working out new storage APIS * WIP: first pass adding new storage things to subxt-core * Second pass over Address type and start impl in Subxt * WIP new storage APIs * WIP New storage APIs roughly completed, lots of errors still * Remove PlainorMap enum; plain and map values now use same struct to simplify usage * Begin 'fixing' errors * WIP splitting errors and tidying payload/address traits * Get subxt-core compiling * Small fixes in subxt-core and remove metadata mod * subxt-core: cargo check --all-targets passes * Fix test * WIP starting to update subxt from subxt-core changes * WIP splitting up subxt errors into smaller variants * WIP errors: add DispatchError errors * Port new Storage APIs to subxt-core * cargo check -p subxt passes * Quick-fix errors in subxt-cli (explore subcommand) * fmt * Finish fixing codegen up and start fixing examples * get Subxt examples compiling and bytes_at for constants * Add some arcs to limit lifetimes in subxt/subxt-core storage APIs * A little Arcing to allow more method chaining in Storage APIs, aligning with Subxt * Update codegen test * cargo check --all-targets passing * cargo check --features 'unstable-light-client' passing * clippy * Remove unused dep in subxt * use published frame-decode * fix wasm-example * Add new tx extension to fix daily tests * Remove unused subxt_core::dynamic::DecodedValue type * Update book to match changes * Update docs to fix more broken bits * Add missing docs * fmt * allow larger result errs for now * Add missing alloc imports in subxt-core * Fix doc tests and fix bug getting constant info * Fix V14 -> Metadata transform for storage & constants * Fix parachain example * Fix FFI example * BlockLength decodes t ostruct, not u128 * use fetch/iter shorthands rather than entry in most storage tests * Fix some integration tests * Fix Runtime codegen tests * Expose the dynamic custom_value selecter and use in a UI test * Update codegen metadata * Tidy CLI storage query and support (str,str) as a storage address * Add (str,str) as valid constant address too * Show string tuple in constants example * Via the magic of traits, avoid needing any clones of queries/addresses and accept references to them * clippy * [v0.50] update scale-info-legacy and frame-decode to latest (#2119) * bump scale-info-legacy and frame-decode to latest * Remove something we don't need in this PR * Fully remove unused for now dep * [v0.50] Convert historic metadata to subxt::Metadata (#2120) * First pass converting historic metadatas to our subxt::Metadata type * use published frame-decode * fmt and rename legacy metadata macro * Enable legacy feature where needed in subxt_metadata so it compiles on its own * Use cargo hack more in CI and fix subxt-metadata features * Add tests for metadata conversion (need to optimise; some too expensive right now * Address performance and equality issues in metadata conversion testing * fmt * fmt all * clippy * Fix a doc link * Test codegen and fixes to make it work * Remove local frame-decode patch * bump frame-decode to latest * [v0.50.0] Allow visiting extrinsic fields in subxt_historic (#2124) * Allow visiting extrinsic fields * fmt * Don't use local scale-decode dep * Clippy and tidy * Extend 'subxt codegen' CLI to work with legacy metadatas * Simplify historic extrinsics example now that AccountId32s have paths/names * clippy * clippy * clippy.. * Allow visiting storage values, too, and clean up extrinsic visiting a little by narrowing lifetime * Try to fix flaky test * Add custom value decode to extrinsics example * Remove useless else branch ra thought I needed * Simplify examples * Prep to release v0.0.5 (#2126)
2026-06-13 10:31:04 +00:00 · 2025-11-22 10:44:03 +00:00
parent 586b814ecd
commit 8203679cbd
158 changed files with 13736 additions and 16451 deletions
@@ -7,28 +7,39 @@

 pub mod payload;

-use crate::error::{Error, MetadataError};
-use crate::metadata::{DecodeWithMetadata, Metadata};
+use crate::Metadata;
+use crate::error::ViewFunctionError;
+use alloc::string::ToString;
 use alloc::vec::Vec;
 use payload::Payload;
+use scale_decode::IntoVisitor;

 /// Run the validation logic against some View Function payload you'd like to use. Returns `Ok(())`
 /// if the payload is valid (or if it's not possible to check since the payload has no validation hash).
 /// Return an error if the payload was not valid or something went wrong trying to validate it (ie
 /// the View Function in question do not exist at all)
-pub fn validate<P: Payload>(payload: &P, metadata: &Metadata) -> Result<(), Error> {
-    let Some(static_hash) = payload.validation_hash() else {
+pub fn validate<P: Payload>(payload: P, metadata: &Metadata) -> Result<(), ViewFunctionError> {
+    let Some(hash) = payload.validation_hash() else {
        return Ok(());
    };

-    let view_function = metadata
-        .view_function_by_query_id(payload.query_id())
-        .ok_or_else(|| MetadataError::ViewFunctionNotFound(*payload.query_id()))?;
-    if static_hash != view_function.hash() {
-        return Err(MetadataError::IncompatibleCodegen.into());
-    }
+    let pallet_name = payload.pallet_name();
+    let function_name = payload.function_name();

-    Ok(())
+    let view_function = metadata
+        .pallet_by_name(pallet_name)
+        .ok_or_else(|| ViewFunctionError::PalletNotFound(pallet_name.to_string()))?
+        .view_function_by_name(function_name)
+        .ok_or_else(|| ViewFunctionError::ViewFunctionNotFound {
+            pallet_name: pallet_name.to_string(),
+            function_name: function_name.to_string(),
+        })?;
+
+    if hash != view_function.hash() {
+        Err(ViewFunctionError::IncompatibleCodegen)
+    } else {
+        Ok(())
+    }
 }

 /// The name of the Runtime API call which can execute
@@ -36,34 +47,37 @@ pub const CALL_NAME: &str = "RuntimeViewFunction_execute_view_function";

 /// Encode the bytes that will be passed to the "execute_view_function" Runtime API call,
 /// to execute the View Function represented by the given payload.
-pub fn call_args<P: Payload>(payload: &P, metadata: &Metadata) -> Result<Vec<u8>, Error> {
-    let mut call_args = Vec::with_capacity(32);
-    call_args.extend_from_slice(payload.query_id());
+pub fn call_args<P: Payload>(
+    payload: P,
+    metadata: &Metadata,
+) -> Result<Vec<u8>, ViewFunctionError> {
+    let inputs = frame_decode::view_functions::encode_view_function_inputs(
+        payload.pallet_name(),
+        payload.function_name(),
+        payload.args(),
+        metadata,
+        metadata.types(),
+    )
+    .map_err(ViewFunctionError::CouldNotEncodeInputs)?;

-    let mut call_arg_params = Vec::new();
-    payload.encode_args_to(metadata, &mut call_arg_params)?;
-
-    use codec::Encode;
-    call_arg_params.encode_to(&mut call_args);
-
-    Ok(call_args)
+    Ok(inputs)
 }

 /// Decode the value bytes at the location given by the provided View Function payload.
 pub fn decode_value<P: Payload>(
    bytes: &mut &[u8],
-    payload: &P,
+    payload: P,
    metadata: &Metadata,
-) -> Result<P::ReturnType, Error> {
-    let view_function = metadata
-        .view_function_by_query_id(payload.query_id())
-        .ok_or_else(|| MetadataError::ViewFunctionNotFound(*payload.query_id()))?;
-
-    let val = <P::ReturnType as DecodeWithMetadata>::decode_with_metadata(
-        &mut &bytes[..],
-        view_function.output_ty(),
+) -> Result<P::ReturnType, ViewFunctionError> {
+    let value = frame_decode::view_functions::decode_view_function_response(
+        payload.pallet_name(),
+        payload.function_name(),
+        bytes,
        metadata,
-    )?;
+        metadata.types(),
+        P::ReturnType::into_visitor(),
+    )
+    .map_err(ViewFunctionError::CouldNotDecodeResponse)?;

-    Ok(val)
+    Ok(value)
 }
@@ -5,17 +5,12 @@
 //! This module contains the trait and types used to represent
 //! View Function calls that can be made.

-use alloc::vec::Vec;
+use alloc::borrow::Cow;
+use alloc::string::String;
 use core::marker::PhantomData;
 use derive_where::derive_where;
-use scale_encode::EncodeAsFields;
-use scale_value::Composite;
-
-use crate::Error;
-use crate::dynamic::DecodedValueThunk;
-use crate::error::MetadataError;
-
-use crate::metadata::{DecodeWithMetadata, Metadata};
+use frame_decode::view_functions::IntoEncodableValues;
+use scale_decode::DecodeAsType;

 /// This represents a View Function payload that can call into the runtime of node.
 ///
@@ -33,24 +28,19 @@ use crate::metadata::{DecodeWithMetadata, Metadata};
 ///
 /// Each argument of the View Function must be scale-encoded.
 pub trait Payload {
+    /// Type of the arguments for this call.
+    type ArgsType: IntoEncodableValues;
    /// The return type of the function call.
-    // Note: `DecodeWithMetadata` is needed to decode the function call result
-    // with the `subxt::Metadata.
-    type ReturnType: DecodeWithMetadata;
+    type ReturnType: DecodeAsType;

-    /// The payload target.
-    fn query_id(&self) -> &[u8; 32];
+    /// The View Function pallet name.
+    fn pallet_name(&self) -> &str;

-    /// Scale encode the arguments data.
-    fn encode_args_to(&self, metadata: &Metadata, out: &mut Vec<u8>) -> Result<(), Error>;
+    /// The View Function function name.
+    fn function_name(&self) -> &str;

-    /// Encode arguments data and return the output. This is a convenience
-    /// wrapper around [`Payload::encode_args_to`].
-    fn encode_args(&self, metadata: &Metadata) -> Result<Vec<u8>, Error> {
-        let mut v = Vec::new();
-        self.encode_args_to(metadata, &mut v)?;
-        Ok(v)
-    }
+    /// The arguments.
+    fn args(&self) -> &Self::ArgsType;

    /// Returns the statically generated validation hash.
    fn validation_hash(&self) -> Option<[u8; 32]> {
@@ -58,45 +48,61 @@ pub trait Payload {
    }
 }

+// A reference to a payload is a valid payload.
+impl<P: Payload + ?Sized> Payload for &'_ P {
+    type ArgsType = P::ArgsType;
+    type ReturnType = P::ReturnType;
+
+    fn pallet_name(&self) -> &str {
+        P::pallet_name(*self)
+    }
+
+    fn function_name(&self) -> &str {
+        P::function_name(*self)
+    }
+
+    fn args(&self) -> &Self::ArgsType {
+        P::args(*self)
+    }
+
+    fn validation_hash(&self) -> Option<[u8; 32]> {
+        P::validation_hash(*self)
+    }
+}
+
 /// A View Function payload containing the generic argument data
-/// and interpreting the result of the call as `ReturnTy`.
+/// and interpreting the result of the call as `ReturnType`.
 ///
 /// This can be created from static values (ie those generated
 /// via the `subxt` macro) or dynamic values via [`dynamic`].
-#[derive_where(Clone, Debug, Eq, Ord, PartialEq, PartialOrd; ArgsData)]
-pub struct DefaultPayload<ArgsData, ReturnTy> {
-    query_id: [u8; 32],
-    args_data: ArgsData,
+#[derive_where(Clone, Debug, Eq, Ord, PartialEq, PartialOrd; ArgsType)]
+pub struct StaticPayload<ArgsType, ReturnType> {
+    pallet_name: Cow<'static, str>,
+    function_name: Cow<'static, str>,
+    args: ArgsType,
    validation_hash: Option<[u8; 32]>,
-    _marker: PhantomData<ReturnTy>,
+    _marker: PhantomData<ReturnType>,
 }

-/// A statically generated View Function payload.
-pub type StaticPayload<ArgsData, ReturnTy> = DefaultPayload<ArgsData, ReturnTy>;
 /// A dynamic View Function payload.
-pub type DynamicPayload = DefaultPayload<Composite<()>, DecodedValueThunk>;
+pub type DynamicPayload<ArgsType, ReturnType> = StaticPayload<ArgsType, ReturnType>;

-impl<ArgsData: EncodeAsFields, ReturnTy: DecodeWithMetadata> Payload
-    for DefaultPayload<ArgsData, ReturnTy>
+impl<ArgsType: IntoEncodableValues, ReturnType: DecodeAsType> Payload
+    for StaticPayload<ArgsType, ReturnType>
 {
-    type ReturnType = ReturnTy;
+    type ArgsType = ArgsType;
+    type ReturnType = ReturnType;

-    fn query_id(&self) -> &[u8; 32] {
-        &self.query_id
+    fn pallet_name(&self) -> &str {
+        &self.pallet_name
    }

-    fn encode_args_to(&self, metadata: &Metadata, out: &mut Vec<u8>) -> Result<(), Error> {
-        let view_function = metadata
-            .view_function_by_query_id(&self.query_id)
-            .ok_or(MetadataError::ViewFunctionNotFound(self.query_id))?;
-        let mut fields = view_function
-            .inputs()
-            .map(|input| scale_encode::Field::named(input.ty, &input.name));
+    fn function_name(&self) -> &str {
+        &self.function_name
+    }

-        self.args_data
-            .encode_as_fields_to(&mut fields, metadata.types(), out)?;
-
-        Ok(())
+    fn args(&self) -> &Self::ArgsType {
+        &self.args
    }

    fn validation_hash(&self) -> Option<[u8; 32]> {
@@ -104,30 +110,37 @@ impl<ArgsData: EncodeAsFields, ReturnTy: DecodeWithMetadata> Payload
    }
 }

-impl<ReturnTy, ArgsData> DefaultPayload<ArgsData, ReturnTy> {
-    /// Create a new [`DefaultPayload`] for a View Function call.
-    pub fn new(query_id: [u8; 32], args_data: ArgsData) -> Self {
-        DefaultPayload {
-            query_id,
-            args_data,
+impl<ReturnTy, ArgsType> StaticPayload<ArgsType, ReturnTy> {
+    /// Create a new [`StaticPayload`] for a View Function call.
+    pub fn new(
+        pallet_name: impl Into<String>,
+        function_name: impl Into<String>,
+        args: ArgsType,
+    ) -> Self {
+        StaticPayload {
+            pallet_name: pallet_name.into().into(),
+            function_name: function_name.into().into(),
+            args,
            validation_hash: None,
            _marker: PhantomData,
        }
    }

-    /// Create a new static [`DefaultPayload`] for a View Function call
+    /// Create a new static [`StaticPayload`] for a View Function call
    /// using static function name and scale-encoded argument data.
    ///
    /// This is only expected to be used from codegen.
    #[doc(hidden)]
    pub fn new_static(
-        query_id: [u8; 32],
-        args_data: ArgsData,
+        pallet_name: &'static str,
+        function_name: &'static str,
+        args: ArgsType,
        hash: [u8; 32],
-    ) -> DefaultPayload<ArgsData, ReturnTy> {
-        DefaultPayload {
-            query_id,
-            args_data,
+    ) -> StaticPayload<ArgsType, ReturnTy> {
+        StaticPayload {
+            pallet_name: Cow::Borrowed(pallet_name),
+            function_name: Cow::Borrowed(function_name),
+            args,
            validation_hash: Some(hash),
            _marker: core::marker::PhantomData,
        }
@@ -140,14 +153,13 @@ impl<ReturnTy, ArgsData> DefaultPayload<ArgsData, ReturnTy> {
            ..self
        }
    }
-
-    /// Returns the arguments data.
-    pub fn args_data(&self) -> &ArgsData {
-        &self.args_data
-    }
 }

 /// Create a new [`DynamicPayload`] to call a View Function.
-pub fn dynamic(query_id: [u8; 32], args_data: impl Into<Composite<()>>) -> DynamicPayload {
-    DefaultPayload::new(query_id, args_data.into())
+pub fn dynamic<ArgsType, ReturnType>(
+    pallet_name: impl Into<String>,
+    function_name: impl Into<String>,
+    args: ArgsType,
+) -> DynamicPayload<ArgsType, ReturnType> {
+    DynamicPayload::new(pallet_name, function_name, args)
 }