Static Decoding of Signed Extensions: Simple Approach

subxt/examples/blocks_subscribing.rs

@@ -40,7 +40,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             for evt in events.iter() {
                 let evt = evt?;
-
                 let pallet_name = evt.pallet_name();
                 let event_name = evt.variant_name();
                 let event_values = evt.field_values()?;

subxt/examples/setup_config_signed_extension.rs

@@ -45,6 +45,7 @@ pub struct CustomSignedExtension;
 // up in the chain metadata in order to know when and if to use it.
 impl<T: Config> signed_extensions::SignedExtension<T> for CustomSignedExtension {
     const NAME: &'static str = "CustomSignedExtension";
+    type Decoded = ();
 }
 
 // Gather together any params we need for our signed extension, here none.

subxt/src/blocks/extrinsic_types.rs

@@ -12,6 +12,8 @@ use crate::{
     Metadata,
 };
 
+use crate::config::signed_extensions::{ChargeAssetTxPayment, ChargeTransactionPayment};
+use crate::config::SignedExtension;
 use crate::dynamic::DecodedValue;
 use crate::utils::strip_compact_prefix;
 use codec::{Compact, Decode};
@@ -366,12 +368,13 @@ where
     }
 
     /// Returns `None` if the extrinsic is not signed.
-    pub fn signed_extensions(&self) -> Option<ExtrinsicSignedExtensions<'_>> {
+    pub fn signed_extensions(&self) -> Option<ExtrinsicSignedExtensions<'_, T>> {
         let signed = self.signed_details.as_ref()?;
         let extra_bytes = &self.bytes[signed.signature_end_idx..signed.extra_end_idx];
         Some(ExtrinsicSignedExtensions {
             bytes: extra_bytes,
             metadata: &self.metadata,
+            _marker: std::marker::PhantomData,
         })
     }
 
@@ -605,21 +608,22 @@ impl<T: Config> ExtrinsicEvents<T> {
 
 /// The signed extensions of an extrinsic.
 #[derive(Debug, Clone)]
-pub struct ExtrinsicSignedExtensions<'a> {
+pub struct ExtrinsicSignedExtensions<'a, T: Config> {
     bytes: &'a [u8],
     metadata: &'a Metadata,
+    _marker: std::marker::PhantomData<T>,
 }
 
-impl<'a> ExtrinsicSignedExtensions<'a> {
+impl<'a, T: Config> ExtrinsicSignedExtensions<'a, T> {
     /// Returns an iterator over each of the signed extension details of the extrinsic.
     /// If the decoding of any signed extension fails, an error item is yielded and the iterator stops.
-    pub fn iter(&self) -> impl Iterator<Item = Result<ExtrinsicSignedExtension<'a>, Error>> {
+    pub fn iter(&self) -> impl Iterator<Item = Result<ExtrinsicSignedExtension<T>, Error>> {
         let signed_extension_types = self.metadata.extrinsic().signed_extensions();
         let num_signed_extensions = signed_extension_types.len();
         let bytes = self.bytes;
-        let metadata = self.metadata;
         let mut index = 0;
         let mut byte_start_idx = 0;
+        let metadata = &self.metadata;
 
         std::iter::from_fn(move || {
             if index == num_signed_extensions {
@@ -649,25 +653,38 @@ impl<'a> ExtrinsicSignedExtensions<'a> {
                 ty_id,
                 identifier: extension.identifier(),
                 metadata,
+                _marker: std::marker::PhantomData,
             }))
         })
     }
 
+    fn find_by_name(&self, name: &str) -> Option<ExtrinsicSignedExtension<'_, T>> {
+        let signed_extension = self
+            .iter()
+            .find_map(|e| e.ok().filter(|e| e.name() == name))?;
+        Some(signed_extension)
+    }
+
+    /// Searches through all signed extensions to find a specific one.
+    /// If the Signed Extension is found, but decoding failed, `Some(Err(err))` is returned.
+    pub fn find<S: SignedExtension<T>>(&self) -> Option<Result<S::Decoded, Error>> {
+        let signed_extension = self.find_by_name(S::NAME)?;
+        signed_extension.as_signed_extra::<S>().transpose()
+    }
+
     /// The tip of an extrinsic, extracted from the ChargeTransactionPayment or ChargeAssetTxPayment
     /// signed extension, depending on which is present.
     ///
     /// Returns `None` if  `tip` was not found or decoding failed.
     pub fn tip(&self) -> Option<u128> {
-        let tip = self.iter().find_map(|e| {
-            e.ok().filter(|e| {
-                e.name() == "ChargeTransactionPayment" || e.name() == "ChargeAssetTxPayment"
-            })
-        })?;
-
-        // Note: ChargeAssetTxPayment might have addition information in it (asset_id).
-        // But both should start with a compact encoded u128, so this decoding is fine.
-        let tip = Compact::<u128>::decode(&mut tip.bytes()).ok()?.0;
-        Some(tip)
+        // Note: the overhead of iterating twice should be negligible.
+        self.find::<ChargeTransactionPayment>()
+            .map(|e| e.map(|e| e.tip()))
+            .or_else(|| {
+                self.find::<ChargeAssetTxPayment>()
+                    .map(|e| e.map(|e| e.tip()))
+            })?
+            .ok()
     }
 
     /// The nonce of the account that submitted the extrinsic, extracted from the CheckNonce signed extension.
