Module execution 

Execution layer specific types for .era1 files

Contains implementations for compressed execution layer data structures:

• CompressedHeader - Block header
• CompressedBody - Block body
• CompressedReceipts - Block receipts
• TotalDifficulty - Block total difficulty

These types use Snappy compression to match the specification.

See also https://github.com/eth-clients/e2store-format-specs/blob/main/formats/era1.md

Examples

CompressedHeader

use alloy_consensus::Header;
use reth_era::{common::decode::DecodeCompressedRlp, era1::types::execution::CompressedHeader};

let header = Header { number: 100, ..Default::default() };
// Compress the header: rlp encoding and Snappy compression
let compressed = CompressedHeader::from_header(&header)?;
// Decompressed and decode typed compressed header
let decoded_header: Header = compressed.decode_header()?;
assert_eq!(decoded_header.number, 100);

CompressedBody

use alloy_consensus::{BlockBody, Header};
use alloy_primitives::Bytes;
use reth_era::{common::decode::DecodeCompressedRlp, era1::types::execution::CompressedBody};
use reth_ethereum_primitives::TransactionSigned;

let body: BlockBody<Bytes> = BlockBody {
    transactions: vec![Bytes::from(vec![1, 2, 3])],
    ommers: vec![],
    withdrawals: None,
};
// Compress the body: rlp encoding and snappy compression
let compressed_body = CompressedBody::from_body(&body)?;
// Decode back to typed body by decompressing and decoding
let decoded_body: alloy_consensus::BlockBody<alloy_primitives::Bytes> =
    compressed_body.decode()?;
assert_eq!(decoded_body.transactions.len(), 1);

CompressedReceipts

use alloy_consensus::{Eip658Value, Receipt, ReceiptEnvelope, ReceiptWithBloom};
use reth_era::{
    common::decode::DecodeCompressedRlp, era1::types::execution::CompressedReceipts,
};

let receipt =
    Receipt { status: Eip658Value::Eip658(true), cumulative_gas_used: 21000, logs: vec![] };
let receipt_with_bloom = ReceiptWithBloom::new(receipt, Default::default());
let enveloped_receipt = ReceiptEnvelope::Legacy(receipt_with_bloom);
// Compress the receipt: rlp encoding and snappy compression
let compressed_receipt_data = CompressedReceipts::from_encodable(&enveloped_receipt)?;
// Get raw receipt by decoding and decompressing compressed and encoded receipt
let decompressed_receipt = compressed_receipt_data.decode::<ReceiptEnvelope>()?;
assert_eq!(decompressed_receipt.cumulative_gas_used(), 21000);

Structs

Accumulator

Accumulator is computed by constructing an SSZ list of header-records and calculating the hash_tree_root

BlockTuple

A block tuple in an Era1 file, containing all components for a single block

CompressedBody

Compressed block body using snappyFramed(rlp(body))

CompressedHeader

Compressed block header using snappyFramed(rlp(header))

CompressedReceipts

Compressed receipts using snappyFramed(rlp(receipts))

SnappyRlpCodec

Generic codec for Snappy-compressed RLP data

TotalDifficulty

Total difficulty for a block

Constants

ACCUMULATOR

Accumulator record type

COMPRESSED_BODY

CompressedBody record type

COMPRESSED_HEADER

CompressedHeader record type

COMPRESSED_RECEIPTS

CompressedReceipts record type

MAX_BLOCKS_PER_ERA1

Maximum number of blocks in an Era1 file, limited by accumulator size

TOTAL_DIFFICULTY

TotalDifficulty record type