feat: more journal

Author: prestwich

src/journal/coder.rs

@@ -1,5 +1,6 @@
 use crate::journal::{AcctDiff, BundleStateIndex, InfoOutcome};
 use alloy::{
+    consensus::Header,
     primitives::{Address, Bytes, B256, U256},
     rlp::{Buf, BufMut},
 };
@@ -69,6 +70,9 @@ pub enum JournalDecodeError {
 
     /// Error decoding an EIP-7702 bytecode.
     Eip7702Decode(Eip7702DecodeError),
+
+    /// RLP decoding error.
+    Rlp(alloy::rlp::Error),
 }
 
 impl core::fmt::Display for JournalDecodeError {
@@ -89,6 +93,9 @@ impl core::fmt::Display for JournalDecodeError {
             Self::Eip7702Decode(e) => {
                 write!(f, "error decoding EIP-7702 bytecode: {e}")
             }
+            Self::Rlp(e) => {
+                write!(f, "error decoding RLP: {e}")
+            }
         }
     }
 }
@@ -97,6 +104,7 @@ impl core::error::Error for JournalDecodeError {
     fn cause(&self) -> Option<&dyn core::error::Error> {
         match self {
             Self::Eip7702Decode(e) => Some(e),
+            Self::Rlp(e) => Some(e),
             _ => None,
         }
     }
@@ -108,6 +116,7 @@ impl core::error::Error for JournalDecodeError {
     fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
         match self {
             Self::Eip7702Decode(e) => Some(e),
+            Self::Rlp(e) => Some(e),
             _ => None,
         }
     }
@@ -119,6 +128,12 @@ impl From<Eip7702DecodeError> for JournalDecodeError {
     }
 }
 
+impl From<alloy::rlp::Error> for JournalDecodeError {
+    fn from(err: alloy::rlp::Error) -> Self {
+        Self::Rlp(err)
+    }
+}
+
 macro_rules! check_len {
     ($buf:ident, $ty_name:literal, $len:expr) => {
         let rem = $buf.remaining();
@@ -601,6 +616,24 @@ impl JournalDecode for BundleState {
     }
 }
 
+impl JournalEncode for Header {
+    fn serialized_size(&self) -> usize {
+        // Assuming the header is encoded in a way that is compatible with RLP
+        alloy::rlp::Encodable::length(&self)
+    }
+
+    fn encode(&self, buf: &mut dyn BufMut) {
+        // Assuming the header is encoded in a way that is compatible with RLP
+        alloy::rlp::Encodable::encode(self, buf);
+    }
+}
+
+impl JournalDecode for Header {
+    fn decode(buf: &mut &[u8]) -> Result<Self> {
+        alloy::rlp::Decodable::decode(buf).map_err(Into::into)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

src/journal/mod.rs

@@ -56,3 +56,6 @@ pub use coder::{JournalDecode, JournalDecodeError, JournalEncode};
 
 mod index;
 pub use index::{AcctDiff, BundleStateIndex, InfoOutcome};
+
+mod update;
+pub use update::BlockUpdate;

src/journal/update.rs

@@ -0,0 +1,47 @@
+use crate::journal::{BundleStateIndex, JournalDecode, JournalDecodeError, JournalEncode};
+use alloy::primitives::{keccak256, B256};
+use std::sync::OnceLock;
+
+/// Journal associated with a block
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockUpdate<'a> {
+    /// The height of the block.
+    height: u64,
+
+    /// The previous journal hash.
+    prev_journal_hash: B256,
+
+    /// The indexed changes.
+    journal: BundleStateIndex<'a>,
+
+    /// The serialized journal
+    serialized: OnceLock<Vec<u8>>,
+
+    /// The hash of the serialized journal
+    hash: OnceLock<B256>,
+}
+
+impl JournalEncode for BlockUpdate<'_> {
+    fn serialized_size(&self) -> usize {
+        8 + 32 + self.journal.serialized_size()
+    }
+
+    fn encode(&self, buf: &mut dyn alloy::rlp::BufMut) {
+        self.height.encode(buf);
+        self.prev_journal_hash.encode(buf);
+        self.journal.encode(buf);
+    }
+}
+
+impl JournalDecode for BlockUpdate<'static> {
+    fn decode(buf: &mut &[u8]) -> Result<Self, JournalDecodeError> {
+        let original = *buf;
+        Ok(Self {
+            height: JournalDecode::decode(buf)?,
+            prev_journal_hash: JournalDecode::decode(buf)?,
+            journal: JournalDecode::decode(buf)?,
+            serialized: OnceLock::from(original.to_vec()),
+            hash: OnceLock::from(keccak256(original)),
+        })
+    }
+}