zkinterface_bellman 1.3.2

Bellman circuit construction and proving system for zkInterface
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

use zkinterface::{Reader, Result};
use zkinterface_bellman::zkif_backend::{setup, prove, verify, validate};
use std::io;
use std::io::Read;
use std::env;
use bls12_381::Scalar as Bls12Scalar;


const USAGE: &str = "Bellman prover.

Validate that the witness satisfies the constraints:

    zkif_bellman validate

Print the circuit in a text-form:

    zkif_bellman print

Generate public parameters:

    zkif_bellman setup <workspace>

Generate a proof using the public parameters:

    zkif_bellman prove <workspace>

The circuit and witness are read from stdin in zkInterface format.
The filenames of keys and proofs are derived from the workspace argument; defaults to the current directory.

";

pub fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let args: Vec<&str> = args.iter().map(|a| &a[..]).collect();
    if args.len() <= 1 {
        eprintln!("{}", USAGE);
        return Err("Missing command.".into());
    }

    let mut reader = Reader::new();
    let mut buffer = vec![];
    io::stdin().read_to_end(&mut buffer)?;
    reader.push_message(buffer)?;

    let command = args[1];
    let workspace = env::current_dir()?;

    match &command[..] {
        "validate" => validate::<Bls12Scalar>(&reader, false),
        "print" => validate::<Bls12Scalar>(&reader, true),
        "setup" => setup(&reader, &workspace),
        "prove" => prove(&reader, &workspace),
        "verify" => verify(&reader, &workspace),
        _ => {
            eprintln!("{}", USAGE);
            Err(format!("Unknown command {}", command).into())
        }
    }
}