Struct ExecutionVerifier

pub struct ExecutionVerifier;

Verifier for EVM execution layer proofs

Provides methods to verify execution headers, account states, and transactions against trusted MMR roots and header state roots. All verifications are cryptographically sound and establish trust through the STWO proof → MMR proof → Merkle proof chain.

Implementations

impl ExecutionVerifier

pub fn verify_header_proof( proof: &ExecutionHeaderProof, root: FixedBytes<32>, ) -> Result<ExecutionHeader, VerifyError>

Verifies an execution layer header using an MMR inclusion proof

This method establishes trust in an execution header by:

1. Verifying the MMR root matches the expected root from the STWO proof
2. Verifying the MMR inclusion proof
3. Verifying the header hash matches the value committed in the MMR

Once verified, the header can be trusted and used to verify accounts and transactions.

Arguments

• proof - The execution header proof containing the header and MMR inclusion proof
• root - The trusted MMR root from the verified STWO proof

Returns

Returns the verified ExecutionHeader containing all block data (number, timestamp, state root, transactions root, etc.)

Errors

Returns an error if:

• InvalidMmrRoot: The MMR root in the proof doesn’t match the expected root
• InvalidMmrProof: The MMR inclusion proof is invalid
• InvalidHeaderHash: The header hash doesn’t match the MMR commitment

Example

use bankai_verify::evm::ExecutionVerifier;
use bankai_types::fetch::evm::execution::ExecutionHeaderProof;
use alloy_primitives::FixedBytes;

let verified_header = ExecutionVerifier::verify_header_proof(&proof, mmr_root)?;
println!("Verified block {}", verified_header.number);
println!("State root: {:?}", verified_header.state_root);

pub fn verify_account_proof( account_proof: &AccountProof, headers: &[ExecutionHeader], ) -> Result<Account, VerifyError>

Verifies an account’s state using a Merkle Patricia Trie proof

This method verifies an account’s state (balance, nonce, code hash, storage root) against a previously verified execution header. The verification uses a Merkle Patricia Trie proof to establish that the account state is included in the header’s state root.

Arguments

• account_proof - The account proof containing the account state and MPT proof
• headers - List of previously verified execution headers. Must contain the header for the block number referenced in the account proof

Returns

Returns the verified Account containing:

• Balance (in wei)
• Nonce (transaction count)
• Code hash (contract code hash, or empty for EOAs)
• Storage root (Merkle root of contract storage)

Errors

Returns an error if:

• InvalidExecutionHeaderProof: The referenced header is not in the verified headers list
• InvalidStateRoot: The state root in the proof doesn’t match the header’s state root
• InvalidAccountProof: The MPT proof verification failed

Example

use bankai_verify::evm::ExecutionVerifier;
use bankai_types::fetch::evm::execution::AccountProof;
use bankai_types::verify::evm::execution::ExecutionHeader;

let account = ExecutionVerifier::verify_account_proof(&account_proof, &verified_headers)?;
println!("Account balance: {} wei", account.balance);
println!("Account nonce: {}", account.nonce);

pub fn verify_storage_slot_proof( slot_proof: &StorageSlotProof, headers: &[ExecutionHeader], ) -> Result<Vec<(U256, U256)>, VerifyError>

Verifies one or more storage slots from the same contract using Merkle Patricia Trie proofs.

This method establishes that storage slot values are committed in the state of a given block by:

1. Verifying the contract account is included in the block’s state trie (against the verified header’s state_root)
2. Verifying each storage slot is included in the contract’s storage trie (against the account’s storage_root)

Arguments

• slot_proof - The storage slot proof containing the account proof and individual storage slot proofs
• headers - List of previously verified execution headers. Must contain the header for the block number referenced in the storage slot proof

Returns

Returns a vector of verified (slot_key, slot_value) pairs in the same order as the input.

Errors

Returns an error if:

• InvalidExecutionHeaderProof: The referenced header is not in the verified headers list
• InvalidStateRoot: The state root in the proof doesn’t match the header’s state root
• InvalidAccountProof: The account MPT proof verification failed
• InvalidStorageProof: Any storage slot MPT proof verification failed

Example

use bankai_verify::evm::ExecutionVerifier;
use bankai_types::fetch::evm::execution::StorageSlotProof;
use bankai_types::verify::evm::execution::ExecutionHeader;

let values = ExecutionVerifier::verify_storage_slot_proof(&slot_proof, &verified_headers)?;
for (key, value) in values {
    println!("Slot {:?} = {}", key, value);
}

fn verify_storage_slot_entry( storage_root: FixedBytes<32>, slot_key: U256, slot_value: U256, storage_mpt_proof: &[Bytes], ) -> Result<(), VerifyError>

Internal helper to verify a single storage slot entry against a storage root

pub fn verify_tx_proof( proof: &TxProof, headers: &[ExecutionHeader], ) -> Result<TxEnvelope, VerifyError>

Verifies a transaction using a Merkle Patricia Trie proof

This method verifies that a transaction was included in a specific block by validating an MPT proof against a previously verified execution header. The proof establishes that the transaction exists at a specific index in the block’s transaction list.

Arguments

• proof - The transaction proof containing the encoded transaction and MPT proof
• headers - List of previously verified execution headers. Must contain the header for the block number referenced in the transaction proof

Returns

Returns the verified TxEnvelope containing the full transaction data including:

• Transaction type (Legacy, EIP-1559, EIP-2930, etc.)
• From/to addresses
• Value transferred
• Gas limit and gas price
• Input data
• Signature (v, r, s)

Errors

Returns an error if:

• InvalidExecutionHeaderProof: The referenced header is not in the verified headers list
• InvalidTxProof: The MPT proof verification failed
• InvalidRlpDecode: The transaction data could not be decoded

Example

use bankai_verify::evm::ExecutionVerifier;
use bankai_types::fetch::evm::execution::TxProof;
use bankai_types::verify::evm::execution::ExecutionHeader;

let tx = ExecutionVerifier::verify_tx_proof(&tx_proof, &verified_headers)?;
println!("Verified transaction in block {}", tx_proof.block_number);