signet-journal 0.16.2

Utilities for working with trevm journals in the Signet chain.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::HostJournal;
use alloy::{consensus::Header, primitives::B256};
use trevm::journal::{JournalDecode, JournalDecodeError, JournalEncode};

/// Journal versions.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Journal<'a> {
    /// Version 1
    V1(HostJournal<'a>),
}

impl<'a> Journal<'a> {
    /// Get the host height.
    pub const fn host_height(&self) -> u64 {
        match self {
            Journal::V1(journal) => journal.host_height(),
        }
    }

    /// Get the previous journal hash.
    pub const fn prev_journal_hash(&self) -> B256 {
        match self {
            Journal::V1(journal) => journal.prev_journal_hash(),
        }
    }

    /// Get the rollup block header.
    pub fn header(&self) -> &Header {
        match self {
            Journal::V1(journal) => journal.header(),
        }
    }

    /// Get a reference to the host journal.
    pub const fn journal(&self) -> &HostJournal<'a> {
        match self {
            Journal::V1(journal) => journal,
        }
    }

    /// Get the journal hash.
    pub fn journal_hash(&self) -> B256 {
        match self {
            Journal::V1(journal) => journal.journal_hash(),
        }
    }

    /// Get the rollup height.
    pub fn rollup_height(&self) -> u64 {
        match self {
            Journal::V1(journal) => journal.rollup_height(),
        }
    }
}

impl JournalEncode for Journal<'_> {
    fn serialized_size(&self) -> usize {
        // 1 byte for the version
        1 + match self {
            Journal::V1(journal) => journal.serialized_size(),
        }
    }

    fn encode(&self, buf: &mut dyn alloy::rlp::BufMut) {
        match self {
            Journal::V1(journal) => {
                1u8.encode(buf);
                journal.encode(buf)
            }
        }
    }
}

impl JournalDecode for Journal<'static> {
    fn decode(buf: &mut &[u8]) -> Result<Self, JournalDecodeError> {
        let version: u8 = JournalDecode::decode(buf)?;
        match version {
            1 => JournalDecode::decode(buf).map(Journal::V1),
            _ => Err(JournalDecodeError::InvalidTag {
                ty_name: "Journal",
                tag: version,
                max_expected: 1,
            }),
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::{host::test::make_state_diff, JournalMeta};
    use std::borrow::Cow;

    #[test]
    fn roundtrip() {
        let journal = Journal::V1(HostJournal::new(
            JournalMeta::new(42, B256::repeat_byte(0x17), Cow::Owned(Header::default())),
            make_state_diff(),
        ));
        let mut buf = Vec::new();
        journal.encode(&mut buf);
        let decoded = Journal::decode(&mut &buf[..]).unwrap();
        assert_eq!(journal, decoded);
    }
}