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 setupStr utils.SetupString
 98	println(i[0].String())
 99	err := json.Unmarshal([]byte(i[0].String()), &setupStr)
100	if err != nil {
101		println("error parsing setup from stringified json")
102	}
103	setup, err := utils.SetupFromString(setupStr)
104	if err != nil {
105		println("error " + err.Error())
106	}
107
108	var proofStr utils.ProofString
109	err = json.Unmarshal([]byte(i[1].String()), &proofStr)
110	if err != nil {
111		println(i[1].String())
112		println("error parsing proof from stringified json")
113	}
114	proof, err := utils.ProofFromString(proofStr)
115	if err != nil {
116		println("error " + err.Error())
117	}
118
119	var publicInputs []*big.Int
120	err = json.Unmarshal([]byte(i[2].String()), &publicInputs)
121	if err != nil {
122		println(i[2].String())
123		println("error parsing publicInputs from stringified json")
124	}
125
126	verified := snark.VerifyProof(setup, proof, publicInputs, false)
127	if err != nil {
128		println("error verifiyng proof", err)
129	}
130	verifiedJson, err := json.Marshal(verified)
131	if err != nil {
132		println("error marshal verified to json", err)
133	}
134	println("verifiedJson", string(verifiedJson))
135	return js.ValueOf(string(verifiedJson))
136}
137
138func grothGenerateProofs(this js.Value, i []js.Value) interface{} {
139	var circuitStr utils.CircuitString
140	err := json.Unmarshal([]byte(i[0].String()), &circuitStr)
141	if err != nil {
142		println(i[0].String())
143		println("error parsing circuit from stringified json")
144	}
145	circuit, err := utils.CircuitFromString(circuitStr)
146	if err != nil {
147		println("error " + err.Error())
148	}
149	sj, err := json.Marshal(circuit)
150	if err != nil {
151		println("error " + err.Error())
152	}
153	println("circuit", string(sj))
154
155	var setupStr utils.GrothSetupString
156	println(i[1].String())
157	err = json.Unmarshal([]byte(i[1].String()), &setupStr)
158	if err != nil {
159		println("error parsing setup from stringified json")
160	}
161	setup, err := utils.GrothSetupFromString(setupStr)
162	if err != nil {
163		println("error " + err.Error())
164	}
165	sj, err = json.Marshal(setup)
166	if err != nil {
167		println("error " + err.Error())
168	}
169	println("set", string(sj))
170
171	var pxStr []string
172	err = json.Unmarshal([]byte(i[2].String()), &pxStr)
173	if err != nil {
174		println("error parsing pxStr from stringified json")
175	}
176	px, err := utils.ArrayStringToBigInt(pxStr)
177	if err != nil {
178		println(err.Error())
179	}
180	sj, err = json.Marshal(px)
181	if err != nil {
182		println("error " + err.Error())
183	}
184	println("px", string(sj))
185
186	var inputs circuitcompiler.Inputs
187	err = json.Unmarshal([]byte(i[3].String()), &inputs)
188	if err != nil {
189		println("error parsing inputs from stringified json")
190	}
191	w, err := circuit.CalculateWitness(inputs.Private, inputs.Public)
192
193	proof, err := groth16.GenerateProofs(circuit, setup, w, px)
194	if err != nil {
195		println("error generating proof", err)
196	}
197	proofString := utils.GrothProofToString(proof)
198	proofJson, err := json.Marshal(proofString)
199	if err != nil {
200		println("error marshal proof to json", err)
201	}
202	println("proofJson", string(proofJson))
203	return js.ValueOf(string(proofJson))
204}
205
206func grothVerifyProofs(this js.Value, i []js.Value) interface{} {
207	var setupStr utils.GrothSetupString
208	println(i[0].String())
209	err := json.Unmarshal([]byte(i[0].String()), &setupStr)
210	if err != nil {
211		println("error parsing setup from stringified json")
212	}
213	setup, err := utils.GrothSetupFromString(setupStr)
214	if err != nil {
215		println("error " + err.Error())
216	}
217
218	var proofStr utils.GrothProofString
219	err = json.Unmarshal([]byte(i[1].String()), &proofStr)
220	if err != nil {
221		println(i[1].String())
222		println("error parsing proof from stringified json")
223	}
224	proof, err := utils.GrothProofFromString(proofStr)
225	if err != nil {
226		println("error " + err.Error())
227	}
228
229	var publicInputs []*big.Int
230	err = json.Unmarshal([]byte(i[2].String()), &publicInputs)
231	if err != nil {
232		println(i[2].String())
233		println("error parsing publicInputs from stringified json")
234	}
235
236	verified := groth16.VerifyProof(setup, proof, publicInputs, false)
237	if err != nil {
238		println("error verifiyng proof", err)
239	}
240	verifiedJson, err := json.Marshal(verified)
241	if err != nil {
242		println("error marshal verified to json", err)
243	}
244	println("verifiedJson", string(verifiedJson))
245	return js.ValueOf(string(verifiedJson))
246}