Make sp_core and sp_runtime dependencies optional, and bump to latest (#760)

* begin porting over traits; remove Config use of Hash * port over the Header bits that we need * sp_core_hashing where possible, move Verify to PairSigner, remove unused errors * tidy up Config things and move related bits into one place * fix codegen * copy Era over * move AccountId, Address, Signer to Signer trait and a pass over fixing examples * impl MultiAddress, MultiSignature, AccountId32 and add back to Config (for decoding later) * Copy over StorageKey, StorageData, StorageChangeSet * subxt core compiling with no sp_core or sp_runtime * Get examples compiling * pass over fixing tests * cargo fmt * clippy tweaks and update polkadot.rs * fix codegen docs * port over special DigestItem encoding/decoding * clippy and doc fixes * cargo fmt and example fix * more cargo fmt-ing... * substrate-extra to substrate-compat * cargo.toml comments * simplify PairSigner trait bounds * move RPC types to a separate file * fix docs * Add some tests for things and other PR feedback * bump to latest sp deps * avoid needing substrate-compat feature in a test
2026-06-23 20:11:06 +00:00 · 2023-01-10 12:02:41 +00:00
parent ea5daa444f
commit b316301d61
47 changed files with 2658 additions and 1736 deletions
@@ -0,0 +1,270 @@
+// Copyright 2019-2022 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. A basic
+//! implementation of the trait is provided ([`BaseExtrinsicParams`]) which is
+//! used by the provided Substrate and Polkadot configuration.
+
+use crate::{
+    utils::Encoded,
+    Config,
+};
+use codec::{
+    Compact,
+    Decode,
+    Encode,
+};
+use core::fmt::Debug;
+use derivative::Derivative;
+use serde::{
+    Deserialize,
+    Serialize,
+};
+
+/// This trait allows you to configure the "signed extra" and
+/// "additional" parameters that are signed and used in transactions.
+/// see [`BaseExtrinsicParams`] for an implementation that is compatible with
+/// a Polkadot node.
+pub trait ExtrinsicParams<Index, Hash>: Debug + '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 OtherParams;
+
+    /// Construct a new instance of our [`ExtrinsicParams`]
+    fn new(
+        spec_version: u32,
+        tx_version: u32,
+        nonce: Index,
+        genesis_hash: Hash,
+        other_params: Self::OtherParams,
+    ) -> Self;
+
+    /// 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>);
+}
+
+/// An implementation of [`ExtrinsicParams`] that is suitable for constructing
+/// extrinsics that can be sent to a node with the same signed extra and additional
+/// parameters as a Polkadot/Substrate node. The way that tip payments are specified
+/// differs between Substrate and Polkadot nodes, and so we are generic over that in
+/// order to support both here with relative ease.
+///
+/// If your node differs in the "signed extra" and "additional" parameters expected
+/// to be sent/signed with a transaction, then you can define your own type which
+/// implements the [`ExtrinsicParams`] trait.
+#[derive(Derivative)]
+#[derivative(Debug(bound = "Tip: Debug"))]
+pub struct BaseExtrinsicParams<T: Config, Tip: Debug> {
+    era: Era,
+    nonce: T::Index,
+    tip: Tip,
+    spec_version: u32,
+    transaction_version: u32,
+    genesis_hash: T::Hash,
+    mortality_checkpoint: T::Hash,
+    marker: std::marker::PhantomData<T>,
+}
+
+/// This builder allows you to provide the parameters that can be configured in order to
+/// construct a [`BaseExtrinsicParams`] value. This implements [`Default`], which allows
+/// [`BaseExtrinsicParams`] to be used with convenience methods like `sign_and_submit_default()`.
+///
+/// Prefer to use [`super::substrate::SubstrateExtrinsicParamsBuilder`] for a version of this
+/// tailored towards Substrate, or [`super::polkadot::PolkadotExtrinsicParamsBuilder`] for a
+/// version tailored to Polkadot.
+#[derive(Derivative)]
+#[derivative(
+    Debug(bound = "Tip: Debug"),
+    Clone(bound = "Tip: Clone"),
+    Copy(bound = "Tip: Copy"),
+    PartialEq(bound = "Tip: PartialEq")
+)]
+pub struct BaseExtrinsicParamsBuilder<T: Config, Tip> {
+    era: Era,
+    mortality_checkpoint: Option<T::Hash>,
+    tip: Tip,
+}
+
+impl<T: Config, Tip: Default> BaseExtrinsicParamsBuilder<T, Tip> {
+    /// Instantiate the default set of [`BaseExtrinsicParamsBuilder`]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the [`Era`], which defines how long the transaction will be valid for
+    /// (it can be either immortal, or it can be mortal and expire after a certain amount
+    /// of time). The second argument is the block hash after which the transaction
+    /// becomes valid, and must align with the era phase (see the [`Era::Mortal`] docs
+    /// for more detail on that).
+    pub fn era(mut self, era: Era, checkpoint: T::Hash) -> Self {
+        self.era = era;
+        self.mortality_checkpoint = Some(checkpoint);
+        self
+    }
+
+    /// Set the tip you'd like to give to the block author
+    /// for this transaction.
+    pub fn tip(mut self, tip: impl Into<Tip>) -> Self {
+        self.tip = tip.into();
+        self
+    }
+}
+
+impl<T: Config, Tip: Default> Default for BaseExtrinsicParamsBuilder<T, Tip> {
+    fn default() -> Self {
+        Self {
+            era: Era::Immortal,
+            mortality_checkpoint: None,
+            tip: Tip::default(),
+        }
+    }
+}
+
+impl<T: Config, Tip: Debug + Encode + 'static> ExtrinsicParams<T::Index, T::Hash>
+    for BaseExtrinsicParams<T, Tip>
+{
+    type OtherParams = BaseExtrinsicParamsBuilder<T, Tip>;
+
+    fn new(
+        // Provided from subxt client:
+        spec_version: u32,
+        transaction_version: u32,
+        nonce: T::Index,
+        genesis_hash: T::Hash,
+        // Provided externally:
+        other_params: Self::OtherParams,
+    ) -> Self {
+        BaseExtrinsicParams {
+            era: other_params.era,
+            mortality_checkpoint: other_params
+                .mortality_checkpoint
+                .unwrap_or(genesis_hash),
+            tip: other_params.tip,
+            nonce,
+            spec_version,
+            transaction_version,
+            genesis_hash,
+            marker: std::marker::PhantomData,
+        }
+    }
+
+    fn encode_extra_to(&self, v: &mut Vec<u8>) {
+        let nonce: u64 = self.nonce.into();
+        let tip = Encoded(self.tip.encode());
+        (self.era, Compact(nonce), tip).encode_to(v);
+    }
+
+    fn encode_additional_to(&self, v: &mut Vec<u8>) {
+        (
+            self.spec_version,
+            self.transaction_version,
+            self.genesis_hash,
+            self.mortality_checkpoint,
+        )
+            .encode_to(v);
+    }
+}
+
+// Dev note: This and related bits taken from `sp_runtime::generic::Era`
+/// An era to describe the longevity of a transaction.
+#[derive(PartialEq, Eq, Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum Era {
+    /// The transaction is valid forever. The genesis hash must be present in the signed content.
+    Immortal,
+
+    /// Period and phase are encoded:
+    /// - The period of validity from the block hash found in the signing material.
+    /// - The phase in the period that this transaction's lifetime begins (and, importantly,
+    /// implies which block hash is included in the signature material). If the `period` is
+    /// greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that
+    /// `period` is.
+    ///
+    /// When used on `FRAME`-based runtimes, `period` cannot exceed `BlockHashCount` parameter
+    /// of `system` module.
+    Mortal(Period, Phase),
+}
+
+/// Era period
+pub type Period = u64;
+
+/// Era phase
+pub type Phase = u64;
+
+// E.g. with period == 4:
+// 0         10        20        30        40
+// 0123456789012345678901234567890123456789012
+//              |...|
+//    authored -/   \- expiry
+// phase = 1
+// n = Q(current - phase, period) + phase
+impl Era {
+    /// Create a new era based on a period (which should be a power of two between 4 and 65536
+    /// inclusive) and a block number on which it should start (or, for long periods, be shortly
+    /// after the start).
+    ///
+    /// If using `Era` in the context of `FRAME` runtime, make sure that `period`
+    /// does not exceed `BlockHashCount` parameter passed to `system` module, since that
+    /// prunes old blocks and renders transactions immediately invalid.
+    pub fn mortal(period: u64, current: u64) -> Self {
+        let period = period
+            .checked_next_power_of_two()
+            .unwrap_or(1 << 16)
+            .clamp(4, 1 << 16);
+        let phase = current % period;
+        let quantize_factor = (period >> 12).max(1);
+        let quantized_phase = phase / quantize_factor * quantize_factor;
+
+        Self::Mortal(period, quantized_phase)
+    }
+
+    /// Create an "immortal" transaction.
+    pub fn immortal() -> Self {
+        Self::Immortal
+    }
+}
+
+// Both copied from `sp_runtime::generic::Era`; this is the wire interface and so
+// it's really the most important bit here.
+impl Encode for Era {
+    fn encode_to<T: codec::Output + ?Sized>(&self, output: &mut T) {
+        match self {
+            Self::Immortal => output.push_byte(0),
+            Self::Mortal(period, phase) => {
+                let quantize_factor = (*period >> 12).max(1);
+                let encoded = (period.trailing_zeros() - 1).clamp(1, 15) as u16
+                    | ((phase / quantize_factor) << 4) as u16;
+                encoded.encode_to(output);
+            }
+        }
+    }
+}
+impl Decode for Era {
+    fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
+        let first = input.read_byte()?;
+        if first == 0 {
+            Ok(Self::Immortal)
+        } else {
+            let encoded = first as u64 + ((input.read_byte()? as u64) << 8);
+            let period = 2 << (encoded % (1 << 4));
+            let quantize_factor = (period >> 12).max(1);
+            let phase = (encoded >> 4) * quantize_factor;
+            if period >= 4 && phase < period {
+                Ok(Self::Mortal(period, phase))
+            } else {
+                Err("Invalid period and phase".into())
+            }
+        }
+    }
+}
@@ -0,0 +1,157 @@
+// Copyright 2019-2022 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.
+
+pub mod extrinsic_params;
+pub mod polkadot;
+pub mod substrate;
+
+use codec::{
+    Codec,
+    Encode,
+    EncodeLike,
+};
+use core::fmt::Debug;
+use serde::Serialize;
+
+pub use extrinsic_params::ExtrinsicParams;
+pub use polkadot::PolkadotConfig;
+pub use substrate::SubstrateConfig;
+
+/// Runtime types.
+// Note: the 'static bound isn't strictly required, but currently deriving TypeInfo
+// automatically applies a 'static bound to all generic types (including this one),
+// and so until that is resolved, we'll keep the (easy to satisfy) constraint here.
+pub trait Config: 'static {
+    /// Account index (aka nonce) type. This stores the number of previous
+    /// transactions associated with a sender account.
+    type Index: Parameter
+        + Member
+        + serde::de::DeserializeOwned
+        + Default
+        + Copy
+        + scale_info::TypeInfo
+        + Into<u64>;
+
+    /// The block number type used by the runtime.
+    type BlockNumber: Parameter
+        + Member
+        + Default
+        + Copy
+        + std::hash::Hash
+        + std::str::FromStr
+        + Into<u64>;
+
+    /// The output of the `Hashing` function.
+    type Hash: Parameter
+        + Member
+        + serde::Serialize
+        + serde::de::DeserializeOwned
+        + Ord
+        + Default
+        + Copy
+        + std::hash::Hash
+        + AsRef<[u8]>
+        + AsMut<[u8]>
+        + scale_info::TypeInfo;
+
+    /// The account ID type.
+    type AccountId: Clone + Serialize;
+
+    /// The address type.
+    type Address: Encode + From<Self::AccountId>;
+
+    /// The signature type.
+    type Signature: Encode;
+
+    /// The hashing system (algorithm) being used in the runtime (e.g. Blake2).
+    type Hasher: Hasher<Output = Self::Hash>;
+
+    /// The block header.
+    type Header: Parameter
+        + Header<Number = Self::BlockNumber, Hasher = Self::Hasher>
+        + Member
+        + serde::de::DeserializeOwned;
+
+    /// This type defines the extrinsic extra and additional parameters.
+    type ExtrinsicParams: extrinsic_params::ExtrinsicParams<Self::Index, Self::Hash>;
+}
+
+/// Parameter trait copied from `substrate::frame_support`.
+pub trait Parameter: Codec + EncodeLike + Clone + Eq + Debug {}
+impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + Debug {}
+
+/// A type that can be used in runtime structures. Copied from `sp_runtime::traits`.
+pub trait Member: Send + Sync + Sized + Debug + Eq + PartialEq + Clone + 'static {}
+impl<T: Send + Sync + Sized + Debug + Eq + PartialEq + Clone + 'static> Member for T {}
+
+/// 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 {
+    /// The block number type for this header.
+    type Number;
+    /// 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)
+    }
+}
+
+/// Take a type implementing [`Config`] (eg [`SubstrateConfig`]), and some type which describes the
+/// additional and extra parameters to pass to an extrinsic (see [`ExtrinsicParams`]),
+/// and returns a type implementing [`Config`] with those new [`ExtrinsicParams`].
+///
+/// # Example
+///
+/// ```
+/// use subxt::config::{ SubstrateConfig, WithExtrinsicParams, polkadot::PolkadotExtrinsicParams };
+///
+/// // This is how PolkadotConfig is implemented:
+/// type PolkadotConfig = WithExtrinsicParams<SubstrateConfig, PolkadotExtrinsicParams<SubstrateConfig>>;
+/// ```
+pub struct WithExtrinsicParams<
+    T: Config,
+    E: extrinsic_params::ExtrinsicParams<T::Index, T::Hash>,
+> {
+    _marker: std::marker::PhantomData<(T, E)>,
+}
+
+impl<T: Config, E: extrinsic_params::ExtrinsicParams<T::Index, T::Hash>> Config
+    for WithExtrinsicParams<T, E>
+{
+    type Index = T::Index;
+    type BlockNumber = T::BlockNumber;
+    type Hash = T::Hash;
+    type AccountId = T::AccountId;
+    type Address = T::Address;
+    type Signature = T::Signature;
+    type Hasher = T::Hasher;
+    type Header = T::Header;
+    type ExtrinsicParams = E;
+}
@@ -0,0 +1,49 @@
+// Copyright 2019-2022 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 codec::Encode;
+
+use super::extrinsic_params::{
+    BaseExtrinsicParams,
+    BaseExtrinsicParamsBuilder,
+};
+
+/// Default set of commonly used types by Polkadot nodes.
+pub type PolkadotConfig = super::WithExtrinsicParams<
+    super::SubstrateConfig,
+    PolkadotExtrinsicParams<super::SubstrateConfig>,
+>;
+
+/// A struct representing the signed extra and additional parameters required
+/// to construct a transaction for a polkadot node.
+pub type PolkadotExtrinsicParams<T> = BaseExtrinsicParams<T, PlainTip>;
+
+/// A builder which leads to [`PolkadotExtrinsicParams`] being constructed.
+/// This is what you provide to methods like `sign_and_submit()`.
+pub type PolkadotExtrinsicParamsBuilder<T> = BaseExtrinsicParamsBuilder<T, PlainTip>;
+
+// Because Era is one of the args to our extrinsic params.
+pub use super::extrinsic_params::Era;
+
+/// A tip payment.
+#[derive(Copy, Clone, Debug, Default, Encode)]
+pub struct PlainTip {
+    #[codec(compact)]
+    tip: u128,
+}
+
+impl PlainTip {
+    /// Create a new tip of the amount provided.
+    pub fn new(amount: u128) -> Self {
+        PlainTip { tip: amount }
+    }
+}
+
+impl From<u128> for PlainTip {
+    fn from(n: u128) -> Self {
+        PlainTip::new(n)
+    }
+}
@@ -0,0 +1,294 @@
+// Copyright 2019-2022 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::{
+    extrinsic_params::{
+        BaseExtrinsicParams,
+        BaseExtrinsicParamsBuilder,
+    },
+    Config,
+    Hasher,
+    Header,
+};
+use codec::{
+    Decode,
+    Encode,
+};
+use serde::{
+    Deserialize,
+    Serialize,
+};
+
+pub use crate::utils::{
+    account_id::AccountId32,
+    multi_address::MultiAddress,
+    multi_signature::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 Index = u32;
+    type BlockNumber = u32;
+    type Hash = H256;
+    type AccountId = AccountId32;
+    type Address = MultiAddress<Self::AccountId, u32>;
+    type Signature = MultiSignature;
+    type Hasher = BlakeTwo256;
+    type Header = SubstrateHeader<Self::BlockNumber, BlakeTwo256>;
+    type ExtrinsicParams = SubstrateExtrinsicParams<Self>;
+}
+
+/// A struct representing the signed extra and additional parameters required
+/// to construct a transaction for the default substrate node.
+pub type SubstrateExtrinsicParams<T> = BaseExtrinsicParams<T, AssetTip>;
+
+/// A builder which leads to [`SubstrateExtrinsicParams`] being constructed.
+/// This is what you provide to methods like `sign_and_submit()`.
+pub type SubstrateExtrinsicParamsBuilder<T> = BaseExtrinsicParamsBuilder<T, AssetTip>;
+
+// Because Era is one of the args to our extrinsic params.
+pub use super::extrinsic_params::Era;
+
+/// A tip payment made in the form of a specific asset.
+#[derive(Copy, Clone, Debug, Default, Encode)]
+pub struct AssetTip {
+    #[codec(compact)]
+    tip: u128,
+    asset: Option<u32>,
+}
+
+impl AssetTip {
+    /// Create a new tip of the amount provided.
+    pub fn new(amount: u128) -> Self {
+        AssetTip {
+            tip: amount,
+            asset: None,
+        }
+    }
+
+    /// Designate the tip as being of a particular asset class.
+    /// If this is not set, then the native currency is used.
+    pub fn of_asset(mut self, asset: u32) -> Self {
+        self.asset = Some(asset);
+        self
+    }
+}
+
+impl From<u128> for AssetTip {
+    fn from(n: u128) -> Self {
+        AssetTip::new(n)
+    }
+}
+
+/// 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_core_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: Copy + Into<U256> + TryFrom<U256> + Encode, H: Hasher + Encode> Header
+    for SubstrateHeader<N, H>
+where
+    N: Copy + Into<U256> + TryFrom<U256> + Encode,
+    H: Hasher + Encode,
+    SubstrateHeader<N, H>: Encode,
+{
+    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> + TryFrom<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: Copy + Into<U256> + TryFrom<U256>>(
+    d: D,
+) -> Result<T, D::Error>
+where
+    D: serde::Deserializer<'a>,
+{
+    let u256: U256 = serde::Deserialize::deserialize(d)?;
+    TryFrom::try_from(u256).map_err(|_| serde::de::Error::custom("Try from failed"))
+}