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

use halo2_base::AssignedValue;

use crate::{
    utils::component::{circuit::PromiseBuilder, types::LogicalEmpty, ComponentType},
    Field,
};

use super::{
    combo::PromiseBuilderCombo,
    empty::EmptyPromiseLoader,
    multi::{ComponentTypeList, MultiPromiseLoader, RlcAdapter},
    single,
};

/// Sub-trait for dummy fulfillment. Only used to create dummy circuits for
/// the purpose of proving/verifying key generation.
pub trait DummyPromiseBuilder<F: Field>: PromiseBuilder<F> {
    /// This should be the same behavior as `fulfill_promise_results` but with
    /// dummy results. The exact configuration of the results is determined by
    /// the `loader_params` of the promise builder.
    fn fulfill_dummy_promise_results(&mut self);
}

impl<F: Field> DummyPromiseBuilder<F> for EmptyPromiseLoader<F> {
    fn fulfill_dummy_promise_results(&mut self) {}
}

impl<F: Field, T: ComponentType<F>> DummyPromiseBuilder<F> for single::PromiseLoader<F, T> {
    fn fulfill_dummy_promise_results(&mut self) {
        self.comp_loader.load_dummy_promise_results();
    }
}

impl<F: Field, FIRST: DummyPromiseBuilder<F>, SECOND: DummyPromiseBuilder<F>> DummyPromiseBuilder<F>
    for PromiseBuilderCombo<F, FIRST, SECOND>
{
    fn fulfill_dummy_promise_results(&mut self) {
        let (first, second) = &mut self.to_combine;
        first.fulfill_dummy_promise_results();
        second.fulfill_dummy_promise_results();
    }
}

impl<
        F: Field,
        VT: ComponentType<
            F,
            OutputValue = LogicalEmpty<F>,
            OutputWitness = LogicalEmpty<AssignedValue<F>>,
        >,
        CLIST: ComponentTypeList<F>,
        A: RlcAdapter<F>,
    > DummyPromiseBuilder<F> for MultiPromiseLoader<F, VT, CLIST, A>
{
    fn fulfill_dummy_promise_results(&mut self) {
        for comp_loader in &mut self.comp_loaders {
            comp_loader.load_dummy_promise_results();
        }
    }
}