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 Pk struct {
138 G1T [][3]string
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.Pk.G1T = Array3BigIntToString(setup.Pk.G1T)
163 s.Pk.A = Array3BigIntToString(setup.Pk.A)
164 s.Pk.B = Array32BigIntToString(setup.Pk.B)
165 s.Pk.C = Array3BigIntToString(setup.Pk.C)
166 s.Pk.Kp = Array3BigIntToString(setup.Pk.Kp)
167 s.Pk.Ap = Array3BigIntToString(setup.Pk.Ap)
168 s.Pk.Bp = Array3BigIntToString(setup.Pk.Bp)
169 s.Pk.Cp = Array3BigIntToString(setup.Pk.Cp)
170 s.Pk.Z = ArrayBigIntToString(setup.Pk.Z)
171 s.Vk.Vka = BigInt32ToString(setup.Vk.Vka)
172 s.Vk.Vkb = BigInt3ToString(setup.Vk.Vkb)
173 s.Vk.Vkc = BigInt32ToString(setup.Vk.Vkc)
174 s.Vk.IC = Array3BigIntToString(setup.Vk.IC)
175 s.Vk.G1Kbg = BigInt3ToString(setup.Vk.G1Kbg)
176 s.Vk.G2Kbg = BigInt32ToString(setup.Vk.G2Kbg)
177 s.Vk.G2Kg = BigInt32ToString(setup.Vk.G2Kg)
178 s.Vk.Vkz = BigInt32ToString(setup.Vk.Vkz)
179 return s
180}
181func SetupFromString(s SetupString) (snark.Setup, error) {
182 var o snark.Setup
183 var err error
184 o.Pk.G1T, err = Array3StringToBigInt(s.Pk.G1T)
185 if err != nil {
186 return o, err
187 }
188 o.Pk.A, err = Array3StringToBigInt(s.Pk.A)
189 if err != nil {
190 return o, err
191 }
192 o.Pk.B, err = Array32StringToBigInt(s.Pk.B)
193 if err != nil {
194 return o, err
195 }
196 o.Pk.C, err = Array3StringToBigInt(s.Pk.C)
197 if err != nil {
198 return o, err
199 }
200 o.Pk.Kp, err = Array3StringToBigInt(s.Pk.Kp)
201 if err != nil {
202 return o, err
203 }
204 o.Pk.Ap, err = Array3StringToBigInt(s.Pk.Ap)
205 if err != nil {
206 return o, err
207 }
208 o.Pk.Bp, err = Array3StringToBigInt(s.Pk.Bp)
209 if err != nil {
210 return o, err
211 }
212 o.Pk.Cp, err = Array3StringToBigInt(s.Pk.Cp)
213 if err != nil {
214 return o, err
215 }
216 o.Pk.Z, err = ArrayStringToBigInt(s.Pk.Z)
217 if err != nil {
218 return o, err
219 }
220
221 o.Vk.Vka, err = String32ToBigInt(s.Vk.Vka)
222 if err != nil {
223 return o, err
224 }
225 o.Vk.Vkb, err = String3ToBigInt(s.Vk.Vkb)
226 if err != nil {
227 return o, err
228 }
229 o.Vk.Vkc, err = String32ToBigInt(s.Vk.Vkc)
230 if err != nil {
231 return o, err
232 }
233 o.Vk.IC, err = Array3StringToBigInt(s.Vk.IC)
234 if err != nil {
235 return o, err
236 }
237 o.Vk.G1Kbg, err = String3ToBigInt(s.Vk.G1Kbg)
238 if err != nil {
239 return o, err
240 }
241 o.Vk.G2Kbg, err = String32ToBigInt(s.Vk.G2Kbg)
242 if err != nil {
243 return o, err
244 }
245 o.Vk.G2Kg, err = String32ToBigInt(s.Vk.G2Kg)
246 if err != nil {
247 return o, err
248 }
249 o.Vk.Vkz, err = String32ToBigInt(s.Vk.Vkz)
250 if err != nil {
251 return o, err
252 }
253
254 return o, nil
255
256}
257
258// circuit
259type CircuitString struct {
260 NVars int
261 NPublic int
262 NSignals int
263 PrivateInputs []string
264 PublicInputs []string
265 Signals []string
266 Witness []string
267 Constraints []circuitcompiler.Constraint
268 R1CS struct {
269 A [][]string
270 B [][]string
271 C [][]string
272 }
273}
274
275func ArrayArrayBigIntToString(b [][]*big.Int) [][]string {
276 var o [][]string
277 for i := 0; i < len(b); i++ {
278 o = append(o, ArrayBigIntToString(b[i]))
279 }
280 return o
281}
282func ArrayArrayStringToBigInt(s [][]string) ([][]*big.Int, error) {
283 var o [][]*big.Int
284 for i := 0; i < len(s); i++ {
285 parsed, err := ArrayStringToBigInt(s[i])
286 if err != nil {
287 return o, err
288 }
289 o = append(o, parsed)
290 }
291 return o, nil
292}
293func CircuitToString(c circuitcompiler.Circuit) CircuitString {
294 var cs CircuitString
295 cs.NVars = c.NVars
296 cs.NPublic = c.NPublic
297 cs.NSignals = c.NSignals
298 cs.PrivateInputs = c.PrivateInputs
299 cs.PublicInputs = c.PublicInputs
300 cs.Signals = c.Signals
301 cs.Witness = ArrayBigIntToString(c.Witness)
302 cs.Constraints = c.Constraints
303 cs.R1CS.A = ArrayArrayBigIntToString(c.R1CS.A)
304 cs.R1CS.B = ArrayArrayBigIntToString(c.R1CS.B)
305 cs.R1CS.C = ArrayArrayBigIntToString(c.R1CS.C)
306 return cs
307}
308func CircuitFromString(cs CircuitString) (circuitcompiler.Circuit, error) {
309 var c circuitcompiler.Circuit
310 var err error
311 c.NVars = cs.NVars
312 c.NPublic = cs.NPublic
313 c.NSignals = cs.NSignals
314 c.PrivateInputs = cs.PrivateInputs
315 c.PublicInputs = cs.PublicInputs
316 c.Signals = cs.Signals
317 c.Witness, err = ArrayStringToBigInt(cs.Witness)
318 if err != nil {
319 return c, err
320 }
321 c.Constraints = cs.Constraints
322 c.R1CS.A, err = ArrayArrayStringToBigInt(cs.R1CS.A)
323 if err != nil {
324 return c, err
325 }
326 c.R1CS.B, err = ArrayArrayStringToBigInt(cs.R1CS.B)
327 if err != nil {
328 return c, err
329 }
330 c.R1CS.C, err = ArrayArrayStringToBigInt(cs.R1CS.C)
331 if err != nil {
332 return c, err
333 }
334 return c, nil
335}
336
337// Proof
338type ProofString struct {
339 PiA [3]string
340 PiAp [3]string
341 PiB [3][2]string
342 PiBp [3]string
343 PiC [3]string
344 PiCp [3]string
345 PiH [3]string
346 PiKp [3]string
347}
348
349func ProofToString(p snark.Proof) ProofString {
350 var s ProofString
351 s.PiA = BigInt3ToString(p.PiA)
352 s.PiAp = BigInt3ToString(p.PiAp)
353 s.PiB = BigInt32ToString(p.PiB)
354 s.PiBp = BigInt3ToString(p.PiBp)
355 s.PiC = BigInt3ToString(p.PiC)
356 s.PiCp = BigInt3ToString(p.PiCp)
357 s.PiH = BigInt3ToString(p.PiH)
358 s.PiKp = BigInt3ToString(p.PiKp)
359 return s
360}
361func ProofFromString(s ProofString) (snark.Proof, error) {
362 var p snark.Proof
363 var err error
364
365 p.PiA, err = String3ToBigInt(s.PiA)
366 if err != nil {
367 return p, err
368 }
369 p.PiAp, err = String3ToBigInt(s.PiAp)
370 if err != nil {
371 return p, err
372 }
373 p.PiB, err = String32ToBigInt(s.PiB)
374 if err != nil {
375 return p, err
376 }
377 p.PiBp, err = String3ToBigInt(s.PiBp)
378 if err != nil {
379 return p, err
380 }
381 p.PiC, err = String3ToBigInt(s.PiC)
382 if err != nil {
383 return p, err
384 }
385 p.PiCp, err = String3ToBigInt(s.PiCp)
386 if err != nil {
387 return p, err
388 }
389 p.PiH, err = String3ToBigInt(s.PiH)
390 if err != nil {
391 return p, err
392 }
393 p.PiKp, err = String3ToBigInt(s.PiKp)
394 if err != nil {
395 return p, err
396 }
397 return p, nil
398}
399
400// groth
401type GrothSetupString struct {
402 Pk struct { // Proving Key
403 BACDelta [][3]string
404 Z []string
405 G1 struct {
406 Alpha [3]string
407 Beta [3]string
408 Delta [3]string
409 At [][3]string
410 BACGamma [][3]string
411 }
412 G2 struct {
413 Beta [3][2]string
414 Gamma [3][2]string
415 Delta [3][2]string
416 BACGamma [][3][2]string
417 }
418 PowersTauDelta [][3]string
419 }
420 Vk struct {
421 IC [][3]string
422 G1 struct {
423 Alpha [3]string
424 }
425 G2 struct {
426 Beta [3][2]string
427 Gamma [3][2]string
428 Delta [3][2]string
429 }
430 }
431}
432
433func GrothSetupToString(setup groth16.Setup) GrothSetupString {
434 var s GrothSetupString
435 s.Pk.BACDelta = Array3BigIntToString(setup.Pk.BACDelta)
436 s.Pk.Z = ArrayBigIntToString(setup.Pk.Z)
437 s.Pk.G1.Alpha = BigInt3ToString(setup.Pk.G1.Alpha)
438 s.Pk.G1.Beta = BigInt3ToString(setup.Pk.G1.Beta)
439 s.Pk.G1.Delta = BigInt3ToString(setup.Pk.G1.Delta)
440 s.Pk.G1.At = Array3BigIntToString(setup.Pk.G1.At)
441 s.Pk.G1.BACGamma = Array3BigIntToString(setup.Pk.G1.BACGamma)
442 s.Pk.G2.Beta = BigInt32ToString(setup.Pk.G2.Beta)
443 s.Pk.G2.Gamma = BigInt32ToString(setup.Pk.G2.Gamma)
444 s.Pk.G2.Delta = BigInt32ToString(setup.Pk.G2.Delta)
445 s.Pk.G2.BACGamma = Array32BigIntToString(setup.Pk.G2.BACGamma)
446 s.Pk.PowersTauDelta = Array3BigIntToString(setup.Pk.PowersTauDelta)
447 s.Vk.IC = Array3BigIntToString(setup.Vk.IC)
448 s.Vk.G1.Alpha = BigInt3ToString(setup.Vk.G1.Alpha)
449 s.Vk.G2.Beta = BigInt32ToString(setup.Vk.G2.Beta)
450 s.Vk.G2.Gamma = BigInt32ToString(setup.Vk.G2.Gamma)
451 s.Vk.G2.Delta = BigInt32ToString(setup.Vk.G2.Delta)
452 return s
453}
454func GrothSetupFromString(s GrothSetupString) (groth16.Setup, error) {
455 var o groth16.Setup
456 var err error
457 o.Pk.BACDelta, err = Array3StringToBigInt(s.Pk.BACDelta)
458 if err != nil {
459 return o, err
460 }
461 o.Pk.Z, err = ArrayStringToBigInt(s.Pk.Z)
462 if err != nil {
463 return o, err
464 }
465 o.Pk.G1.Alpha, err = String3ToBigInt(s.Pk.G1.Alpha)
466 if err != nil {
467 return o, err
468 }
469 o.Pk.G1.Beta, err = String3ToBigInt(s.Pk.G1.Beta)
470 if err != nil {
471 return o, err
472 }
473 o.Pk.G1.Delta, err = String3ToBigInt(s.Pk.G1.Delta)
474 if err != nil {
475 return o, err
476 }
477 o.Pk.G1.At, err = Array3StringToBigInt(s.Pk.G1.At)
478 if err != nil {
479 return o, err
480 }
481 o.Pk.G1.BACGamma, err = Array3StringToBigInt(s.Pk.G1.BACGamma)
482 if err != nil {
483 return o, err
484 }
485 o.Pk.G2.Beta, err = String32ToBigInt(s.Pk.G2.Beta)
486 if err != nil {
487 return o, err
488 }
489 o.Pk.G2.Gamma, err = String32ToBigInt(s.Pk.G2.Gamma)
490 if err != nil {
491 return o, err
492 }
493 o.Pk.G2.Delta, err = String32ToBigInt(s.Pk.G2.Delta)
494 if err != nil {
495 return o, err
496 }
497 o.Pk.G2.BACGamma, err = Array32StringToBigInt(s.Pk.G2.BACGamma)
498 if err != nil {
499 return o, err
500 }
501 o.Pk.PowersTauDelta, err = Array3StringToBigInt(s.Pk.PowersTauDelta)
502 if err != nil {
503 return o, err
504 }
505 o.Vk.IC, err = Array3StringToBigInt(s.Vk.IC)
506 if err != nil {
507 return o, err
508 }
509 o.Vk.G1.Alpha, err = String3ToBigInt(s.Vk.G1.Alpha)
510 if err != nil {
511 return o, err
512 }
513 o.Vk.G2.Beta, err = String32ToBigInt(s.Vk.G2.Beta)
514 if err != nil {
515 return o, err
516 }
517 o.Vk.G2.Gamma, err = String32ToBigInt(s.Vk.G2.Gamma)
518 if err != nil {
519 return o, err
520 }
521 o.Vk.G2.Delta, err = String32ToBigInt(s.Vk.G2.Delta)
522 if err != nil {
523 return o, err
524 }
525 return o, nil
526}
527
528type GrothProofString struct {
529 PiA [3]string
530 PiB [3][2]string
531 PiC [3]string
532}
533
534func GrothProofToString(p groth16.Proof) GrothProofString {
535 var s GrothProofString
536 s.PiA = BigInt3ToString(p.PiA)
537 s.PiB = BigInt32ToString(p.PiB)
538 s.PiC = BigInt3ToString(p.PiC)
539 return s
540}
541func GrothProofFromString(s GrothProofString) (groth16.Proof, error) {
542 var p groth16.Proof
543 var err error
544
545 p.PiA, err = String3ToBigInt(s.PiA)
546 if err != nil {
547 return p, err
548 }
549 p.PiB, err = String32ToBigInt(s.PiB)
550 if err != nil {
551 return p, err
552 }
553 p.PiC, err = String3ToBigInt(s.PiC)
554 if err != nil {
555 return p, err
556 }
557 return p, nil
558}