lettuce 0.1.3

Healthy lattice consructions in pure Rust.
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 super::*;
use crate::*;

#[derive(Default)]
pub struct TransparentInnerProdNIZKArg<E: RingElement> {
    pub wtns_hash: [u8; 32], // used for rlc challenge
    pub wtns_args: HashMap<u64, TransparentInnerProd<10, E>>,
    pub constraints: Vec<TransparentInnerProdBuilderConstraint>,
}

impl<E: RingElement> TransparentInnerProdNIZKArg<E> {
    pub fn builder() -> TransparentInnerProdSystemBuilder<E> {
        TransparentInnerProdSystemBuilder::default()
    }

    pub fn verify(&self) -> Result<()> {
        let transcript = Transcript::<E>::from(&self.wtns_hash);
        for constraint in &self.constraints {
            match constraint {
                TransparentInnerProdBuilderConstraint::Mul(a_i, b_i, c_i) => {
                    if let Some(c) = self.wtns_args.get(c_i)
                        && let Some(a) = self.wtns_args.get(a_i)
                        && let Some(b) = self.wtns_args.get(b_i)
                    {
                        let a = a.eval(transcript.clone())?;
                        let b = b.eval(transcript.clone())?;
                        let c = c.eval(transcript.clone())?;
                        for ((a, b), c) in a.into_iter().zip(b.into_iter()).zip(c.into_iter()) {
                            println!("{a} * {b} = {c}");
                            if a * b != c {
                                anyhow::bail!("mul constraint failed");
                            }
                        }
                    } else {
                        anyhow::bail!("non-existent witness index");
                    }
                }
                TransparentInnerProdBuilderConstraint::Add(a_i, b_i, c_i) => {
                    // this is simple equality check
                    if let Some(c) = self.wtns_args.get(c_i)
                        && let Some(a) = self.wtns_args.get(a_i)
                        && let Some(b) = self.wtns_args.get(b_i)
                    {
                        let a = a.eval(transcript.clone())?;
                        let b = b.eval(transcript.clone())?;
                        let c = c.eval(transcript.clone())?;
                        for ((a, b), c) in a.into_iter().zip(b.into_iter()).zip(c.into_iter()) {
                            if a + b != c {
                                anyhow::bail!("add constraint failed");
                            }
                        }
                    } else {
                        anyhow::bail!("non-existent witness index");
                    }
                }
            }
        }
        Ok(())
    }
}