axiom-eth 0.4.0

This crate is the main library for building ZK circuits that prove data about the Ethereum virtual machine (EVM).
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

use crate::Field;
use crate::{
    mpt::{MPTInput, MPTProof, MPTProofWitness},
    rlp::types::{RlpArrayWitness, RlpFieldTrace, RlpFieldWitness},
};
use ethers_core::types::H256;
use getset::Getters;
use halo2_base::{AssignedValue, Context};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug)]
pub struct EthReceiptInputAssigned<F: Field> {
    pub tx_idx: AssignedValue<F>,
    pub proof: MPTProof<F>,
}

#[derive(Clone, Debug, Getters)]
pub struct EthReceiptWitness<F: Field> {
    pub receipt_type: AssignedValue<F>,
    pub tx_idx: AssignedValue<F>,
    pub idx_witness: RlpFieldWitness<F>,
    #[getset(get = "pub")]
    pub(crate) value: RlpArrayWitness<F>,
    pub logs: RlpArrayWitness<F>,
    #[getset(get = "pub")]
    pub(crate) mpt_witness: MPTProofWitness<F>,
}

#[derive(Clone, Debug)]
pub struct EthReceiptTrace<F: Field> {
    pub receipt_type: AssignedValue<F>,
    pub value_trace: Vec<RlpFieldTrace<F>>,
}

#[derive(Clone, Debug)]
pub struct EthReceiptFieldWitness<F: Field> {
    pub field_idx: AssignedValue<F>,
    /// Value of the field, right padded to some max length
    pub value_bytes: Vec<AssignedValue<F>>,
    pub value_len: AssignedValue<F>,
}

#[derive(Clone, Debug)]
pub struct EthReceiptLogWitness<F: Field> {
    pub log_idx: AssignedValue<F>,
    /// Log in bytes, right padded to some max length
    pub log_bytes: Vec<AssignedValue<F>>,
    pub log_len: AssignedValue<F>,
}

#[derive(Clone, Debug)]
pub struct EthReceiptLogFieldWitness<F: Field> {
    /// Witness for parsed log list
    pub log_list: RlpArrayWitness<F>,
    /// Witness for parsed topics list
    pub topics_list: RlpArrayWitness<F>,
}

impl<F: Field> EthReceiptLogFieldWitness<F> {
    /// Variable number of topics.
    pub fn num_topics(&self) -> AssignedValue<F> {
        self.topics_list.list_len.unwrap()
    }
    /// List of topics, each topic as bytes. The list is padded to fixed length.
    pub fn topics_bytes(&self) -> Vec<Vec<AssignedValue<F>>> {
        self.topics_list.field_witness.iter().map(|h| h.field_cells.clone()).collect()
    }
    pub fn address(&self) -> &[AssignedValue<F>] {
        &self.log_list.field_witness[0].field_cells
    }
    pub fn data_bytes(&self) -> &[AssignedValue<F>] {
        &self.log_list.field_witness[2].field_cells
    }
    pub fn data_len(&self) -> AssignedValue<F> {
        self.log_list.field_witness[2].field_len
    }
}

// rust native types

#[derive(Clone, Debug, Hash, Serialize, Deserialize)]
pub struct EthReceiptInput {
    pub idx: usize,
    pub proof: MPTInput,
}

#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
pub struct EthBlockReceiptInput {
    pub block_number: u32,
    pub block_hash: H256, // provided for convenience, actual block_hash is computed from block_header
    pub block_header: Vec<u8>,
    pub receipt: EthReceiptInput,
}

impl EthReceiptInput {
    pub fn assign<F: Field>(self, ctx: &mut Context<F>) -> EthReceiptInputAssigned<F> {
        // let block_hash = encode_h256_to_field(&self.block_hash);
        // let block_hash = block_hash.map(|block_hash| ctx.load_witness(block_hash));
        let tx_idx = ctx.load_witness(F::from(self.idx as u64));
        let proof = self.proof.assign(ctx);
        EthReceiptInputAssigned { tx_idx, proof }
    }
}