acvm 0.46.0

The virtual machine that processes ACIR given a backend/proof system.
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

use acir::{
    circuit::opcodes::FunctionInput,
    native_types::{Witness, WitnessMap},
    BlackBoxFunc, FieldElement,
};

use acvm_blackbox_solver::BigIntSolver;

use crate::pwg::OpcodeResolutionError;

/// Resolve BigInt opcodes by storing BigInt values (and their moduli) by their ID in the BigIntSolver
/// - When it encounters a bigint operation opcode, it performs the operation on the stored values
/// and store the result using the provided ID.
/// - When it gets a to_bytes opcode, it simply looks up the value and resolves the output witness accordingly.
#[derive(Default)]
pub(crate) struct AcvmBigIntSolver {
    bigint_solver: BigIntSolver,
}

impl AcvmBigIntSolver {
    pub(crate) fn bigint_from_bytes(
        &mut self,
        inputs: &[FunctionInput],
        modulus: &[u8],
        output: u32,
        initial_witness: &mut WitnessMap,
    ) -> Result<(), OpcodeResolutionError> {
        let bytes = inputs
            .iter()
            .map(|input| initial_witness.get(&input.witness).unwrap().to_u128() as u8)
            .collect::<Vec<u8>>();
        self.bigint_solver.bigint_from_bytes(&bytes, modulus, output)?;
        Ok(())
    }

    pub(crate) fn bigint_to_bytes(
        &self,
        input: u32,
        outputs: &[Witness],
        initial_witness: &mut WitnessMap,
    ) -> Result<(), OpcodeResolutionError> {
        let mut bytes = self.bigint_solver.bigint_to_bytes(input)?;
        while bytes.len() < outputs.len() {
            bytes.push(0);
        }
        bytes.iter().zip(outputs.iter()).for_each(|(byte, output)| {
            initial_witness.insert(*output, FieldElement::from(*byte as u128));
        });
        Ok(())
    }

    pub(crate) fn bigint_op(
        &mut self,
        lhs: u32,
        rhs: u32,
        output: u32,
        func: BlackBoxFunc,
    ) -> Result<(), OpcodeResolutionError> {
        self.bigint_solver.bigint_op(lhs, rhs, output, func)?;
        Ok(())
    }
}