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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use super::*;
use eth_valkyoth_codec::DecodeError;
use eth_valkyoth_primitives::{Gas, Nonce, Wei};

pub(super) const DYNAMIC_FEE_TX: &[u8] = &[
    0x02, 0xce, 0x01, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xc0, 0x01, 0x01, 0x02,
];

#[test]
fn decodes_dynamic_fee_transaction_as_unvalidated() {
    let result = decode_dynamic_fee_transaction(DYNAMIC_FEE_TX, TEST_LIMITS);
    assert!(result.is_ok());

    if let Ok(tx) = result {
        assert_eq!(tx.chain_id.get(), 1);
        assert_eq!(tx.nonce, Nonce::new(2));
        assert_eq!(tx.max_priority_fee_per_gas, Wei::from_u128(3));
        assert_eq!(tx.max_fee_per_gas, Wei::from_u128(4));
        assert_eq!(tx.gas_limit, Gas::new(21_000));
        assert_eq!(tx.to, DynamicFeeTransactionTo::Create);
        assert_eq!(tx.value, Wei::from_u128(5));
        assert_eq!(tx.input, &[]);
        assert_eq!(tx.access_list.address_count(), 0);
        assert_eq!(tx.access_list.storage_key_count(), 0);
        assert_eq!(tx.y_parity, SignatureYParity::Odd);
        assert_eq!(last_byte(tx.r), Some(1));
        assert_eq!(last_byte(tx.s), Some(2));
    }
}

#[test]
fn dynamic_fee_decoder_defers_fee_order_validation() {
    let tx = [
        0x02, 0xce, 0x01, 0x02, 0x04, 0x03, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xc0, 0x01, 0x01,
        0x02,
    ];

    let result = decode_dynamic_fee_transaction(&tx, TEST_LIMITS);
    assert!(result.is_ok());
    if let Ok(tx) = result {
        assert_eq!(tx.max_priority_fee_per_gas, Wei::from_u128(4));
        assert_eq!(tx.max_fee_per_gas, Wei::from_u128(3));
    }
}

#[test]
fn rejects_non_dynamic_fee_transaction_type() {
    assert_eq!(
        decode_dynamic_fee_transaction(&[0x01, 0xc0], TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::WrongTransactionType { type_byte: 1 })
    );
    assert_eq!(
        decode_dynamic_fee_transaction(CREATE_TX, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::WrongTransactionType { type_byte: 0 })
    );
}

#[test]
fn rejects_wrong_dynamic_fee_field_count() {
    assert_eq!(
        decode_dynamic_fee_transaction(&[0x02, 0xc0], TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::WrongFieldCount {
            expected: DYNAMIC_FEE_TRANSACTION_FIELD_COUNT,
            found: 0,
        })
    );
}

#[test]
fn rejects_malformed_dynamic_fee_payload_as_payload_field() {
    assert_eq!(
        decode_dynamic_fee_transaction(&[0x02, 0x80], TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::FieldDecode {
            field: DynamicFeeTransactionField::Payload,
            source: DecodeError::UnexpectedScalar,
        })
    );
}

#[test]
fn rejects_reserved_dynamic_fee_chain_id_zero() {
    let tx = [
        0x02, 0xce, 0x80, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xc0, 0x01, 0x01,
        0x02,
    ];

    assert_eq!(
        decode_dynamic_fee_transaction(&tx, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::FieldDecode {
            field: DynamicFeeTransactionField::ChainId,
            source: DecodeError::Malformed,
        })
    );
}

#[test]
fn rejects_invalid_dynamic_fee_to_length() {
    let tx = [
        0x02, 0xce, 0x01, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x01, 0x05, 0x80, 0xc0, 0x01, 0x01,
        0x02,
    ];

    assert_eq!(
        decode_dynamic_fee_transaction(&tx, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::InvalidToLength { found: 1 })
    );
}

#[test]
fn rejects_invalid_dynamic_fee_access_list_entry_field_count() {
    let tx = [
        0x02, 0xcf, 0x01, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xc1, 0xc0, 0x01,
        0x01, 0x02,
    ];

    assert_eq!(
        decode_dynamic_fee_transaction(&tx, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::InvalidAccessListEntryFieldCount { found: 0 })
    );
}

#[test]
fn rejects_invalid_dynamic_fee_y_parity() {
    let tx = [
        0x02, 0xce, 0x01, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xc0, 0x02, 0x01,
        0x02,
    ];

    assert_eq!(
        decode_dynamic_fee_transaction(&tx, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::InvalidYParity { value: 2 })
    );
}

#[test]
fn rejects_invalid_dynamic_fee_storage_key_length() {
    let tx = [
        0x02, 0xe6, 0x01, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xd8, 0xd7, 0x94,
        0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
        0x11, 0x11, 0x11, 0x11, 0x11, 0xc1, 0x01, 0x01, 0x01, 0x02,
    ];

    assert_eq!(
        decode_dynamic_fee_transaction(&tx, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::InvalidStorageKeyLength { found: 1 })
    );
}

#[test]
fn rejects_invalid_dynamic_fee_access_list_address_length() {
    let tx = [
        0x02, 0xd1, 0x01, 0x02, 0x03, 0x04, 0x82, 0x52, 0x08, 0x80, 0x05, 0x80, 0xc3, 0xc2, 0x01,
        0xc0, 0x01, 0x01, 0x02,
    ];

    assert_eq!(
        decode_dynamic_fee_transaction(&tx, TEST_LIMITS),
        Err(DynamicFeeTransactionDecodeError::InvalidAccessListAddressLength { found: 1 })
    );
}