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>

core/src/config/default_extrinsic_params.rs

@@ -0,0 +1,156 @@
+// 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 super::signed_extensions::CheckNonceParams;
+use super::{signed_extensions, ExtrinsicParams};
+use super::{Config, Header};
+
+/// The default [`super::ExtrinsicParams`] implementation understands common signed extensions
+/// and how to apply them to a given chain.
+pub type DefaultExtrinsicParams<T> = signed_extensions::AnyOf<
+    T,
+    (
+        signed_extensions::CheckSpecVersion,
+        signed_extensions::CheckTxVersion,
+        signed_extensions::CheckNonce,
+        signed_extensions::CheckGenesis<T>,
+        signed_extensions::CheckMortality<T>,
+        signed_extensions::ChargeAssetTxPayment<T>,
+        signed_extensions::ChargeTransactionPayment,
+    ),
+>;
+
+/// A builder that outputs the set of [`super::ExtrinsicParams::Params`] required for
+/// [`DefaultExtrinsicParams`]. This may expose methods that aren't applicable to the current
+/// chain; such values will simply be ignored if so.
+pub struct DefaultExtrinsicParamsBuilder<T: Config> {
+    /// `None` means the tx will be immortal.
+    mortality: Option<Mortality<T::Hash>>,
+    /// `None` means the nonce will be automatically set.
+    nonce: Option<u64>,
+    /// `None` means we'll use the native token.
+    tip_of_asset_id: Option<T::AssetId>,
+    tip: u128,
+    tip_of: u128,
+}
+
+struct Mortality<Hash> {
+    /// Block hash that mortality starts from
+    checkpoint_hash: Hash,
+    /// Block number that mortality starts from (must
+    // point to the same block as the hash above)
+    checkpoint_number: u64,
+    /// How many blocks the tx is mortal for
+    period: u64,
+}
+
+impl<T: Config> Default for DefaultExtrinsicParamsBuilder<T> {
+    fn default() -> Self {
+        Self {
+            mortality: None,
+            tip: 0,
+            tip_of: 0,
+            tip_of_asset_id: None,
+            nonce: None,
+        }
+    }
+}
+
+impl<T: Config> DefaultExtrinsicParamsBuilder<T> {
+    /// Configure new extrinsic params. We default to providing no tip
+    /// and using an immortal transaction unless otherwise configured
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Make the transaction mortal, given a block header that it should be mortal from,
+    /// and the number of blocks (roughly; it'll be rounded to a power of two) that it will
+    /// be mortal for.
+    pub fn mortal(mut self, from_block: &T::Header, for_n_blocks: u64) -> Self {
+        self.mortality = Some(Mortality {
+            checkpoint_hash: from_block.hash(),
+            checkpoint_number: from_block.number().into(),
+            period: for_n_blocks,
+        });
+        self
+    }
+
+    /// Provide a specific nonce for the submitter of the extrinsic
+    pub fn nonce(mut self, nonce: u64) -> Self {
+        self.nonce = Some(nonce);
+        self
+    }
+
+    /// Make the transaction mortal, given a block number and block hash (which must both point to
+    /// the same block) that it should be mortal from, and the number of blocks (roughly; it'll be
+    /// rounded to a power of two) that it will be mortal for.
+    ///
+    /// Prefer to use [`DefaultExtrinsicParamsBuilder::mortal()`], which ensures that the block hash
+    /// and number align.
+    pub fn mortal_unchecked(
+        mut self,
+        from_block_number: u64,
+        from_block_hash: T::Hash,
+        for_n_blocks: u64,
+    ) -> Self {
+        self.mortality = Some(Mortality {
+            checkpoint_hash: from_block_hash,
+            checkpoint_number: from_block_number,
+            period: for_n_blocks,
+        });
+        self
+    }
+
+    /// Provide a tip to the block author in the chain's native token.
+    pub fn tip(mut self, tip: u128) -> Self {
+        self.tip = tip;
+        self.tip_of = tip;
+        self.tip_of_asset_id = None;
+        self
+    }
+
+    /// Provide a tip to the block author using the token denominated by the `asset_id` provided. This
+    /// is not applicable on chains which don't use the `ChargeAssetTxPayment` signed extension; in this
+    /// case, no tip will be given.
+    pub fn tip_of(mut self, tip: u128, asset_id: T::AssetId) -> Self {
+        self.tip = 0;
+        self.tip_of = tip;
+        self.tip_of_asset_id = Some(asset_id);
+        self
+    }
+
+    /// Build the extrinsic parameters.
+    pub fn build(self) -> <DefaultExtrinsicParams<T> as ExtrinsicParams<T>>::Params {
+        let check_mortality_params = if let Some(mortality) = self.mortality {
+            signed_extensions::CheckMortalityParams::mortal(
+                mortality.period,
+                mortality.checkpoint_number,
+                mortality.checkpoint_hash,
+            )
+        } else {
+            signed_extensions::CheckMortalityParams::immortal()
+        };
+
+        let charge_asset_tx_params = if let Some(asset_id) = self.tip_of_asset_id {
+            signed_extensions::ChargeAssetTxPaymentParams::tip_of(self.tip, asset_id)
+        } else {
+            signed_extensions::ChargeAssetTxPaymentParams::tip(self.tip)
+        };
+
+        let charge_transaction_params =
+            signed_extensions::ChargeTransactionPaymentParams::tip(self.tip);
+
+        let check_nonce_params = CheckNonceParams(self.nonce);
+
+        (
+            (),
+            (),
+            check_nonce_params,
+            (),
+            check_mortality_params,
+            charge_asset_tx_params,
+            charge_transaction_params,
+        )
+    }
+}

