go-circom-prover-verifier/parsers/parsers_test.go
parsers/parsers_test.goRaw
1package parsers
2
3import (
4 "encoding/json"
5 "io/ioutil"
6 "os"
7 "testing"
8
9 "github.com/iden3/go-circom-prover-verifier/types"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12)
13
14func TestParseArrayG1(t *testing.T) {
15 aS := [][]string{
16 {
17 "16145916318196730299582072104388453231952213805668281741813587224450782397538",
18 "4434505318477484327659527264104806919103674231447634885054368605283938696207",
19 "1",
20 },
21 {
22 "10618406967550056457559358662746625591602641004174976323307214433994084907915",
23 "1843236360452735081347085412539192450068665510574800388201121698908391533923",
24 "1",
25 },
26 {
27 "1208972877970123411566574123860641832032384890981476033353526096830198333194",
28 "777503551507025252294438107100944741641946695980350712141258191590862204805",
29 "1",
30 },
31 {
32 "0",
33 "1",
34 "0",
35 },
36 }
37
38 a, err := arrayStringToG1(aS)
39 assert.Nil(t, err)
40 assert.Equal(t, "bn256.G1(23b243c928ce40c4cc2dad366e9f61723aef65866e1c66f42a08697f2f030462, 09cdd7500688fb487ec9f27b5a732d68fa0f3ddca5c2c790e330fdfb03b77c0f)", a[0].String())
41 assert.Equal(t, "bn256.G1(1779ce2c586b5fc523e72e755d969a63473052aaad7c11eb5bf0ecdcfdfefb8b, 04133c1c74206dace57cd3d76ce59be381bbf08f51a5b3edc2b0c183d43eed63)", a[1].String())
42 assert.Equal(t, "bn256.G1(02ac4120598d2f2bb81bc09b8df596403360577b0c5ff52485d1ef2200f23f0a, 01b80d298de75f867d6484c55c3da02c042bb4eb9a1734d3386786aaa669af85)", a[2].String())
43 assert.Equal(t, "bn256.G1(0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000001)", a[3].String())
44}
45
46func TestParseG2(t *testing.T) {
47 aS := [][]string{
48 {
49 "9283666785342556550467669770956850930982548182701254051508520248901282197973",
50 "11369378229277445316894458966429873744779877313900506577160370623273013178252",
51 },
52 {
53 "10625777544326349817513295021482494426101347915428005055375725845993157551870",
54 "21401790227434807639472120486932615400751346915707967674912972446672152512583",
55 },
56 {
57 "1",
58 "0",
59 },
60 }
61
62 a, err := stringToG2(aS)
63 assert.Nil(t, err)
64 assert.Equal(t, "bn256.G2((1922d70c934543aa655ec3277f7fa10a25ec973a4f001a7c54ce4954b4916f8c, 14865e836947c42cf35b47d30e06535fff9dab319c4296e28afde368960671d5), (2f50fbe77925b0a9d718c9ab38638bafa7c65f43f0d09035e518df97ad294847, 177dfa1a3b8627faf0425d9511bcb4c6ca986ea05e3803b5c643c35b94a7e6fe))", a.String())
65
66 aS = [][]string{
67 {
68 "13973091636763944887728510851169742544309374663995476311690518173988838518856",
69 "12903946180439304546475897520537621821375470264150438270817301786763517825250",
70 },
71 {
72 "370374369234123593044872519351942112043402224488849374153134091815693350697",
73 "17423079115073430837335625309232513526393852743032331213038909731579295753224",
74 },
75 {
76 "1",
77 "0",
78 },
79 }
80 a, err = stringToG2(aS)
81 assert.Nil(t, err)
82 assert.Equal(t, "bn256.G2((1c875fed67fff3b35f115b03706ec45f281b5f6cc71a99107240e09fce4910e2, 1ee47d566e9a099626b9860bcd96f6d4a1ed65f115d3efa8e05e5f42cc793048), (26851d022ce9961df65a430811824aaf3118710ac03b0614a50c05ee27d8e408, 00d19fdce25b0d78fb317a5f1789823b7ed76274b0d1be9c685792c73b347729))", a.String())
83}
84
85func TestParseArrayG2(t *testing.T) {
86 aS := [][][]string{
87 {
88 {
89 "0",
90 "0",
91 },
92 {
93 "1",
94 "0",
95 },
96 {
97 "0",
98 "0",
99 },
100 },
101 {
102 {
103 "0",
104 "0",
105 },
106 {
107 "1",
108 "0",
109 },
110 {
111 "0",
112 "0",
113 },
114 },
115 {
116 {
117 "0",
118 "0",
119 },
120 {
121 "1",
122 "0",
123 },
124 {
125 "0",
126 "0",
127 },
128 },
129 {
130 {
131 "9283666785342556550467669770956850930982548182701254051508520248901282197973",
132 "11369378229277445316894458966429873744779877313900506577160370623273013178252",
133 },
134 {
135 "10625777544326349817513295021482494426101347915428005055375725845993157551870",
136 "21401790227434807639472120486932615400751346915707967674912972446672152512583",
137 },
138 {
139 "1",
140 "0",
141 },
142 },
143 }
144
145 a, err := arrayStringToG2(aS)
146 assert.Nil(t, err)
147 assert.Equal(t, "bn256.G2((0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000000), (0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000001))", a[0].String())
148 assert.Equal(t, "bn256.G2((1922d70c934543aa655ec3277f7fa10a25ec973a4f001a7c54ce4954b4916f8c, 14865e836947c42cf35b47d30e06535fff9dab319c4296e28afde368960671d5), (2f50fbe77925b0a9d718c9ab38638bafa7c65f43f0d09035e518df97ad294847, 177dfa1a3b8627faf0425d9511bcb4c6ca986ea05e3803b5c643c35b94a7e6fe))", a[3].String())
149
150}
151
152func testCircuitParseWitnessBin(t *testing.T, circuit string) {
153 witnessBinFile, err := os.Open("../testdata/" + circuit + "/witness.bin")
154 require.Nil(t, err)
155 defer witnessBinFile.Close()
156 witness, err := ParseWitnessBin(witnessBinFile)
157 require.Nil(t, err)
158
159 witnessJson, err := ioutil.ReadFile("../testdata/" + circuit + "/witness.json")
160 require.Nil(t, err)
161 w, err := ParseWitness(witnessJson)
162 require.Nil(t, err)
163
164 assert.Equal(t, len(w), len(witness))
165 assert.Equal(t, w[0], witness[0])
166 assert.Equal(t, w[1], witness[1])
167 assert.Equal(t, w[10], witness[10])
168 assert.Equal(t, w[len(w)-3], witness[len(w)-3])
169 assert.Equal(t, w[len(w)-2], witness[len(w)-2])
170 assert.Equal(t, w[len(w)-1], witness[len(w)-1])
171}
172
173func TestParseWitnessBin(t *testing.T) {
174 testCircuitParseWitnessBin(t, "circuit1k")
175 testCircuitParseWitnessBin(t, "circuit5k")
176}
177
178func TestProofSmartContractFormat(t *testing.T) {
179 proofJson, err := ioutil.ReadFile("../testdata/circuit1k/proof.json")
180 require.Nil(t, err)
181 proof, err := ParseProof(proofJson)
182 require.Nil(t, err)
183 pS := ProofToString(proof)
184
185 pSC := ProofToSmartContractFormat(proof)
186 assert.Nil(t, err)
187 assert.Equal(t, pS.A[0], pSC.A[0])
188 assert.Equal(t, pS.A[1], pSC.A[1])
189 assert.Equal(t, pS.B[0][0], pSC.B[0][1])
190 assert.Equal(t, pS.B[0][1], pSC.B[0][0])
191 assert.Equal(t, pS.B[1][0], pSC.B[1][1])
192 assert.Equal(t, pS.B[1][1], pSC.B[1][0])
193 assert.Equal(t, pS.C[0], pSC.C[0])
194 assert.Equal(t, pS.C[1], pSC.C[1])
195 assert.Equal(t, pS.Protocol, pSC.Protocol)
196
197 pSC2 := ProofStringToSmartContractFormat(pS)
198 assert.Equal(t, pSC, pSC2)
199}
200
201func TestProofJSON(t *testing.T) {
202 proofJson, err := ioutil.ReadFile("../testdata/circuit1k/proof.json")
203 require.Nil(t, err)
204 proof, err := ParseProof(proofJson)
205 require.Nil(t, err)
206
207 proof1JSON, err := json.Marshal(proof)
208 require.Nil(t, err)
209 var proof1 types.Proof
210 err = json.Unmarshal(proof1JSON, &proof1)
211 require.Nil(t, err)
212 require.Equal(t, *proof, proof1)
213}
214
215func testCircuitParsePkBin(t *testing.T, circuit string) {
216 pkBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.bin")
217 require.Nil(t, err)
218 defer pkBinFile.Close()
219 pk, err := ParsePkBin(pkBinFile)
220 require.Nil(t, err)
221
222 pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
223 require.Nil(t, err)
224 pkJ, err := ParsePk(pkJson)
225 require.Nil(t, err)
226
227 assert.Equal(t, pkJ.NVars, pk.NVars)
228 assert.Equal(t, pkJ.NPublic, pk.NPublic)
229 assert.Equal(t, pkJ.DomainSize, pk.DomainSize)
230 assert.Equal(t, pkJ.VkAlpha1, pk.VkAlpha1)
231 assert.Equal(t, pkJ.VkBeta1, pk.VkBeta1)
232 assert.Equal(t, pkJ.VkDelta1, pk.VkDelta1)
233 assert.Equal(t, pkJ.VkDelta2, pk.VkDelta2)
234 assert.Equal(t, pkJ.PolsA, pk.PolsA)
235 assert.Equal(t, pkJ.PolsB, pk.PolsB)
236 assert.Equal(t, pkJ.A, pk.A)
237 assert.Equal(t, pkJ.B1, pk.B1)
238 assert.Equal(t, pkJ.B2, pk.B2)
239 assert.Equal(t, pkJ.C, pk.C)
240 assert.Equal(t, pkJ.HExps[:pkJ.DomainSize], pk.HExps[:pk.DomainSize]) // circom behaviour
241
242 assert.Equal(t, pkJ.NVars, pk.NVars)
243 assert.Equal(t, pkJ.NPublic, pk.NPublic)
244 assert.Equal(t, pkJ.DomainSize, pk.DomainSize)
245}
246
247func TestParsePkBin(t *testing.T) {
248 testCircuitParsePkBin(t, "circuit1k")
249 testCircuitParsePkBin(t, "circuit5k")
250}
251
252func testGoCircomPkFormat(t *testing.T, circuit string) {
253 pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
254 require.Nil(t, err)
255 pk, err := ParsePk(pkJson)
256 require.Nil(t, err)
257
258 pkGBin, err := PkToGoBin(pk)
259 require.Nil(t, err)
260 err = ioutil.WriteFile("../testdata/"+circuit+"/proving_key.go.bin", pkGBin, 0644)
261 assert.Nil(t, err)
262
263 // parse ProvingKeyGo
264 pkGoBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.go.bin")
265 require.Nil(t, err)
266 defer pkGoBinFile.Close()
267 pkG, err := ParsePkGoBin(pkGoBinFile)
268 require.Nil(t, err)
269 assert.Equal(t, pk.VkAlpha1, pkG.VkAlpha1)
270 assert.Equal(t, pk.VkBeta1, pkG.VkBeta1)
271 assert.Equal(t, pk.VkDelta1, pkG.VkDelta1)
272 assert.Equal(t, pk.VkBeta2, pkG.VkBeta2)
273 assert.Equal(t, pk.VkDelta2, pkG.VkDelta2)
274 assert.Equal(t, pk.A, pkG.A)
275 assert.Equal(t, pk.B1, pkG.B1)
276 assert.Equal(t, pk.B2, pkG.B2)
277 assert.Equal(t, pk.C, pkG.C)
278 assert.Equal(t, pk.HExps, pkG.HExps)
279 assert.Equal(t, pk.PolsA, pkG.PolsA)
280 assert.Equal(t, pk.PolsB, pkG.PolsB)
281
282 assert.Equal(t, pk.NVars, pkG.NVars)
283 assert.Equal(t, pk.NPublic, pkG.NPublic)
284 assert.Equal(t, pk.DomainSize, pkG.DomainSize)
285}
286
287func TestGoCircomPkFormat(t *testing.T) {
288 testGoCircomPkFormat(t, "circuit1k")
289 testGoCircomPkFormat(t, "circuit5k")
290 // testGoCircomPkFormat(t, "circuit10k")
291 // testGoCircomPkFormat(t, "circuit20k")
292}
293
294func benchmarkParsePk(b *testing.B, circuit string) {
295 pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
296 require.Nil(b, err)
297
298 pkBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.bin")
299 require.Nil(b, err)
300 defer pkBinFile.Close()
301
302 pkGoBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.go.bin")
303 require.Nil(b, err)
304 defer pkGoBinFile.Close()
305
306 b.Run("ParsePkJson "+circuit, func(b *testing.B) {
307 for i := 0; i < b.N; i++ {
308 _, err = ParsePk(pkJson)
309 require.Nil(b, err)
310 }
311 })
312 b.Run("ParsePkBin "+circuit, func(b *testing.B) {
313 for i := 0; i < b.N; i++ {
314 pkBinFile.Seek(0, 0)
315 _, err = ParsePkBin(pkBinFile)
316 require.Nil(b, err)
317 }
318 })
319 b.Run("ParsePkGoBin "+circuit, func(b *testing.B) {
320 for i := 0; i < b.N; i++ {
321 pkGoBinFile.Seek(0, 0)
322 _, err = ParsePkGoBin(pkGoBinFile)
323 require.Nil(b, err)
324 }
325 })
326}
327
328func BenchmarkParsePk(b *testing.B) {
329 benchmarkParsePk(b, "circuit1k")
330 benchmarkParsePk(b, "circuit5k")
331 // benchmarkParsePk(b, "circuit10k")
332 // benchmarkParsePk(b, "circuit20k")
333}