Fix binary parser bug, make go.bin format deterministic

Remove unnecessary structs & polsC

cli/.gitignore

@@ -0,0 +1 @@
+cli

cli/cli.go

@@ -159,7 +159,9 @@ func cmdConvert(provingKeyPath, provingKeyBinPath string) error {
 	if err != nil {
 		return err
 	}
-	err = ioutil.WriteFile(provingKeyBinPath, pkGBin, 0644)
+	if err = ioutil.WriteFile(provingKeyBinPath, pkGBin, 0644); err != nil {
+		return err
+	}
 
 	return nil
 }

parsers/parsers.go

@@ -10,6 +10,7 @@ import (
 	"io"
 	"math/big"
 	"os"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -34,7 +35,6 @@ type PkString struct {
 	DomainSize int                 `json:"domainSize"`
 	PolsA      []map[string]string `json:"polsA"`
 	PolsB      []map[string]string `json:"polsB"`
-	PolsC      []map[string]string `json:"polsC"`
 }
 
 // WitnessString contains the Witness in string representation
@@ -149,10 +149,6 @@ func pkStringToPk(ps PkString) (*types.Pk, error) {
 	if err != nil {
 		return nil, err
 	}
-	p.PolsC, err = polsStringToBigInt(ps.PolsC)
-	if err != nil {
-		return nil, err
-	}
 
 	return &p, nil
 }
@@ -819,9 +815,9 @@ func ParsePkBin(f *os.File) (*types.Pk, error) {
 	if err != nil {
 		return nil, err
 	}
-	pk.C = append(pk.C, z) // circom behaviour (3x null==["0", "0", "0"])
+	for i := 0; i < pk.NPublic+1; i++ {
-	pk.C = append(pk.C, z)
+		pk.C = append(pk.C, z)
-	pk.C = append(pk.C, z)
+	}
 	for i := pk.NPublic + 1; i < pk.NVars; i++ {
 		b, err = readNBytes(r, 64)
 		if err != nil {
@@ -974,6 +970,15 @@ func coordFromMont(u, q *big.Int) *big.Int {
 	)
 }
 
+func sortedKeys(m map[int]*big.Int) []int {
+	keys := make([]int, 0, len(m))
+	for k, _ := range m {
+		keys = append(keys, k)
+	}
+	sort.Ints(keys)
+	return keys
+}
+
 // PkToGoBin converts the ProvingKey (*types.Pk) into binary format defined by
 // go-circom-prover-verifier.  PkGoBin is a own go-circom-prover-verifier
 // binary format that allows to go faster when parsing.
@@ -1022,7 +1027,8 @@ func PkToGoBin(pk *types.Pk) ([]byte, error) {
 		binary.LittleEndian.PutUint32(b[:], uint32(len(pk.PolsA[i])))
 		r = append(r, b[:]...)
 		o += 4
-		for j, v := range pk.PolsA[i] {
+		for _, j := range sortedKeys(pk.PolsA[i]) {
+			v := pk.PolsA[i][j]
 			binary.LittleEndian.PutUint32(b[:], uint32(j))
 			r = append(r, b[:]...)
 			r = append(r, addPadding32(v.Bytes())...)
@@ -1035,7 +1041,8 @@ func PkToGoBin(pk *types.Pk) ([]byte, error) {
 		binary.LittleEndian.PutUint32(b[:], uint32(len(pk.PolsB[i])))
 		r = append(r, b[:]...)
 		o += 4
-		for j, v := range pk.PolsB[i] {
+		for _, j := range sortedKeys(pk.PolsB[i]) {
+			v := pk.PolsB[i][j]
 			binary.LittleEndian.PutUint32(b[:], uint32(j))
 			r = append(r, b[:]...)
 			r = append(r, addPadding32(v.Bytes())...)
@@ -1284,9 +1291,9 @@ func ParsePkGoBin(f *os.File) (*types.Pk, error) {
 	if err != nil {
 		return nil, err
 	}
-	pk.C = append(pk.C, z)
+	for i := 0; i < pk.NPublic+1; i++ {
-	pk.C = append(pk.C, z)
+		pk.C = append(pk.C, z)
-	pk.C = append(pk.C, z)
+	}
 	for i := pk.NPublic + 1; i < pk.NVars; i++ {
 		b, err = readNBytes(r, 64)
 		if err != nil {

parsers/parsers_test.go

@@ -238,6 +238,10 @@ func testCircuitParsePkBin(t *testing.T, circuit string) {
 	assert.Equal(t, pkJ.B2, pk.B2)
 	assert.Equal(t, pkJ.C, pk.C)
 	assert.Equal(t, pkJ.HExps[:pkJ.DomainSize], pk.HExps[:pk.DomainSize]) // circom behaviour
+
+	assert.Equal(t, pkJ.NVars, pk.NVars)
+	assert.Equal(t, pkJ.NPublic, pk.NPublic)
+	assert.Equal(t, pkJ.DomainSize, pk.DomainSize)
 }
 
 func TestParsePkBin(t *testing.T) {
@@ -274,6 +278,10 @@ func testGoCircomPkFormat(t *testing.T, circuit string) {
 	assert.Equal(t, pk.HExps, pkG.HExps)
 	assert.Equal(t, pk.PolsA, pkG.PolsA)
 	assert.Equal(t, pk.PolsB, pkG.PolsB)
+
+	assert.Equal(t, pk.NVars, pkG.NVars)
+	assert.Equal(t, pk.NPublic, pkG.NPublic)
+	assert.Equal(t, pk.DomainSize, pkG.DomainSize)
 }
 
 func TestGoCircomPkFormat(t *testing.T) {

prover/prover.go

@@ -13,36 +13,6 @@ import (
 	//"fmt"
 )
 
-// Proof is the data structure of the Groth16 zkSNARK proof
-type Proof struct {
-	A *bn256.G1
-	B *bn256.G2
-	C *bn256.G1
-}
-
-// Pk holds the data structure of the ProvingKey
-type Pk struct {
-	A          []*bn256.G1
-	B2         []*bn256.G2
-	B1         []*bn256.G1
-	C          []*bn256.G1
-	NVars      int
-	NPublic    int
-	VkAlpha1   *bn256.G1
-	VkDelta1   *bn256.G1
-	VkBeta1    *bn256.G1
-	VkBeta2    *bn256.G2
-	VkDelta2   *bn256.G2
-	HExps      []*bn256.G1
-	DomainSize int
-	PolsA      []map[int]*big.Int
-	PolsB      []map[int]*big.Int
-	PolsC      []map[int]*big.Int
-}
-
-// Witness contains the witness
-type Witness []*big.Int
-
 // Group Size
 const (
 	GSIZE = 6

types/types.go

@@ -83,7 +83,6 @@ type Pk struct {
 	DomainSize int
 	PolsA      []map[int]*big.Int
 	PolsB      []map[int]*big.Int
-	PolsC      []map[int]*big.Int
 }
 
 // Witness contains the witness