serlp = "0.3.1"
serde = { version = "1.0", features = ['derive'] }
This example shows how can we encode a real transcation on ETH mainnet with the help of serlp.
The transcation is the #0 transcation of https://api.etherscan.io/api?module=proxy&action=eth_getBlockByNumber&tag=0xa1a489&boolean=true&apikey=YourApiKeyToken. The encoded data is from README of https://github.com/zhangchiqing/merkle-patricia-trie.
fn test_bn() {
#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
struct LegacyTx {
nonce: u64,
#[serde(with = "biguint")]
gas_price: BigUint,
gas_limit: u64,
#[serde(with = "byte_array")]
to: [u8; 20],
#[serde(with = "biguint")]
value: BigUint,
#[serde(with = "serde_bytes")]
data: Vec<u8>,
#[serde(with = "biguint")]
v: BigUint,
#[serde(with = "biguint")]
r: BigUint,
#[serde(with = "biguint")]
s: BigUint
}
let mut to = [0; 20];
to.copy_from_slice(&hex::decode("a3bed4e1c75d00fa6f4e5e6922db7261b5e9acd2").unwrap());
let bn = |s| BigUint::from_bytes_be(&hex::decode(s).unwrap());
let tx = LegacyTx {
nonce: 0xa5,
gas_price: bn("2e90edd000"),
gas_limit: 0x12bc2,
to,
value: bn("00"),
data: hex::decode("a9059cbb0000000000000000000000008bda8b9823b8490e8cf220dc7b91d97da1c54e250000000000000000000000000000000000000000000000056bc75e2d63100000").unwrap(),
v: bn("26"),
r: bn("6c89b57113cf7da8aed7911310e03d49be5e40de0bd73af4c9c54726c478691b"),
s: bn("56223f039fab98d47c71f84190cf285ce8fc7d9181d6769387e5efd0a970e2e9")
};
let expected = "f8ab81a5852e90edd00083012bc294a3bed4e1c75d00fa6f4e5e6922db7261b5e9acd280b844a9059cbb0000000000000000000000008bda8b9823b8490e8cf220dc7b91d97da1c54e250000000000000000000000000000000000000000000000056bc75e2d6310000026a06c89b57113cf7da8aed7911310e03d49be5e40de0bd73af4c9c54726c478691ba056223f039fab98d47c71f84190cf285ce8fc7d9181d6769387e5efd0a970e2e9";
let encoded = to_bytes(&tx).unwrap();
let orig: LegacyTx = from_bytes(&encoded).unwrap();
assert_eq!(orig, tx);
assert_eq!(hex::encode(encoded), expected);
}- bool
- float numbers and signed integers
- maps
- enum (only deserialize)
We do not support enum when deserializing because we lost some information (i.e. variant index) about the original value when serializing. However, in some specific cases you can derive Deserialize trait for a enum with the help of RlpProxy, which will be discussed later.
We have to choose this approach because there is no enums in Golang while ETH is written in go. Treating enums as a transparent layer can make our furture implementation compatiable with ETH.
Accroding to the ETH Yellow Paper, all supported data structure can be represented with either recursive list of byte arrays or byte arrays
. So we can transform all Rust's compound types, for example, tuple, struct and list, into lists. And then encode them as exactly described in the paper
We have a RlpProxy struct that implemented Deserialize trait, which just stores the original rlp encoded data after deserialization (no matter what type it is). You can gain more control over the deserialization process with it.
Here is an example:
#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
#[serde(from = "RlpProxy")]
enum Classify {
Zero(u8),
One(u8),
Ten((u8, u8))
}
impl From<RlpProxy> for Classify {
fn from(proxy: RlpProxy) -> Self {
let raw = proxy.raw();
let mut tree = proxy.rlp_tree();
if tree.value_count() == 2 {
return Classify::Ten(from_bytes(raw).unwrap())
}
let val = tree.next().unwrap()[0];
match val {
0 => Classify::Zero(0),
1 => Classify::One(1),
_ => panic!("Value Error.")
}
}
}We provide two (de)serializers for frequently used types in blockchain.
biguintfornum_bigint::BigUintbyte_arrayfor[u8; N]
Put #[serde(with = "biguint")] or #[serde(with = "byte_array")] before your struct field to use them.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent