revm-context-interface 17.0.1

Revm context interface crates
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

use super::Transaction;
use either::Either;
use primitives::{Address, Bytes, TxKind, B256, U256};

impl<L, R> Transaction for Either<L, R>
where
    L: Transaction + 'static,
    R: for<'a> Transaction<
            AccessListItem<'a> = L::AccessListItem<'a>,
            Authorization<'a> = L::Authorization<'a>,
        > + 'static,
{
    type AccessListItem<'a> = L::AccessListItem<'a>;

    type Authorization<'a> = L::Authorization<'a>;

    fn tx_type(&self) -> u8 {
        match self {
            Either::Left(l) => l.tx_type(),
            Either::Right(r) => r.tx_type(),
        }
    }

    fn caller(&self) -> Address {
        match self {
            Either::Left(l) => l.caller(),
            Either::Right(r) => r.caller(),
        }
    }

    fn gas_limit(&self) -> u64 {
        match self {
            Either::Left(l) => l.gas_limit(),
            Either::Right(r) => r.gas_limit(),
        }
    }

    fn value(&self) -> U256 {
        match self {
            Either::Left(l) => l.value(),
            Either::Right(r) => r.value(),
        }
    }

    fn input(&self) -> &Bytes {
        match self {
            Either::Left(l) => l.input(),
            Either::Right(r) => r.input(),
        }
    }

    fn nonce(&self) -> u64 {
        match self {
            Either::Left(l) => l.nonce(),
            Either::Right(r) => r.nonce(),
        }
    }

    fn kind(&self) -> TxKind {
        match self {
            Either::Left(l) => l.kind(),
            Either::Right(r) => r.kind(),
        }
    }

    fn chain_id(&self) -> Option<u64> {
        match self {
            Either::Left(l) => l.chain_id(),
            Either::Right(r) => r.chain_id(),
        }
    }

    fn gas_price(&self) -> u128 {
        match self {
            Either::Left(l) => l.gas_price(),
            Either::Right(r) => r.gas_price(),
        }
    }

    fn access_list(&self) -> Option<impl Iterator<Item = Self::AccessListItem<'_>>> {
        match self {
            Either::Left(l) => l.access_list().map(Either::Left),
            Either::Right(r) => r.access_list().map(Either::Right),
        }
    }

    fn blob_versioned_hashes(&self) -> &[B256] {
        match self {
            Either::Left(l) => l.blob_versioned_hashes(),
            Either::Right(r) => r.blob_versioned_hashes(),
        }
    }

    fn max_fee_per_blob_gas(&self) -> u128 {
        match self {
            Either::Left(l) => l.max_fee_per_blob_gas(),
            Either::Right(r) => r.max_fee_per_blob_gas(),
        }
    }

    fn authorization_list_len(&self) -> usize {
        match self {
            Either::Left(l) => l.authorization_list_len(),
            Either::Right(r) => r.authorization_list_len(),
        }
    }

    fn authorization_list(&self) -> impl Iterator<Item = Self::Authorization<'_>> {
        match self {
            Either::Left(l) => Either::Left(l.authorization_list()),
            Either::Right(r) => Either::Right(r.authorization_list()),
        }
    }

    fn max_priority_fee_per_gas(&self) -> Option<u128> {
        match self {
            Either::Left(l) => l.max_priority_fee_per_gas(),
            Either::Right(r) => r.max_priority_fee_per_gas(),
        }
    }
}