espresso_node/persistence/
no_storage.rs

1//! Mock implementation of persistence, for testing.
2use std::{collections::BTreeMap, sync::Arc};
3
4use anyhow::bail;
5use async_trait::async_trait;
6use espresso_types::{
7    AuthenticatedValidatorMap, Leaf2, NetworkConfig, PubKey, RegisteredValidatorMap,
8    StakeTableHash,
9    traits::{EventsPersistenceRead, MembershipPersistence, StakeTuple},
10    v0::traits::{EventConsumer, PersistenceOptions, SequencerPersistence},
11    v0_3::{EventKey, IndexedStake, RegisteredValidator, RewardAmount, StakeTableEvent},
12};
13use hotshot::InitializerEpochInfo;
14use hotshot_libp2p_networking::network::behaviours::dht::store::persistent::{
15    DhtPersistentStorage, SerializableRecord,
16};
17use hotshot_types::{
18    data::{
19        DaProposal, DaProposal2, EpochNumber, QuorumProposalWrapper, VidCommitment,
20        VidDisperseShare,
21    },
22    drb::{DrbInput, DrbResult},
23    event::{Event, EventType, HotShotAction, LeafInfo},
24    message::Proposal,
25    new_protocol::CoordinatorEvent,
26    simple_certificate::{
27        CertificatePair, LightClientStateUpdateCertificateV2, NextEpochQuorumCertificate2,
28        QuorumCertificate2, UpgradeCertificate,
29    },
30    traits::metrics::Metrics,
31    vote::HasViewNumber,
32};
33
34use crate::{NodeType, SeqTypes, ViewNumber};
35
36#[derive(Clone, Copy, Debug)]
37pub struct Options;
38
39#[async_trait]
40impl PersistenceOptions for Options {
41    type Persistence = NoStorage;
42
43    fn set_view_retention(&mut self, _: u64) {}
44
45    async fn create(&mut self) -> anyhow::Result<Self::Persistence> {
46        Ok(NoStorage)
47    }
48
49    async fn reset(self) -> anyhow::Result<()> {
50        Ok(())
51    }
52}
53
54#[derive(Clone, Copy, Debug)]
55pub struct NoStorage;
56
57#[async_trait]
58impl SequencerPersistence for NoStorage {
59    async fn load_config(&self) -> anyhow::Result<Option<NetworkConfig>> {
60        Ok(None)
61    }
62
63    async fn save_config(&self, _: &NetworkConfig) -> anyhow::Result<()> {
64        Ok(())
65    }
66
67    async fn persist_decided_leaves(
68        &self,
69        view_number: ViewNumber,
70        leaves: impl IntoIterator<Item = (&LeafInfo<SeqTypes>, CertificatePair<SeqTypes>)> + Send,
71        deciding_qc: Option<Arc<CertificatePair<SeqTypes>>>,
72        consumer: &(impl EventConsumer + 'static),
73    ) -> anyhow::Result<()> {
74        let leaves = leaves
75            .into_iter()
76            .map(|(info_ref, qc)| (info_ref.clone(), qc))
77            .collect::<Vec<_>>();
78        for (leaf_info, qc) in leaves {
79            // Insert the deciding QC at the appropriate position, with the last decide event in the
80            // chain.
81            let deciding_qc = if let Some(deciding_qc) = &deciding_qc {
82                (deciding_qc.view_number() == qc.view_number() + 1).then_some(deciding_qc.clone())
83            } else {
84                None
85            };
86
87            consumer
88                .handle_event(&CoordinatorEvent::LegacyEvent(Event {
89                    view_number,
90                    event: EventType::Decide {
91                        leaf_chain: Arc::new(vec![leaf_info.clone()]),
92                        committing_qc: Arc::new(qc),
93                        deciding_qc,
94                        block_size: None,
95                    },
96                }))
97                .await?;
98        }
99        Ok(())
100    }
101
102    async fn load_latest_acted_view(&self) -> anyhow::Result<Option<ViewNumber>> {
103        Ok(None)
104    }
105
106    async fn load_restart_view(&self) -> anyhow::Result<Option<ViewNumber>> {
107        Ok(None)
108    }
109
110    async fn load_anchor_leaf(&self) -> anyhow::Result<Option<(Leaf2, CertificatePair<SeqTypes>)>> {
111        Ok(None)
112    }
113
114    async fn load_da_proposal(
115        &self,
116        _view: ViewNumber,
117    ) -> anyhow::Result<Option<Proposal<SeqTypes, DaProposal2<SeqTypes>>>> {
118        Ok(None)
119    }
120
121    async fn load_vid_share(
122        &self,
123        _view: ViewNumber,
124    ) -> anyhow::Result<Option<Proposal<SeqTypes, VidDisperseShare<SeqTypes>>>> {
125        Ok(None)
126    }
127
128    async fn load_quorum_proposals(
129        &self,
130    ) -> anyhow::Result<BTreeMap<ViewNumber, Proposal<SeqTypes, QuorumProposalWrapper<SeqTypes>>>>
131    {
132        Ok(Default::default())
133    }
134    async fn load_quorum_proposal(
135        &self,
136        view: ViewNumber,
137    ) -> anyhow::Result<Proposal<SeqTypes, QuorumProposalWrapper<SeqTypes>>> {
138        bail!("proposal {view:?} not available");
139    }
140    async fn load_upgrade_certificate(
141        &self,
142    ) -> anyhow::Result<Option<UpgradeCertificate<SeqTypes>>> {
143        Ok(None)
144    }
145
146    async fn append_vid(
147        &self,
148        _proposal: &Proposal<SeqTypes, VidDisperseShare<SeqTypes>>,
149    ) -> anyhow::Result<()> {
150        Ok(())
151    }
152    async fn append_da(
153        &self,
154        _proposal: &Proposal<SeqTypes, DaProposal<SeqTypes>>,
155        _vid_commit: VidCommitment,
156    ) -> anyhow::Result<()> {
157        Ok(())
158    }
159    async fn record_action(
160        &self,
161        _view: ViewNumber,
162        _epoch: Option<EpochNumber>,
163        _action: HotShotAction,
164    ) -> anyhow::Result<()> {
165        Ok(())
166    }
167    async fn append_quorum_proposal2(
168        &self,
169        _proposal: &Proposal<SeqTypes, QuorumProposalWrapper<SeqTypes>>,
170    ) -> anyhow::Result<()> {
171        Ok(())
172    }
173    async fn store_upgrade_certificate(
174        &self,
175        _decided_upgrade_certificate: Option<UpgradeCertificate<SeqTypes>>,
176    ) -> anyhow::Result<()> {
177        Ok(())
178    }
179
180    async fn store_next_epoch_quorum_certificate(
181        &self,
182        _high_qc: NextEpochQuorumCertificate2<SeqTypes>,
183    ) -> anyhow::Result<()> {
184        Ok(())
185    }
186
187    async fn load_next_epoch_quorum_certificate(
188        &self,
189    ) -> anyhow::Result<Option<NextEpochQuorumCertificate2<SeqTypes>>> {
190        Ok(None)
191    }
192
193    async fn store_eqc(
194        &self,
195        _high_qc: QuorumCertificate2<SeqTypes>,
196        _next_epoch_high_qc: NextEpochQuorumCertificate2<SeqTypes>,
197    ) -> anyhow::Result<()> {
198        Ok(())
199    }
200
201    async fn load_eqc(
202        &self,
203    ) -> Option<(
204        QuorumCertificate2<SeqTypes>,
205        NextEpochQuorumCertificate2<SeqTypes>,
206    )> {
207        None
208    }
209
210    async fn append_da2(
211        &self,
212        _proposal: &Proposal<SeqTypes, DaProposal2<SeqTypes>>,
213        _vid_commit: VidCommitment,
214    ) -> anyhow::Result<()> {
215        Ok(())
216    }
217
218    async fn append_proposal2(
219        &self,
220        _proposal: &Proposal<SeqTypes, QuorumProposalWrapper<SeqTypes>>,
221    ) -> anyhow::Result<()> {
222        Ok(())
223    }
224
225    async fn migrate_anchor_leaf(&self) -> anyhow::Result<()> {
226        Ok(())
227    }
228
229    async fn migrate_da_proposals(&self) -> anyhow::Result<()> {
230        Ok(())
231    }
232
233    async fn migrate_vid_shares(&self) -> anyhow::Result<()> {
234        Ok(())
235    }
236
237    async fn migrate_quorum_proposals(&self) -> anyhow::Result<()> {
238        Ok(())
239    }
240
241    async fn migrate_quorum_certificates(&self) -> anyhow::Result<()> {
242        Ok(())
243    }
244
245    async fn migrate_x25519_keys(&self) -> anyhow::Result<()> {
246        Ok(())
247    }
248
249    async fn store_drb_result(
250        &self,
251        _epoch: EpochNumber,
252        _drb_result: DrbResult,
253    ) -> anyhow::Result<()> {
254        Ok(())
255    }
256
257    async fn store_drb_input(&self, _drb_input: DrbInput) -> anyhow::Result<()> {
258        Ok(())
259    }
260    async fn load_drb_input(&self, _epoch: u64) -> anyhow::Result<DrbInput> {
261        bail!("Cannot load from NoStorage")
262    }
263
264    async fn store_epoch_root(
265        &self,
266        _epoch: EpochNumber,
267        _block_header: <SeqTypes as NodeType>::BlockHeader,
268    ) -> anyhow::Result<()> {
269        Ok(())
270    }
271
272    async fn load_start_epoch_info(&self) -> anyhow::Result<Vec<InitializerEpochInfo<SeqTypes>>> {
273        Ok(Vec::new())
274    }
275
276    async fn add_state_cert(
277        &self,
278        _state_cert: LightClientStateUpdateCertificateV2<SeqTypes>,
279    ) -> anyhow::Result<()> {
280        Ok(())
281    }
282
283    async fn load_state_cert(
284        &self,
285    ) -> anyhow::Result<Option<LightClientStateUpdateCertificateV2<SeqTypes>>> {
286        Ok(None)
287    }
288
289    async fn get_state_cert_by_epoch(
290        &self,
291        _epoch: u64,
292    ) -> anyhow::Result<Option<LightClientStateUpdateCertificateV2<SeqTypes>>> {
293        Ok(None)
294    }
295
296    async fn insert_state_cert(
297        &self,
298        _epoch: u64,
299        _cert: LightClientStateUpdateCertificateV2<SeqTypes>,
300    ) -> anyhow::Result<()> {
301        Ok(())
302    }
303
304    fn enable_metrics(&mut self, _metrics: &dyn Metrics) {}
305}
306
307#[async_trait]
308impl MembershipPersistence for NoStorage {
309    async fn load_stake(&self, _epoch: EpochNumber) -> anyhow::Result<Option<StakeTuple>> {
310        Ok(None)
311    }
312
313    async fn load_latest_stake(&self, _limit: u64) -> anyhow::Result<Option<Vec<IndexedStake>>> {
314        Ok(None)
315    }
316
317    async fn store_stake(
318        &self,
319        _epoch: EpochNumber,
320        _stake: AuthenticatedValidatorMap,
321        _block_reward: Option<RewardAmount>,
322        _stake_table_hash: Option<StakeTableHash>,
323    ) -> anyhow::Result<()> {
324        Ok(())
325    }
326
327    async fn store_events(
328        &self,
329        _l1: u64,
330        _events: Vec<(EventKey, StakeTableEvent)>,
331    ) -> anyhow::Result<()> {
332        Ok(())
333    }
334    async fn load_events(
335        &self,
336        _from_l1_block: u64,
337        _l1_block: u64,
338    ) -> anyhow::Result<(
339        Option<EventsPersistenceRead>,
340        Vec<(EventKey, StakeTableEvent)>,
341    )> {
342        Ok((None, Vec::new()))
343    }
344
345    async fn delete_stake_tables(&self) -> anyhow::Result<()> {
346        Ok(())
347    }
348
349    async fn store_all_validators(
350        &self,
351        _epoch: EpochNumber,
352        _all_validators: RegisteredValidatorMap,
353    ) -> anyhow::Result<()> {
354        Ok(())
355    }
356
357    async fn load_all_validators(
358        &self,
359        _epoch: EpochNumber,
360        _offset: u64,
361        _limit: u64,
362    ) -> anyhow::Result<Vec<RegisteredValidator<PubKey>>> {
363        Ok(Default::default())
364    }
365}
366
367#[async_trait]
368impl DhtPersistentStorage for NoStorage {
369    /// Don't do anything
370    async fn save(&self, _records: Vec<SerializableRecord>) -> anyhow::Result<()> {
371        Ok(())
372    }
373
374    /// Don't do anything
375    async fn load(&self) -> anyhow::Result<Vec<SerializableRecord>> {
376        Ok(vec![])
377    }
378}
espresso_node/persistence/no_storage.rs

espresso_node/persistence/
no_storage.rs
