Struct Block 

pub struct Block {
    pub number: u32,
    pub hash: H256,
    pub parent_hash: H256,
    pub header: Vec<u8>,
    pub extrinsics: Vec<Vec<u8>>,
    pub parent: Option<Box<Block>>,
    /* private fields */
}

A block in a forked blockchain.

Represents a single block with its metadata and associated storage state. Blocks can be created as fork points from live chains or as child blocks extending an existing fork.

Storage Model

Each block has an associated LocalStorageLayer that tracks storage modifications. The storage layer uses a layered architecture:

• Local modifications: In-memory changes for the current block
• Committed state: Previously committed blocks stored in SQLite
• Remote state: Original chain state fetched lazily via RPC + cache for faster relaunches.

Cloning

Block is cheap to clone, as LocalStorageLayer is cheap to clone.

Fields

number: u32

The block number (height).

hash: H256

The block hash.

parent_hash: H256

The parent block hash.

header: Vec<u8>

The encoded block header.

extrinsics: Vec<Vec<u8>>

The extrinsics (transactions) in this block.

parent: Option<Box<Block>>

The parent block. Keeping blocks in memory is cheap as the LocalStorageLayer is shared between all fork-produced blocks.

Implementations

impl Block

pub async fn fork_point( endpoint: &Url, cache: StorageCache, block_fork_point: BlockForkPoint, ) -> Result<Self, BlockError>

Create a new block at a fork point from a live chain.

This is the entry point for creating a forked chain. It fetches the block header from the remote chain and sets up a LocalStorageLayer for tracking subsequent modifications.

Arguments

• endpoint - RPC client url.
• cache - Storage cache for persisting fetched and modified values
• block_fork_point - Hash or number of the block to fork from

Returns

A new Block representing the fork point, with an empty extrinsics list (since we’re forking from existing chain state, not producing new blocks).

pub async fn child( &mut self, hash: H256, header: Vec<u8>, extrinsics: Vec<Vec<u8>>, ) -> Result<Self, BlockError>

Create a new child block with the given hash, header, and extrinsics.

This commits the parent’s storage modifications and creates a new block that shares the same storage layer (including metadata versions).

Arguments

• hash - The block hash
• header - The encoded block header
• extrinsics - The extrinsics (transactions) in this block

Note

The child block shares the same storage layer as the parent, including metadata versions. If a runtime upgrade occurred (:code storage changed), the new metadata should be registered via storage.register_metadata_version().

pub fn mocked_for_call( hash: H256, number: u32, storage: LocalStorageLayer, ) -> Self

Create a mocked Block for executing runtime calls on historical blocks.

This block uses the real block hash and number (for correct storage queries) but placeholder values for other fields since the executor only needs storage access. The storage layer delegates to remote for historical data.

Arguments

• hash - The real block hash being queried
• number - The actual block number (needed for correct storage queries)
• storage - Storage layer that delegates to remote for historical data

pub fn storage(&self) -> &LocalStorageLayer

Get a reference to the storage layer.

Use this to read storage values at this block’s height.

Example

let value = block.storage().get(block.number, &key).await?;

pub fn storage_mut(&mut self) -> &mut LocalStorageLayer

Get a mutable reference to the storage layer.

Use this to modify storage values. Modifications are tracked locally and can be committed using LocalStorageLayer::commit.

Example

block.storage_mut().set(&key, Some(&value))?;
block.storage_mut().commit().await?;

pub async fn metadata(&self) -> Result<Arc<Metadata>, BlockError>

Get the runtime metadata for this block.

This provides access to pallet and call indices for dynamic extrinsic encoding. Use this in inherent providers to look up pallet indices instead of relying on hardcoded values.

Returns an Arc<Metadata> which can be used like a reference (via Deref). The metadata is shared across all blocks that use the same runtime version, avoiding unnecessary cloning.

Example

let metadata = block.metadata().await?;
let pallet = metadata.pallet_by_name("Timestamp")?;
let pallet_index = pallet.index();
let call_variant = pallet.call_variant_by_name("set")?;
let call_index = call_variant.index;

pub async fn runtime_code(&self) -> Result<Vec<u8>, BlockError>

Get the runtime code (:code) for this block.

Retrieves the WASM runtime code from the storage layer, which handles the layered lookup (local modifications → cache → remote).

Returns

The runtime WASM code as bytes.

Errors

Returns BlockError::RuntimeCodeNotFound if the :code key is not found in storage.

Example

let runtime_code = block.runtime_code().await?;
let executor = RuntimeExecutor::new(runtime_code)?;

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Block

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.