1use std::ops::Deref;
2use std::ops::DerefMut;
3
4use super::CompressedSNARK;
5use super::ProverKey;
6use super::PublicParams;
7use super::VerifierKey;
8use super::SNARK;
9use crate::circuit::Circuit;
10use crate::prelude::nova;
11use crate::prelude::nova::traits::circuit::TrivialCircuit;
12use crate::prelude::nova::traits::snark::RelaxedR1CSSNARKTrait;
13use crate::prelude::nova::traits::Engine;
14use crate::prelude::nova::RecursiveSNARK;
15
16impl<E1, E2> AsRef<SNARK<E1, E2>> for SNARK<E1, E2>
17where
18 E1: Engine<Base = <E2 as Engine>::Scalar>,
19 E2: Engine<Base = <E1 as Engine>::Scalar>,
20{
21 fn as_ref(&self) -> &Self {
22 self
23 }
24}
25
26impl<E1, E2> Deref for SNARK<E1, E2>
27where
28 E1: Engine<Base = <E2 as Engine>::Scalar>,
29 E2: Engine<Base = <E1 as Engine>::Scalar>,
30{
31 type Target =
32 RecursiveSNARK<E1, E2, Circuit<<E1 as Engine>::Scalar>, TrivialCircuit<E2::Scalar>>;
33 fn deref(&self) -> &Self::Target {
34 &self.inner
35 }
36}
37
38impl<E1, E2> DerefMut for SNARK<E1, E2>
39where
40 E1: Engine<Base = <E2 as Engine>::Scalar>,
41 E2: Engine<Base = <E1 as Engine>::Scalar>,
42{
43 fn deref_mut(&mut self) -> &mut Self::Target {
44 &mut self.inner
45 }
46}
47
48impl<E1, E2>
49 From<nova::PublicParams<E1, E2, Circuit<<E1 as Engine>::Scalar>, TrivialCircuit<E2::Scalar>>>
50 for PublicParams<E1, E2>
51where
52 E1: Engine<Base = <E2 as Engine>::Scalar>,
53 E2: Engine<Base = <E1 as Engine>::Scalar>,
54{
55 fn from(
56 pp: nova::PublicParams<E1, E2, Circuit<<E1 as Engine>::Scalar>, TrivialCircuit<E2::Scalar>>,
57 ) -> Self {
58 Self { inner: pp }
59 }
60}
61
62impl<E1, E2> Deref for PublicParams<E1, E2>
63where
64 E1: Engine<Base = <E2 as Engine>::Scalar>,
65 E2: Engine<Base = <E1 as Engine>::Scalar>,
66{
67 type Target =
68 nova::PublicParams<E1, E2, Circuit<<E1 as Engine>::Scalar>, TrivialCircuit<E2::Scalar>>;
69 fn deref(&self) -> &Self::Target {
70 &self.inner
71 }
72}
73
74impl<E1, E2> DerefMut for PublicParams<E1, E2>
75where
76 E1: Engine<Base = <E2 as Engine>::Scalar>,
77 E2: Engine<Base = <E1 as Engine>::Scalar>,
78{
79 fn deref_mut(&mut self) -> &mut Self::Target {
80 &mut self.inner
81 }
82}
83
84impl<E1, E2> AsRef<PublicParams<E1, E2>> for PublicParams<E1, E2>
85where
86 E1: Engine<Base = <E2 as Engine>::Scalar>,
87 E2: Engine<Base = <E1 as Engine>::Scalar>,
88{
89 fn as_ref(&self) -> &Self {
90 self
91 }
92}
93
94impl<E1, E2, S1, S2> Deref for ProverKey<E1, E2, S1, S2>
95where
96 E1: Engine<Base = <E2 as Engine>::Scalar>,
97 E2: Engine<Base = <E1 as Engine>::Scalar>,
98 S1: RelaxedR1CSSNARKTrait<E1>,
99 S2: RelaxedR1CSSNARKTrait<E2>,
100{
101 type Target = nova::ProverKey<
102 E1,
103 E2,
104 Circuit<<E1 as Engine>::Scalar>,
105 TrivialCircuit<<E2 as Engine>::Scalar>,
106 S1,
107 S2,
108 >;
109 fn deref(&self) -> &Self::Target {
110 &self.pk
111 }
112}
113
114impl<E1, E2, S1, S2> DerefMut for ProverKey<E1, E2, S1, S2>
115where
116 E1: Engine<Base = <E2 as Engine>::Scalar>,
117 E2: Engine<Base = <E1 as Engine>::Scalar>,
118 S1: RelaxedR1CSSNARKTrait<E1>,
119 S2: RelaxedR1CSSNARKTrait<E2>,
120{
121 fn deref_mut(&mut self) -> &mut Self::Target {
122 &mut self.pk
123 }
124}
125
126impl<E1, E2, S1, S2> AsRef<ProverKey<E1, E2, S1, S2>> for ProverKey<E1, E2, S1, S2>
127where
128 E1: Engine<Base = <E2 as Engine>::Scalar>,
129 E2: Engine<Base = <E1 as Engine>::Scalar>,
130 S1: RelaxedR1CSSNARKTrait<E1>,
131 S2: RelaxedR1CSSNARKTrait<E2>,
132{
133 fn as_ref(&self) -> &Self {
134 self
135 }
136}
137
138impl<E1, E2, S1, S2> Deref for VerifierKey<E1, E2, S1, S2>
139where
140 E1: Engine<Base = <E2 as Engine>::Scalar>,
141 E2: Engine<Base = <E1 as Engine>::Scalar>,
142 S1: RelaxedR1CSSNARKTrait<E1>,
143 S2: RelaxedR1CSSNARKTrait<E2>,
144{
145 type Target = nova::VerifierKey<
146 E1,
147 E2,
148 Circuit<<E1 as Engine>::Scalar>,
149 TrivialCircuit<<E2 as Engine>::Scalar>,
150 S1,
151 S2,
152 >;
153 fn deref(&self) -> &Self::Target {
154 &self.vk
155 }
156}
157
158impl<E1, E2, S1, S2> DerefMut for VerifierKey<E1, E2, S1, S2>
159where
160 E1: Engine<Base = <E2 as Engine>::Scalar>,
161 E2: Engine<Base = <E1 as Engine>::Scalar>,
162 S1: RelaxedR1CSSNARKTrait<E1>,
163 S2: RelaxedR1CSSNARKTrait<E2>,
164{
165 fn deref_mut(&mut self) -> &mut Self::Target {
166 &mut self.vk
167 }
168}
169
170impl<E1, E2, S1, S2> AsRef<VerifierKey<E1, E2, S1, S2>> for VerifierKey<E1, E2, S1, S2>
171where
172 E1: Engine<Base = <E2 as Engine>::Scalar>,
173 E2: Engine<Base = <E1 as Engine>::Scalar>,
174 S1: RelaxedR1CSSNARKTrait<E1>,
175 S2: RelaxedR1CSSNARKTrait<E2>,
176{
177 fn as_ref(&self) -> &Self {
178 self
179 }
180}
181
182impl<E1, E2, S1, S2> Deref for CompressedSNARK<E1, E2, S1, S2>
183where
184 E1: Engine<Base = <E2 as Engine>::Scalar>,
185 E2: Engine<Base = <E1 as Engine>::Scalar>,
186 S1: RelaxedR1CSSNARKTrait<E1>,
187 S2: RelaxedR1CSSNARKTrait<E2>,
188{
189 type Target = nova::CompressedSNARK<
190 E1,
191 E2,
192 Circuit<<E1 as Engine>::Scalar>,
193 TrivialCircuit<<E2 as Engine>::Scalar>,
194 S1,
195 S2,
196 >;
197 fn deref(&self) -> &Self::Target {
198 &self.inner
199 }
200}
201
202impl<E1, E2, S1, S2> DerefMut for CompressedSNARK<E1, E2, S1, S2>
203where
204 E1: Engine<Base = <E2 as Engine>::Scalar>,
205 E2: Engine<Base = <E1 as Engine>::Scalar>,
206 S1: RelaxedR1CSSNARKTrait<E1>,
207 S2: RelaxedR1CSSNARKTrait<E2>,
208{
209 fn deref_mut(&mut self) -> &mut Self::Target {
210 &mut self.inner
211 }
212}
213
214impl<E1, E2, S1, S2> AsRef<CompressedSNARK<E1, E2, S1, S2>> for CompressedSNARK<E1, E2, S1, S2>
215where
216 E1: Engine<Base = <E2 as Engine>::Scalar>,
217 E2: Engine<Base = <E1 as Engine>::Scalar>,
218 S1: RelaxedR1CSSNARKTrait<E1>,
219 S2: RelaxedR1CSSNARKTrait<E2>,
220{
221 fn as_ref(&self) -> &Self {
222 self
223 }
224}
225
226impl<E1, E2, S1, S2>
227 From<
228 nova::CompressedSNARK<
229 E1,
230 E2,
231 Circuit<<E1 as Engine>::Scalar>,
232 TrivialCircuit<E2::Scalar>,
233 S1,
234 S2,
235 >,
236 > for CompressedSNARK<E1, E2, S1, S2>
237where
238 E1: Engine<Base = <E2 as Engine>::Scalar>,
239 E2: Engine<Base = <E1 as Engine>::Scalar>,
240 S1: RelaxedR1CSSNARKTrait<E1>,
241 S2: RelaxedR1CSSNARKTrait<E2>,
242{
243 fn from(
244 snark: nova::CompressedSNARK<
245 E1,
246 E2,
247 Circuit<<E1 as Engine>::Scalar>,
248 TrivialCircuit<E2::Scalar>,
249 S1,
250 S2,
251 >,
252 ) -> Self {
253 Self { inner: snark }
254 }
255}
256
257impl<E1, E2, S1, S2> From<CompressedSNARK<E1, E2, S1, S2>>
258 for nova::CompressedSNARK<
259 E1,
260 E2,
261 Circuit<<E1 as Engine>::Scalar>,
262 TrivialCircuit<E2::Scalar>,
263 S1,
264 S2,
265 >
266where
267 E1: Engine<Base = <E2 as Engine>::Scalar>,
268 E2: Engine<Base = <E1 as Engine>::Scalar>,
269 S1: RelaxedR1CSSNARKTrait<E1>,
270 S2: RelaxedR1CSSNARKTrait<E2>,
271{
272 fn from(val: CompressedSNARK<E1, E2, S1, S2>) -> Self {
273 val.inner
274 }
275}