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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use bellpepper_core::{Circuit, SynthesisError};

use super::prover::{create_proof_batch_priority, create_random_proof_batch_priority};
use super::{ParameterSource, Proof};
use crate::gpu;
use pairing::MultiMillerLoop;
use rand_core::RngCore;

/// Creates a single proof where the randomization vector is already predefined
pub fn create_proof<E, C, P: ParameterSource<E>>(
    circuit: C,
    params: P,
    r: E::Fr,
    s: E::Fr,
) -> Result<Proof<E>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    let proofs =
        create_proof_batch_priority::<E, C, P>(vec![circuit], params, vec![r], vec![s], false)?;
    Ok(proofs.into_iter().next().unwrap())
}

/// Creates a single proof.
pub fn create_random_proof<E, C, R, P: ParameterSource<E>>(
    circuit: C,
    params: P,
    rng: &mut R,
) -> Result<Proof<E>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    R: RngCore,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    let proofs =
        create_random_proof_batch_priority::<E, C, R, P>(vec![circuit], params, rng, false)?;
    Ok(proofs.into_iter().next().unwrap())
}

/// Creates a batch of proofs where the randomization vector is already predefined
pub fn create_proof_batch<E, C, P: ParameterSource<E>>(
    circuits: Vec<C>,
    params: P,
    r: Vec<E::Fr>,
    s: Vec<E::Fr>,
) -> Result<Vec<Proof<E>>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    create_proof_batch_priority::<E, C, P>(circuits, params, r, s, false)
}

/// Creates a batch of proofs.
pub fn create_random_proof_batch<E, C, R, P: ParameterSource<E>>(
    circuits: Vec<C>,
    params: P,
    rng: &mut R,
) -> Result<Vec<Proof<E>>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    R: RngCore,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    create_random_proof_batch_priority::<E, C, R, P>(circuits, params, rng, false)
}

/// Creates a single proof.
/// When several proofs are run in parallel on the GPU, it will get priority and will never be
/// aborted or pushed down to CPU.
pub fn create_proof_in_priority<E, C, P: ParameterSource<E>>(
    circuit: C,
    params: P,
    r: E::Fr,
    s: E::Fr,
) -> Result<Proof<E>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    let proofs =
        create_proof_batch_priority::<E, C, P>(vec![circuit], params, vec![r], vec![s], true)?;
    Ok(proofs.into_iter().next().unwrap())
}

/// Creates a batch of proofs.
/// When several proofs are run in parallel on the GPU, it will get priority and will never be
/// aborted or pushed down to CPU.
pub fn create_random_proof_in_priority<E, C, R, P: ParameterSource<E>>(
    circuit: C,
    params: P,
    rng: &mut R,
) -> Result<Proof<E>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    R: RngCore,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    let proofs =
        create_random_proof_batch_priority::<E, C, R, P>(vec![circuit], params, rng, true)?;
    Ok(proofs.into_iter().next().unwrap())
}

/// Creates a batch of proofs where the randomization vector is already predefined.
/// When several proofs are run in parallel on the GPU, it will get priority and will never be
/// aborted or pushed down to CPU.
pub fn create_proof_batch_in_priority<E, C, P: ParameterSource<E>>(
    circuits: Vec<C>,
    params: P,
    r: Vec<E::Fr>,
    s: Vec<E::Fr>,
) -> Result<Vec<Proof<E>>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    create_proof_batch_priority::<E, C, P>(circuits, params, r, s, true)
}

/// Creates a batch of proofs.
/// When several proofs are run in parallel on the GPU, it will get priority and will never be
/// aborted or pushed down to CPU.
pub fn create_random_proof_batch_in_priority<E, C, R, P: ParameterSource<E>>(
    circuits: Vec<C>,
    params: P,
    rng: &mut R,
) -> Result<Vec<Proof<E>>, SynthesisError>
where
    E: MultiMillerLoop,
    C: Circuit<E::Fr> + Send,
    R: RngCore,
    E::Fr: gpu::GpuName,
    E::G1Affine: gpu::GpuName,
    E::G2Affine: gpu::GpuName,
{
    create_random_proof_batch_priority::<E, C, R, P>(circuits, params, rng, true)
}