signet-test-utils 0.9.0

Common utilities for testing Signet components
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::{chain::Chain, specs::HostBlockSpec};
use alloy::consensus::BlobTransactionSidecar;
use signet_types::primitives::TransactionSigned;
use std::{collections::BTreeMap, sync::Arc};

/// A shim for reth_exex::ExExNotification that allows us to use it in tests.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExExNotification {
    /// Chain got committed without a reorg, and only the new chain is returned.
    Committed {
        /// The new chain after commit.
        new: Arc<Chain>,
    },
    /// Chain got reorged, and both the old and the new chains are returned.
    Reorged {
        /// The old chain before reorg.
        old: Arc<Chain>,
        /// The new chain after reorg.
        new: Arc<Chain>,
    },
    /// Chain got reverted, and only the old chain is returned.
    Reverted {
        /// The old chain before reversion.
        old: Arc<Chain>,
    },
}

/// A notification spec.
#[derive(Debug, Default)]
pub struct NotificationSpec {
    /// The old blocks.
    pub old: Vec<HostBlockSpec>,
    /// The new blocks.
    pub new: Vec<HostBlockSpec>,
}

impl NotificationSpec {
    /// Make a new notification spec from a single block
    pub fn commit_single_block(block: HostBlockSpec) -> Self {
        Self { old: vec![], new: vec![block] }
    }

    /// Make a new notification spec from a single block
    pub fn revert_single_block(block: HostBlockSpec) -> Self {
        Self { old: vec![block], new: vec![] }
    }

    /// Commit a block to the spec.
    pub fn commit(mut self, block: HostBlockSpec) -> Self {
        self.new.push(block);
        self
    }

    /// Add a block to revert to the spec.
    pub fn revert(mut self, block: HostBlockSpec) -> Self {
        self.old.push(block);
        self
    }

    /// Convert to an exex notification.
    pub fn to_exex_notification(&self) -> NotificationWithSidecars {
        let mut sidecars = BTreeMap::new();

        // we do not accumulate sidecars for the old chain.
        let old_chain = if !self.old.is_empty() {
            let num = self.old[0].block_number();
            let (mut chain, _sidecar) = self.old[0].to_chain();

            // we enumerate to ensure they're in block number order
            for (i, block) in self.old.iter().enumerate().skip(1) {
                block.set_block_number(num + i as u64);
                chain.append_block(block.recovered_block(), block.execution_outcome());
            }
            Some(chain)
        } else {
            None
        };

        let new_chain = if !self.new.is_empty() {
            let num = self.new[0].block_number();
            let (mut chain, sidecar) = self.new[0].to_chain();
            // accumulate sidecar if necessary
            if let Some(sidecar) = sidecar {
                let tx = self.new[0].sealed_block().body.transactions().last().unwrap().clone();
                sidecars.insert(num, (sidecar, tx));
            }

            // we enumerate to ensure they're in block number order
            for (i, block) in self.new.iter().enumerate().skip(1) {
                block.set_block_number(num + i as u64);

                let execution_outcome = block.execution_outcome();

                // accumualate the sidecar here if necessary
                if let Some(sidecar) = block.sidecar.clone() {
                    let tx = block.sealed_block().body.transactions().last().unwrap().clone();
                    sidecars.insert(block.block_number(), (sidecar, tx));
                }

                chain.append_block(block.recovered_block(), execution_outcome)
            }

            Some(chain)
        } else {
            None
        };

        match (old_chain, new_chain) {
            (Some(old_chain), Some(new_chain)) => NotificationWithSidecars {
                notification: ExExNotification::Reorged {
                    old: Arc::new(old_chain),
                    new: Arc::new(new_chain),
                },
                sidecars,
            },
            (Some(old_chain), None) => NotificationWithSidecars {
                notification: ExExNotification::Reverted { old: Arc::new(old_chain) },
                sidecars,
            },
            (None, Some(new_chain)) => NotificationWithSidecars {
                notification: ExExNotification::Committed { new: Arc::new(new_chain) },
                sidecars,
            },
            (None, None) => panic!("missing old and new chains"),
        }
    }
}

/// A notification with sidecars associated with the new chain.
#[derive(Debug, Clone)]
pub struct NotificationWithSidecars {
    /// The notification.
    pub notification: ExExNotification,
    /// Sidecars associated with the new chain.
    pub sidecars: BTreeMap<u64, (BlobTransactionSidecar, TransactionSigned)>,
}

impl NotificationWithSidecars {
    /// Make a new notification from a single block
    pub fn commit_single_block(block: HostBlockSpec) -> Self {
        NotificationSpec::commit_single_block(block).to_exex_notification()
    }

    /// Make a new notification from a single block
    pub fn revert_single_block(block: HostBlockSpec) -> Self {
        NotificationSpec::revert_single_block(block).to_exex_notification()
    }
}