provekit_acir 1.0.0-beta.11-alpha.2

ACIR is the IR that the VM processes, it is analogous to LLVM IR
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

use acir_field::AcirField;
use noir_protobuf::ProtoCodec;

use crate::native_types;
use crate::proto::acir::witness::{WitnessMap, WitnessStack};

use super::ProtoSchema;

impl<F> ProtoCodec<native_types::WitnessMap<F>, WitnessMap> for ProtoSchema<F>
where
    F: AcirField,
{
    fn encode(value: &native_types::WitnessMap<F>) -> WitnessMap {
        use crate::proto::acir::witness::witness_map::*;

        let values = value
            .clone()
            .into_iter()
            .map(|(w, f)| WitnessValue {
                witness: Self::encode_some(&w),
                field: Self::encode_some(&f),
            })
            .collect();

        WitnessMap { values }
    }

    fn decode(value: &WitnessMap) -> color_eyre::eyre::Result<native_types::WitnessMap<F>> {
        let mut wm = native_types::WitnessMap::default();
        for wv in &value.values {
            wm.insert(
                Self::decode_some_wrap(&wv.witness, "witness")?,
                Self::decode_some_wrap(&wv.field, "field")?,
            );
        }
        Ok(wm)
    }
}

impl<F> ProtoCodec<native_types::WitnessStack<F>, WitnessStack> for ProtoSchema<F>
where
    F: AcirField,
{
    fn encode(value: &native_types::WitnessStack<F>) -> WitnessStack {
        use crate::proto::acir::witness::witness_stack::*;

        let mut value = value.clone();
        let mut stack = Vec::new();
        while let Some(item) = value.pop() {
            stack.push(StackItem { index: item.index, witness: Self::encode_some(&item.witness) });
        }
        stack.reverse();

        WitnessStack { stack }
    }

    fn decode(value: &WitnessStack) -> color_eyre::eyre::Result<native_types::WitnessStack<F>> {
        let mut ws = native_types::WitnessStack::default();
        for item in &value.stack {
            ws.push(item.index, Self::decode_some_wrap(&item.witness, "witness")?);
        }
        Ok(ws)
    }
}