go-snark/utils/base10parsers.go
utils/base10parsers.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 GrothPkString struct { // Proving Key
402 BACDelta [][3]string
403 Z []string
404 G1 struct {
405 Alpha [3]string
406 Beta [3]string
407 Delta [3]string
408 At [][3]string
409 BACGamma [][3]string
410 }
411 G2 struct {
412 Beta [3][2]string
413 Gamma [3][2]string
414 Delta [3][2]string
415 BACGamma [][3][2]string
416 }
417 PowersTauDelta [][3]string
418}
419type GrothVkString struct {
420 IC [][3]string
421 G1 struct {
422 Alpha [3]string
423 }
424 G2 struct {
425 Beta [3][2]string
426 Gamma [3][2]string
427 Delta [3][2]string
428 }
429}
430type GrothSetupString struct {
431 Pk GrothPkString
432 Vk GrothVkString
433}
434
435func GrothSetupToString(setup groth16.Setup) GrothSetupString {
436 var s GrothSetupString
437 s.Pk.BACDelta = Array3BigIntToString(setup.Pk.BACDelta)
438 s.Pk.Z = ArrayBigIntToString(setup.Pk.Z)
439 s.Pk.G1.Alpha = BigInt3ToString(setup.Pk.G1.Alpha)
440 s.Pk.G1.Beta = BigInt3ToString(setup.Pk.G1.Beta)
441 s.Pk.G1.Delta = BigInt3ToString(setup.Pk.G1.Delta)
442 s.Pk.G1.At = Array3BigIntToString(setup.Pk.G1.At)
443 s.Pk.G1.BACGamma = Array3BigIntToString(setup.Pk.G1.BACGamma)
444 s.Pk.G2.Beta = BigInt32ToString(setup.Pk.G2.Beta)
445 s.Pk.G2.Gamma = BigInt32ToString(setup.Pk.G2.Gamma)
446 s.Pk.G2.Delta = BigInt32ToString(setup.Pk.G2.Delta)
447 s.Pk.G2.BACGamma = Array32BigIntToString(setup.Pk.G2.BACGamma)
448 s.Pk.PowersTauDelta = Array3BigIntToString(setup.Pk.PowersTauDelta)
449 s.Vk.IC = Array3BigIntToString(setup.Vk.IC)
450 s.Vk.G1.Alpha = BigInt3ToString(setup.Vk.G1.Alpha)
451 s.Vk.G2.Beta = BigInt32ToString(setup.Vk.G2.Beta)
452 s.Vk.G2.Gamma = BigInt32ToString(setup.Vk.G2.Gamma)
453 s.Vk.G2.Delta = BigInt32ToString(setup.Vk.G2.Delta)
454 return s
455}
456func GrothVkFromString(s GrothVkString) (groth16.Vk, error) {
457 var vk groth16.Vk
458 var err error
459 vk.IC, err = Array3StringToBigInt(s.IC)
460 if err != nil {
461 return vk, err
462 }
463 vk.G1.Alpha, err = String3ToBigInt(s.G1.Alpha)
464 if err != nil {
465 return vk, err
466 }
467 vk.G2.Beta, err = String32ToBigInt(s.G2.Beta)
468 if err != nil {
469 return vk, err
470 }
471 vk.G2.Gamma, err = String32ToBigInt(s.G2.Gamma)
472 if err != nil {
473 return vk, err
474 }
475 vk.G2.Delta, err = String32ToBigInt(s.G2.Delta)
476 if err != nil {
477 return vk, err
478 }
479 return vk, nil
480}
481func GrothSetupFromString(s GrothSetupString) (groth16.Setup, error) {
482 var o groth16.Setup
483 var err error
484 o.Pk.BACDelta, err = Array3StringToBigInt(s.Pk.BACDelta)
485 if err != nil {
486 return o, err
487 }
488 o.Pk.Z, err = ArrayStringToBigInt(s.Pk.Z)
489 if err != nil {
490 return o, err
491 }
492 o.Pk.G1.Alpha, err = String3ToBigInt(s.Pk.G1.Alpha)
493 if err != nil {
494 return o, err
495 }
496 o.Pk.G1.Beta, err = String3ToBigInt(s.Pk.G1.Beta)
497 if err != nil {
498 return o, err
499 }
500 o.Pk.G1.Delta, err = String3ToBigInt(s.Pk.G1.Delta)
501 if err != nil {
502 return o, err
503 }
504 o.Pk.G1.At, err = Array3StringToBigInt(s.Pk.G1.At)
505 if err != nil {
506 return o, err
507 }
508 o.Pk.G1.BACGamma, err = Array3StringToBigInt(s.Pk.G1.BACGamma)
509 if err != nil {
510 return o, err
511 }
512 o.Pk.G2.Beta, err = String32ToBigInt(s.Pk.G2.Beta)
513 if err != nil {
514 return o, err
515 }
516 o.Pk.G2.Gamma, err = String32ToBigInt(s.Pk.G2.Gamma)
517 if err != nil {
518 return o, err
519 }
520 o.Pk.G2.Delta, err = String32ToBigInt(s.Pk.G2.Delta)
521 if err != nil {
522 return o, err
523 }
524 o.Pk.G2.BACGamma, err = Array32StringToBigInt(s.Pk.G2.BACGamma)
525 if err != nil {
526 return o, err
527 }
528 o.Pk.PowersTauDelta, err = Array3StringToBigInt(s.Pk.PowersTauDelta)
529 if err != nil {
530 return o, err
531 }
532 o.Vk.IC, err = Array3StringToBigInt(s.Vk.IC)
533 if err != nil {
534 return o, err
535 }
536 o.Vk.G1.Alpha, err = String3ToBigInt(s.Vk.G1.Alpha)
537 if err != nil {
538 return o, err
539 }
540 o.Vk.G2.Beta, err = String32ToBigInt(s.Vk.G2.Beta)
541 if err != nil {
542 return o, err
543 }
544 o.Vk.G2.Gamma, err = String32ToBigInt(s.Vk.G2.Gamma)
545 if err != nil {
546 return o, err
547 }
548 o.Vk.G2.Delta, err = String32ToBigInt(s.Vk.G2.Delta)
549 if err != nil {
550 return o, err
551 }
552 return o, nil
553}
554
555type GrothProofString struct {
556 PiA [3]string
557 PiB [3][2]string
558 PiC [3]string
559}
560
561func GrothProofToString(p groth16.Proof) GrothProofString {
562 var s GrothProofString
563 s.PiA = BigInt3ToString(p.PiA)
564 s.PiB = BigInt32ToString(p.PiB)
565 s.PiC = BigInt3ToString(p.PiC)
566 return s
567}
568func GrothProofFromString(s GrothProofString) (groth16.Proof, error) {
569 var p groth16.Proof
570 var err error
571
572 p.PiA, err = String3ToBigInt(s.PiA)
573 if err != nil {
574 return p, err
575 }
576 p.PiB, err = String32ToBigInt(s.PiB)
577 if err != nil {
578 return p, err
579 }
580 p.PiC, err = String3ToBigInt(s.PiC)
581 if err != nil {
582 return p, err
583 }
584 return p, nil
585}