eth-state-fold 0.9.0

An Ethereum reader library
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

// (c) Cartesi and individual authors (see AUTHORS)
// SPDX-License-Identifier: Apache-2.0 (see LICENSE)

use crate::{FoldMiddleware, Foldable, StateFoldEnvironment, SyncMiddleware};

use eth_state_fold_test::mock_middleware::MockError;

use eth_state_fold_types::ethers;
use eth_state_fold_types::Block;
use ethers::providers::Middleware;

use async_trait::async_trait;
use std::sync::Arc;

#[derive(Clone, Debug)]
pub(crate) struct MockFold;

#[async_trait]
impl Foldable for MockFold {
    type InitialState = ();
    type Error = MockError;
    type UserData = ();

    async fn sync<M: Middleware>(
        _initial_state: &Self::InitialState,
        _block: &Block,
        _env: &StateFoldEnvironment<M, ()>,
        _access: Arc<SyncMiddleware<M>>,
    ) -> Result<Self, Self::Error> {
        unreachable!()
    }

    async fn fold<M: Middleware>(
        _previous_state: &Self,
        _block: &Block,
        _env: &StateFoldEnvironment<M, ()>,
        _access: Arc<FoldMiddleware<M>>,
    ) -> Result<Self, Self::Error> {
        unreachable!()
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct IncrementFold {
    pub(crate) low_hash: u64,
    pub(crate) n: u64,
    pub(crate) initial_state: u64,
}

#[async_trait]
impl Foldable for IncrementFold {
    type InitialState = u64;
    type Error = MockError;
    type UserData = ();

    async fn sync<M: Middleware>(
        initial_state: &Self::InitialState,
        block: &Block,
        _env: &StateFoldEnvironment<M, ()>,
        _access: Arc<SyncMiddleware<M>>,
    ) -> Result<Self, Self::Error> {
        Ok(Self {
            low_hash: block.hash.to_low_u64_be(),
            n: block.number.as_u64() + initial_state,
            initial_state: *initial_state,
        })
    }

    async fn fold<M: Middleware>(
        previous_state: &Self,
        block: &Block,
        _env: &StateFoldEnvironment<M, ()>,
        _access: Arc<FoldMiddleware<M>>,
    ) -> Result<Self, Self::Error> {
        assert_eq!(
            previous_state.n + 1,
            block.number.as_u64() + previous_state.initial_state
        );

        Ok(Self {
            low_hash: block.hash.to_low_u64_be(),
            n: previous_state.n + 1,
            initial_state: previous_state.initial_state,
        })
    }
}