core/src/config/extrinsic_params.rs

@@ -0,0 +1,42 @@
+// 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 contains a trait which controls the parameters that must
+//! be provided in order to successfully construct an extrinsic.
+//! [`crate::config::DefaultExtrinsicParams`] provides a general-purpose
+//! implementation of this that will work in many cases.
+
+use super::refine_params::RefineParams;
+use crate::{client::ClientState, error::ExtrinsicParamsError, Config};
+use alloc::vec::Vec;
+
+/// This trait allows you to configure the "signed extra" and
+/// "additional" parameters that are a part of the transaction payload
+/// or the signer payload respectively.
+pub trait ExtrinsicParams<T: Config>: ExtrinsicParamsEncoder + Sized + 'static {
+    /// These parameters can be provided to the constructor along with
+    /// some default parameters that `subxt` understands, in order to
+    /// help construct your [`ExtrinsicParams`] object.
+    type Params: RefineParams<T>;
+
+    /// Construct a new instance of our [`ExtrinsicParams`].
+    fn new(client: &ClientState<T>, params: Self::Params) -> Result<Self, ExtrinsicParamsError>;
+}
+
+/// This trait is expected to be implemented for any [`ExtrinsicParams`], and
+/// defines how to encode the "additional" and "extra" params. Both functions
+/// are optional and will encode nothing by default.
+pub trait ExtrinsicParamsEncoder: 'static {
+    /// This is expected to SCALE encode the "signed extra" parameters
+    /// to some buffer that has been provided. These are the parameters
+    /// which are sent along with the transaction, as well as taken into
+    /// account when signing the transaction.
+    fn encode_extra_to(&self, _v: &mut Vec<u8>) {}
+
+    /// This is expected to SCALE encode the "additional" parameters
+    /// to some buffer that has been provided. These parameters are _not_
+    /// sent along with the transaction, but are taken into account when
+    /// signing it, meaning the client and node must agree on their values.
+    fn encode_additional_to(&self, _v: &mut Vec<u8>) {}
+}

core/src/config/mod.rs

@@ -0,0 +1,156 @@
+// 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.
+
+//! This module provides a [`Config`] type, which is used to define various
+//! types that are important in order to speak to a particular chain.
+//! [`SubstrateConfig`] provides a default set of these types suitable for the
+//! default Substrate node implementation, and [`PolkadotConfig`] for a
+//! Polkadot node.
+
+mod default_extrinsic_params;
+mod extrinsic_params;
+mod refine_params;
+
+pub mod polkadot;
+pub mod signed_extensions;
+pub mod substrate;
+
+use crate::macros::cfg_substrate_compat;
+use codec::{Decode, Encode};
+use core::fmt::Debug;
+use scale_decode::DecodeAsType;
+use scale_encode::EncodeAsType;
+use serde::{de::DeserializeOwned, Serialize};
+
+pub use default_extrinsic_params::{DefaultExtrinsicParams, DefaultExtrinsicParamsBuilder};
+pub use extrinsic_params::{ExtrinsicParams, ExtrinsicParamsEncoder};
+pub use polkadot::{PolkadotConfig, PolkadotExtrinsicParams, PolkadotExtrinsicParamsBuilder};
+pub use refine_params::{RefineParams, RefineParamsData};
+pub use signed_extensions::SignedExtension;
+pub use substrate::{SubstrateConfig, SubstrateExtrinsicParams, SubstrateExtrinsicParamsBuilder};
+
+/// Runtime types.
+// Note: the `Send + Sync + 'static` bound isn't strictly required, but currently deriving
+// TypeInfo automatically applies a 'static bound to all generic types (including this one),
+// And we want the compiler to infer `Send` and `Sync` OK for things which have `T: Config`
+// rather than having to `unsafe impl` them ourselves.
+pub trait Config: Sized + Send + Sync + 'static {
+    /// The output of the `Hasher` function.
+    type Hash: BlockHash;
+
+    /// The account ID type.
+    type AccountId: Debug + Clone + Encode;
+
+    /// The address type.
+    type Address: Debug + Encode + From<Self::AccountId>;
+
+    /// The signature type.
+    type Signature: Debug + Encode;
+
+    /// The hashing system (algorithm) being used in the runtime (e.g. Blake2).
+    type Hasher: Debug + Hasher<Output = Self::Hash>;
+
+    /// The block header.
+    type Header: Debug + Header<Hasher = Self::Hasher> + Sync + Send + DeserializeOwned;
+
+    /// This type defines the extrinsic extra and additional parameters.
+    type ExtrinsicParams: ExtrinsicParams<Self>;
+
+    /// This is used to identify an asset in the `ChargeAssetTxPayment` signed extension.
+    type AssetId: Debug + Clone + Encode + DecodeAsType + EncodeAsType;
+}
+
+/// given some [`Config`], this return the other params needed for its `ExtrinsicParams`.
+pub type ParamsFor<T> = <<T as Config>::ExtrinsicParams as ExtrinsicParams<T>>::Params;
+
+/// Block hashes must conform to a bunch of things to be used in Subxt.
+pub trait BlockHash:
+    Debug
+    + Copy
+    + Send
+    + Sync
+    + Decode
+    + AsRef<[u8]>
+    + Serialize
+    + DeserializeOwned
+    + Encode
+    + PartialEq
+    + Eq
+    + core::hash::Hash
+{
+}
+impl<T> BlockHash for T where
+    T: Debug
+        + Copy
+        + Send
+        + Sync
+        + Decode
+        + AsRef<[u8]>
+        + Serialize
+        + DeserializeOwned
+        + Encode
+        + PartialEq
+        + Eq
+        + core::hash::Hash
+{
+}
+
+/// This represents the hasher used by a node to hash things like block headers
+/// and extrinsics.
+pub trait Hasher {
+    /// The type given back from the hash operation
+    type Output;
+
+    /// Hash some bytes to the given output type.
+    fn hash(s: &[u8]) -> Self::Output;
+
+    /// Hash some SCALE encodable type to the given output type.
+    fn hash_of<S: Encode>(s: &S) -> Self::Output {
+        let out = s.encode();
+        Self::hash(&out)
+    }
+}
+
+/// This represents the block header type used by a node.
+pub trait Header: Sized + Encode + Decode {
+    /// The block number type for this header.
+    type Number: Into<u64>;
+    /// The hasher used to hash this header.
+    type Hasher: Hasher;
+
+    /// Return the block number of this header.
+    fn number(&self) -> Self::Number;
+
+    /// Hash this header.
+    fn hash(&self) -> <Self::Hasher as Hasher>::Output {
+        Self::Hasher::hash_of(self)
+    }
+}
+
+cfg_substrate_compat! {
+    /// implement subxt's Hasher and Header traits for some substrate structs
+    mod substrate_impls {
+        use super::*;
+
+        impl<T: sp_runtime::traits::Header> Header for T
+        where
+            <T as sp_runtime::traits::Header>::Number: Into<u64>,
+        {
+            type Number = T::Number;
+            type Hasher = T::Hashing;
+
+            fn number(&self) -> Self::Number {
+                *self.number()
+            }
+        }
+
+        impl<T: sp_runtime::traits::Hash> Hasher for T {
+            type Output = T::Output;
+
+            fn hash(s: &[u8]) -> Self::Output {
+                <T as sp_runtime::traits::Hash>::hash(s)
+            }
+        }
+    }
+}

