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 benchmarkParsePk(b *testing.B, circuit string) {
249	pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
250	require.Nil(b, err)
251
252	pkBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.bin")
253	require.Nil(b, err)
254	defer pkBinFile.Close()
255
256	b.Run("Parse Pk bin "+circuit, func(b *testing.B) {
257		for i := 0; i < b.N; i++ {
258			ParsePk(pkJson)
259		}
260	})
261	b.Run("Parse Pk json "+circuit, func(b *testing.B) {
262		for i := 0; i < b.N; i++ {
263			ParsePkBin(pkBinFile)
264		}
265	})
266}
267
268func BenchmarkParsePk(b *testing.B) {
269	benchmarkParsePk(b, "circuit1k")
270	benchmarkParsePk(b, "circuit5k")
271	// benchmarkParsePk(b, "circuit10k")
272	// benchmarkParsePk(b, "circuit20k")
273}