@@ -684,14 +701,15 @@ impl<'a> ExtrinsicSignedExtensions<'a> {
 
 /// A single signed extension
 #[derive(Debug, Clone)]
-pub struct ExtrinsicSignedExtension<'a> {
+pub struct ExtrinsicSignedExtension<'a, T: Config> {
     bytes: &'a [u8],
     ty_id: u32,
     identifier: &'a str,
     metadata: &'a Metadata,
+    _marker: std::marker::PhantomData<T>,
 }
 
-impl<'a> ExtrinsicSignedExtension<'a> {
+impl<'a, T: Config> ExtrinsicSignedExtension<'a, T> {
     /// The bytes representing this signed extension.
     pub fn bytes(&self) -> &'a [u8] {
         self.bytes
@@ -709,11 +727,23 @@ impl<'a> ExtrinsicSignedExtension<'a> {
 
     /// Signed Extension as a [`scale_value::Value`]
     pub fn value(&self) -> Result<DecodedValue, Error> {
-        let value =
-            DecodedValue::decode_as_type(&mut &self.bytes[..], self.ty_id, self.metadata.types())?;
+        self.as_type()
+    }
 
+    /// Decodes the `extra` bytes of this Signed Extension into a static type.
+    fn as_type<E: DecodeAsType>(&self) -> Result<E, Error> {
+        let value = E::decode_as_type(&mut &self.bytes[..], self.ty_id, self.metadata.types())?;
         Ok(value)
     }
+
+    /// Decodes the `extra` bytes of this Signed Extension into its associated `Decoded` type.
+    /// Returns `Ok(None)` if the identitfier of this Signed Extension object does not line up with the `NAME` constant of the provided Signed Extension type.
+    pub fn as_signed_extra<S: SignedExtension<T>>(&self) -> Result<Option<S::Decoded>, Error> {
+        if self.identifier != S::NAME {
+            return Ok(None);
+        }
+        self.as_type::<S::Decoded>().map(Some)
+    }
 }
 
 #[cfg(test)]

subxt/src/config/signed_extensions.rs

@@ -12,6 +12,7 @@ use crate::utils::Era;
 use crate::{client::OfflineClientT, Config};
 use codec::{Compact, Encode};
 use core::fmt::Debug;
+use scale_decode::DecodeAsType;
 use std::collections::HashMap;
 
 /// A single [`SignedExtension`] has a unique name, but is otherwise the
@@ -21,6 +22,11 @@ pub trait SignedExtension<T: Config>: ExtrinsicParams<T> {
     /// The name of the signed extension. This is used to associate it
     /// with the signed extensions that the node is making use of.
     const NAME: &'static str;
+
+    /// The type representing the `extra` bytes of a signed extension.
+    /// Decoding from this type should be symmetrical to the respective
+    /// `ExtrinsicParamsEncoder::encode_extra_to()` implementation of this signed extension.
+    type Decoded: DecodeAsType;
 }
 
 /// The [`CheckSpecVersion`] signed extension.
@@ -48,6 +54,7 @@ impl ExtrinsicParamsEncoder for CheckSpecVersion {
 
 impl<T: Config> SignedExtension<T> for CheckSpecVersion {
     const NAME: &'static str = "CheckSpecVersion";
+    type Decoded = ();
 }
 
 /// The [`CheckNonce`] signed extension.
@@ -75,6 +82,7 @@ impl ExtrinsicParamsEncoder for CheckNonce {
 
 impl<T: Config> SignedExtension<T> for CheckNonce {
     const NAME: &'static str = "CheckNonce";
+    type Decoded = Compact<u64>;
 }
 
 /// The [`CheckTxVersion`] signed extension.
@@ -102,6 +110,7 @@ impl ExtrinsicParamsEncoder for CheckTxVersion {
 
 impl<T: Config> SignedExtension<T> for CheckTxVersion {
     const NAME: &'static str = "CheckTxVersion";
+    type Decoded = ();
 }
 
 /// The [`CheckGenesis`] signed extension.
@@ -134,6 +143,7 @@ impl<T: Config> ExtrinsicParamsEncoder for CheckGenesis<T> {
 
 impl<T: Config> SignedExtension<T> for CheckGenesis<T> {
     const NAME: &'static str = "CheckGenesis";
+    type Decoded = ();
 }
 
 /// The [`CheckMortality`] signed extension.
@@ -213,15 +223,28 @@ impl<T: Config> ExtrinsicParamsEncoder for CheckMortality<T> {
 
 impl<T: Config> SignedExtension<T> for CheckMortality<T> {
     const NAME: &'static str = "CheckMortality";
+    type Decoded = Era;
 }
 
 /// The [`ChargeAssetTxPayment`] signed extension.
-#[derive(Debug)]
+#[derive(Debug, DecodeAsType)]
 pub struct ChargeAssetTxPayment {
     tip: Compact<u128>,
     asset_id: Option<u32>,
 }
 
+impl ChargeAssetTxPayment {
+    /// Tip to the extrinsic author in the native chain token.
+    pub fn tip(&self) -> u128 {
+        self.tip.0
+    }
+
+    /// Tip to the extrinsic author using the asset ID given.
+    pub fn asset_id(&self) -> Option<u32> {
+        self.asset_id
+    }
+}
+
 /// Parameters to configure the [`ChargeAssetTxPayment`] signed extension.
 #[derive(Default)]
 pub struct ChargeAssetTxPaymentParams {
@@ -277,14 +300,22 @@ impl ExtrinsicParamsEncoder for ChargeAssetTxPayment {
 
 impl<T: Config> SignedExtension<T> for ChargeAssetTxPayment {
     const NAME: &'static str = "ChargeAssetTxPayment";
+    type Decoded = Self;
 }
 
 /// The [`ChargeTransactionPayment`] signed extension.
-#[derive(Debug)]
+#[derive(Debug, DecodeAsType)]
 pub struct ChargeTransactionPayment {
     tip: Compact<u128>,
 }
 
+impl ChargeTransactionPayment {
+    /// Tip to the extrinsic author in the native chain token.
+    pub fn tip(&self) -> u128 {
+        self.tip.0
+    }
+}
+
 /// Parameters to configure the [`ChargeTransactionPayment`] signed extension.
 #[derive(Default)]
 pub struct ChargeTransactionPaymentParams {
@@ -325,6 +356,7 @@ impl ExtrinsicParamsEncoder for ChargeTransactionPayment {
 
 impl<T: Config> SignedExtension<T> for ChargeTransactionPayment {
     const NAME: &'static str = "ChargeTransactionPayment";
+    type Decoded = Self;
 }
 
 /// This accepts a tuple of [`SignedExtension`]s, and will dynamically make use of whichever

subxt/src/utils/era.rs

@@ -2,9 +2,13 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
+use scale_decode::DecodeAsType;
+
 // Dev note: This and related bits taken from `sp_runtime::generic::Era`
 /// An era to describe the longevity of a transaction.
-#[derive(PartialEq, Default, Eq, Clone, Copy, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(
+    PartialEq, Default, Eq, Clone, Copy, Debug, serde::Serialize, serde::Deserialize, DecodeAsType,
+)]
 pub enum Era {
     /// The transaction is valid forever. The genesis hash must be present in the signed content.
     #[default]

testing/integration-tests/src/full_client/blocks/mod.rs

@@ -5,8 +5,10 @@
 use crate::{test_context, utils::node_runtime};
 use codec::{Compact, Encode};
 use futures::StreamExt;
-
+use subxt::config::signed_extensions::{ChargeAssetTxPayment, CheckMortality, CheckNonce};
 use subxt::config::DefaultExtrinsicParamsBuilder;
+use subxt::config::SubstrateConfig;
+use subxt::utils::Era;
 use subxt_metadata::Metadata;
 use subxt_signer::sr25519::dev;
 
@@ -272,38 +274,64 @@ async fn decode_signed_extensions_from_blocks() {
         }};
     }
 
-    let expected_signed_extensions = [
-        "CheckNonZeroSender",
-        "CheckSpecVersion",
-        "CheckTxVersion",
-        "CheckGenesis",
-        "CheckMortality",
-        "CheckNonce",
-        "CheckWeight",
-        "ChargeAssetTxPayment",
-    ];
-
     let transaction1 = submit_transfer_extrinsic_and_get_it_back!(1234);
     let extensions1 = transaction1.signed_extensions().unwrap();
     let nonce1 = extensions1.nonce().unwrap();
+    let nonce1_static = extensions1.find::<CheckNonce>().unwrap().unwrap().0;
     let tip1 = extensions1.tip().unwrap();
+    let tip1_static: u128 = extensions1
+        .find::<ChargeAssetTxPayment>()
+        .unwrap()
+        .unwrap()
+        .tip();
 
     let transaction2 = submit_transfer_extrinsic_and_get_it_back!(5678);
     let extensions2 = transaction2.signed_extensions().unwrap();
     let nonce2 = extensions2.nonce().unwrap();
+    let nonce2_static = extensions2.find::<CheckNonce>().unwrap().unwrap().0;
     let tip2 = extensions2.tip().unwrap();
+    let tip2_static: u128 = extensions2
+        .find::<ChargeAssetTxPayment>()
+        .unwrap()
+        .unwrap()
+        .tip();
 
     assert_eq!(nonce1, 0);
+    assert_eq!(nonce1, nonce1_static);
     assert_eq!(tip1, 1234);
+    assert_eq!(tip1, tip1_static);
     assert_eq!(nonce2, 1);
+    assert_eq!(nonce2, nonce2_static);
     assert_eq!(tip2, 5678);
+    assert_eq!(tip2, tip2_static);
+
+    let expected_signed_extensions = [
+        "CheckNonZeroSender",
+        "CheckSpecVersion",
+        "CheckTxVersion",
+        "CheckGenesis",
+        "CheckMortality",
+        "CheckNonce",
+        "CheckWeight",
+        "ChargeAssetTxPayment",
+    ];
 
     assert_eq!(extensions1.iter().count(), expected_signed_extensions.len());
     for (e, expected_name) in extensions1.iter().zip(expected_signed_extensions.iter()) {
         assert_eq!(e.unwrap().name(), *expected_name);
     }
+
     assert_eq!(extensions2.iter().count(), expected_signed_extensions.len());
     for (e, expected_name) in extensions2.iter().zip(expected_signed_extensions.iter()) {
         assert_eq!(e.unwrap().name(), *expected_name);
     }
+
+    // check that era decodes:
+    for extensions in [&extensions1, &extensions2] {
+        let era: Era = extensions
+            .find::<CheckMortality<SubstrateConfig>>()
+            .unwrap()
+            .unwrap();
+        assert_eq!(era, Era::Immortal)
+    }
 }