1package parsers
  2
  3import (
  4	"io/ioutil"
  5	"os"
  6	"testing"
  7
  8	"github.com/stretchr/testify/assert"
  9	"github.com/stretchr/testify/require"
 10)
 11
 12func TestParseArrayG1(t *testing.T) {
 13	aS := [][]string{
 14		{
 15			"16145916318196730299582072104388453231952213805668281741813587224450782397538",
 16			"4434505318477484327659527264104806919103674231447634885054368605283938696207",
 17			"1",
 18		},
 19		{
 20			"10618406967550056457559358662746625591602641004174976323307214433994084907915",
 21			"1843236360452735081347085412539192450068665510574800388201121698908391533923",
 22			"1",
 23		},
 24		{
 25			"1208972877970123411566574123860641832032384890981476033353526096830198333194",
 26			"777503551507025252294438107100944741641946695980350712141258191590862204805",
 27			"1",
 28		},
 29		{
 30			"0",
 31			"1",
 32			"0",
 33		},
 34	}
 35
 36	a, err := arrayStringToG1(aS)
 37	assert.Nil(t, err)
 38	assert.Equal(t, "bn256.G1(23b243c928ce40c4cc2dad366e9f61723aef65866e1c66f42a08697f2f030462, 09cdd7500688fb487ec9f27b5a732d68fa0f3ddca5c2c790e330fdfb03b77c0f)", a[0].String())
 39	assert.Equal(t, "bn256.G1(1779ce2c586b5fc523e72e755d969a63473052aaad7c11eb5bf0ecdcfdfefb8b, 04133c1c74206dace57cd3d76ce59be381bbf08f51a5b3edc2b0c183d43eed63)", a[1].String())
 40	assert.Equal(t, "bn256.G1(02ac4120598d2f2bb81bc09b8df596403360577b0c5ff52485d1ef2200f23f0a, 01b80d298de75f867d6484c55c3da02c042bb4eb9a1734d3386786aaa669af85)", a[2].String())
 41	assert.Equal(t, "bn256.G1(0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000001)", a[3].String())
 42}
 43
 44func TestParseG2(t *testing.T) {
 45	aS := [][]string{
 46		{
 47			"9283666785342556550467669770956850930982548182701254051508520248901282197973",
 48			"11369378229277445316894458966429873744779877313900506577160370623273013178252",
 49		},
 50		{
 51			"10625777544326349817513295021482494426101347915428005055375725845993157551870",
 52			"21401790227434807639472120486932615400751346915707967674912972446672152512583",
 53		},
 54		{
 55			"1",
 56			"0",
 57		},
 58	}
 59
 60	a, err := stringToG2(aS)
 61	assert.Nil(t, err)
 62	assert.Equal(t, "bn256.G2((1922d70c934543aa655ec3277f7fa10a25ec973a4f001a7c54ce4954b4916f8c, 14865e836947c42cf35b47d30e06535fff9dab319c4296e28afde368960671d5), (2f50fbe77925b0a9d718c9ab38638bafa7c65f43f0d09035e518df97ad294847, 177dfa1a3b8627faf0425d9511bcb4c6ca986ea05e3803b5c643c35b94a7e6fe))", a.String())
 63
 64	aS = [][]string{
 65		{
 66			"13973091636763944887728510851169742544309374663995476311690518173988838518856",
 67			"12903946180439304546475897520537621821375470264150438270817301786763517825250",
 68		},
 69		{
 70			"370374369234123593044872519351942112043402224488849374153134091815693350697",
 71			"17423079115073430837335625309232513526393852743032331213038909731579295753224",
 72		},
 73		{
 74			"1",
 75			"0",
 76		},
 77	}
 78	a, err = stringToG2(aS)
 79	assert.Nil(t, err)
 80	assert.Equal(t, "bn256.G2((1c875fed67fff3b35f115b03706ec45f281b5f6cc71a99107240e09fce4910e2, 1ee47d566e9a099626b9860bcd96f6d4a1ed65f115d3efa8e05e5f42cc793048), (26851d022ce9961df65a430811824aaf3118710ac03b0614a50c05ee27d8e408, 00d19fdce25b0d78fb317a5f1789823b7ed76274b0d1be9c685792c73b347729))", a.String())
 81}
 82
 83func TestParseArrayG2(t *testing.T) {
 84	aS := [][][]string{
 85		{
 86			{
 87				"0",
 88				"0",
 89			},
 90			{
 91				"1",
 92				"0",
 93			},
 94			{
 95				"0",
 96				"0",
 97			},
 98		},
 99		{
100			{
101				"0",
102				"0",
103			},
104			{
105				"1",
106				"0",
107			},
108			{
109				"0",
110				"0",
111			},
112		},
113		{
114			{
115				"0",
116				"0",
117			},
118			{
119				"1",
120				"0",
121			},
122			{
123				"0",
124				"0",
125			},
126		},
127		{
128			{
129				"9283666785342556550467669770956850930982548182701254051508520248901282197973",
130				"11369378229277445316894458966429873744779877313900506577160370623273013178252",
131			},
132			{
133				"10625777544326349817513295021482494426101347915428005055375725845993157551870",
134				"21401790227434807639472120486932615400751346915707967674912972446672152512583",
135			},
136			{
137				"1",
138				"0",
139			},
140		},
141	}
142
143	a, err := arrayStringToG2(aS)
144	assert.Nil(t, err)
145	assert.Equal(t, "bn256.G2((0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000000), (0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000001))", a[0].String())
146	assert.Equal(t, "bn256.G2((1922d70c934543aa655ec3277f7fa10a25ec973a4f001a7c54ce4954b4916f8c, 14865e836947c42cf35b47d30e06535fff9dab319c4296e28afde368960671d5), (2f50fbe77925b0a9d718c9ab38638bafa7c65f43f0d09035e518df97ad294847, 177dfa1a3b8627faf0425d9511bcb4c6ca986ea05e3803b5c643c35b94a7e6fe))", a[3].String())
147
148}
149
150func testCircuitParseWitnessBin(t *testing.T, circuit string) {
151	witnessBinFile, err := os.Open("../testdata/" + circuit + "/witness.bin")
152	require.Nil(t, err)
153	defer witnessBinFile.Close()
154	witness, err := ParseWitnessBin(witnessBinFile)
155	require.Nil(t, err)
156
157	witnessJson, err := ioutil.ReadFile("../testdata/" + circuit + "/witness.json")
158	require.Nil(t, err)
159	w, err := ParseWitness(witnessJson)
160	require.Nil(t, err)
161
162	assert.Equal(t, len(w), len(witness))
163	assert.Equal(t, w[0], witness[0])
164	assert.Equal(t, w[1], witness[1])
165	assert.Equal(t, w[10], witness[10])
166	assert.Equal(t, w[len(w)-3], witness[len(w)-3])
167	assert.Equal(t, w[len(w)-2], witness[len(w)-2])
168	assert.Equal(t, w[len(w)-1], witness[len(w)-1])
169}
170
171func TestParseWitnessBin(t *testing.T) {
172	testCircuitParseWitnessBin(t, "circuit1k")
173	testCircuitParseWitnessBin(t, "circuit5k")
174}
175
176func TestProofSmartContractFormat(t *testing.T) {
177	proofJson, err := ioutil.ReadFile("../testdata/circuit1k/proof.json")
178	require.Nil(t, err)
179	proof, err := ParseProof(proofJson)
180	require.Nil(t, err)
181	pS := ProofToString(proof)
182
183	pSC := ProofToSmartContractFormat(proof)
184	assert.Nil(t, err)
185	assert.Equal(t, pS.A[0], pSC.A[0])
186	assert.Equal(t, pS.A[1], pSC.A[1])
187	assert.Equal(t, pS.B[0][0], pSC.B[0][1])
188	assert.Equal(t, pS.B[0][1], pSC.B[0][0])
189	assert.Equal(t, pS.B[1][0], pSC.B[1][1])
190	assert.Equal(t, pS.B[1][1], pSC.B[1][0])
191	assert.Equal(t, pS.C[0], pSC.C[0])
192	assert.Equal(t, pS.C[1], pSC.C[1])
193	assert.Equal(t, pS.Protocol, pSC.Protocol)
194
195	pSC2 := ProofStringToSmartContractFormat(pS)
196	assert.Equal(t, pSC, pSC2)
197
198}
199
200func testCircuitParsePkBin(t *testing.T, circuit string) {
201	pkBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.bin")
202	require.Nil(t, err)
203	defer pkBinFile.Close()
204	pk, err := ParsePkBin(pkBinFile)
205	require.Nil(t, err)
206
207	pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
208	require.Nil(t, err)
209	pkJ, err := ParsePk(pkJson)
210	require.Nil(t, err)
211
212	assert.Equal(t, pkJ.NVars, pk.NVars)
213	assert.Equal(t, pkJ.NPublic, pk.NPublic)
214	assert.Equal(t, pkJ.DomainSize, pk.DomainSize)
215	assert.Equal(t, pkJ.VkAlpha1, pk.VkAlpha1)
216	assert.Equal(t, pkJ.VkBeta1, pk.VkBeta1)
217	assert.Equal(t, pkJ.VkDelta1, pk.VkDelta1)
218	assert.Equal(t, pkJ.VkDelta2, pk.VkDelta2)
219	assert.Equal(t, pkJ.PolsA, pk.PolsA)
220	assert.Equal(t, pkJ.PolsB, pk.PolsB)
221	assert.Equal(t, pkJ.A, pk.A)
222	assert.Equal(t, pkJ.B1, pk.B1)
223	assert.Equal(t, pkJ.B2, pk.B2)
224	assert.Equal(t, pkJ.C, pk.C)
225	assert.Equal(t, pkJ.HExps[:pkJ.DomainSize], pk.HExps[:pk.DomainSize]) // circom behaviour
226}
227
228func TestParsePkBin(t *testing.T) {
229	testCircuitParsePkBin(t, "circuit1k")
230	testCircuitParsePkBin(t, "circuit5k")
231}
232
233func benchmarkParsePk(b *testing.B, circuit string) {
234	pkJson, err := ioutil.ReadFile("../testdata/" + circuit + "/proving_key.json")
235	require.Nil(b, err)
236
237	pkBinFile, err := os.Open("../testdata/" + circuit + "/proving_key.bin")
238	require.Nil(b, err)
239	defer pkBinFile.Close()
240
241	b.Run("Parse Pk bin "+circuit, func(b *testing.B) {
242		for i := 0; i < b.N; i++ {
243			ParsePk(pkJson)
244		}
245	})
246	b.Run("Parse Pk json "+circuit, func(b *testing.B) {
247		for i := 0; i < b.N; i++ {
248			ParsePkBin(pkBinFile)
249		}
250	})
251}
252
253func BenchmarkParsePk(b *testing.B) {
254	benchmarkParsePk(b, "circuit1k")
255	benchmarkParsePk(b, "circuit5k")
256	// benchmarkParsePk(b, "circuit10k")
257	// benchmarkParsePk(b, "circuit20k")
258}