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