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 "github.com/arnaucube/go-snark/groth16"
10)
11
12// []*big.Int
13func ArrayBigIntToString(b []*big.Int) []string {
14 var o []string
15 for i := 0; i < len(b); i++ {
16 o = append(o, b[i].String())
17 }
18 return o
19}
20func ArrayStringToBigInt(s []string) ([]*big.Int, error) {
21 var px []*big.Int
22 for i := 0; i < len(s); i++ {
23 param, ok := new(big.Int).SetString(s[i], 10)
24 if !ok {
25 return nil, errors.New("error parsing px from pxString")
26 }
27 px = append(px, param)
28 }
29 return px, nil
30}
31
32// [3]*big.Int
33func String3ToBigInt(s [3]string) ([3]*big.Int, error) {
34 var o [3]*big.Int
35 for i := 0; i < len(s); i++ {
36 param, ok := new(big.Int).SetString(s[i], 10)
37 if !ok {
38 return o, errors.New("error parsing [3]*big.Int from [3]string")
39 }
40 o[i] = param
41 }
42 return o, nil
43}
44func BigInt3ToString(b [3]*big.Int) [3]string {
45 var o [3]string
46 o[0] = b[0].String()
47 o[1] = b[1].String()
48 o[2] = b[2].String()
49 return o
50}
51
52// [][3]*big.Int
53func Array3StringToBigInt(s [][3]string) ([][3]*big.Int, error) {
54 var o [][3]*big.Int
55 for i := 0; i < len(s); i++ {
56 parsed, err := String3ToBigInt(s[i])
57 if err != nil {
58 return o, err
59 }
60 o = append(o, parsed)
61 }
62 return o, nil
63}
64func Array3BigIntToString(b [][3]*big.Int) [][3]string {
65 var o [][3]string
66 for i := 0; i < len(b); i++ {
67 o = append(o, BigInt3ToString(b[i]))
68 }
69 return o
70}
71
72func String2ToBigInt(s [2]string) ([2]*big.Int, error) {
73 var o [2]*big.Int
74 for i := 0; i < len(s); i++ {
75 param, ok := new(big.Int).SetString(s[i], 10)
76 if !ok {
77 return o, errors.New("error parsing [2]*big.Int from [2]string")
78 }
79 o[i] = param
80 }
81 return o, nil
82}
83
84// [3][2]*big.Int
85func String32ToBigInt(s [3][2]string) ([3][2]*big.Int, error) {
86 var o [3][2]*big.Int
87 var err error
88
89 o[0], err = String2ToBigInt(s[0])
90 if err != nil {
91 return o, err
92 }
93 o[1], err = String2ToBigInt(s[1])
94 if err != nil {
95 return o, err
96 }
97 o[2], err = String2ToBigInt(s[2])
98 if err != nil {
99 return o, err
100 }
101 return o, nil
102}
103func BigInt32ToString(b [3][2]*big.Int) [3][2]string {
104 var o [3][2]string
105 o[0][0] = b[0][0].String()
106 o[0][1] = b[0][1].String()
107 o[1][0] = b[1][0].String()
108 o[1][1] = b[1][1].String()
109 o[2][0] = b[2][0].String()
110 o[2][1] = b[2][1].String()
111 return o
112}
113
114// [][3][2]*big.Int
115func Array32StringToBigInt(s [][3][2]string) ([][3][2]*big.Int, error) {
116 var o [][3][2]*big.Int
117 for i := 0; i < len(s); i++ {
118 parsed, err := String32ToBigInt(s[i])
119 if err != nil {
120 return o, err
121 }
122 o = append(o, parsed)
123 }
124 return o, nil
125}
126func Array32BigIntToString(b [][3][2]*big.Int) [][3][2]string {
127 var o [][3][2]string
128 for i := 0; i < len(b); i++ {
129 o = append(o, BigInt32ToString(b[i]))
130 }
131 return o
132}
133
134// Setup
135type SetupString struct {
136 // public
137 G1T [][3]string
138 G2T [][3][2]string
139 Pk struct {
140 A [][3]string
141 B [][3][2]string
142 C [][3]string
143 Kp [][3]string
144 Ap [][3]string
145 Bp [][3]string
146 Cp [][3]string
147 Z []string
148 }
149 Vk struct {
150 Vka [3][2]string
151 Vkb [3]string
152 Vkc [3][2]string
153 IC [][3]string
154 G1Kbg [3]string
155 G2Kbg [3][2]string
156 G2Kg [3][2]string
157 Vkz [3][2]string
158 }
159}
160
161func SetupToString(setup snark.Setup) SetupString {
162 var s SetupString
163 s.G1T = Array3BigIntToString(setup.G1T)
164 s.G2T = Array32BigIntToString(setup.G2T)
165 s.Pk.A = Array3BigIntToString(setup.Pk.A)
166 s.Pk.B = Array32BigIntToString(setup.Pk.B)
167 s.Pk.C = Array3BigIntToString(setup.Pk.C)
168 s.Pk.Kp = Array3BigIntToString(setup.Pk.Kp)
169 s.Pk.Ap = Array3BigIntToString(setup.Pk.Ap)
170 s.Pk.Bp = Array3BigIntToString(setup.Pk.Bp)
171 s.Pk.Cp = Array3BigIntToString(setup.Pk.Cp)
172 s.Pk.Z = ArrayBigIntToString(setup.Pk.Z)
173 s.Vk.Vka = BigInt32ToString(setup.Vk.Vka)
174 s.Vk.Vkb = BigInt3ToString(setup.Vk.Vkb)
175 s.Vk.Vkc = BigInt32ToString(setup.Vk.Vkc)
176 s.Vk.IC = Array3BigIntToString(setup.Vk.IC)
177 s.Vk.G1Kbg = BigInt3ToString(setup.Vk.G1Kbg)
178 s.Vk.G2Kbg = BigInt32ToString(setup.Vk.G2Kbg)
179 s.Vk.G2Kg = BigInt32ToString(setup.Vk.G2Kg)
180 s.Vk.Vkz = BigInt32ToString(setup.Vk.Vkz)
181 return s
182}
183func SetupFromString(s SetupString) (snark.Setup, error) {
184 var o snark.Setup
185 var err error
186 o.G1T, err = Array3StringToBigInt(s.G1T)
187 if err != nil {
188 return o, err
189 }
190 o.G2T, err = Array32StringToBigInt(s.G2T)
191 if err != nil {
192 return o, err
193 }
194 o.Pk.A, err = Array3StringToBigInt(s.Pk.A)
195 if err != nil {
196 return o, err
197 }
198 o.Pk.B, err = Array32StringToBigInt(s.Pk.B)
199 if err != nil {
200 return o, err
201 }
202 o.Pk.C, err = Array3StringToBigInt(s.Pk.C)
203 if err != nil {
204 return o, err
205 }
206 o.Pk.Kp, err = Array3StringToBigInt(s.Pk.Kp)
207 if err != nil {
208 return o, err
209 }
210 o.Pk.Ap, err = Array3StringToBigInt(s.Pk.Ap)
211 if err != nil {
212 return o, err
213 }
214 o.Pk.Bp, err = Array3StringToBigInt(s.Pk.Bp)
215 if err != nil {
216 return o, err
217 }
218 o.Pk.Cp, err = Array3StringToBigInt(s.Pk.Cp)
219 if err != nil {
220 return o, err
221 }
222 o.Pk.Z, err = ArrayStringToBigInt(s.Pk.Z)
223 if err != nil {
224 return o, err
225 }
226
227 o.Vk.Vka, err = String32ToBigInt(s.Vk.Vka)
228 if err != nil {
229 return o, err
230 }
231 o.Vk.Vkb, err = String3ToBigInt(s.Vk.Vkb)
232 if err != nil {
233 return o, err
234 }
235 o.Vk.Vkc, err = String32ToBigInt(s.Vk.Vkc)
236 if err != nil {
237 return o, err
238 }
239 o.Vk.IC, err = Array3StringToBigInt(s.Vk.IC)
240 if err != nil {
241 return o, err
242 }
243 o.Vk.G1Kbg, err = String3ToBigInt(s.Vk.G1Kbg)
244 if err != nil {
245 return o, err
246 }
247 o.Vk.G2Kbg, err = String32ToBigInt(s.Vk.G2Kbg)
248 if err != nil {
249 return o, err
250 }
251 o.Vk.G2Kg, err = String32ToBigInt(s.Vk.G2Kg)
252 if err != nil {
253 return o, err
254 }
255 o.Vk.Vkz, err = String32ToBigInt(s.Vk.Vkz)
256 if err != nil {
257 return o, err
258 }
259
260 return o, nil
261
262}
263
264// circuit
265type CircuitString struct {
266 NVars int
267 NPublic int
268 NSignals int
269 PrivateInputs []string
270 PublicInputs []string
271 Signals []string
272 Witness []string
273 Constraints []circuitcompiler.Constraint
274 R1CS struct {
275 A [][]string
276 B [][]string
277 C [][]string
278 }
279}
280
281func ArrayArrayBigIntToString(b [][]*big.Int) [][]string {
282 var o [][]string
283 for i := 0; i < len(b); i++ {
284 o = append(o, ArrayBigIntToString(b[i]))
285 }
286 return o
287}
288func ArrayArrayStringToBigInt(s [][]string) ([][]*big.Int, error) {
289 var o [][]*big.Int
290 for i := 0; i < len(s); i++ {
291 parsed, err := ArrayStringToBigInt(s[i])
292 if err != nil {
293 return o, err
294 }
295 o = append(o, parsed)
296 }
297 return o, nil
298}
299func CircuitToString(c circuitcompiler.Circuit) CircuitString {
300 var cs CircuitString
301 cs.NVars = c.NVars
302 cs.NPublic = c.NPublic
303 cs.NSignals = c.NSignals
304 cs.PrivateInputs = c.PrivateInputs
305 cs.PublicInputs = c.PublicInputs
306 cs.Signals = c.Signals
307 cs.Witness = ArrayBigIntToString(c.Witness)
308 cs.Constraints = c.Constraints
309 cs.R1CS.A = ArrayArrayBigIntToString(c.R1CS.A)
310 cs.R1CS.B = ArrayArrayBigIntToString(c.R1CS.B)
311 cs.R1CS.C = ArrayArrayBigIntToString(c.R1CS.C)
312 return cs
313}
314func CircuitFromString(cs CircuitString) (circuitcompiler.Circuit, error) {
315 var c circuitcompiler.Circuit
316 var err error
317 c.NVars = cs.NVars
318 c.NPublic = cs.NPublic
319 c.NSignals = cs.NSignals
320 c.PrivateInputs = cs.PrivateInputs
321 c.PublicInputs = cs.PublicInputs
322 c.Signals = cs.Signals
323 c.Witness, err = ArrayStringToBigInt(cs.Witness)
324 if err != nil {
325 return c, err
326 }
327 c.Constraints = cs.Constraints
328 c.R1CS.A, err = ArrayArrayStringToBigInt(cs.R1CS.A)
329 if err != nil {
330 return c, err
331 }
332 c.R1CS.B, err = ArrayArrayStringToBigInt(cs.R1CS.B)
333 if err != nil {
334 return c, err
335 }
336 c.R1CS.C, err = ArrayArrayStringToBigInt(cs.R1CS.C)
337 if err != nil {
338 return c, err
339 }
340 return c, nil
341}
342
343// Proof
344type ProofString struct {
345 PiA [3]string
346 PiAp [3]string
347 PiB [3][2]string
348 PiBp [3]string
349 PiC [3]string
350 PiCp [3]string
351 PiH [3]string
352 PiKp [3]string
353}
354
355func ProofToString(p snark.Proof) ProofString {
356 var s ProofString
357 s.PiA = BigInt3ToString(p.PiA)
358 s.PiAp = BigInt3ToString(p.PiAp)
359 s.PiB = BigInt32ToString(p.PiB)
360 s.PiBp = BigInt3ToString(p.PiBp)
361 s.PiC = BigInt3ToString(p.PiC)
362 s.PiCp = BigInt3ToString(p.PiCp)
363 s.PiH = BigInt3ToString(p.PiH)
364 s.PiKp = BigInt3ToString(p.PiKp)
365 return s
366}
367func ProofFromString(s ProofString) (snark.Proof, error) {
368 var p snark.Proof
369 var err error
370
371 p.PiA, err = String3ToBigInt(s.PiA)
372 if err != nil {
373 return p, err
374 }
375 p.PiAp, err = String3ToBigInt(s.PiAp)
376 if err != nil {
377 return p, err
378 }
379 p.PiB, err = String32ToBigInt(s.PiB)
380 if err != nil {
381 return p, err
382 }
383 p.PiBp, err = String3ToBigInt(s.PiBp)
384 if err != nil {
385 return p, err
386 }
387 p.PiC, err = String3ToBigInt(s.PiC)
388 if err != nil {
389 return p, err
390 }
391 p.PiCp, err = String3ToBigInt(s.PiCp)
392 if err != nil {
393 return p, err
394 }
395 p.PiH, err = String3ToBigInt(s.PiH)
396 if err != nil {
397 return p, err
398 }
399 p.PiKp, err = String3ToBigInt(s.PiKp)
400 if err != nil {
401 return p, err
402 }
403 return p, nil
404}
405
406// groth
407type GrothSetupString struct {
408 Pk struct { // Proving Key
409 BACDelta [][3]string
410 Z []string
411 G1 struct {
412 Alpha [3]string
413 Beta [3]string
414 Delta [3]string
415 At [][3]string
416 BACGamma [][3]string
417 }
418 G2 struct {
419 Beta [3][2]string
420 Gamma [3][2]string
421 Delta [3][2]string
422 BACGamma [][3][2]string
423 }
424 PowersTauDelta [][3]string
425 }
426 Vk struct {
427 IC [][3]string
428 G1 struct {
429 Alpha [3]string
430 }
431 G2 struct {
432 Beta [3][2]string
433 Gamma [3][2]string
434 Delta [3][2]string
435 }
436 }
437}
438
439func GrothSetupToString(setup groth16.Setup) GrothSetupString {
440 var s GrothSetupString
441 s.Pk.BACDelta = Array3BigIntToString(setup.Pk.BACDelta)
442 s.Pk.Z = ArrayBigIntToString(setup.Pk.Z)
443 s.Pk.G1.Alpha = BigInt3ToString(setup.Pk.G1.Alpha)
444 s.Pk.G1.Beta = BigInt3ToString(setup.Pk.G1.Beta)
445 s.Pk.G1.Delta = BigInt3ToString(setup.Pk.G1.Delta)
446 s.Pk.G1.At = Array3BigIntToString(setup.Pk.G1.At)
447 s.Pk.G1.BACGamma = Array3BigIntToString(setup.Pk.G1.BACGamma)
448 s.Pk.G2.Beta = BigInt32ToString(setup.Pk.G2.Beta)
449 s.Pk.G2.Gamma = BigInt32ToString(setup.Pk.G2.Gamma)
450 s.Pk.G2.Delta = BigInt32ToString(setup.Pk.G2.Delta)
451 s.Pk.G2.BACGamma = Array32BigIntToString(setup.Pk.G2.BACGamma)
452 s.Pk.PowersTauDelta = Array3BigIntToString(setup.Pk.PowersTauDelta)
453 s.Vk.IC = Array3BigIntToString(setup.Vk.IC)
454 s.Vk.G1.Alpha = BigInt3ToString(setup.Vk.G1.Alpha)
455 s.Vk.G2.Beta = BigInt32ToString(setup.Vk.G2.Beta)
456 s.Vk.G2.Gamma = BigInt32ToString(setup.Vk.G2.Gamma)
457 s.Vk.G2.Delta = BigInt32ToString(setup.Vk.G2.Delta)
458 return s
459}
460func GrothSetupFromString(s GrothSetupString) (groth16.Setup, error) {
461 var o groth16.Setup
462 var err error
463 o.Pk.BACDelta, err = Array3StringToBigInt(s.Pk.BACDelta)
464 if err != nil {
465 return o, err
466 }
467 o.Pk.Z, err = ArrayStringToBigInt(s.Pk.Z)
468 if err != nil {
469 return o, err
470 }
471 o.Pk.G1.Alpha, err = String3ToBigInt(s.Pk.G1.Alpha)
472 if err != nil {
473 return o, err
474 }
475 o.Pk.G1.Beta, err = String3ToBigInt(s.Pk.G1.Beta)
476 if err != nil {
477 return o, err
478 }
479 o.Pk.G1.Delta, err = String3ToBigInt(s.Pk.G1.Delta)
480 if err != nil {
481 return o, err
482 }
483 o.Pk.G1.At, err = Array3StringToBigInt(s.Pk.G1.At)
484 if err != nil {
485 return o, err
486 }
487 o.Pk.G1.BACGamma, err = Array3StringToBigInt(s.Pk.G1.BACGamma)
488 if err != nil {
489 return o, err
490 }
491 o.Pk.G2.Beta, err = String32ToBigInt(s.Pk.G2.Beta)
492 if err != nil {
493 return o, err
494 }
495 o.Pk.G2.Gamma, err = String32ToBigInt(s.Pk.G2.Gamma)
496 if err != nil {
497 return o, err
498 }
499 o.Pk.G2.Delta, err = String32ToBigInt(s.Pk.G2.Delta)
500 if err != nil {
501 return o, err
502 }
503 o.Pk.G2.BACGamma, err = Array32StringToBigInt(s.Pk.G2.BACGamma)
504 if err != nil {
505 return o, err
506 }
507 o.Pk.PowersTauDelta, err = Array3StringToBigInt(s.Pk.PowersTauDelta)
508 if err != nil {
509 return o, err
510 }
511 o.Vk.IC, err = Array3StringToBigInt(s.Vk.IC)
512 if err != nil {
513 return o, err
514 }
515 o.Vk.G1.Alpha, err = String3ToBigInt(s.Vk.G1.Alpha)
516 if err != nil {
517 return o, err
518 }
519 o.Vk.G2.Beta, err = String32ToBigInt(s.Vk.G2.Beta)
520 if err != nil {
521 return o, err
522 }
523 o.Vk.G2.Gamma, err = String32ToBigInt(s.Vk.G2.Gamma)
524 if err != nil {
525 return o, err
526 }
527 o.Vk.G2.Delta, err = String32ToBigInt(s.Vk.G2.Delta)
528 if err != nil {
529 return o, err
530 }
531 return o, nil
532}
533
534type GrothProofString struct {
535 PiA [3]string
536 PiB [3][2]string
537 PiC [3]string
538}
539
540func GrothProofToString(p groth16.Proof) GrothProofString {
541 var s GrothProofString
542 s.PiA = BigInt3ToString(p.PiA)
543 s.PiB = BigInt32ToString(p.PiB)
544 s.PiC = BigInt3ToString(p.PiC)
545 return s
546}
547func GrothProofFromString(s GrothProofString) (groth16.Proof, error) {
548 var p groth16.Proof
549 var err error
550
551 p.PiA, err = String3ToBigInt(s.PiA)
552 if err != nil {
553 return p, err
554 }
555 p.PiB, err = String32ToBigInt(s.PiB)
556 if err != nil {
557 return p, err
558 }
559 p.PiC, err = String3ToBigInt(s.PiC)
560 if err != nil {
561 return p, err
562 }
563 return p, nil
564}