eth-valkyoth-protocol 0.25.2

Fork-aware no_std Ethereum protocol validation state.
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

use eth_valkyoth_codec::{DecodeError, RlpInteger, RlpItem, RlpList, RlpScalar};
use eth_valkyoth_primitives::{Address, ChainId};

use super::access_list::AccessListTransactionTo;

pub(crate) const ADDRESS_BYTES: usize = 20;

pub(crate) fn decode_chain_id<'a, F, E>(
    fields: &mut impl Iterator<Item = Result<RlpItem<'a>, DecodeError>>,
    field: F,
    err: impl Copy + Fn(F, DecodeError) -> E,
) -> Result<ChainId, E>
where
    F: Copy,
{
    let integer = RlpInteger::try_from_scalar(next_scalar(fields, field, err)?)
        .map_err(|source| err(field, source))?;
    ChainId::try_from_signed_canonical_be_slice(integer.payload())
        .map_err(|_| err(field, DecodeError::Malformed))
}

pub(crate) fn decode_to<E>(
    scalar: RlpScalar<'_>,
    invalid_len: impl Fn(usize) -> E,
) -> Result<AccessListTransactionTo, E> {
    let payload = scalar.payload();
    if payload.is_empty() {
        return Ok(AccessListTransactionTo::Create);
    }
    let found = payload.len();
    let bytes: [u8; ADDRESS_BYTES] = payload.try_into().map_err(|_| invalid_len(found))?;
    Ok(AccessListTransactionTo::Call(Address::from_bytes(bytes)))
}

pub(crate) fn decode_required_address<E>(
    scalar: RlpScalar<'_>,
    invalid_len: impl Fn(usize) -> E,
) -> Result<Address, E> {
    let found = scalar.payload().len();
    let bytes: [u8; ADDRESS_BYTES] = scalar
        .payload()
        .try_into()
        .map_err(|_| invalid_len(found))?;
    Ok(Address::from_bytes(bytes))
}

pub(crate) fn next_scalar<'a, F, E>(
    fields: &mut impl Iterator<Item = Result<RlpItem<'a>, DecodeError>>,
    field: F,
    err: impl Fn(F, DecodeError) -> E,
) -> Result<RlpScalar<'a>, E>
where
    F: Copy,
{
    let item = fields
        .next()
        .ok_or(err(field, DecodeError::Malformed))?
        .map_err(|source| err(field, source))?;
    match item {
        RlpItem::Scalar(scalar) => Ok(scalar),
        RlpItem::List(_) => Err(err(field, DecodeError::UnexpectedList)),
    }
}

pub(crate) fn next_list<'a, F, E>(
    fields: &mut impl Iterator<Item = Result<RlpItem<'a>, DecodeError>>,
    field: F,
    err: impl Fn(F, DecodeError) -> E,
) -> Result<RlpList<'a>, E>
where
    F: Copy,
{
    let item = fields
        .next()
        .ok_or(err(field, DecodeError::Malformed))?
        .map_err(|source| err(field, source))?;
    match item {
        RlpItem::List(list) => Ok(list),
        RlpItem::Scalar(_) => Err(err(field, DecodeError::UnexpectedScalar)),
    }
}

pub(crate) fn decode_u64_field<'a, F, E>(
    fields: &mut impl Iterator<Item = Result<RlpItem<'a>, DecodeError>>,
    field: F,
    err: impl Copy + Fn(F, DecodeError) -> E,
) -> Result<u64, E>
where
    F: Copy,
{
    RlpInteger::try_from_scalar(next_scalar(fields, field, err)?)
        .and_then(RlpInteger::to_u64)
        .map_err(|source| err(field, source))
}

pub(crate) fn decode_u256_field<'a, F, E>(
    fields: &mut impl Iterator<Item = Result<RlpItem<'a>, DecodeError>>,
    field: F,
    err: impl Copy + Fn(F, DecodeError) -> E,
) -> Result<[u8; 32], E>
where
    F: Copy,
{
    RlpInteger::try_from_scalar(next_scalar(fields, field, err)?)
        .and_then(RlpInteger::to_be_bytes32)
        .map_err(|source| err(field, source))
}