go-snark/wasm/utils/utils.go
wasm/utils/utils.goRaw
1package utils
2
3import (
4 "errors"
5 "math/big"
6
7 snark "github.com/arnaucube/go-snark"
8 "github.com/arnaucube/go-snark/circuitcompiler"
9)
10
11// []*big.Int
12func ArrayBigIntToString(b []*big.Int) []string {
13 var o []string
14 for i := 0; i < len(b); i++ {
15 o = append(o, b[i].String())
16 }
17 return o
18}
19func ArrayStringToBigInt(s []string) ([]*big.Int, error) {
20 var px []*big.Int
21 for i := 0; i < len(s); i++ {
22 param, ok := new(big.Int).SetString(s[i], 10)
23 if !ok {
24 return nil, errors.New("error parsing px from pxString")
25 }
26 px = append(px, param)
27 }
28 return px, nil
29}
30
31// [3]*big.Int
32func String3ToBigInt(s [3]string) ([3]*big.Int, error) {
33 var o [3]*big.Int
34 for i := 0; i < len(s); i++ {
35 param, ok := new(big.Int).SetString(s[i], 10)
36 if !ok {
37 return o, errors.New("error parsing [3]*big.Int from [3]string")
38 }
39 o[i] = param
40 }
41 return o, nil
42}
43func BigInt3ToString(b [3]*big.Int) [3]string {
44 var o [3]string
45 o[0] = b[0].String()
46 o[1] = b[1].String()
47 o[2] = b[2].String()
48 return o
49}
50
51// [][3]*big.Int
52func Array3StringToBigInt(s [][3]string) ([][3]*big.Int, error) {
53 var o [][3]*big.Int
54 for i := 0; i < len(s); i++ {
55 parsed, err := String3ToBigInt(s[i])
56 if err != nil {
57 return o, err
58 }
59 o = append(o, parsed)
60 }
61 return o, nil
62}
63func Array3BigIntToString(b [][3]*big.Int) [][3]string {
64 var o [][3]string
65 for i := 0; i < len(b); i++ {
66 o = append(o, BigInt3ToString(b[i]))
67 }
68 return o
69}
70
71func String2ToBigInt(s [2]string) ([2]*big.Int, error) {
72 var o [2]*big.Int
73 for i := 0; i < len(s); i++ {
74 param, ok := new(big.Int).SetString(s[i], 10)
75 if !ok {
76 return o, errors.New("error parsing [2]*big.Int from [2]string")
77 }
78 o[i] = param
79 }
80 return o, nil
81}
82
83// [3][2]*big.Int
84func String32ToBigInt(s [3][2]string) ([3][2]*big.Int, error) {
85 var o [3][2]*big.Int
86 var err error
87
88 o[0], err = String2ToBigInt(s[0])
89 if err != nil {
90 return o, err
91 }
92 o[1], err = String2ToBigInt(s[1])
93 if err != nil {
94 return o, err
95 }
96 o[2], err = String2ToBigInt(s[2])
97 if err != nil {
98 return o, err
99 }
100 return o, nil
101}
102func BigInt32ToString(b [3][2]*big.Int) [3][2]string {
103 var o [3][2]string
104 o[0][0] = b[0][0].String()
105 o[0][1] = b[0][1].String()
106 o[1][0] = b[1][0].String()
107 o[1][1] = b[1][1].String()
108 o[2][0] = b[2][0].String()
109 o[2][1] = b[2][1].String()
110 return o
111}
112
113// [][3][2]*big.Int
114func Array32StringToBigInt(s [][3][2]string) ([][3][2]*big.Int, error) {
115 var o [][3][2]*big.Int
116 for i := 0; i < len(s); i++ {
117 parsed, err := String32ToBigInt(s[i])
118 if err != nil {
119 return o, err
120 }
121 o = append(o, parsed)
122 }
123 return o, nil
124}
125func Array32BigIntToString(b [][3][2]*big.Int) [][3][2]string {
126 var o [][3][2]string
127 for i := 0; i < len(b); i++ {
128 o = append(o, BigInt32ToString(b[i]))
129 }
130 return o
131}
132
133// Setup
134type SetupString struct {
135 // public
136 G1T [][3]string
137 G2T [][3][2]string
138 Pk struct {
139 A [][3]string
140 B [][3][2]string
141 C [][3]string
142 Kp [][3]string
143 Ap [][3]string
144 Bp [][3]string
145 Cp [][3]string
146 Z []string
147 }
148 Vk struct {
149 Vka [3][2]string
150 Vkb [3]string
151 Vkc [3][2]string
152 IC [][3]string
153 G1Kbg [3]string
154 G2Kbg [3][2]string
155 G2Kg [3][2]string
156 Vkz [3][2]string
157 }
158}
159
160func SetupToString(setup snark.Setup) SetupString {
161 var s SetupString
162 s.G1T = Array3BigIntToString(setup.G1T)
163 s.G2T = Array32BigIntToString(setup.G2T)
164 s.Pk.A = Array3BigIntToString(setup.Pk.A)
165 s.Pk.B = Array32BigIntToString(setup.Pk.B)
166 s.Pk.C = Array3BigIntToString(setup.Pk.C)
167 s.Pk.Kp = Array3BigIntToString(setup.Pk.Kp)
168 s.Pk.Ap = Array3BigIntToString(setup.Pk.Ap)
169 s.Pk.Bp = Array3BigIntToString(setup.Pk.Bp)
170 s.Pk.Cp = Array3BigIntToString(setup.Pk.Cp)
171 s.Pk.Z = ArrayBigIntToString(setup.Pk.Z)
172 s.Vk.Vka = BigInt32ToString(setup.Vk.Vka)
173 s.Vk.Vkb = BigInt3ToString(setup.Vk.Vkb)
174 s.Vk.Vkc = BigInt32ToString(setup.Vk.Vkc)
175 s.Vk.IC = Array3BigIntToString(setup.Vk.IC)
176 s.Vk.G1Kbg = BigInt3ToString(setup.Vk.G1Kbg)
177 s.Vk.G2Kbg = BigInt32ToString(setup.Vk.G2Kbg)
178 s.Vk.G2Kg = BigInt32ToString(setup.Vk.G2Kg)
179 s.Vk.Vkz = BigInt32ToString(setup.Vk.Vkz)
180 return s
181}
182func SetupFromString(s SetupString) (snark.Setup, error) {
183 var o snark.Setup
184 var err error
185 o.G1T, err = Array3StringToBigInt(s.G1T)
186 if err != nil {
187 return o, err
188 }
189 o.G2T, err = Array32StringToBigInt(s.G2T)
190 if err != nil {
191 return o, err
192 }
193 o.Pk.A, err = Array3StringToBigInt(s.Pk.A)
194 if err != nil {
195 return o, err
196 }
197 o.Pk.B, err = Array32StringToBigInt(s.Pk.B)
198 if err != nil {
199 return o, err
200 }
201 o.Pk.C, err = Array3StringToBigInt(s.Pk.C)
202 if err != nil {
203 return o, err
204 }
205 o.Pk.Kp, err = Array3StringToBigInt(s.Pk.Kp)
206 if err != nil {
207 return o, err
208 }
209 o.Pk.Ap, err = Array3StringToBigInt(s.Pk.Ap)
210 if err != nil {
211 return o, err
212 }
213 o.Pk.Bp, err = Array3StringToBigInt(s.Pk.Bp)
214 if err != nil {
215 return o, err
216 }
217 o.Pk.Cp, err = Array3StringToBigInt(s.Pk.Cp)
218 if err != nil {
219 return o, err
220 }
221 o.Pk.Z, err = ArrayStringToBigInt(s.Pk.Z)
222 if err != nil {
223 return o, err
224 }
225
226 o.Vk.Vka, err = String32ToBigInt(s.Vk.Vka)
227 if err != nil {
228 return o, err
229 }
230 o.Vk.Vkb, err = String3ToBigInt(s.Vk.Vkb)
231 if err != nil {
232 return o, err
233 }
234 o.Vk.Vkc, err = String32ToBigInt(s.Vk.Vkc)
235 if err != nil {
236 return o, err
237 }
238 o.Vk.IC, err = Array3StringToBigInt(s.Vk.IC)
239 if err != nil {
240 return o, err
241 }
242 o.Vk.G1Kbg, err = String3ToBigInt(s.Vk.G1Kbg)
243 if err != nil {
244 return o, err
245 }
246 o.Vk.G2Kbg, err = String32ToBigInt(s.Vk.G2Kbg)
247 if err != nil {
248 return o, err
249 }
250 o.Vk.G2Kg, err = String32ToBigInt(s.Vk.G2Kg)
251 if err != nil {
252 return o, err
253 }
254 o.Vk.Vkz, err = String32ToBigInt(s.Vk.Vkz)
255 if err != nil {
256 return o, err
257 }
258
259 return o, nil
260
261}
262
263// circuit
264type CircuitString struct {
265 NVars int
266 NPublic int
267 NSignals int
268 PrivateInputs []string
269 PublicInputs []string
270 Signals []string
271 Witness []string
272 Constraints []circuitcompiler.Constraint
273 R1CS struct {
274 A [][]string
275 B [][]string
276 C [][]string
277 }
278}
279
280func ArrayArrayBigIntToString(b [][]*big.Int) [][]string {
281 var o [][]string
282 for i := 0; i < len(b); i++ {
283 o = append(o, ArrayBigIntToString(b[i]))
284 }
285 return o
286}
287func ArrayArrayStringToBigInt(s [][]string) ([][]*big.Int, error) {
288 var o [][]*big.Int
289 for i := 0; i < len(s); i++ {
290 parsed, err := ArrayStringToBigInt(s[i])
291 if err != nil {
292 return o, err
293 }
294 o = append(o, parsed)
295 }
296 return o, nil
297}
298func CircuitToString(c circuitcompiler.Circuit) CircuitString {
299 var cs CircuitString
300 cs.NVars = c.NVars
301 cs.NPublic = c.NPublic
302 cs.NSignals = c.NSignals
303 cs.PrivateInputs = c.PrivateInputs
304 cs.PublicInputs = c.PublicInputs
305 cs.Signals = c.Signals
306 cs.Witness = ArrayBigIntToString(c.Witness)
307 cs.Constraints = c.Constraints
308 cs.R1CS.A = ArrayArrayBigIntToString(c.R1CS.A)
309 cs.R1CS.B = ArrayArrayBigIntToString(c.R1CS.B)
310 cs.R1CS.C = ArrayArrayBigIntToString(c.R1CS.C)
311 return cs
312}
313func CircuitFromString(cs CircuitString) (circuitcompiler.Circuit, error) {
314 var c circuitcompiler.Circuit
315 var err error
316 c.NVars = cs.NVars
317 c.NPublic = cs.NPublic
318 c.NSignals = cs.NSignals
319 c.PrivateInputs = cs.PrivateInputs
320 c.PublicInputs = cs.PublicInputs
321 c.Signals = cs.Signals
322 c.Witness, err = ArrayStringToBigInt(cs.Witness)
323 if err != nil {
324 return c, err
325 }
326 c.Constraints = cs.Constraints
327 c.R1CS.A, err = ArrayArrayStringToBigInt(cs.R1CS.A)
328 if err != nil {
329 return c, err
330 }
331 c.R1CS.B, err = ArrayArrayStringToBigInt(cs.R1CS.B)
332 if err != nil {
333 return c, err
334 }
335 c.R1CS.C, err = ArrayArrayStringToBigInt(cs.R1CS.C)
336 if err != nil {
337 return c, err
338 }
339 return c, nil
340}
341
342// Proof
343type ProofString struct {
344 PiA [3]string
345 PiAp [3]string
346 PiB [3][2]string
347 PiBp [3]string
348 PiC [3]string
349 PiCp [3]string
350 PiH [3]string
351 PiKp [3]string
352}
353
354func ProofToString(p snark.Proof) ProofString {
355 var s ProofString
356 s.PiA = BigInt3ToString(p.PiA)
357 s.PiAp = BigInt3ToString(p.PiAp)
358 s.PiB = BigInt32ToString(p.PiB)
359 s.PiBp = BigInt3ToString(p.PiBp)
360 s.PiC = BigInt3ToString(p.PiC)
361 s.PiCp = BigInt3ToString(p.PiCp)
362 s.PiH = BigInt3ToString(p.PiH)
363 s.PiKp = BigInt3ToString(p.PiKp)
364 return s
365}
366func ProofFromString(s ProofString) (snark.Proof, error) {
367 var p snark.Proof
368 var err error
369
370 p.PiA, err = String3ToBigInt(s.PiA)
371 if err != nil {
372 return p, err
373 }
374 p.PiAp, err = String3ToBigInt(s.PiAp)
375 if err != nil {
376 return p, err
377 }
378 p.PiB, err = String32ToBigInt(s.PiB)
379 if err != nil {
380 return p, err
381 }
382 p.PiBp, err = String3ToBigInt(s.PiBp)
383 if err != nil {
384 return p, err
385 }
386 p.PiC, err = String3ToBigInt(s.PiC)
387 if err != nil {
388 return p, err
389 }
390 p.PiCp, err = String3ToBigInt(s.PiCp)
391 if err != nil {
392 return p, err
393 }
394 p.PiH, err = String3ToBigInt(s.PiH)
395 if err != nil {
396 return p, err
397 }
398 p.PiKp, err = String3ToBigInt(s.PiKp)
399 if err != nil {
400 return p, err
401 }
402 return p, nil
403}