reth_trie/proof_v2/
value.rs

1//! Generic value encoder types for proof calculation with lazy evaluation.
2
3use alloy_primitives::{B256, U256};
4use alloy_rlp::Encodable;
5use reth_execution_errors::trie::StateProofError;
6
7/// A trait for deferred RLP-encoding of leaf values.
8pub trait DeferredValueEncoder {
9    /// RLP encodes the value into the provided buffer.
10    ///
11    /// # Arguments
12    ///
13    /// * `buf` - A mutable buffer to encode the data into
14    fn encode(self, buf: &mut Vec<u8>) -> Result<(), StateProofError>;
15}
16
17/// A trait for RLP-encoding values for proof calculation. This trait is designed to allow the lazy
18/// computation of leaf values in a generic way.
19///
20/// When calculating a leaf value in a storage trie the [`DeferredValueEncoder`] simply holds onto
21/// the slot value, and the `encode` method synchronously RLP-encodes it.
22///
23/// When calculating a leaf value in the accounts trie we create a [`DeferredValueEncoder`] to
24/// initiate any asynchronous computation of the account's storage root we want to do. Later we call
25/// [`DeferredValueEncoder::encode`] to obtain the result of that computation and RLP-encode it.
26pub trait LeafValueEncoder {
27    /// The type of value being encoded (e.g., U256 for storage, Account for accounts).
28    type Value;
29
30    /// The type that will compute and encode the value when needed.
31    type DeferredEncoder: DeferredValueEncoder;
32
33    /// Returns an encoder that will RLP-encode the value when its `encode` method is called.
34    ///
35    /// # Arguments
36    ///
37    /// * `key` - The key the value was stored at in the DB
38    /// * `value` - The value to encode
39    ///
40    /// The returned deferred encoder will be called as late as possible in the algorithm to
41    /// maximize the time available for parallel computation (e.g., storage root calculation).
42    fn deferred_encoder(&mut self, key: B256, value: Self::Value) -> Self::DeferredEncoder;
43}
44
45/// An encoder for storage slot values.
46///
47/// This encoder simply RLP-encodes U256 storage values directly.
48#[derive(Debug, Clone, Copy, Default)]
49pub struct StorageValueEncoder;
50
51/// The deferred encoder for a storage slot value.
52#[derive(Debug, Clone, Copy)]
53pub struct StorageDeferredValueEncoder(U256);
54
55impl DeferredValueEncoder for StorageDeferredValueEncoder {
56    fn encode(self, buf: &mut Vec<u8>) -> Result<(), StateProofError> {
57        self.0.encode(buf);
58        Ok(())
59    }
60}
61
62impl LeafValueEncoder for StorageValueEncoder {
63    type Value = U256;
64    type DeferredEncoder = StorageDeferredValueEncoder;
65
66    fn deferred_encoder(&mut self, _key: B256, value: Self::Value) -> Self::DeferredEncoder {
67        StorageDeferredValueEncoder(value)
68    }
69}
reth_trie/proof_v2/value.rs

reth_trie/proof_v2/
value.rs