core/src/config/polkadot.rs

@@ -0,0 +1,33 @@
+// 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.
+
+//! Polkadot specific configuration
+
+use super::{Config, DefaultExtrinsicParams, DefaultExtrinsicParamsBuilder};
+
+use crate::config::SubstrateConfig;
+pub use crate::utils::{AccountId32, MultiAddress, MultiSignature};
+pub use primitive_types::{H256, U256};
+
+/// Default set of commonly used types by Polkadot nodes.
+pub enum PolkadotConfig {}
+
+impl Config for PolkadotConfig {
+    type Hash = <SubstrateConfig as Config>::Hash;
+    type AccountId = <SubstrateConfig as Config>::AccountId;
+    type Address = MultiAddress<Self::AccountId, ()>;
+    type Signature = <SubstrateConfig as Config>::Signature;
+    type Hasher = <SubstrateConfig as Config>::Hasher;
+    type Header = <SubstrateConfig as Config>::Header;
+    type ExtrinsicParams = PolkadotExtrinsicParams<Self>;
+    type AssetId = u32;
+}
+
+/// A struct representing the signed extra and additional parameters required
+/// to construct a transaction for a polkadot node.
+pub type PolkadotExtrinsicParams<T> = DefaultExtrinsicParams<T>;
+
+/// A builder which leads to [`PolkadotExtrinsicParams`] being constructed.
+/// This is what you provide to methods like `sign_and_submit()`.
+pub type PolkadotExtrinsicParamsBuilder<T> = DefaultExtrinsicParamsBuilder<T>;

core/src/config/refine_params.rs

@@ -0,0 +1,87 @@
+// 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.
+
+//! Refining params with values fetched from the chain
+
+use crate::Config;
+
+/// Data that can be used to refine the params of signed extensions.
+pub struct RefineParamsData<T: Config> {
+    account_nonce: u64,
+    block_number: u64,
+    block_hash: T::Hash,
+}
+
+impl<T: Config> RefineParamsData<T> {
+    #[doc(hidden)]
+    /// Creates a new [`RefineParamsData`] instance. Called from `subxt` when refining signed extensions.
+    pub fn new(account_nonce: u64, block_number: u64, block_hash: T::Hash) -> Self {
+        RefineParamsData {
+            account_nonce,
+            block_number,
+            block_hash,
+        }
+    }
+
+    /// account nonce for extrinsic author
+    pub fn account_nonce(&self) -> u64 {
+        self.account_nonce
+    }
+
+    /// latest finalized block number
+    pub fn block_number(&self) -> u64 {
+        self.block_number
+    }
+
+    /// latest finalized block hash
+    pub fn block_hash(&self) -> T::Hash {
+        self.block_hash
+    }
+}
+
+/// Types implementing [`RefineParams`] can be modified to reflect live information from the chain.
+pub trait RefineParams<T: Config> {
+    /// Refine params to an extrinsic. There is usually some notion of 'the param is already set/unset' in types implementing this trait.
+    /// The refinement should most likely not affect cases where a param is in a 'is already set by the user' state.
+    fn refine(&mut self, _data: &RefineParamsData<T>) {}
+}
+
+impl<T: Config> RefineParams<T> for () {}
+
+macro_rules! impl_tuples {
+    ($($ident:ident $index:tt),+) => {
+
+        impl <T: Config, $($ident : RefineParams<T>),+> RefineParams<T> for ($($ident,)+){
+            fn refine(&mut self, data: &RefineParamsData<T>) {
+                $(self.$index.refine(data);)+
+            }
+
+        }
+    }
+}
+
+#[rustfmt::skip]
+const _: () = {
+    impl_tuples!(A 0);
+    impl_tuples!(A 0, B 1);
+    impl_tuples!(A 0, B 1, C 2);
+    impl_tuples!(A 0, B 1, C 2, D 3);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, U 19);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, U 19, V 20);
+};

