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
243func TestParsePkBin(t *testing.T) {
244 testCircuitParsePkBin(t, "circuit1k")
245 testCircuitParsePkBin(t, "circuit5k")
246}
247
248func testGoCircomPkFormat(t *testing.T, circuit string) {
249 pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
250 require.Nil(t, err)
251 pk, err := ParsePk(pkJson)
252 require.Nil(t, err)
253
254 pkGBin, err := PkToGoBin(pk)
255 require.Nil(t, err)
256 err = ioutil.WriteFile("../testdata/"+circuit+"/proving_key.go.bin", pkGBin, 0644)
257 assert.Nil(t, err)
258
259 // parse ProvingKeyGo
260 pkGoBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.go.bin")
261 require.Nil(t, err)
262 defer pkGoBinFile.Close()
263 pkG, err := ParsePkGoBin(pkGoBinFile)
264 require.Nil(t, err)
265 assert.Equal(t, pk.VkAlpha1, pkG.VkAlpha1)
266 assert.Equal(t, pk.VkBeta1, pkG.VkBeta1)
267 assert.Equal(t, pk.VkDelta1, pkG.VkDelta1)
268 assert.Equal(t, pk.VkBeta2, pkG.VkBeta2)
269 assert.Equal(t, pk.VkDelta2, pkG.VkDelta2)
270 assert.Equal(t, pk.A, pkG.A)
271 assert.Equal(t, pk.B1, pkG.B1)
272 assert.Equal(t, pk.B2, pkG.B2)
273 assert.Equal(t, pk.C, pkG.C)
274 assert.Equal(t, pk.HExps, pkG.HExps)
275 assert.Equal(t, pk.PolsA, pkG.PolsA)
276 assert.Equal(t, pk.PolsB, pkG.PolsB)
277}
278
279func TestGoCircomPkFormat(t *testing.T) {
280 testGoCircomPkFormat(t, "circuit1k")
281 testGoCircomPkFormat(t, "circuit5k")
282 // testGoCircomPkFormat(t, "circuit10k")
283 // testGoCircomPkFormat(t, "circuit20k")
284}
285
286func benchmarkParsePk(b *testing.B, circuit string) {
287 pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
288 require.Nil(b, err)
289
290 pkBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.bin")
291 require.Nil(b, err)
292 defer pkBinFile.Close()
293
294 pkGoBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.go.bin")
295 require.Nil(b, err)
296 defer pkGoBinFile.Close()
297
298 b.Run("ParsePkJson "+circuit, func(b *testing.B) {
299 for i := 0; i < b.N; i++ {
300 ParsePkBin(pkBinFile)
301 }
302 })
303 b.Run("ParsePkBin "+circuit, func(b *testing.B) {
304 for i := 0; i < b.N; i++ {
305 ParsePk(pkJson)
306 }
307 })
308 b.Run("ParsePkGoBin "+circuit, func(b *testing.B) {
309 for i := 0; i < b.N; i++ {
310 ParsePkGoBin(pkBinFile)
311 }
312 })
313}
314
315func BenchmarkParsePk(b *testing.B) {
316 benchmarkParsePk(b, "circuit1k")
317 benchmarkParsePk(b, "circuit5k")
318 // benchmarkParsePk(b, "circuit10k")
319 // benchmarkParsePk(b, "circuit20k")
320}