Struct BlockLogHeader 

pub struct BlockLogHeader {
    pub batch_seq: u64,
    pub prev_block_hash: [u8; 32],
    pub commands_hash: [u8; 32],
    pub batch_root: [u8; 32],
    pub command_count: u64,
    pub first_seq: u64,
    pub timestamp: u64,
    pub signer: [u8; 20],
    pub signature: Vec<u8>,
}

Serializable signed block header stored in the WAL block log.

The header commits to an ordered batch of engine commands through commands_hash, and to the previous block through prev_block_hash. The signature is stored next to the signed fields, but is intentionally excluded from block_hash().

Fields

batch_seq: u64

Monotonic block number, starting at zero.

prev_block_hash: [u8; 32]

Hash of the previous block header. Zero for the genesis block.

commands_hash: [u8; 32]

keccak256(cmd1_identity_hash || cmd2_identity_hash || ...).

batch_root: [u8; 32]

Composite commitment root for state, risk, command, obligation, and intent roots.

command_count: u64

Number of commands committed by this block.

first_seq: u64

Global command sequence number of the first command in this block.

timestamp: u64

Timestamp in milliseconds when the block was finalized.

signer: [u8; 20]

Public address of the signer encoded as raw EVM address bytes.

signature: Vec<u8>

Signature bytes over block_hash(). Empty means unsigned.

Implementations

impl BlockLogHeader

pub fn unsigned_from_identity_hashes( batch_seq: u64, prev_block_hash: [u8; 32], identity_hashes: &[[u8; 32]], batch_root: [u8; 32], first_seq: u64, timestamp: u64, signer: [u8; 20], ) -> Self

Build an unsigned block-log header from ordered command identity hashes.

This is intentionally pure. Callers provide sequencing, timestamp, signer identity, and batch root. The function derives only the command commitment and command count.

pub fn block_hash(&self) -> [u8; 32]

Compute the block hash over the signed fields. The signature is excluded.

pub fn validator_rsm_metadata_hash(&self, directive_hash: [u8; 32]) -> [u8; 32]

Compute the Solidity ValidatorRsm.blockHash(metadata) value for this header.

This is intentionally distinct from block_hash(). The WAL block hash signs local log metadata, including timestamp and signer, while ValidatorRsm commits to the on-chain directive hash instead.

Trait Implementations

impl Clone for BlockLogHeader

fn clone(&self) -> BlockLogHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockLogHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlockLogHeader

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BlockLogHeader

fn eq(&self, other: &BlockLogHeader) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BlockLogHeader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BlockLogHeader

impl StructuralPartialEq for BlockLogHeader