ethrex-common 17.0.0

Core Ethereum data types and block validation for the ethrex Ethereum execution client
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

use bytes::BufMut;
use ethereum_types::{Address, H256, U256};
use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode, error::RLPDecodeError};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AssetDiff {
    pub token_l1: Address,
    pub token_src_l2: Address,
    pub token_dst_l2: Address,
    pub value: U256,
}

/// Represents the amount of balance to transfer to the bridge contract for a specific chain.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BalanceDiff {
    pub chain_id: U256,
    pub value: U256,
    pub value_per_token: Vec<AssetDiff>,
    pub message_hashes: Vec<H256>,
}

impl RLPEncode for BalanceDiff {
    fn encode(&self, buf: &mut dyn BufMut) {
        self.chain_id.encode(buf);
        self.value.encode(buf);
        self.value_per_token.encode(buf);
        self.message_hashes.encode(buf);
    }
}

impl RLPDecode for BalanceDiff {
    fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
        let (chain_id, rlp) = U256::decode_unfinished(rlp)?;
        let (value, rlp) = U256::decode_unfinished(rlp)?;
        let (value_per_token, rlp) = Vec::<AssetDiff>::decode_unfinished(rlp)?;
        let (message_hashes, rlp) = Vec::<H256>::decode_unfinished(rlp)?;
        Ok((
            BalanceDiff {
                chain_id,
                value,
                value_per_token,
                message_hashes,
            },
            rlp,
        ))
    }
}

impl RLPEncode for AssetDiff {
    fn encode(&self, buf: &mut dyn BufMut) {
        self.token_l1.encode(buf);
        self.token_src_l2.encode(buf);
        self.token_dst_l2.encode(buf);
        self.value.encode(buf);
    }
}

impl RLPDecode for AssetDiff {
    fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
        let (token_l1, rlp) = Address::decode_unfinished(rlp)?;
        let (token_src_l2, rlp) = Address::decode_unfinished(rlp)?;
        let (token_dst_l2, rlp) = Address::decode_unfinished(rlp)?;
        let (value, rlp) = U256::decode_unfinished(rlp)?;
        Ok((
            AssetDiff {
                token_l1,
                token_src_l2,
                token_dst_l2,
                value,
            },
            rlp,
        ))
    }
}