Struct Prover 

pub struct Prover<B> { /* private fields */ }

High-level prover that orchestrates the zero-knowledge proof generation process.

The Prover serves as the main entry point for creating zero-knowledge proofs using a specific backend implementation. It handles the circuit compilation process and creates circuit-specific provers for actual proof generation.

Type Parameters

• B - The backend implementation that defines the underlying cryptographic operations

Implementations

impl<B> Prover<B>

where B: Backend,

pub fn new() -> Prover<B>

Creates a new prover instance with the specified backend.

This initializes the backend and prepares the prover for circuit compilation. The backend is created using its Backend::new() method.

Returns

A new Prover instance ready for circuit compilation.

Examples found in repository

examples/simple.rs (line 42)

fn run<B: Backend>() {
    let prover = Prover::<B>::new();

    let circuit_prover = prover.compile_circuit::<TestCircuit>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    let circuit_witness = Witness::<TestCircuit> {
        a: 3,
        b: 4,
        c: 7, // 3 + 4 = 7
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

examples/constant.rs (line 45)

fn run<B: Backend>() {
    let prover = Prover::<B>::new();

    let circuit_prover = prover.compile_circuit::<TestCircuit>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    let circuit_witness = Witness::<TestCircuit> {
        a: 3,
        b: 4,
        c: 17, // 3 + 4 = 7
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

examples/generics.rs (line 30)

fn run() {
    let prover = Groth16BN254GnarkProver::new();

    let circuit_prover = prover.compile_circuit::<TestCircuit<u32>>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    let circuit_witness = Witness::<TestCircuit<u32>> {
        a: 3,
        b: 4,
        c: 7, // 3 + 4 = 7
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

examples/subcircuit.rs (line 59)

fn main() {
    let prover = PlonkBN254GnarkProver::new();

    let circuit_prover = prover.compile_circuit::<CompositeCircuit>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    // let solidity_contract = vk.export_solidity().unwrap();
    // println!("Solidity contract: {}", solidity_contract);

    let circuit_witness = Witness::<CompositeCircuit> {
        adder: Witness::<AdderCircuit> { a: 1, b: 2, sum: 3 },
        multiplier: Witness::<MultiplierCircuit> {
            x: 2,
            y: 3,
            product: 6,
        },
        final_result: 9,
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let solidity_proof = proof.to_solidity().unwrap();
    println!("Solidity proof: {:#?}", solidity_proof);

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

pub fn compile_circuit<C>( self, ) -> Result<CircuitProver<B, <C as CircuitElement>::CircuitWitness>, Error>

where C: CircuitElement, <<C as CircuitElement>::CircuitWitness as CircuitWitness>::CircuitElement: Circuit,

Compiles a circuit and creates a circuit-specific prover.

This method takes a circuit witness type and compiles it into a form suitable for the backend. It creates the circuit definition by instantiating the circuit with fresh variables and then compiling it using the backend.

Type Parameters

• C - The circuit witness type that implements CircuitWitness

Returns

Returns a CircuitProver instance that can be used for setup, proving, and verification operations on the compiled circuit.

Errors

This function may return an error if:

• Circuit compilation fails due to invalid constraints
• The backend cannot represent the circuit
• Internal compilation errors occur

Examples found in repository

examples/simple.rs (line 44)

fn run<B: Backend>() {
    let prover = Prover::<B>::new();

    let circuit_prover = prover.compile_circuit::<TestCircuit>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    let circuit_witness = Witness::<TestCircuit> {
        a: 3,
        b: 4,
        c: 7, // 3 + 4 = 7
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

examples/constant.rs (line 47)

fn run<B: Backend>() {
    let prover = Prover::<B>::new();

    let circuit_prover = prover.compile_circuit::<TestCircuit>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    let circuit_witness = Witness::<TestCircuit> {
        a: 3,
        b: 4,
        c: 17, // 3 + 4 = 7
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

examples/generics.rs (line 32)

fn run() {
    let prover = Groth16BN254GnarkProver::new();

    let circuit_prover = prover.compile_circuit::<TestCircuit<u32>>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    let circuit_witness = Witness::<TestCircuit<u32>> {
        a: 3,
        b: 4,
        c: 7, // 3 + 4 = 7
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

examples/subcircuit.rs (line 61)

fn main() {
    let prover = PlonkBN254GnarkProver::new();

    let circuit_prover = prover.compile_circuit::<CompositeCircuit>().unwrap();
    let (pk, vk) = circuit_prover.setup().unwrap();

    // let solidity_contract = vk.export_solidity().unwrap();
    // println!("Solidity contract: {}", solidity_contract);

    let circuit_witness = Witness::<CompositeCircuit> {
        adder: Witness::<AdderCircuit> { a: 1, b: 2, sum: 3 },
        multiplier: Witness::<MultiplierCircuit> {
            x: 2,
            y: 3,
            product: 6,
        },
        final_result: 9,
    };

    let proof = circuit_prover.prove(&pk, &circuit_witness).unwrap();

    let solidity_proof = proof.to_solidity().unwrap();
    println!("Solidity proof: {:#?}", solidity_proof);

    let public_witness = circuit_witness.into_public_witness();
    circuit_prover.verify(&vk, &proof, public_witness).unwrap();
}

Trait Implementations

impl<B> Default for Prover<B>

where B: Backend,

fn default() -> Prover<B>

Returns the “default value” for a type.