1package main
  2
  3import (
  4	"encoding/json"
  5	"math/big"
  6	"syscall/js"
  7
  8	"github.com/arnaucube/go-snark"
  9	"github.com/arnaucube/go-snark/circuitcompiler"
 10	"github.com/arnaucube/go-snark/groth16"
 11	"github.com/arnaucube/go-snark/wasm/utils"
 12)
 13
 14func main() {
 15	c := make(chan struct{}, 0)
 16	println("WASM Go Initialized")
 17	registerCallbacks()
 18	<-c
 19}
 20
 21func registerCallbacks() {
 22	js.Global().Set("generateProofs", js.FuncOf(generateProofs))
 23	js.Global().Set("verifyProofs", js.FuncOf(verifyProofs))
 24	js.Global().Set("grothGenerateProofs", js.FuncOf(grothGenerateProofs))
 25	js.Global().Set("grothVerifyProofs", js.FuncOf(grothVerifyProofs))
 26}
 27
 28func generateProofs(this js.Value, i []js.Value) interface{} {
 29	var circuitStr utils.CircuitString
 30	err := json.Unmarshal([]byte(i[0].String()), &circuitStr)
 31	if err != nil {
 32		println(i[0].String())
 33		println("error parsing circuit from stringified json")
 34	}
 35	circuit, err := utils.CircuitFromString(circuitStr)
 36	if err != nil {
 37		println("error " + err.Error())
 38	}
 39	sj, err := json.Marshal(circuit)
 40	if err != nil {
 41		println("error " + err.Error())
 42	}
 43	println("circuit", string(sj))
 44
 45	var setupStr utils.SetupString
 46	println(i[1].String())
 47	err = json.Unmarshal([]byte(i[1].String()), &setupStr)
 48	if err != nil {
 49		println("error parsing setup from stringified json")
 50	}
 51	setup, err := utils.SetupFromString(setupStr)
 52	if err != nil {
 53		println("error " + err.Error())
 54	}
 55	sj, err = json.Marshal(setup)
 56	if err != nil {
 57		println("error " + err.Error())
 58	}
 59	println("set", string(sj))
 60
 61	var pxStr []string
 62	err = json.Unmarshal([]byte(i[2].String()), &pxStr)
 63	if err != nil {
 64		println("error parsing pxStr from stringified json")
 65	}
 66	px, err := utils.ArrayStringToBigInt(pxStr)
 67	if err != nil {
 68		println(err.Error())
 69	}
 70	sj, err = json.Marshal(px)
 71	if err != nil {
 72		println("error " + err.Error())
 73	}
 74	println("px", string(sj))
 75
 76	var inputs circuitcompiler.Inputs
 77	err = json.Unmarshal([]byte(i[3].String()), &inputs)
 78	if err != nil {
 79		println("error parsing inputs from stringified json")
 80	}
 81	w, err := circuit.CalculateWitness(inputs.Private, inputs.Public)
 82
 83	proof, err := snark.GenerateProofs(circuit, setup, w, px)
 84	if err != nil {
 85		println("error generating proof", err)
 86	}
 87	proofString := utils.ProofToString(proof)
 88	proofJson, err := json.Marshal(proofString)
 89	if err != nil {
 90		println("error marshal proof to json", err)
 91	}
 92	println("proofJson", string(proofJson))
 93	return js.ValueOf(string(proofJson))
 94}
 95
 96func verifyProofs(this js.Value, i []js.Value) interface{} {
 97	var circuitStr utils.CircuitString
 98	err := json.Unmarshal([]byte(i[0].String()), &circuitStr)
 99	if err != nil {
100		println(i[0].String())
101		println("error parsing circuit from stringified json")
102	}
103	circuit, err := utils.CircuitFromString(circuitStr)
104	if err != nil {
105		println("error " + err.Error())
106	}
107
108	var setupStr utils.SetupString
109	println(i[1].String())
110	err = json.Unmarshal([]byte(i[1].String()), &setupStr)
111	if err != nil {
112		println("error parsing setup from stringified json")
113	}
114	setup, err := utils.SetupFromString(setupStr)
115	if err != nil {
116		println("error " + err.Error())
117	}
118
119	var proofStr utils.ProofString
120	err = json.Unmarshal([]byte(i[2].String()), &proofStr)
121	if err != nil {
122		println(i[0].String())
123		println("error parsing proof from stringified json")
124	}
125	proof, err := utils.ProofFromString(proofStr)
126	if err != nil {
127		println("error " + err.Error())
128	}
129
130	var publicInputs []*big.Int
131	err = json.Unmarshal([]byte(i[3].String()), &publicInputs)
132	if err != nil {
133		println(i[0].String())
134		println("error parsing publicInputs from stringified json")
135	}
136
137	verified := snark.VerifyProof(circuit, setup, proof, publicInputs, false)
138	if err != nil {
139		println("error verifiyng proof", err)
140	}
141	verifiedJson, err := json.Marshal(verified)
142	if err != nil {
143		println("error marshal verified to json", err)
144	}
145	println("verifiedJson", string(verifiedJson))
146	return js.ValueOf(string(verifiedJson))
147}
148
149func grothGenerateProofs(this js.Value, i []js.Value) interface{} {
150	var circuitStr utils.CircuitString
151	err := json.Unmarshal([]byte(i[0].String()), &circuitStr)
152	if err != nil {
153		println(i[0].String())
154		println("error parsing circuit from stringified json")
155	}
156	circuit, err := utils.CircuitFromString(circuitStr)
157	if err != nil {
158		println("error " + err.Error())
159	}
160	sj, err := json.Marshal(circuit)
161	if err != nil {
162		println("error " + err.Error())
163	}
164	println("circuit", string(sj))
165
166	var setupStr utils.GrothSetupString
167	println(i[1].String())
168	err = json.Unmarshal([]byte(i[1].String()), &setupStr)
169	if err != nil {
170		println("error parsing setup from stringified json")
171	}
172	setup, err := utils.GrothSetupFromString(setupStr)
173	if err != nil {
174		println("error " + err.Error())
175	}
176	sj, err = json.Marshal(setup)
177	if err != nil {
178		println("error " + err.Error())
179	}
180	println("set", string(sj))
181
182	var pxStr []string
183	err = json.Unmarshal([]byte(i[2].String()), &pxStr)
184	if err != nil {
185		println("error parsing pxStr from stringified json")
186	}
187	px, err := utils.ArrayStringToBigInt(pxStr)
188	if err != nil {
189		println(err.Error())
190	}
191	sj, err = json.Marshal(px)
192	if err != nil {
193		println("error " + err.Error())
194	}
195	println("px", string(sj))
196
197	var inputs circuitcompiler.Inputs
198	err = json.Unmarshal([]byte(i[3].String()), &inputs)
199	if err != nil {
200		println("error parsing inputs from stringified json")
201	}
202	w, err := circuit.CalculateWitness(inputs.Private, inputs.Public)
203
204	proof, err := groth16.GenerateProofs(circuit, setup, w, px)
205	if err != nil {
206		println("error generating proof", err)
207	}
208	proofString := utils.GrothProofToString(proof)
209	proofJson, err := json.Marshal(proofString)
210	if err != nil {
211		println("error marshal proof to json", err)
212	}
213	println("proofJson", string(proofJson))
214	return js.ValueOf(string(proofJson))
215}
216
217func grothVerifyProofs(this js.Value, i []js.Value) interface{} {
218	var circuitStr utils.CircuitString
219	err := json.Unmarshal([]byte(i[0].String()), &circuitStr)
220	if err != nil {
221		println(i[0].String())
222		println("error parsing circuit from stringified json")
223	}
224	circuit, err := utils.CircuitFromString(circuitStr)
225	if err != nil {
226		println("error " + err.Error())
227	}
228
229	var setupStr utils.GrothSetupString
230	println(i[1].String())
231	err = json.Unmarshal([]byte(i[1].String()), &setupStr)
232	if err != nil {
233		println("error parsing setup from stringified json")
234	}
235	setup, err := utils.GrothSetupFromString(setupStr)
236	if err != nil {
237		println("error " + err.Error())
238	}
239
240	var proofStr utils.GrothProofString
241	err = json.Unmarshal([]byte(i[2].String()), &proofStr)
242	if err != nil {
243		println(i[0].String())
244		println("error parsing proof from stringified json")
245	}
246	proof, err := utils.GrothProofFromString(proofStr)
247	if err != nil {
248		println("error " + err.Error())
249	}
250
251	var publicInputs []*big.Int
252	err = json.Unmarshal([]byte(i[3].String()), &publicInputs)
253	if err != nil {
254		println(i[0].String())
255		println("error parsing publicInputs from stringified json")
256	}
257
258	verified := groth16.VerifyProof(circuit, setup, proof, publicInputs, false)
259	if err != nil {
260		println("error verifiyng proof", err)
261	}
262	verifiedJson, err := json.Marshal(verified)
263	if err != nil {
264		println("error marshal verified to json", err)
265	}
266	println("verifiedJson", string(verifiedJson))
267	return js.ValueOf(string(verifiedJson))
268}