1package main
  2
  3import (
  4	"encoding/json"
  5	"flag"
  6	"fmt"
  7	"io/ioutil"
  8	"os"
  9	"time"
 10
 11	"github.com/iden3/go-circom-prover-verifier/parsers"
 12	"github.com/iden3/go-circom-prover-verifier/prover"
 13	"github.com/iden3/go-circom-prover-verifier/verifier"
 14)
 15
 16const version = "v0.0.1"
 17
 18func main() {
 19	fmt.Println("go-circom-prover-verifier")
 20	fmt.Println("		", version)
 21
 22	prove := flag.Bool("prove", false, "prover mode")
 23	verify := flag.Bool("verify", false, "verifier mode")
 24	convert := flag.Bool("convert", false, "convert mode, to convert between proving_key.json to proving_key.go.bin")
 25
 26	provingKeyPath := flag.String("pk", "proving_key.json", "provingKey path")
 27	witnessPath := flag.String("witness", "witness.json", "witness path")
 28	proofPath := flag.String("proof", "proof.json", "proof path")
 29	verificationKeyPath := flag.String("vk", "verification_key.json", "verificationKey path")
 30	publicPath := flag.String("public", "public.json", "public signals path")
 31	provingKeyBinPath := flag.String("pkbin", "proving_key.go.bin", "provingKey Bin path")
 32
 33	flag.Parse()
 34
 35	if *prove {
 36		err := cmdProve(*provingKeyPath, *witnessPath, *proofPath, *publicPath)
 37		if err != nil {
 38			fmt.Println("Error:", err)
 39		}
 40		os.Exit(0)
 41	} else if *verify {
 42		err := cmdVerify(*proofPath, *verificationKeyPath, *publicPath)
 43		if err != nil {
 44			fmt.Println("Error:", err)
 45		}
 46		os.Exit(0)
 47	} else if *convert {
 48		err := cmdConvert(*provingKeyPath, *provingKeyBinPath)
 49		if err != nil {
 50			fmt.Println("Error:", err)
 51		}
 52		os.Exit(0)
 53	}
 54	flag.PrintDefaults()
 55}
 56
 57func cmdProve(provingKeyPath, witnessPath, proofPath, publicPath string) error {
 58	fmt.Println("zkSNARK Groth16 prover")
 59
 60	fmt.Println("Reading proving key file:", provingKeyPath)
 61	provingKeyJson, err := ioutil.ReadFile(provingKeyPath)
 62	if err != nil {
 63		return err
 64	}
 65	pk, err := parsers.ParsePk(provingKeyJson)
 66	if err != nil {
 67		return err
 68	}
 69
 70	fmt.Println("Reading witness file:", witnessPath)
 71	witnessJson, err := ioutil.ReadFile(witnessPath)
 72	if err != nil {
 73		return err
 74	}
 75	w, err := parsers.ParseWitness(witnessJson)
 76	if err != nil {
 77		return err
 78	}
 79
 80	fmt.Println("Generating the proof")
 81	beforeT := time.Now()
 82	proof, pubSignals, err := prover.GenerateProof(pk, w)
 83	if err != nil {
 84		return err
 85	}
 86	fmt.Println("proof generation time elapsed:", time.Since(beforeT))
 87
 88	proofStr, err := parsers.ProofToJson(proof)
 89	if err != nil {
 90		return err
 91	}
 92
 93	// write output
 94	err = ioutil.WriteFile(proofPath, proofStr, 0644)
 95	if err != nil {
 96		return err
 97	}
 98	publicStr, err := json.Marshal(parsers.ArrayBigIntToString(pubSignals))
 99	if err != nil {
100		return err
101	}
102	err = ioutil.WriteFile(publicPath, publicStr, 0644)
103	if err != nil {
104		return err
105	}
106	fmt.Println("Proof stored at:", proofPath)
107	fmt.Println("PublicSignals stored at:", publicPath)
108	return nil
109}
110
111func cmdVerify(proofPath, verificationKeyPath, publicPath string) error {
112	fmt.Println("zkSNARK Groth16 verifier")
113
114	proofJson, err := ioutil.ReadFile(proofPath)
115	if err != nil {
116		return err
117	}
118	vkJson, err := ioutil.ReadFile(verificationKeyPath)
119	if err != nil {
120		return err
121	}
122	publicJson, err := ioutil.ReadFile(publicPath)
123	if err != nil {
124		return err
125	}
126
127	public, err := parsers.ParsePublicSignals(publicJson)
128	if err != nil {
129		return err
130	}
131	proof, err := parsers.ParseProof(proofJson)
132	if err != nil {
133		return err
134	}
135	vk, err := parsers.ParseVk(vkJson)
136	if err != nil {
137		return err
138	}
139
140	v := verifier.Verify(vk, proof, public)
141	fmt.Println("verification:", v)
142	return nil
143}
144
145func cmdConvert(provingKeyPath, provingKeyBinPath string) error {
146	fmt.Println("Convertion tool")
147
148	provingKeyJson, err := ioutil.ReadFile(provingKeyPath)
149	if err != nil {
150		return err
151	}
152	pk, err := parsers.ParsePk(provingKeyJson)
153	if err != nil {
154		return err
155	}
156
157	fmt.Printf("Converting proving key json (%s)\nto go proving key binary (%s)\n", provingKeyPath, provingKeyBinPath)
158	pkGBin, err := parsers.PkToGoBin(pk)
159	if err != nil {
160		return err
161	}
162	err = ioutil.WriteFile(provingKeyBinPath, pkGBin, 0644)
163
164	return nil
165}