sigma-compiler 0.2.2

Crate for automatically generating code for sigma zero-knowledge proof protocols of more complex statements than are supported by the sigma-proofs crate. The statements given to this crate are compiled into statements about linear combinations of points, and transformed into the sigma-proofs API.
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

#![allow(non_snake_case)]
use curve25519_dalek::ristretto::RistrettoPoint as G;
use group::Group;
use sha2::Sha512;
use sigma_compiler::*;

#[test]
fn threshold_test() -> sigma_proofs::errors::Result<()> {
    sigma_compiler! { thresh3,
        (x1, x2, x3, x4, x5, rand r),
        (C, const cind G0, const cind G1, const cind G2, const cind G3,
            const cind G4, const cind G5),
        C = r*G0 + x1*G1 + x2*G2 + x3*G3 + x4*G4 + x5*G5,
        THRESH ( 3, x1 = 1, x2 = 2, x3 = 3, x4 = 4, x5 = 5 )
    }

    type Scalar = <G as Group>::Scalar;
    let mut rng = rand::thread_rng();
    let G0 = G::generator();
    let G1 = G::hash_from_bytes::<Sha512>(b"Generator G1");
    let G2 = G::hash_from_bytes::<Sha512>(b"Generator G2");
    let G3 = G::hash_from_bytes::<Sha512>(b"Generator G3");
    let G4 = G::hash_from_bytes::<Sha512>(b"Generator G4");
    let G5 = G::hash_from_bytes::<Sha512>(b"Generator G5");
    let r = Scalar::random(&mut rng);
    let y = Scalar::random(&mut rng);

    // Iterate over all combinations of 5 bits
    for true_pattern in 0u32..32 {
        let x1 = Scalar::from(if true_pattern & 1 == 0 { 2u32 } else { 1u32 });
        let x2 = Scalar::from(if true_pattern & 2 == 0 { 3u32 } else { 2u32 });
        let x3 = Scalar::from(if true_pattern & 4 == 0 { 4u32 } else { 3u32 });
        let x4 = Scalar::from(if true_pattern & 8 == 0 { 5u32 } else { 4u32 });
        let x5 = Scalar::from(if true_pattern & 16 == 0 { 6u32 } else { 5u32 });
        let C = r * G0 + x1 * G1 + x2 * G2 + x3 * G3 + x4 * G4 + x5 * G5;

        let num_true = true_pattern.count_ones();

        let instance = thresh3::Instance {
            C,
            G0,
            G1,
            G2,
            G3,
            G4,
            G5,
        };
        let witness = thresh3::Witness {
            x1,
            x2,
            x3,
            x4,
            x5,
            r,
        };

        match thresh3::prove(&instance, &witness, b"thresh_test", &mut rng) {
            Ok(_) if num_true < 3 => {
                panic!("THRESH passed when it should have failed (true_pattern = {true_pattern})")
            }
            Err(_) if num_true >= 3 => {
                panic!("THRESH failed when it should have passed (true_pattern = {true_pattern})")
            }
            Ok(proof) => {
                thresh3::verify(&instance, &proof, b"thresh_test")?;
            }
            Err(_) => {}
        }
    }
    Ok(())
}