core/src/config/signed_extensions.rs

@@ -0,0 +1,511 @@
+// 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 contains implementations for common signed extensions, each
+//! of which implements [`SignedExtension`], and can be used in conjunction with
+//! [`AnyOf`] to configure the set of signed extensions which are known about
+//! when interacting with a chain.
+
+use super::extrinsic_params::ExtrinsicParams;
+use super::refine_params::RefineParamsData;
+use super::RefineParams;
+use crate::client::ClientState;
+use crate::config::ExtrinsicParamsEncoder;
+use crate::error::ExtrinsicParamsError;
+use crate::utils::Era;
+use crate::Config;
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use codec::{Compact, Encode};
+use core::fmt::Debug;
+use derive_where::derive_where;
+use hashbrown::HashMap;
+use scale_decode::DecodeAsType;
+use scale_info::PortableRegistry;
+
+/// A single [`SignedExtension`] has a unique name, but is otherwise the
+/// same as [`ExtrinsicParams`] in describing how to encode the extra and
+/// additional data.
+pub trait SignedExtension<T: Config>: ExtrinsicParams<T> {
+    /// 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;
+
+    /// This should return true if the signed extension matches the details given.
+    /// Often, this will involve just checking that the identifier given matches that of the
+    /// extension in question.
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool;
+}
+
+/// The [`CheckSpecVersion`] signed extension.
+pub struct CheckSpecVersion(u32);
+
+impl<T: Config> ExtrinsicParams<T> for CheckSpecVersion {
+    type Params = ();
+
+    fn new(client: &ClientState<T>, _params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        Ok(CheckSpecVersion(client.runtime_version().spec_version()))
+    }
+}
+
+impl ExtrinsicParamsEncoder for CheckSpecVersion {
+    fn encode_additional_to(&self, v: &mut Vec<u8>) {
+        self.0.encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for CheckSpecVersion {
+    type Decoded = ();
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "CheckSpecVersion"
+    }
+}
+
+/// The [`CheckNonce`] signed extension.
+pub struct CheckNonce(Compact<u64>);
+
+impl<T: Config> ExtrinsicParams<T> for CheckNonce {
+    type Params = CheckNonceParams;
+
+    fn new(_client: &ClientState<T>, params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        // If no nonce is set (nor by user nor refinement), use a nonce of 0.
+        let nonce = params.0.unwrap_or(0);
+        Ok(CheckNonce(Compact(nonce)))
+    }
+}
+
+impl ExtrinsicParamsEncoder for CheckNonce {
+    fn encode_extra_to(&self, v: &mut Vec<u8>) {
+        self.0.encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for CheckNonce {
+    type Decoded = u64;
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "CheckNonce"
+    }
+}
+
+/// Params for [`CheckNonce`]
+#[derive(Debug, Clone, Default)]
+pub struct CheckNonceParams(pub Option<u64>);
+
+impl<T: Config> RefineParams<T> for CheckNonceParams {
+    fn refine(&mut self, data: &RefineParamsData<T>) {
+        if self.0.is_none() {
+            self.0 = Some(data.account_nonce());
+        }
+    }
+}
+
+/// The [`CheckTxVersion`] signed extension.
+pub struct CheckTxVersion(u32);
+
+impl<T: Config> ExtrinsicParams<T> for CheckTxVersion {
+    type Params = ();
+
+    fn new(client: &ClientState<T>, _params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        Ok(CheckTxVersion(
+            client.runtime_version().transaction_version(),
+        ))
+    }
+}
+
+impl ExtrinsicParamsEncoder for CheckTxVersion {
+    fn encode_additional_to(&self, v: &mut Vec<u8>) {
+        self.0.encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for CheckTxVersion {
+    type Decoded = ();
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "CheckTxVersion"
+    }
+}
+
+/// The [`CheckGenesis`] signed extension.
+pub struct CheckGenesis<T: Config>(T::Hash);
+
+impl<T: Config> ExtrinsicParams<T> for CheckGenesis<T> {
+    type Params = ();
+
+    fn new(client: &ClientState<T>, _params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        Ok(CheckGenesis(client.genesis_hash()))
+    }
+}
+
+impl<T: Config> ExtrinsicParamsEncoder for CheckGenesis<T> {
+    fn encode_additional_to(&self, v: &mut Vec<u8>) {
+        self.0.encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for CheckGenesis<T> {
+    type Decoded = ();
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "CheckGenesis"
+    }
+}
+
+/// The [`CheckMortality`] signed extension.
+pub struct CheckMortality<T: Config> {
+    era: Era,
+    checkpoint: T::Hash,
+}
+
+/// Parameters to configure the [`CheckMortality`] signed extension.
+pub struct CheckMortalityParams<T: Config>(Option<CheckMortalityParamsInner<T>>);
+struct CheckMortalityParamsInner<T: Config> {
+    era: Era,
+    checkpoint: Option<T::Hash>,
+}
+
+impl<T: Config> Default for CheckMortalityParams<T> {
+    fn default() -> Self {
+        CheckMortalityParams(None)
+    }
+}
+
+impl<T: Config> RefineParams<T> for CheckMortalityParams<T> {
+    fn refine(&mut self, data: &RefineParamsData<T>) {
+        if self.0.is_none() {
+            // By default we refine the params to have a mortal transaction valid for 32 blocks.
+            const TX_VALID_FOR: u64 = 32;
+            *self =
+                CheckMortalityParams::mortal(TX_VALID_FOR, data.block_number(), data.block_hash());
+        }
+    }
+}
+
+impl<T: Config> CheckMortalityParams<T> {
+    /// Configure a mortal transaction. The `period` is (roughly) how many
+    /// blocks the transaction will be valid for. The `block_number` and
+    /// `block_hash` should both point to the same block, and are the block that
+    /// the transaction is mortal from.
+    pub fn mortal(period: u64, block_number: u64, block_hash: T::Hash) -> Self {
+        Self(Some(CheckMortalityParamsInner {
+            era: Era::mortal(period, block_number),
+            checkpoint: Some(block_hash),
+        }))
+    }
+    /// An immortal transaction.
+    pub fn immortal() -> Self {
+        Self(Some(CheckMortalityParamsInner {
+            era: Era::Immortal,
+            checkpoint: None,
+        }))
+    }
+}
+
+impl<T: Config> ExtrinsicParams<T> for CheckMortality<T> {
+    type Params = CheckMortalityParams<T>;
+
+    fn new(client: &ClientState<T>, params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        let check_mortality = if let Some(params) = params.0 {
+            CheckMortality {
+                era: params.era,
+                checkpoint: params.checkpoint.unwrap_or(client.genesis_hash()),
+            }
+        } else {
+            CheckMortality {
+                era: Era::Immortal,
+                checkpoint: client.genesis_hash(),
+            }
+        };
+        Ok(check_mortality)
+    }
+}
+
+impl<T: Config> ExtrinsicParamsEncoder for CheckMortality<T> {
+    fn encode_extra_to(&self, v: &mut Vec<u8>) {
+        self.era.encode_to(v);
+    }
+    fn encode_additional_to(&self, v: &mut Vec<u8>) {
+        self.checkpoint.encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for CheckMortality<T> {
+    type Decoded = Era;
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "CheckMortality"
+    }
+}
+
+/// The [`ChargeAssetTxPayment`] signed extension.
+#[derive(DecodeAsType)]
+#[derive_where(Clone, Debug; T::AssetId)]
+#[decode_as_type(trait_bounds = "T::AssetId: DecodeAsType")]
+pub struct ChargeAssetTxPayment<T: Config> {
+    tip: Compact<u128>,
+    asset_id: Option<T::AssetId>,
+}
+
+impl<T: Config> ChargeAssetTxPayment<T> {
+    /// 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<&T::AssetId> {
+        self.asset_id.as_ref()
+    }
+}
+
+/// Parameters to configure the [`ChargeAssetTxPayment`] signed extension.
+pub struct ChargeAssetTxPaymentParams<T: Config> {
+    tip: u128,
+    asset_id: Option<T::AssetId>,
+}
+
+impl<T: Config> Default for ChargeAssetTxPaymentParams<T> {
+    fn default() -> Self {
+        ChargeAssetTxPaymentParams {
+            tip: Default::default(),
+            asset_id: Default::default(),
+        }
+    }
+}
+
+impl<T: Config> ChargeAssetTxPaymentParams<T> {
+    /// Don't provide a tip to the extrinsic author.
+    pub fn no_tip() -> Self {
+        ChargeAssetTxPaymentParams {
+            tip: 0,
+            asset_id: None,
+        }
+    }
+    /// Tip the extrinsic author in the native chain token.
+    pub fn tip(tip: u128) -> Self {
+        ChargeAssetTxPaymentParams {
+            tip,
+            asset_id: None,
+        }
+    }
+    /// Tip the extrinsic author using the asset ID given.
+    pub fn tip_of(tip: u128, asset_id: T::AssetId) -> Self {
+        ChargeAssetTxPaymentParams {
+            tip,
+            asset_id: Some(asset_id),
+        }
+    }
+}
+
+impl<T: Config> ExtrinsicParams<T> for ChargeAssetTxPayment<T> {
+    type Params = ChargeAssetTxPaymentParams<T>;
+
+    fn new(_client: &ClientState<T>, params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        Ok(ChargeAssetTxPayment {
+            tip: Compact(params.tip),
+            asset_id: params.asset_id,
+        })
+    }
+}
+
+impl<T: Config> RefineParams<T> for ChargeAssetTxPaymentParams<T> {}
+
+impl<T: Config> ExtrinsicParamsEncoder for ChargeAssetTxPayment<T> {
+    fn encode_extra_to(&self, v: &mut Vec<u8>) {
+        (self.tip, &self.asset_id).encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for ChargeAssetTxPayment<T> {
+    type Decoded = Self;
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "ChargeAssetTxPayment"
+    }
+}
+
+/// The [`ChargeTransactionPayment`] signed extension.
+#[derive(Clone, 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 {
+    tip: u128,
+}
+
+impl ChargeTransactionPaymentParams {
+    /// Don't provide a tip to the extrinsic author.
+    pub fn no_tip() -> Self {
+        ChargeTransactionPaymentParams { tip: 0 }
+    }
+    /// Tip the extrinsic author in the native chain token.
+    pub fn tip(tip: u128) -> Self {
+        ChargeTransactionPaymentParams { tip }
+    }
+}
+
+impl<T: Config> ExtrinsicParams<T> for ChargeTransactionPayment {
+    type Params = ChargeTransactionPaymentParams;
+
+    fn new(_client: &ClientState<T>, params: Self::Params) -> Result<Self, ExtrinsicParamsError> {
+        Ok(ChargeTransactionPayment {
+            tip: Compact(params.tip),
+        })
+    }
+}
+
+impl<T: Config> RefineParams<T> for ChargeTransactionPaymentParams {}
+
+impl ExtrinsicParamsEncoder for ChargeTransactionPayment {
+    fn encode_extra_to(&self, v: &mut Vec<u8>) {
+        self.tip.encode_to(v);
+    }
+}
+
+impl<T: Config> SignedExtension<T> for ChargeTransactionPayment {
+    type Decoded = Self;
+    fn matches(identifier: &str, _type_id: u32, _types: &PortableRegistry) -> bool {
+        identifier == "ChargeTransactionPayment"
+    }
+}
+
+/// This accepts a tuple of [`SignedExtension`]s, and will dynamically make use of whichever
+/// ones are actually required for the chain in the correct order, ignoring the rest. This
+/// is a sensible default, and allows for a single configuration to work across multiple chains.
+pub struct AnyOf<T, Params> {
+    params: Vec<Box<dyn ExtrinsicParamsEncoder>>,
+    _marker: core::marker::PhantomData<(T, Params)>,
+}
+
+macro_rules! impl_tuples {
+    ($($ident:ident $index:tt),+) => {
+        // We do some magic when the tuple is wrapped in AnyOf. We
+        // look at the metadata, and use this to select and make use of only the extensions
+        // that we actually need for the chain we're dealing with.
+        impl <T, $($ident),+> ExtrinsicParams<T> for AnyOf<T, ($($ident,)+)>
+        where
+            T: Config,
+            $($ident: SignedExtension<T>,)+
+        {
+            type Params = ($($ident::Params,)+);
+
+            fn new(
+                client: &ClientState<T>,
+                params: Self::Params,
+            ) -> Result<Self, ExtrinsicParamsError> {
+                let metadata = client.metadata();
+                let types = metadata.types();
+
+                // For each signed extension in the tuple, find the matching index in the metadata, if
+                // there is one, and add it to a map with that index as the key.
+                let mut exts_by_index = HashMap::new();
+                $({
+                    for (idx, e) in metadata.extrinsic().signed_extensions().iter().enumerate() {
+                        // Skip over any exts that have a match already:
+                        if exts_by_index.contains_key(&idx) {
+                            continue
+                        }
+                        // Break and record as soon as we find a match:
+                        if $ident::matches(e.identifier(), e.extra_ty(), types) {
+                            let ext = $ident::new(client, params.$index)?;
+                            let boxed_ext: Box<dyn ExtrinsicParamsEncoder> = Box::new(ext);
+                            exts_by_index.insert(idx, boxed_ext);
+                            break
+                        }
+                    }
+                })+
+
+                // Next, turn these into an ordered vec, erroring if we haven't matched on any exts yet.
+                let mut params = Vec::new();
+                for (idx, e) in metadata.extrinsic().signed_extensions().iter().enumerate() {
+                    let Some(ext) = exts_by_index.remove(&idx) else {
+                        if is_type_empty(e.extra_ty(), types) {
+                            continue
+                        } else {
+                            return Err(ExtrinsicParamsError::UnknownSignedExtension(e.identifier().to_owned()));
+                        }
+                    };
+                    params.push(ext);
+                }
+
+                Ok(AnyOf {
+                    params,
+                    _marker: core::marker::PhantomData
+                })
+            }
+        }
+
+        impl <T, $($ident),+> ExtrinsicParamsEncoder for AnyOf<T, ($($ident,)+)>
+        where
+            T: Config,
+            $($ident: SignedExtension<T>,)+
+        {
+            fn encode_extra_to(&self, v: &mut Vec<u8>) {
+                for ext in &self.params {
+                    ext.encode_extra_to(v);
+                }
+            }
+            fn encode_additional_to(&self, v: &mut Vec<u8>) {
+                for ext in &self.params {
+                    ext.encode_additional_to(v);
+                }
+            }
+        }
+    }
+}
+
+#[rustfmt::skip]
+const _: () = {
+    impl_tuples!(A 0);
+    impl_tuples!(A 0, B 1);
+    impl_tuples!(A 0, B 1, C 2);
+    impl_tuples!(A 0, B 1, C 2, D 3);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, U 19);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, U 19, V 20);
+};
+
+/// Checks to see whether the type being given is empty, ie would require
+/// 0 bytes to encode.
+fn is_type_empty(type_id: u32, types: &scale_info::PortableRegistry) -> bool {
+    let Some(ty) = types.resolve(type_id) else {
+        // Can't resolve; type may not be empty. Not expected to hit this.
+        return false;
+    };
+
+    use scale_info::TypeDef;
+    match &ty.type_def {
+        TypeDef::Composite(c) => c.fields.iter().all(|f| is_type_empty(f.ty.id, types)),
+        TypeDef::Array(a) => a.len == 0 || is_type_empty(a.type_param.id, types),
+        TypeDef::Tuple(t) => t.fields.iter().all(|f| is_type_empty(f.id, types)),
+        // Explicitly list these in case any additions are made in the future.
+        TypeDef::BitSequence(_)
+        | TypeDef::Variant(_)
+        | TypeDef::Sequence(_)
+        | TypeDef::Compact(_)
+        | TypeDef::Primitive(_) => false,
+    }
+}

core/src/config/substrate.rs

@@ -0,0 +1,337 @@
+// 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.
+
+//! Substrate specific configuration
+
+use super::{Config, DefaultExtrinsicParams, DefaultExtrinsicParamsBuilder, Hasher, Header};
+use alloc::format;
+use alloc::vec::Vec;
+use codec::{Decode, Encode};
+use serde::{Deserialize, Serialize};
+
+pub use crate::utils::{AccountId32, MultiAddress, MultiSignature};
+pub use primitive_types::{H256, U256};
+
+/// Default set of commonly used types by Substrate runtimes.
+// Note: We only use this at the type level, so it should be impossible to
+// create an instance of it.
+pub enum SubstrateConfig {}
+
+impl Config for SubstrateConfig {
+    type Hash = H256;
+    type AccountId = AccountId32;
+    type Address = MultiAddress<Self::AccountId, u32>;
+    type Signature = MultiSignature;
+    type Hasher = BlakeTwo256;
+    type Header = SubstrateHeader<u32, BlakeTwo256>;
+    type ExtrinsicParams = SubstrateExtrinsicParams<Self>;
+    type AssetId = u32;
+}
+
+/// A struct representing the signed extra and additional parameters required
+/// to construct a transaction for the default substrate node.
+pub type SubstrateExtrinsicParams<T> = DefaultExtrinsicParams<T>;
+
+/// A builder which leads to [`SubstrateExtrinsicParams`] being constructed.
+/// This is what you provide to methods like `sign_and_submit()`.
+pub type SubstrateExtrinsicParamsBuilder<T> = DefaultExtrinsicParamsBuilder<T>;
+
+/// A type that can hash values using the blaks2_256 algorithm.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode)]
+pub struct BlakeTwo256;
+
+impl Hasher for BlakeTwo256 {
+    type Output = H256;
+    fn hash(s: &[u8]) -> Self::Output {
+        sp_crypto_hashing::blake2_256(s).into()
+    }
+}
+
+/// A generic Substrate header type, adapted from `sp_runtime::generic::Header`.
+/// The block number and hasher can be configured to adapt this for other nodes.
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SubstrateHeader<N: Copy + Into<U256> + TryFrom<U256>, H: Hasher> {
+    /// The parent hash.
+    pub parent_hash: H::Output,
+    /// The block number.
+    #[serde(
+        serialize_with = "serialize_number",
+        deserialize_with = "deserialize_number"
+    )]
+    #[codec(compact)]
+    pub number: N,
+    /// The state trie merkle root
+    pub state_root: H::Output,
+    /// The merkle root of the extrinsics.
+    pub extrinsics_root: H::Output,
+    /// A chain-specific digest of data useful for light clients or referencing auxiliary data.
+    pub digest: Digest,
+}
+
+impl<N, H> Header for SubstrateHeader<N, H>
+where
+    N: Copy + Into<u64> + Into<U256> + TryFrom<U256> + Encode,
+    H: Hasher + Encode,
+    SubstrateHeader<N, H>: Encode + Decode,
+{
+    type Number = N;
+    type Hasher = H;
+    fn number(&self) -> Self::Number {
+        self.number
+    }
+}
+
+/// Generic header digest. From `sp_runtime::generic::digest`.
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Default)]
+pub struct Digest {
+    /// A list of digest items.
+    pub logs: Vec<DigestItem>,
+}
+
+/// Digest item that is able to encode/decode 'system' digest items and
+/// provide opaque access to other items. From `sp_runtime::generic::digest`.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum DigestItem {
+    /// A pre-runtime digest.
+    ///
+    /// These are messages from the consensus engine to the runtime, although
+    /// the consensus engine can (and should) read them itself to avoid
+    /// code and state duplication. It is erroneous for a runtime to produce
+    /// these, but this is not (yet) checked.
+    ///
+    /// NOTE: the runtime is not allowed to panic or fail in an `on_initialize`
+    /// call if an expected `PreRuntime` digest is not present. It is the
+    /// responsibility of a external block verifier to check this. Runtime API calls
+    /// will initialize the block without pre-runtime digests, so initialization
+    /// cannot fail when they are missing.
+    PreRuntime(ConsensusEngineId, Vec<u8>),
+
+    /// A message from the runtime to the consensus engine. This should *never*
+    /// be generated by the native code of any consensus engine, but this is not
+    /// checked (yet).
+    Consensus(ConsensusEngineId, Vec<u8>),
+
+    /// Put a Seal on it. This is only used by native code, and is never seen
+    /// by runtimes.
+    Seal(ConsensusEngineId, Vec<u8>),
+
+    /// Some other thing. Unsupported and experimental.
+    Other(Vec<u8>),
+
+    /// An indication for the light clients that the runtime execution
+    /// environment is updated.
+    ///
+    /// Currently this is triggered when:
+    /// 1. Runtime code blob is changed or
+    /// 2. `heap_pages` value is changed.
+    RuntimeEnvironmentUpdated,
+}
+
+// From sp_runtime::generic, DigestItem enum indexes are encoded using this:
+#[repr(u32)]
+#[derive(Encode, Decode)]
+enum DigestItemType {
+    Other = 0u32,
+    Consensus = 4u32,
+    Seal = 5u32,
+    PreRuntime = 6u32,
+    RuntimeEnvironmentUpdated = 8u32,
+}
+impl Encode for DigestItem {
+    fn encode(&self) -> Vec<u8> {
+        let mut v = Vec::new();
+
+        match self {
+            Self::Consensus(val, data) => {
+                DigestItemType::Consensus.encode_to(&mut v);
+                (val, data).encode_to(&mut v);
+            }
+            Self::Seal(val, sig) => {
+                DigestItemType::Seal.encode_to(&mut v);
+                (val, sig).encode_to(&mut v);
+            }
+            Self::PreRuntime(val, data) => {
+                DigestItemType::PreRuntime.encode_to(&mut v);
+                (val, data).encode_to(&mut v);
+            }
+            Self::Other(val) => {
+                DigestItemType::Other.encode_to(&mut v);
+                val.encode_to(&mut v);
+            }
+            Self::RuntimeEnvironmentUpdated => {
+                DigestItemType::RuntimeEnvironmentUpdated.encode_to(&mut v);
+            }
+        }
+
+        v
+    }
+}
+impl Decode for DigestItem {
+    fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
+        let item_type: DigestItemType = Decode::decode(input)?;
+        match item_type {
+            DigestItemType::PreRuntime => {
+                let vals: (ConsensusEngineId, Vec<u8>) = Decode::decode(input)?;
+                Ok(Self::PreRuntime(vals.0, vals.1))
+            }
+            DigestItemType::Consensus => {
+                let vals: (ConsensusEngineId, Vec<u8>) = Decode::decode(input)?;
+                Ok(Self::Consensus(vals.0, vals.1))
+            }
+            DigestItemType::Seal => {
+                let vals: (ConsensusEngineId, Vec<u8>) = Decode::decode(input)?;
+                Ok(Self::Seal(vals.0, vals.1))
+            }
+            DigestItemType::Other => Ok(Self::Other(Decode::decode(input)?)),
+            DigestItemType::RuntimeEnvironmentUpdated => Ok(Self::RuntimeEnvironmentUpdated),
+        }
+    }
+}
+
+/// Consensus engine unique ID. From `sp_runtime::ConsensusEngineId`.
+pub type ConsensusEngineId = [u8; 4];
+
+impl serde::Serialize for DigestItem {
+    fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.using_encoded(|bytes| impl_serde::serialize::serialize(bytes, seq))
+    }
+}
+
+impl<'a> serde::Deserialize<'a> for DigestItem {
+    fn deserialize<D>(de: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'a>,
+    {
+        let r = impl_serde::serialize::deserialize(de)?;
+        Decode::decode(&mut &r[..])
+            .map_err(|e| serde::de::Error::custom(format!("Decode error: {e}")))
+    }
+}
+
+fn serialize_number<S, T: Copy + Into<U256>>(val: &T, s: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let u256: U256 = (*val).into();
+    serde::Serialize::serialize(&u256, s)
+}
+
+fn deserialize_number<'a, D, T: TryFrom<U256>>(d: D) -> Result<T, D::Error>
+where
+    D: serde::Deserializer<'a>,
+{
+    // At the time of writing, Smoldot gives back block numbers in numeric rather
+    // than hex format. So let's support deserializing from both here:
+    let number_or_hex = NumberOrHex::deserialize(d)?;
+    let u256 = number_or_hex.into_u256();
+    TryFrom::try_from(u256).map_err(|_| serde::de::Error::custom("Try from failed"))
+}
+
+/// A number type that can be serialized both as a number or a string that encodes a number in a
+/// string.
+///
+/// We allow two representations of the block number as input. Either we deserialize to the type
+/// that is specified in the block type or we attempt to parse given hex value.
+///
+/// The primary motivation for having this type is to avoid overflows when using big integers in
+/// JavaScript (which we consider as an important RPC API consumer).
+#[derive(Copy, Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[serde(untagged)]
+pub enum NumberOrHex {
+    /// The number represented directly.
+    Number(u64),
+    /// Hex representation of the number.
+    Hex(U256),
+}
+
+impl NumberOrHex {
+    /// Converts this number into an U256.
+    pub fn into_u256(self) -> U256 {
+        match self {
+            NumberOrHex::Number(n) => n.into(),
+            NumberOrHex::Hex(h) => h,
+        }
+    }
+}
+
+impl From<NumberOrHex> for U256 {
+    fn from(num_or_hex: NumberOrHex) -> U256 {
+        num_or_hex.into_u256()
+    }
+}
+
+macro_rules! into_number_or_hex {
+    ($($t: ty)+) => {
+        $(
+            impl From<$t> for NumberOrHex {
+                fn from(x: $t) -> Self {
+                    NumberOrHex::Number(x.into())
+                }
+            }
+        )+
+    }
+}
+into_number_or_hex!(u8 u16 u32 u64);
+
+impl From<u128> for NumberOrHex {
+    fn from(n: u128) -> Self {
+        NumberOrHex::Hex(n.into())
+    }
+}
+
+impl From<U256> for NumberOrHex {
+    fn from(n: U256) -> Self {
+        NumberOrHex::Hex(n)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    // Smoldot returns numeric block numbers in the header at the time of writing;
+    // ensure we can deserialize them properly.
+    #[test]
+    fn can_deserialize_numeric_block_number() {
+        let numeric_block_number_json = r#"
+            {
+                "digest": {
+                    "logs": []
+                },
+                "extrinsicsRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "number": 4,
+                "parentHash": "0xcb2690b2c85ceab55be03fc7f7f5f3857e7efeb7a020600ebd4331e10be2f7a5",
+                "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000"
+            }
+        "#;
+
+        let header: SubstrateHeader<u32, BlakeTwo256> =
+            serde_json::from_str(numeric_block_number_json).expect("valid block header");
+        assert_eq!(header.number(), 4);
+    }
+
+    // Substrate returns hex block numbers; ensure we can also deserialize those OK.
+    #[test]
+    fn can_deserialize_hex_block_number() {
+        let numeric_block_number_json = r#"
+            {
+                "digest": {
+                    "logs": []
+                },
+                "extrinsicsRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "number": "0x04",
+                "parentHash": "0xcb2690b2c85ceab55be03fc7f7f5f3857e7efeb7a020600ebd4331e10be2f7a5",
+                "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000"
+            }
+        "#;
+
+        let header: SubstrateHeader<u32, BlakeTwo256> =
+            serde_json::from_str(numeric_block_number_json).expect("valid block header");
+        assert_eq!(header.number(), 4);
+    }
+}