1use super::{
2 blocks::{InMemoryBlocks, InMemoryBlocksStats},
3 BlockState, ExecutedBlock, NewCanonicalChain,
4};
5use crate::{
6 CanonStateNotification, CanonStateNotificationSender, CanonStateNotifications,
7 ChainInfoHeaders, ChainInfoTracker,
8};
9use alloy_consensus::transaction::TransactionMeta;
10use alloy_eips::BlockNumHash;
11use alloy_primitives::{map::B256Map, BlockNumber, TxHash, B256};
12use parking_lot::RwLock;
13use reth_chainspec::ChainInfo;
14use reth_ethereum_primitives::EthPrimitives;
15use reth_execution_types::RecoveredBlockAndExecutionOutput;
16use reth_metrics::{metrics::Gauge, Metrics};
17use reth_primitives_traits::{
18 BlockBody as _, NodePrimitives, RecoveredBlock, SealedBlock, SealedHeader,
19};
20use std::{
21 collections::BTreeMap,
22 sync::{
23 atomic::{AtomicU64, Ordering},
24 Arc,
25 },
26 time::Instant,
27};
28use tokio::sync::{broadcast, watch};
29
30const CANON_STATE_NOTIFICATION_CHANNEL_SIZE: usize = 256;
32
33#[derive(Metrics)]
35#[metrics(scope = "blockchain_tree.in_mem_state")]
36pub(crate) struct InMemoryStateMetrics {
37 pub(crate) earliest_block: Gauge,
39 pub(crate) latest_block: Gauge,
41 pub(crate) num_blocks: Gauge,
43}
44
45#[derive(Debug, Clone, Default)]
60pub struct InMemoryState<N: NodePrimitives = EthPrimitives> {
61 inner: Arc<InMemoryStateInner<N>>,
62}
63
64impl<N: NodePrimitives> InMemoryState<N> {
65 pub(crate) fn new(
66 blocks: B256Map<Arc<BlockState<N>>>,
67 numbers: BTreeMap<u64, B256>,
68 pending: Option<BlockState<N>>,
69 ) -> Self {
70 let this = Self {
71 inner: Arc::new(InMemoryStateInner {
72 blocks: RwLock::new(InMemoryBlocks::new(blocks, numbers, pending)),
73 removal_generation: Default::default(),
74 metrics: Default::default(),
75 }),
76 };
77 this.update_metrics();
78 this
79 }
80
81 pub(crate) fn update_metrics(&self) {
87 let stats = self.inner.blocks.read().stats();
88 self.record_metrics(stats);
89 }
90
91 fn record_metrics(&self, stats: InMemoryBlocksStats) {
93 let InMemoryBlocksStats { count, earliest, latest } = stats;
94 if let Some(earliest_block_number) = earliest {
95 self.inner.metrics.earliest_block.set(earliest_block_number as f64);
96 }
97 if let Some(latest_block_number) = latest {
98 self.inner.metrics.latest_block.set(latest_block_number as f64);
99 }
100 self.inner.metrics.num_blocks.set(count as f64);
101 }
102
103 pub fn state_by_hash(&self, hash: B256) -> Option<Arc<BlockState<N>>> {
105 self.inner.blocks.read().get(&hash).cloned()
106 }
107
108 pub fn contains(&self, hash: &B256) -> bool {
110 self.inner.blocks.read().contains(hash)
111 }
112
113 pub fn block_counts(&self) -> InMemoryStateBlockCounts {
116 self.inner.blocks.read().counts()
117 }
118
119 pub(crate) fn state_by_number(&self, number: u64) -> Option<Arc<BlockState<N>>> {
121 self.inner.blocks.read().canonical().by_number(number).cloned()
122 }
123
124 pub(crate) fn hash_by_number(&self, number: u64) -> Option<B256> {
126 self.inner.blocks.read().canonical().hash_by_number(number)
127 }
128
129 pub(crate) fn head_state(&self) -> Option<Arc<BlockState<N>>> {
131 self.inner.blocks.read().canonical().head().cloned()
132 }
133
134 pub(crate) fn pending_state(&self) -> Option<Arc<BlockState<N>>> {
137 self.inner.blocks.read().pending_state().cloned()
138 }
139
140 pub fn removal_generation(&self) -> u64 {
145 self.inner.removal_generation.load(Ordering::Relaxed)
146 }
147
148 #[cfg(test)]
149 fn block_count(&self) -> usize {
150 self.inner.blocks.read().canonical().len()
151 }
152
153 fn update<R>(&self, f: impl FnOnce(&mut InMemoryBlocks<N>) -> R) -> R {
159 let (result, stats) = {
160 let mut blocks = self.inner.blocks.write();
161 let removed_count = blocks.removed_count();
162 let result = f(&mut blocks);
163 #[cfg(debug_assertions)]
164 blocks.assert_invariants();
165 if blocks.removed_count() != removed_count {
166 self.inner.removal_generation.fetch_add(1, Ordering::Relaxed);
167 }
168 (result, blocks.stats())
169 };
170 self.record_metrics(stats);
171 result
172 }
173}
174
175#[derive(Debug, Default)]
177struct InMemoryStateInner<N: NodePrimitives> {
178 blocks: RwLock<InMemoryBlocks<N>>,
180 removal_generation: AtomicU64,
182 metrics: InMemoryStateMetrics,
184}
185
186#[derive(Debug, Clone, Copy, PartialEq, Eq)]
188pub struct InMemoryStateBlockCounts {
189 pub canonical: usize,
191 pub non_canonical: usize,
193}
194
195#[derive(Debug)]
198pub(crate) struct CanonicalInMemoryStateInner<N: NodePrimitives> {
199 pub(crate) chain_info_tracker: ChainInfoTracker<N>,
202 pub(crate) in_memory_state: InMemoryState<N>,
204 pub(crate) canon_state_notification_sender: CanonStateNotificationSender<N>,
206}
207
208impl<N: NodePrimitives> CanonicalInMemoryStateInner<N> {
209 fn clear(&self) {
211 self.in_memory_state.update(InMemoryBlocks::clear);
212 }
213}
214
215#[derive(Debug, Clone)]
219pub struct CanonicalInMemoryState<N: NodePrimitives = EthPrimitives> {
220 pub(crate) inner: Arc<CanonicalInMemoryStateInner<N>>,
221}
222
223impl<N: NodePrimitives> CanonicalInMemoryState<N> {
224 pub fn new(
227 blocks: B256Map<Arc<BlockState<N>>>,
228 numbers: BTreeMap<u64, B256>,
229 pending: Option<BlockState<N>>,
230 finalized: Option<SealedHeader<N::BlockHeader>>,
231 safe: Option<SealedHeader<N::BlockHeader>>,
232 ) -> Self {
233 let in_memory_state = InMemoryState::new(blocks, numbers, pending);
234 let header = in_memory_state.head_state().map_or_else(SealedHeader::default, |state| {
235 state.block_ref().recovered_block().clone_sealed_header()
236 });
237 let chain_info_tracker =
238 ChainInfoTracker::new(ChainInfoHeaders { canonical_head: header, safe, finalized });
239 let (canon_state_notification_sender, _) =
240 broadcast::channel(CANON_STATE_NOTIFICATION_CHANNEL_SIZE);
241
242 Self {
243 inner: Arc::new(CanonicalInMemoryStateInner {
244 chain_info_tracker,
245 in_memory_state,
246 canon_state_notification_sender,
247 }),
248 }
249 }
250
251 pub fn empty() -> Self {
253 Self::new(B256Map::default(), BTreeMap::new(), None, None, None)
254 }
255
256 pub fn with_head(
263 chain_info_headers: ChainInfoHeaders<N::BlockHeader>,
264 in_memory_state: InMemoryState<N>,
265 ) -> Self {
266 let chain_info_tracker = ChainInfoTracker::new(chain_info_headers);
267 let (canon_state_notification_sender, _) =
268 broadcast::channel(CANON_STATE_NOTIFICATION_CHANNEL_SIZE);
269 let inner = CanonicalInMemoryStateInner {
270 chain_info_tracker,
271 in_memory_state,
272 canon_state_notification_sender,
273 };
274
275 Self { inner: Arc::new(inner) }
276 }
277
278 pub fn hash_by_number(&self, number: u64) -> Option<B256> {
280 self.inner.in_memory_state.hash_by_number(number)
281 }
282
283 pub fn header_by_hash(&self, hash: B256) -> Option<SealedHeader<N::BlockHeader>> {
285 self.state_by_hash(hash)
286 .map(|block| block.block_ref().recovered_block().clone_sealed_header())
287 }
288
289 pub fn clear_state(&self) {
291 self.inner.clear()
292 }
293
294 pub fn insert_executed(&self, block: ExecutedBlock<N>) {
300 self.inner.in_memory_state.update(|blocks| blocks.insert_executed(block));
301 }
302
303 pub fn set_pending_block(&self, pending: ExecutedBlock<N>) {
308 self.inner.in_memory_state.update(|blocks| blocks.insert_pending(pending));
309 }
310
311 pub fn update_chain(&self, new_chain: NewCanonicalChain<N>) {
317 self.inner.in_memory_state.update(|blocks| blocks.update_chain(new_chain));
318 }
319
320 pub fn on_backfill_finished(&self, persisted_hash: B256, backfill: BlockNumHash) {
330 self.inner.in_memory_state.update(|blocks| {
331 let removed = if blocks
332 .canonical()
333 .hash_by_number(backfill.number)
334 .is_none_or(|hash| hash == backfill.hash)
335 {
336 blocks.remove_canonical_until(persisted_hash, backfill.number)
337 } else {
338 Vec::new()
339 };
340 blocks.demote_canonical_chain();
341 (removed, blocks.prune_conflicting_with_finalized(backfill))
342 });
343 }
344
345 pub fn on_blocks_persisted(
358 &self,
359 last_persisted_block: BlockNumHash,
360 state_trie_persisted_block: BlockNumHash,
361 finalized: Option<BlockNumHash>,
362 ) {
363 self.set_persisted(last_persisted_block);
364 self.inner.in_memory_state.update(|blocks| {
365 let removed = blocks.remove_canonical_until(
366 last_persisted_block.hash,
367 state_trie_persisted_block.number.min(last_persisted_block.number),
368 );
369 let disconnected = blocks.prune_built_above(last_persisted_block.number);
370 let pruned = finalized.map(|finalized| {
371 blocks.prune_conflicting_with_finalized(
372 if state_trie_persisted_block.number < finalized.number {
373 state_trie_persisted_block
374 } else {
375 finalized
376 },
377 )
378 });
379 (removed, disconnected, pruned)
380 });
381 }
382
383 pub fn prune_conflicting_with_finalized(&self, finalized: BlockNumHash) {
387 self.inner
388 .in_memory_state
389 .update(|blocks| blocks.prune_conflicting_with_finalized(finalized));
390 }
391
392 pub fn remove_persisted_blocks(&self, persisted_num_hash: BlockNumHash) {
397 self.remove_persisted_blocks_until(persisted_num_hash, persisted_num_hash.number);
398 }
399
400 pub fn remove_persisted_blocks_until(
408 &self,
409 persisted_num_hash: BlockNumHash,
410 remove_until: BlockNumber,
411 ) {
412 self.set_persisted(persisted_num_hash);
413 self.remove_canonical_until(
414 persisted_num_hash.hash,
415 remove_until.min(persisted_num_hash.number),
416 );
417 }
418
419 pub fn remove_canonical_until(&self, persisted_hash: B256, remove_until: BlockNumber) {
425 self.inner
426 .in_memory_state
427 .update(|blocks| blocks.remove_canonical_until(persisted_hash, remove_until));
428 }
429
430 pub fn state_by_hash(&self, hash: B256) -> Option<Arc<BlockState<N>>> {
432 self.inner.in_memory_state.inner.blocks.read().canonical().get(&hash).cloned()
433 }
434
435 pub fn state_by_number(&self, number: u64) -> Option<Arc<BlockState<N>>> {
437 self.inner.in_memory_state.state_by_number(number)
438 }
439
440 pub fn head_state(&self) -> Option<Arc<BlockState<N>>> {
442 self.inner.in_memory_state.head_state()
443 }
444
445 pub fn pending_state(&self) -> Option<Arc<BlockState<N>>> {
447 self.inner.in_memory_state.pending_state()
448 }
449
450 pub fn pending_block_num_hash(&self) -> Option<BlockNumHash> {
452 self.inner
453 .in_memory_state
454 .pending_state()
455 .map(|state| BlockNumHash { number: state.number(), hash: state.hash() })
456 }
457
458 pub fn chain_info(&self) -> ChainInfo {
460 self.inner.chain_info_tracker.chain_info()
461 }
462
463 pub fn get_canonical_block_number(&self) -> u64 {
465 self.inner.chain_info_tracker.get_canonical_block_number()
466 }
467
468 pub fn get_safe_num_hash(&self) -> Option<BlockNumHash> {
470 self.inner.chain_info_tracker.get_safe_num_hash()
471 }
472
473 pub fn get_finalized_num_hash(&self) -> Option<BlockNumHash> {
475 self.inner.chain_info_tracker.get_finalized_num_hash()
476 }
477
478 pub fn on_forkchoice_update_received(&self) {
480 self.inner.chain_info_tracker.on_forkchoice_update_received();
481 }
482
483 pub fn last_received_update_timestamp(&self) -> Option<Instant> {
485 self.inner.chain_info_tracker.last_forkchoice_update_received_at()
486 }
487
488 pub fn set_canonical_head(&self, header: SealedHeader<N::BlockHeader>) {
490 self.inner.chain_info_tracker.set_canonical_head(header);
491 }
492
493 pub fn set_safe(&self, header: SealedHeader<N::BlockHeader>) {
495 self.inner.chain_info_tracker.set_safe(header);
496 }
497
498 pub fn set_finalized(&self, header: SealedHeader<N::BlockHeader>) {
500 self.inner.chain_info_tracker.set_finalized(header);
501 }
502
503 pub fn set_persisted(&self, num_hash: BlockNumHash) {
505 self.inner.chain_info_tracker.set_persisted(num_hash);
506 }
507
508 pub fn get_canonical_head(&self) -> SealedHeader<N::BlockHeader> {
510 self.inner.chain_info_tracker.get_canonical_head()
511 }
512
513 pub fn get_finalized_header(&self) -> Option<SealedHeader<N::BlockHeader>> {
515 self.inner.chain_info_tracker.get_finalized_header()
516 }
517
518 pub fn get_safe_header(&self) -> Option<SealedHeader<N::BlockHeader>> {
520 self.inner.chain_info_tracker.get_safe_header()
521 }
522
523 pub fn get_persisted_num_hash(&self) -> Option<BlockNumHash> {
525 self.inner.chain_info_tracker.get_persisted_num_hash()
526 }
527
528 pub fn pending_sealed_header(&self) -> Option<SealedHeader<N::BlockHeader>> {
530 self.pending_state().map(|h| h.block_ref().recovered_block().clone_sealed_header())
531 }
532
533 pub fn pending_header(&self) -> Option<N::BlockHeader> {
535 self.pending_sealed_header().map(|sealed_header| sealed_header.unseal())
536 }
537
538 pub fn pending_block(&self) -> Option<SealedBlock<N::Block>> {
540 self.pending_state()
541 .map(|block_state| block_state.block_ref().recovered_block().sealed_block().clone())
542 }
543
544 pub fn pending_recovered_block(&self) -> Option<Arc<RecoveredBlock<N::Block>>> {
546 self.pending_state().map(|block_state| Arc::clone(&block_state.block_ref().recovered_block))
547 }
548
549 pub fn pending_block_and_receipts(
551 &self,
552 ) -> Option<RecoveredBlockAndExecutionOutput<N::Block, N::Receipt>> {
553 self.pending_state().map(|block_state| {
554 RecoveredBlockAndExecutionOutput::new(
555 Arc::clone(&block_state.block_ref().recovered_block),
556 Arc::clone(&block_state.block_ref().execution_output),
557 )
558 })
559 }
560
561 pub fn subscribe_canon_state(&self) -> CanonStateNotifications<N> {
563 self.inner.canon_state_notification_sender.subscribe()
564 }
565
566 pub fn subscribe_safe_block(&self) -> watch::Receiver<Option<SealedHeader<N::BlockHeader>>> {
568 self.inner.chain_info_tracker.subscribe_safe_block()
569 }
570
571 pub fn subscribe_finalized_block(
573 &self,
574 ) -> watch::Receiver<Option<SealedHeader<N::BlockHeader>>> {
575 self.inner.chain_info_tracker.subscribe_finalized_block()
576 }
577
578 pub fn subscribe_persisted_block(&self) -> watch::Receiver<Option<BlockNumHash>> {
580 self.inner.chain_info_tracker.subscribe_persisted_block()
581 }
582
583 pub fn notify_canon_state(&self, event: CanonStateNotification<N>) {
585 self.inner.canon_state_notification_sender.send(event).ok();
586 }
587
588 pub fn canonical_chain(&self) -> impl Iterator<Item = Arc<BlockState<N>>> {
593 self.inner.in_memory_state.head_state().into_iter().flat_map(|head| head.iter())
594 }
595
596 pub fn transaction_by_hash(&self, hash: TxHash) -> Option<N::SignedTx> {
600 for block_state in self.canonical_chain() {
601 if let Some(tx) =
602 block_state.block_ref().recovered_block().body().transaction_by_hash(&hash)
603 {
604 return Some(tx.clone())
605 }
606 }
607 None
608 }
609
610 pub fn transaction_by_hash_with_meta(
615 &self,
616 tx_hash: TxHash,
617 ) -> Option<(N::SignedTx, TransactionMeta)> {
618 for block_state in self.canonical_chain() {
619 if let Some(indexed) = block_state.find_indexed(tx_hash) {
620 return Some((indexed.tx().clone(), indexed.meta()));
621 }
622 }
623 None
624 }
625}
626
627#[derive(Debug)]
638pub struct CanonicalInMemoryStateWriter<N: NodePrimitives = EthPrimitives> {
639 canonical_in_memory_state: CanonicalInMemoryState<N>,
640}
641
642impl<N: NodePrimitives> CanonicalInMemoryStateWriter<N> {
643 pub fn new(
649 chain_info_headers: ChainInfoHeaders<N::BlockHeader>,
650 in_memory_state: InMemoryState<N>,
651 ) -> Self {
652 Self {
653 canonical_in_memory_state: CanonicalInMemoryState::with_head(
654 chain_info_headers,
655 in_memory_state,
656 ),
657 }
658 }
659
660 pub const fn canonical_in_memory_state(&self) -> &CanonicalInMemoryState<N> {
662 &self.canonical_in_memory_state
663 }
664
665 pub fn clear_state(&mut self) {
667 self.canonical_in_memory_state.clear_state();
668 }
669
670 pub fn insert_executed(&mut self, block: ExecutedBlock<N>) {
672 self.canonical_in_memory_state.insert_executed(block);
673 }
674
675 pub fn set_pending_block(&mut self, pending: ExecutedBlock<N>) {
677 self.canonical_in_memory_state.set_pending_block(pending);
678 }
679
680 pub fn update_chain(&mut self, new_chain: NewCanonicalChain<N>) {
682 self.canonical_in_memory_state.update_chain(new_chain);
683 }
684
685 pub fn on_backfill_finished(
687 &mut self,
688 last_persisted_hash: B256,
689 backfill_block: BlockNumHash,
690 ) {
691 self.canonical_in_memory_state.on_backfill_finished(last_persisted_hash, backfill_block);
692 }
693
694 pub fn on_blocks_persisted(
696 &mut self,
697 last_persisted_block: BlockNumHash,
698 state_trie_persisted_block: BlockNumHash,
699 finalized: Option<BlockNumHash>,
700 ) {
701 self.canonical_in_memory_state.on_blocks_persisted(
702 last_persisted_block,
703 state_trie_persisted_block,
704 finalized,
705 );
706 }
707
708 pub fn on_forkchoice_update_received(&mut self) {
710 self.canonical_in_memory_state.on_forkchoice_update_received();
711 }
712
713 pub fn set_canonical_head(&mut self, header: SealedHeader<N::BlockHeader>) {
715 self.canonical_in_memory_state.set_canonical_head(header);
716 }
717
718 pub fn set_safe(&mut self, header: SealedHeader<N::BlockHeader>) {
720 self.canonical_in_memory_state.set_safe(header);
721 }
722
723 pub fn set_finalized(&mut self, header: SealedHeader<N::BlockHeader>) {
725 self.canonical_in_memory_state.set_finalized(header);
726 }
727
728 pub fn notify_canon_state(&mut self, event: CanonStateNotification<N>) {
730 self.canonical_in_memory_state.notify_canon_state(event);
731 }
732}
733
734#[cfg(test)]
735mod tests {
736 use super::*;
737 use crate::test_utils::TestBlockBuilder;
738 use rand::Rng;
739
740 fn create_mock_state(
741 test_block_builder: &mut TestBlockBuilder<EthPrimitives>,
742 block_number: u64,
743 parent_hash: B256,
744 ) -> BlockState {
745 BlockState::new(
746 test_block_builder.get_executed_block_with_number(block_number, parent_hash),
747 )
748 }
749
750 #[test]
751 fn test_in_memory_state_impl_state_by_hash() {
752 let mut state_by_hash = B256Map::default();
753 let number = rand::rng().random::<u64>();
754 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
755 let state = Arc::new(create_mock_state(&mut test_block_builder, number, B256::random()));
756 state_by_hash.insert(state.hash(), state.clone());
757
758 let in_memory_state = InMemoryState::new(state_by_hash, BTreeMap::new(), None);
759
760 assert_eq!(in_memory_state.state_by_hash(state.hash()), Some(state));
761 assert_eq!(in_memory_state.state_by_hash(B256::random()), None);
762 }
763
764 #[test]
765 fn test_in_memory_state_impl_state_by_number() {
766 let mut state_by_hash = B256Map::default();
767 let mut hash_by_number = BTreeMap::new();
768
769 let number = rand::rng().random::<u64>();
770 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
771 let state = Arc::new(create_mock_state(&mut test_block_builder, number, B256::random()));
772 let hash = state.hash();
773
774 state_by_hash.insert(hash, state.clone());
775 hash_by_number.insert(number, hash);
776
777 let in_memory_state = InMemoryState::new(state_by_hash, hash_by_number, None);
778
779 assert_eq!(in_memory_state.state_by_number(number), Some(state));
780 assert_eq!(in_memory_state.state_by_number(number + 1), None);
781 }
782
783 #[test]
784 fn test_in_memory_state_impl_head_state() {
785 let mut state_by_hash = B256Map::default();
786 let mut hash_by_number = BTreeMap::new();
787 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
788 let state1 = Arc::new(create_mock_state(&mut test_block_builder, 1, B256::random()));
789 let hash1 = state1.hash();
790 let state2 = Arc::new(create_mock_state(&mut test_block_builder, 2, hash1));
791 let hash2 = state2.hash();
792 hash_by_number.insert(1, hash1);
793 hash_by_number.insert(2, hash2);
794 state_by_hash.insert(hash1, state1);
795 state_by_hash.insert(hash2, state2);
796
797 let in_memory_state = InMemoryState::new(state_by_hash, hash_by_number, None);
798 let head_state = in_memory_state.head_state().unwrap();
799
800 assert_eq!(head_state.hash(), hash2);
801 assert_eq!(head_state.number(), 2);
802 }
803
804 #[test]
805 fn test_in_memory_state_impl_pending_state() {
806 let pending_number = rand::rng().random::<u64>();
807 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
808 let pending_state =
809 create_mock_state(&mut test_block_builder, pending_number, B256::random());
810 let pending_hash = pending_state.hash();
811
812 let in_memory_state =
813 InMemoryState::new(B256Map::default(), BTreeMap::new(), Some(pending_state));
814
815 let result = in_memory_state.pending_state();
816 assert!(result.is_some());
817 let actual_pending_state = result.unwrap();
818 assert_eq!(actual_pending_state.block.recovered_block().hash(), pending_hash);
819 assert_eq!(actual_pending_state.block.recovered_block().number, pending_number);
820 }
821
822 #[test]
823 fn test_in_memory_state_impl_no_pending_state() {
824 let in_memory_state: InMemoryState =
825 InMemoryState::new(B256Map::default(), BTreeMap::new(), None);
826
827 assert_eq!(in_memory_state.pending_state(), None);
828 }
829
830 #[test]
831 fn test_in_memory_state_chain_update() {
832 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
833 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
834 let block1 = test_block_builder.get_executed_block_with_number(0, B256::random());
835 let block2 = test_block_builder.get_executed_block_with_number(0, B256::random());
836 let chain = NewCanonicalChain::Commit { new: vec![block1.clone()] };
837 state.update_chain(chain);
838 assert_eq!(
839 state.head_state().unwrap().block_ref().recovered_block().hash(),
840 block1.recovered_block().hash()
841 );
842 assert_eq!(
843 state.state_by_number(0).unwrap().block_ref().recovered_block().hash(),
844 block1.recovered_block().hash()
845 );
846
847 let chain = NewCanonicalChain::Reorg { new: vec![block2.clone()], old: vec![block1] };
848 state.update_chain(chain);
849 assert_eq!(
850 state.head_state().unwrap().block_ref().recovered_block().hash(),
851 block2.recovered_block().hash()
852 );
853 assert_eq!(
854 state.state_by_number(0).unwrap().block_ref().recovered_block().hash(),
855 block2.recovered_block().hash()
856 );
857
858 assert_eq!(state.inner.in_memory_state.block_count(), 1);
859 }
860
861 #[test]
862 fn test_in_memory_state_set_pending_block() {
863 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
864 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
865
866 let block1 = test_block_builder.get_executed_block_with_number(0, B256::random());
868
869 let block2 =
871 test_block_builder.get_executed_block_with_number(1, block1.recovered_block().hash());
872
873 let chain = NewCanonicalChain::Commit { new: vec![block1.clone(), block2.clone()] };
875 state.update_chain(chain);
876
877 assert!(state.pending_state().is_none());
879
880 state.set_pending_block(block2.clone());
882
883 assert_eq!(
885 *state.pending_state().unwrap(),
886 BlockState::with_parent(block2.clone(), Some(Arc::new(BlockState::new(block1))))
887 );
888
889 assert_eq!(state.pending_block().unwrap(), block2.recovered_block().sealed_block().clone());
891
892 assert_eq!(
894 state.pending_block_num_hash().unwrap(),
895 BlockNumHash { number: 1, hash: block2.recovered_block().hash() }
896 );
897
898 assert_eq!(state.pending_header().unwrap(), block2.recovered_block().header().clone());
900
901 assert_eq!(
903 state.pending_sealed_header().unwrap(),
904 block2.recovered_block().clone_sealed_header()
905 );
906
907 let pending_block = state.pending_recovered_block().unwrap();
909 assert!(Arc::ptr_eq(&pending_block, &block2.recovered_block));
910
911 let pending = state.pending_block_and_receipts().unwrap();
913 assert!(Arc::ptr_eq(pending.block(), &block2.recovered_block));
914 assert!(Arc::ptr_eq(pending.execution_output(), &block2.execution_output));
915 }
916
917 #[test]
918 fn test_in_memory_state_executed_blocks_are_not_canonical() {
919 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
920 let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
921 let block1 = test_block_builder.get_executed_block_with_number(1, B256::random());
922 let block1_hash = block1.recovered_block().hash();
923 let block2 = test_block_builder.get_executed_block_with_number(2, block1_hash);
924 let block2_hash = block2.recovered_block().hash();
925 let fork2 = test_block_builder.get_executed_block_with_number(2, block1_hash);
926 let fork2_hash = fork2.recovered_block().hash();
927 let tracked = |hash| state.inner.in_memory_state.inner.blocks.read().contains(&hash);
928
929 state.insert_executed(block1.clone());
931 state.insert_executed(block2.clone());
932 state.insert_executed(fork2.clone());
933 assert!(tracked(block1_hash) && tracked(block2_hash) && tracked(fork2_hash));
934 assert!(state.state_by_hash(block2_hash).is_none());
935 assert!(state.head_state().is_none());
936 assert!(state.pending_state().is_none());
937
938 state.update_chain(NewCanonicalChain::Commit { new: vec![block1, block2.clone()] });
940 assert_eq!(state.head_state().unwrap().hash(), block2_hash);
941 assert!(state.state_by_hash(fork2_hash).is_none());
942
943 state.update_chain(NewCanonicalChain::Reorg { new: vec![fork2], old: vec![block2] });
945 assert_eq!(state.head_state().unwrap().hash(), fork2_hash);
946 assert!(state.state_by_hash(block2_hash).is_none());
947 assert!(tracked(block2_hash));
948
949 state.prune_conflicting_with_finalized(BlockNumHash::new(2, fork2_hash));
951 assert!(!tracked(block2_hash));
952 assert_eq!(state.inner.in_memory_state.block_count(), 2);
953 }
954
955 #[test]
956 fn test_canonical_in_memory_state_canonical_chain_empty() {
957 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
958 assert!(state.canonical_chain().next().is_none());
959 }
960
961 #[test]
962 fn test_canonical_in_memory_state_canonical_chain_single_block() {
963 let block = TestBlockBuilder::eth().get_executed_block_with_number(1, B256::random());
964 let hash = block.recovered_block().hash();
965 let mut blocks = B256Map::default();
966 blocks.insert(hash, Arc::new(BlockState::new(block)));
967 let mut numbers = BTreeMap::new();
968 numbers.insert(1, hash);
969
970 let state = CanonicalInMemoryState::new(blocks, numbers, None, None, None);
971 let chain: Vec<_> = state.canonical_chain().collect();
972
973 assert_eq!(chain.len(), 1);
974 assert_eq!(chain[0].number(), 1);
975 assert_eq!(chain[0].hash(), hash);
976 }
977
978 #[test]
979 fn test_canonical_in_memory_state_canonical_chain_multiple_blocks() {
980 let mut parent_hash = B256::random();
981 let mut block_builder = TestBlockBuilder::eth();
982 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
983
984 for i in 1..=3 {
985 let block = block_builder.get_executed_block_with_number(i, parent_hash);
986 let hash = block.recovered_block().hash();
987 state.update_chain(NewCanonicalChain::Commit { new: vec![block] });
988 parent_hash = hash;
989 }
990
991 let chain: Vec<_> = state.canonical_chain().collect();
992
993 assert_eq!(chain.len(), 3);
994 assert_eq!(chain[0].number(), 3);
995 assert_eq!(chain[1].number(), 2);
996 assert_eq!(chain[2].number(), 1);
997 }
998
999 #[test]
1001 fn test_canonical_in_memory_state_canonical_chain_with_pending_block() {
1002 let mut parent_hash = B256::random();
1003 let mut block_builder = TestBlockBuilder::<EthPrimitives>::eth();
1004 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1005
1006 for i in 1..=2 {
1007 let block = block_builder.get_executed_block_with_number(i, parent_hash);
1008 let hash = block.recovered_block().hash();
1009 state.update_chain(NewCanonicalChain::Commit { new: vec![block] });
1010 parent_hash = hash;
1011 }
1012
1013 let pending_block = block_builder.get_executed_block_with_number(3, parent_hash);
1014 state.set_pending_block(pending_block);
1015 let chain: Vec<_> = state.canonical_chain().collect();
1016
1017 assert_eq!(chain.len(), 2);
1018 assert_eq!(chain[0].number(), 2);
1019 assert_eq!(chain[1].number(), 1);
1020 }
1021
1022 #[test]
1023 fn test_canonical_in_memory_state_remove_persisted_blocks() {
1024 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1025 let blocks = TestBlockBuilder::eth().get_executed_blocks(1..6).collect::<Vec<_>>();
1026 let num_hash = |number: usize| blocks[number - 1].recovered_block().num_hash();
1027 let chain = |state: &BlockState| state.chain().map(BlockState::number).collect::<Vec<_>>();
1029
1030 state.update_chain(NewCanonicalChain::Commit { new: blocks[..4].to_vec() });
1031 state.set_pending_block(blocks[4].clone());
1032
1033 let untracked = BlockNumHash::new(2, B256::random());
1035 state.remove_persisted_blocks(untracked);
1036 assert_eq!(state.get_persisted_num_hash(), Some(untracked));
1037 assert_eq!(chain(&state.head_state().unwrap()), [4, 3, 2, 1]);
1038 assert_eq!(chain(&state.pending_state().unwrap()), [5, 4, 3, 2, 1]);
1039
1040 state.remove_persisted_blocks_until(num_hash(2), 1);
1043 assert_eq!(state.get_persisted_num_hash(), Some(num_hash(2)));
1044 assert_eq!(state.hash_by_number(1), None);
1045 assert_eq!(state.state_by_hash(num_hash(1).hash), None);
1046 assert_eq!(chain(&state.state_by_number(2).unwrap()), [2]);
1047 assert_eq!(chain(&state.head_state().unwrap()), [4, 3, 2]);
1048 assert_eq!(chain(&state.pending_state().unwrap()), [5, 4, 3, 2]);
1049
1050 state.remove_persisted_blocks_until(num_hash(3), 4);
1052 assert_eq!(state.hash_by_number(3), None);
1053 assert_eq!(chain(&state.head_state().unwrap()), [4]);
1054 assert_eq!(chain(&state.pending_state().unwrap()), [5, 4]);
1055
1056 state.remove_persisted_blocks(num_hash(4));
1058 assert_eq!(state.head_state(), None);
1059 assert_eq!(state.inner.in_memory_state.block_count(), 0);
1060 assert_eq!(chain(&state.pending_state().unwrap()), [5]);
1061
1062 state.clear_state();
1063 assert_eq!(state.pending_state(), None);
1064 }
1065
1066 #[test]
1067 fn test_in_memory_state_removal_generation() {
1068 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1069 let in_memory_state = &state.inner.in_memory_state;
1070 let mut block_builder = TestBlockBuilder::eth();
1071 let blocks = block_builder.get_executed_blocks(1..4).collect::<Vec<_>>();
1072 let hash = |number: usize| blocks[number - 1].recovered_block().hash();
1073 let fork = block_builder.get_executed_block_with_number(2, hash(1));
1074 let fork_hash = fork.recovered_block().hash();
1075
1076 let generation = in_memory_state.removal_generation();
1078 state.update_chain(NewCanonicalChain::Commit { new: blocks.clone() });
1079 state.insert_executed(fork);
1080 assert_eq!(in_memory_state.removal_generation(), generation);
1081
1082 assert_eq!(in_memory_state.state_by_hash(fork_hash).unwrap().hash(), fork_hash);
1085 assert_eq!(in_memory_state.state_by_hash(hash(3)).unwrap().hash(), hash(3));
1086 assert_eq!(state.state_by_hash(fork_hash), None);
1087
1088 state.remove_canonical_until(fork_hash, 3);
1090 assert_eq!(in_memory_state.removal_generation(), generation);
1091 assert_eq!(state.canonical_chain().count(), 3);
1092
1093 state.remove_canonical_until(hash(2), 1);
1095 let after_canonical_block = in_memory_state.removal_generation();
1096 assert!(after_canonical_block > generation);
1097 assert_eq!(in_memory_state.state_by_hash(hash(1)), None);
1098
1099 state.remove_canonical_until(hash(1), 2);
1101 let after_chain_base = in_memory_state.removal_generation();
1102 assert!(after_chain_base > after_canonical_block);
1103 assert_eq!(state.canonical_chain().map(|state| state.number()).collect::<Vec<_>>(), [3]);
1104
1105 state.prune_conflicting_with_finalized(blocks[2].recovered_block().num_hash());
1107 let after_fork = in_memory_state.removal_generation();
1108 assert!(after_fork > after_chain_base);
1109 assert_eq!(in_memory_state.state_by_hash(fork_hash), None);
1110
1111 state.clear_state();
1112 assert!(in_memory_state.removal_generation() > after_fork);
1113 assert_eq!(in_memory_state.state_by_hash(hash(3)), None);
1114 }
1115
1116 #[test]
1117 fn test_on_backfill_finished_is_one_update() {
1118 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1119 let in_memory_state = &state.inner.in_memory_state;
1120 let mut block_builder = TestBlockBuilder::eth();
1121 let blocks = block_builder.get_executed_blocks(1..4).collect::<Vec<_>>();
1122 let hash = |number: usize| blocks[number - 1].recovered_block().hash();
1123 let fork = block_builder.get_executed_block_with_number(2, hash(1));
1124 let fork_hash = fork.recovered_block().hash();
1125 state.update_chain(NewCanonicalChain::Commit { new: blocks.clone() });
1126 state.insert_executed(fork);
1127
1128 let generation = in_memory_state.removal_generation();
1131 state.on_backfill_finished(hash(1), blocks[1].recovered_block().num_hash());
1132 assert_eq!(in_memory_state.removal_generation(), generation + 1);
1133 assert_eq!(state.canonical_chain().count(), 0);
1134 for removed in [hash(1), hash(2), fork_hash] {
1135 assert_eq!(in_memory_state.state_by_hash(removed), None);
1136 }
1137 assert_eq!(in_memory_state.state_by_hash(hash(3)).unwrap().hash(), hash(3));
1138 }
1139
1140 #[test]
1141 fn test_on_backfill_finished_at_conflicting_block() {
1142 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1143 let in_memory_state = &state.inner.in_memory_state;
1144 let mut block_builder = TestBlockBuilder::eth();
1145 let blocks = block_builder.get_executed_blocks(1..4).collect::<Vec<_>>();
1146 let hash = |number: usize| blocks[number - 1].recovered_block().hash();
1147 let fork = block_builder.get_executed_block_with_number(2, hash(1));
1148 let fork_hash = fork.recovered_block().hash();
1149 let fork_child = block_builder.get_executed_block_with_number(3, fork_hash);
1150 let fork_child_hash = fork_child.recovered_block().hash();
1151 state.update_chain(NewCanonicalChain::Commit { new: blocks.clone() });
1152 state.insert_executed(fork.clone());
1153 state.insert_executed(fork_child);
1154
1155 let generation = in_memory_state.removal_generation();
1158 state.on_backfill_finished(hash(1), fork.recovered_block().num_hash());
1159 assert_eq!(in_memory_state.removal_generation(), generation + 1);
1160 assert_eq!(state.canonical_chain().count(), 0);
1161 for removed in [hash(1), hash(2), hash(3)] {
1162 assert_eq!(in_memory_state.state_by_hash(removed), None);
1163 }
1164 for kept in [fork_hash, fork_child_hash] {
1165 assert_eq!(in_memory_state.state_by_hash(kept).unwrap().hash(), kept);
1166 }
1167 }
1168
1169 #[test]
1170 fn test_on_blocks_persisted() {
1171 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1172 let in_memory_state = &state.inner.in_memory_state;
1173 let mut block_builder = TestBlockBuilder::eth();
1174 let blocks = block_builder.get_executed_blocks(1..6).collect::<Vec<_>>();
1175 let hash = |number: usize| blocks[number - 1].recovered_block().hash();
1176 let num_hash = |number: usize| blocks[number - 1].recovered_block().num_hash();
1177 let forks = (2..5)
1179 .map(|number| {
1180 block_builder.get_executed_block_with_number(number as u64, hash(number - 1))
1181 })
1182 .collect::<Vec<_>>();
1183 let fork_hash = |number: usize| forks[number - 2].recovered_block().hash();
1184 state.update_chain(NewCanonicalChain::Commit { new: blocks.clone() });
1185 for fork in &forks {
1186 state.insert_executed(fork.clone());
1187 }
1188
1189 let generation = in_memory_state.removal_generation();
1192 state.on_blocks_persisted(num_hash(2), num_hash(1), None);
1193 assert_eq!(in_memory_state.removal_generation(), generation + 1);
1194 assert_eq!(state.get_persisted_num_hash(), Some(num_hash(2)));
1195 assert_eq!(
1196 in_memory_state.block_counts(),
1197 InMemoryStateBlockCounts { canonical: 4, non_canonical: 3 }
1198 );
1199 assert!(!in_memory_state.contains(&hash(1)));
1200
1201 state.on_blocks_persisted(num_hash(2), num_hash(2), Some(num_hash(4)));
1204 assert_eq!(in_memory_state.removal_generation(), generation + 2);
1205 assert_eq!(
1206 in_memory_state.block_counts(),
1207 InMemoryStateBlockCounts { canonical: 3, non_canonical: 2 }
1208 );
1209 assert!(!in_memory_state.contains(&fork_hash(2)));
1210
1211 state.on_blocks_persisted(num_hash(4), num_hash(4), Some(num_hash(3)));
1213 assert_eq!(
1214 in_memory_state.block_counts(),
1215 InMemoryStateBlockCounts { canonical: 1, non_canonical: 1 }
1216 );
1217 assert!(!in_memory_state.contains(&fork_hash(3)));
1218 assert!(in_memory_state.contains(&fork_hash(4)));
1219 }
1220
1221 #[test]
1222 fn test_on_blocks_persisted_after_disk_removal() {
1223 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1224 let in_memory_state = &state.inner.in_memory_state;
1225 let mut block_builder = TestBlockBuilder::eth();
1226 let blocks = block_builder.get_executed_blocks(1..9).collect::<Vec<_>>();
1227 let hash = |number: usize| blocks[number - 1].recovered_block().hash();
1228 let num_hash = |number: usize| blocks[number - 1].recovered_block().num_hash();
1229 let fork = block_builder.get_executed_block_with_number(7, hash(6));
1230 let fork_hash = fork.recovered_block().hash();
1231 let fork_child = block_builder.get_executed_block_with_number(8, fork_hash);
1232
1233 state.update_chain(NewCanonicalChain::Commit { new: vec![blocks[7].clone()] });
1236 state.update_chain(NewCanonicalChain::Reorg {
1237 new: vec![blocks[5].clone()],
1238 old: vec![blocks[7].clone()],
1239 });
1240 state.insert_executed(fork);
1241 state.insert_executed(fork_child.clone());
1242 assert_eq!(
1243 in_memory_state.block_counts(),
1244 InMemoryStateBlockCounts { canonical: 1, non_canonical: 3 }
1245 );
1246
1247 state.on_blocks_persisted(num_hash(6), num_hash(6), None);
1250 assert!(!in_memory_state.contains(&hash(8)));
1251 assert_eq!(
1252 in_memory_state.block_counts(),
1253 InMemoryStateBlockCounts { canonical: 0, non_canonical: 2 }
1254 );
1255 assert_eq!(
1256 in_memory_state.state_by_hash(fork_child.recovered_block().hash()).unwrap().anchor(),
1257 num_hash(6)
1258 );
1259 }
1260
1261 #[test]
1262 fn test_in_memory_state_contains_and_block_counts() {
1263 let state: CanonicalInMemoryState = CanonicalInMemoryState::empty();
1264 let in_memory_state = &state.inner.in_memory_state;
1265 let mut block_builder = TestBlockBuilder::eth();
1266 let blocks = block_builder.get_executed_blocks(1..3).collect::<Vec<_>>();
1267 let fork =
1268 block_builder.get_executed_block_with_number(2, blocks[0].recovered_block().hash());
1269 state.update_chain(NewCanonicalChain::Commit { new: blocks.clone() });
1270 state.insert_executed(fork.clone());
1271
1272 assert_eq!(
1273 in_memory_state.block_counts(),
1274 InMemoryStateBlockCounts { canonical: 2, non_canonical: 1 }
1275 );
1276 for block in blocks.iter().chain([&fork]) {
1277 assert!(in_memory_state.contains(&block.recovered_block().hash()));
1278 }
1279 assert!(!in_memory_state.contains(&B256::random()));
1280 }
1281
1282 #[test]
1283 fn test_writer_changes_blocks_of_canonical_state() {
1284 let mut writer = CanonicalInMemoryStateWriter::new(
1285 ChainInfoHeaders {
1286 canonical_head: SealedHeader::default(),
1287 safe: None,
1288 finalized: None,
1289 },
1290 InMemoryState::default(),
1291 );
1292 let state: CanonicalInMemoryState = writer.canonical_in_memory_state().clone();
1293 let mut block_builder = TestBlockBuilder::eth();
1294 let blocks = block_builder.get_executed_blocks(1..4).collect::<Vec<_>>();
1295 let hash = |number: usize| blocks[number - 1].recovered_block().hash();
1296 let num_hash = |number: usize| blocks[number - 1].recovered_block().num_hash();
1297 let fork = block_builder.get_executed_block_with_number(2, hash(1));
1298 let fork_hash = fork.recovered_block().hash();
1299 let in_memory_state = &state.inner.in_memory_state;
1300
1301 writer.insert_executed(blocks[0].clone());
1303 writer.set_pending_block(blocks[1].clone());
1304 assert_eq!(state.pending_block_num_hash(), Some(num_hash(2)));
1305 writer.update_chain(NewCanonicalChain::Commit { new: blocks[..2].to_vec() });
1306 writer.insert_executed(blocks[2].clone());
1307 writer.insert_executed(fork);
1308 assert_eq!(state.canonical_chain().count(), 2);
1309 assert_eq!(
1310 in_memory_state.block_counts(),
1311 InMemoryStateBlockCounts { canonical: 2, non_canonical: 2 }
1312 );
1313
1314 writer.on_blocks_persisted(num_hash(2), num_hash(2), Some(num_hash(2)));
1317 assert_eq!(state.get_persisted_num_hash(), Some(num_hash(2)));
1318 for removed in [hash(1), hash(2), fork_hash] {
1319 assert!(!in_memory_state.contains(&removed));
1320 }
1321
1322 writer.update_chain(NewCanonicalChain::Commit { new: vec![blocks[2].clone()] });
1324 assert_eq!(state.canonical_chain().count(), 1);
1325 writer.on_backfill_finished(hash(2), num_hash(2));
1326 assert_eq!(
1327 in_memory_state.block_counts(),
1328 InMemoryStateBlockCounts { canonical: 0, non_canonical: 1 }
1329 );
1330
1331 writer.clear_state();
1332 assert_eq!(
1333 in_memory_state.block_counts(),
1334 InMemoryStateBlockCounts { canonical: 0, non_canonical: 0 }
1335 );
1336
1337 let header = blocks[2].recovered_block().clone_sealed_header();
1339 writer.on_forkchoice_update_received();
1340 writer.set_canonical_head(header.clone());
1341 writer.set_safe(header.clone());
1342 writer.set_finalized(header.clone());
1343 assert!(state.last_received_update_timestamp().is_some());
1344 assert_eq!(state.get_canonical_head(), header);
1345 assert_eq!(state.get_safe_num_hash(), Some(header.num_hash()));
1346 assert_eq!(state.get_finalized_num_hash(), Some(header.num_hash()));
1347 }
1348}