go-merkletree-iden3/merkletree_test.go
merkletree_test.goRaw
1package merkletree
2
3import (
4 "bytes"
5 "encoding/hex"
6 "fmt"
7 "math/big"
8 "testing"
9
10 "github.com/iden3/go-merkletree/db/memory"
11 "github.com/stretchr/testify/assert"
12 "github.com/stretchr/testify/require"
13)
14
15var debug = false
16
17type Fatalable interface {
18 Fatal(args ...interface{})
19}
20
21func newTestingMerkle(f Fatalable, numLevels int) *MerkleTree {
22 mt, err := NewMerkleTree(memory.NewMemoryStorage(), numLevels)
23 if err != nil {
24 f.Fatal(err)
25 return nil
26 }
27 return mt
28}
29
30func TestHashParsers(t *testing.T) {
31 h0 := NewHashFromBigInt(big.NewInt(0))
32 assert.Equal(t, "0", h0.String())
33 h1 := NewHashFromBigInt(big.NewInt(1))
34 assert.Equal(t, "1", h1.String())
35 h10 := NewHashFromBigInt(big.NewInt(10))
36 assert.Equal(t, "10", h10.String())
37
38 h7l := NewHashFromBigInt(big.NewInt(1234567))
39 assert.Equal(t, "1234567", h7l.String())
40 h8l := NewHashFromBigInt(big.NewInt(12345678))
41 assert.Equal(t, "12345678...", h8l.String())
42
43 b, ok := new(big.Int).SetString("4932297968297298434239270129193057052722409868268166443802652458940273154854", 10)
44 assert.True(t, ok)
45 h := NewHashFromBigInt(b)
46 assert.Equal(t, "4932297968297298434239270129193057052722409868268166443802652458940273154854", h.BigInt().String())
47 assert.Equal(t, "49322979...", h.String())
48 assert.Equal(t, "0ae794eb9c3d8bbb9002e993fc2ed301dcbd2af5508ed072c375e861f1aa5b26", h.Hex())
49}
50
51func TestNewTree(t *testing.T) {
52 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 10)
53 assert.Nil(t, err)
54 assert.Equal(t, "0", mt.Root().String())
55
56 // test vectors generated using https://github.com/iden3/circomlib smt.js
57 err = mt.Add(big.NewInt(1), big.NewInt(2))
58 assert.Nil(t, err)
59 assert.Equal(t, "4932297968297298434239270129193057052722409868268166443802652458940273154854", mt.Root().BigInt().String())
60
61 err = mt.Add(big.NewInt(33), big.NewInt(44))
62 assert.Nil(t, err)
63 assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String())
64
65 err = mt.Add(big.NewInt(1234), big.NewInt(9876))
66 assert.Nil(t, err)
67 assert.Equal(t, "16970503620176669663662021947486532860010370357132361783766545149750777353066", mt.Root().BigInt().String())
68
69 proof, v, err := mt.GenerateProof(big.NewInt(33), nil)
70 assert.Nil(t, err)
71 assert.Equal(t, big.NewInt(44), v)
72
73 assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(33), big.NewInt(44)))
74 assert.True(t, !VerifyProof(mt.Root(), proof, big.NewInt(33), big.NewInt(45)))
75}
76
77func TestAddDifferentOrder(t *testing.T) {
78 mt1 := newTestingMerkle(t, 140)
79 defer mt1.db.Close()
80 for i := 0; i < 16; i++ {
81 k := big.NewInt(int64(i))
82 v := big.NewInt(0)
83 if err := mt1.Add(k, v); err != nil {
84 t.Fatal(err)
85 }
86 }
87
88 mt2 := newTestingMerkle(t, 140)
89 defer mt2.db.Close()
90 for i := 16 - 1; i >= 0; i-- {
91 k := big.NewInt(int64(i))
92 v := big.NewInt(0)
93 if err := mt2.Add(k, v); err != nil {
94 t.Fatal(err)
95 }
96 }
97
98 assert.Equal(t, mt1.Root().Hex(), mt2.Root().Hex())
99 assert.Equal(t, "0967b777d660e54aa3a0f0f3405bb962504d3d69d6b930146cd212dff9913bee", mt1.Root().Hex())
100}
101
102func TestAddRepeatedIndex(t *testing.T) {
103 mt := newTestingMerkle(t, 140)
104 defer mt.db.Close()
105 k := big.NewInt(int64(3))
106 v := big.NewInt(int64(12))
107 if err := mt.Add(k, v); err != nil {
108 t.Fatal(err)
109 }
110 err := mt.Add(k, v)
111 assert.NotNil(t, err)
112 assert.Equal(t, err, ErrEntryIndexAlreadyExists)
113}
114
115func TestGet(t *testing.T) {
116 mt := newTestingMerkle(t, 140)
117 defer mt.db.Close()
118
119 for i := 0; i < 16; i++ {
120 k := big.NewInt(int64(i))
121 v := big.NewInt(int64(i * 2))
122 if err := mt.Add(k, v); err != nil {
123 t.Fatal(err)
124 }
125 }
126 v, _, err := mt.Get(big.NewInt(10))
127 assert.Nil(t, err)
128 assert.Equal(t, big.NewInt(20), v)
129
130 v, _, err = mt.Get(big.NewInt(15))
131 assert.Nil(t, err)
132 assert.Equal(t, big.NewInt(30), v)
133
134 v, _, err = mt.Get(big.NewInt(16))
135 assert.NotNil(t, err)
136 assert.Equal(t, ErrKeyNotFound, err)
137 assert.Nil(t, v)
138}
139
140func TestUpdate(t *testing.T) {
141 mt := newTestingMerkle(t, 140)
142 defer mt.db.Close()
143
144 for i := 0; i < 16; i++ {
145 k := big.NewInt(int64(i))
146 v := big.NewInt(int64(i * 2))
147 if err := mt.Add(k, v); err != nil {
148 t.Fatal(err)
149 }
150 }
151 v, _, err := mt.Get(big.NewInt(10))
152 assert.Nil(t, err)
153 assert.Equal(t, big.NewInt(20), v)
154
155 _, err = mt.Update(big.NewInt(10), big.NewInt(1024))
156 assert.Nil(t, err)
157 v, _, err = mt.Get(big.NewInt(10))
158 assert.Nil(t, err)
159 assert.Equal(t, big.NewInt(1024), v)
160
161 _, err = mt.Update(big.NewInt(1000), big.NewInt(1024))
162 assert.Equal(t, ErrKeyNotFound, err)
163}
164
165func TestUpdate2(t *testing.T) {
166 mt1 := newTestingMerkle(t, 140)
167 defer mt1.db.Close()
168 mt2 := newTestingMerkle(t, 140)
169 defer mt2.db.Close()
170
171 err := mt1.Add(big.NewInt(1), big.NewInt(119))
172 assert.Nil(t, err)
173 err = mt1.Add(big.NewInt(2), big.NewInt(229))
174 assert.Nil(t, err)
175 err = mt1.Add(big.NewInt(9876), big.NewInt(6789))
176 assert.Nil(t, err)
177
178 err = mt2.Add(big.NewInt(1), big.NewInt(11))
179 assert.Nil(t, err)
180 err = mt2.Add(big.NewInt(2), big.NewInt(22))
181 assert.Nil(t, err)
182 err = mt2.Add(big.NewInt(9876), big.NewInt(10))
183 assert.Nil(t, err)
184
185 _, err = mt1.Update(big.NewInt(1), big.NewInt(11))
186 assert.Nil(t, err)
187 _, err = mt1.Update(big.NewInt(2), big.NewInt(22))
188 assert.Nil(t, err)
189 _, err = mt2.Update(big.NewInt(9876), big.NewInt(6789))
190 assert.Nil(t, err)
191
192 assert.Equal(t, mt1.Root(), mt2.Root())
193}
194
195func TestGenerateAndVerifyProof128(t *testing.T) {
196 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 140)
197 require.Nil(t, err)
198 defer mt.db.Close()
199
200 for i := 0; i < 128; i++ {
201 k := big.NewInt(int64(i))
202 v := big.NewInt(0)
203 if err := mt.Add(k, v); err != nil {
204 t.Fatal(err)
205 }
206 }
207 proof, v, err := mt.GenerateProof(big.NewInt(42), nil)
208 assert.Nil(t, err)
209 assert.Equal(t, "0", v.String())
210 assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(42), big.NewInt(0)))
211}
212
213func TestTreeLimit(t *testing.T) {
214 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 5)
215 require.Nil(t, err)
216 defer mt.db.Close()
217
218 for i := 0; i < 16; i++ {
219 err = mt.Add(big.NewInt(int64(i)), big.NewInt(int64(i)))
220 assert.Nil(t, err)
221 }
222
223 // here the tree is full, should not allow to add more data as reaches the maximum number of levels
224 err = mt.Add(big.NewInt(int64(16)), big.NewInt(int64(16)))
225 assert.NotNil(t, err)
226 assert.Equal(t, ErrReachedMaxLevel, err)
227}
228
229func TestSiblingsFromProof(t *testing.T) {
230 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 140)
231 require.Nil(t, err)
232 defer mt.db.Close()
233
234 for i := 0; i < 64; i++ {
235 k := big.NewInt(int64(i))
236 v := big.NewInt(0)
237 if err := mt.Add(k, v); err != nil {
238 t.Fatal(err)
239 }
240 }
241
242 proof, _, err := mt.GenerateProof(big.NewInt(4), nil)
243 if err != nil {
244 t.Fatal(err)
245 }
246
247 siblings := SiblingsFromProof(proof)
248 assert.Equal(t, 6, len(siblings))
249 assert.Equal(t, "23db1f6fb07af47d7715f18960548c215fc7a2e6d25cb4a7eb82c9d3cf69bc26", siblings[0].Hex())
250 assert.Equal(t, "2156e64dedcb76719ec732414dd6a8aa4348dafb24c19351a68fbc4158bb7fba", siblings[1].Hex())
251 assert.Equal(t, "04a8e9b34d5a8b55268ca96b0b8c7c5aaef4f606ec3437ec67e4152d9b323913", siblings[2].Hex())
252 assert.Equal(t, "0ff484133e0d25deb4a7c0cb46d90432e00fcc280948c2fab6fed9476f1e26b2", siblings[3].Hex())
253 assert.Equal(t, "015dff482e87eb2046b8f5323049afd05f8dd8554e2c9aa1ef28991cf205c9b6", siblings[4].Hex())
254 assert.Equal(t, "1e4da486ad68b07acec1406bed5a60732de5ff72d63910f7afbb491f953a8769", siblings[5].Hex())
255}
256
257func TestVerifyProofCases(t *testing.T) {
258 mt := newTestingMerkle(t, 140)
259 defer mt.DB().Close()
260
261 for i := 0; i < 8; i++ {
262 if err := mt.Add(big.NewInt(int64(i)), big.NewInt(0)); err != nil {
263 t.Fatal(err)
264 }
265 }
266
267 // Existence proof
268
269 proof, _, err := mt.GenerateProof(big.NewInt(4), nil)
270 if err != nil {
271 t.Fatal(err)
272 }
273 assert.Equal(t, proof.Existence, true)
274 assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(4), big.NewInt(0)))
275 assert.Equal(t, "000300000000000000000000000000000000000000000000000000000000000728ea2b267d2a9436657f20b5827285175e030f58c07375535106903b16621630b9104d995843c7cffa685009a1b28dcd371022a3b27b3a4d6987f7c8b39b0f2fffc165330710754ca0fc24451bdd5d5f82a05f42f1427fbdf17879c0b84be60f", hex.EncodeToString(proof.Bytes()))
276
277 for i := 8; i < 32; i++ {
278 proof, _, err = mt.GenerateProof(big.NewInt(int64(i)), nil)
279 assert.Nil(t, err)
280 if debug {
281 fmt.Println(i, proof)
282 }
283 }
284 // Non-existence proof, empty aux
285 proof, _, err = mt.GenerateProof(big.NewInt(12), nil)
286 if err != nil {
287 t.Fatal(err)
288 }
289 assert.Equal(t, proof.Existence, false)
290 // assert.True(t, proof.nodeAux == nil)
291 assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(12), big.NewInt(0)))
292 assert.Equal(t, "030300000000000000000000000000000000000000000000000000000000000728ea2b267d2a9436657f20b5827285175e030f58c07375535106903b16621630b9104d995843c7cffa685009a1b28dcd371022a3b27b3a4d6987f7c8b39b0f2fffc165330710754ca0fc24451bdd5d5f82a05f42f1427fbdf17879c0b84be60f04000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(proof.Bytes()))
293
294 // Non-existence proof, diff. node aux
295 proof, _, err = mt.GenerateProof(big.NewInt(10), nil)
296 if err != nil {
297 t.Fatal(err)
298 }
299 assert.Equal(t, proof.Existence, false)
300 assert.True(t, proof.NodeAux != nil)
301 assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(10), big.NewInt(0)))
302 assert.Equal(t, "030300000000000000000000000000000000000000000000000000000000000728ea2b267d2a9436657f20b5827285175e030f58c07375535106903b1662163097fcf8f911b271df196e0a75667b8a4f3024ef39f87201ed2b7cda349ba202296b7aeba35dc19ab0d4f65e175536c9952a90b6de18c3205611c3cd4fb408f01602000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(proof.Bytes()))
303}
304
305func TestVerifyProofFalse(t *testing.T) {
306 mt := newTestingMerkle(t, 140)
307 defer mt.DB().Close()
308
309 for i := 0; i < 8; i++ {
310 if err := mt.Add(big.NewInt(int64(i)), big.NewInt(0)); err != nil {
311 t.Fatal(err)
312 }
313 }
314
315 // Invalid existence proof (node used for verification doesn't
316 // correspond to node in the proof)
317 proof, _, err := mt.GenerateProof(big.NewInt(int64(4)), nil)
318 if err != nil {
319 t.Fatal(err)
320 }
321 assert.Equal(t, proof.Existence, true)
322 assert.True(t, !VerifyProof(mt.Root(), proof, big.NewInt(int64(5)), big.NewInt(int64(5))))
323
324 // Invalid non-existence proof (Non-existence proof, diff. node aux)
325 proof, _, err = mt.GenerateProof(big.NewInt(int64(4)), nil)
326 if err != nil {
327 t.Fatal(err)
328 }
329 assert.Equal(t, proof.Existence, true)
330 // Now we change the proof from existence to non-existence, and add e's
331 // data as auxiliary node.
332 proof.Existence = false
333 proof.NodeAux = &NodeAux{Key: NewHashFromBigInt(big.NewInt(int64(4))), Value: NewHashFromBigInt(big.NewInt(4))}
334 assert.True(t, !VerifyProof(mt.Root(), proof, big.NewInt(int64(4)), big.NewInt(0)))
335}
336
337func TestGraphViz(t *testing.T) {
338 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 10)
339 assert.Nil(t, err)
340
341 mt.Add(big.NewInt(1), big.NewInt(0))
342 mt.Add(big.NewInt(2), big.NewInt(0))
343 mt.Add(big.NewInt(3), big.NewInt(0))
344 mt.Add(big.NewInt(4), big.NewInt(0))
345 mt.Add(big.NewInt(5), big.NewInt(0))
346 mt.Add(big.NewInt(100), big.NewInt(0))
347
348 // mt.PrintGraphViz(nil)
349
350 expected := `digraph hierarchy {
351node [fontname=Monospace,fontsize=10,shape=box]
352"60195538..." -> {"19759736..." "18893277..."}
353"19759736..." -> {"16152312..." "43945008..."}
354"16152312..." -> {"empty0" "13952255..."}
355"empty0" [style=dashed,label=0];
356"13952255..." -> {"61769925..." "empty1"}
357"empty1" [style=dashed,label=0];
358"61769925..." -> {"92723289..." "empty2"}
359"empty2" [style=dashed,label=0];
360"92723289..." -> {"21082735..." "82784818..."}
361"21082735..." [style=filled];
362"82784818..." [style=filled];
363"43945008..." [style=filled];
364"18893277..." -> {"19855703..." "17718670..."}
365"19855703..." -> {"11499909..." "15828714..."}
366"11499909..." [style=filled];
367"15828714..." [style=filled];
368"17718670..." [style=filled];
369}
370`
371 w := bytes.NewBufferString("")
372 mt.GraphViz(w, nil)
373 assert.Equal(t, []byte(expected), w.Bytes())
374}
375
376func TestDelete(t *testing.T) {
377 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 10)
378 assert.Nil(t, err)
379 assert.Equal(t, "0", mt.Root().String())
380
381 // test vectors generated using https://github.com/iden3/circomlib smt.js
382 err = mt.Add(big.NewInt(1), big.NewInt(2))
383 assert.Nil(t, err)
384 assert.Equal(t, "4932297968297298434239270129193057052722409868268166443802652458940273154854", mt.Root().BigInt().String())
385
386 err = mt.Add(big.NewInt(33), big.NewInt(44))
387 assert.Nil(t, err)
388 assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String())
389
390 err = mt.Add(big.NewInt(1234), big.NewInt(9876))
391 assert.Nil(t, err)
392 assert.Equal(t, "16970503620176669663662021947486532860010370357132361783766545149750777353066", mt.Root().BigInt().String())
393
394 // mt.PrintGraphViz(nil)
395
396 err = mt.Delete(big.NewInt(33))
397 // mt.PrintGraphViz(nil)
398 assert.Nil(t, err)
399 assert.Equal(t, "12820263606494630162816839760750120928463716794691735985748071431547370997091", mt.Root().BigInt().String())
400
401 err = mt.Delete(big.NewInt(1234))
402 assert.Nil(t, err)
403 err = mt.Delete(big.NewInt(1))
404 assert.Nil(t, err)
405 assert.Equal(t, "0", mt.Root().String())
406
407}
408
409func TestDelete2(t *testing.T) {
410 mt := newTestingMerkle(t, 140)
411 defer mt.db.Close()
412 for i := 0; i < 8; i++ {
413 k := big.NewInt(int64(i))
414 v := big.NewInt(0)
415 if err := mt.Add(k, v); err != nil {
416 t.Fatal(err)
417 }
418 }
419
420 expectedRoot := mt.Root()
421
422 k := big.NewInt(8)
423 v := big.NewInt(0)
424 err := mt.Add(k, v)
425 require.Nil(t, err)
426
427 err = mt.Delete(big.NewInt(8))
428 assert.Nil(t, err)
429 assert.Equal(t, expectedRoot, mt.Root())
430
431 mt2 := newTestingMerkle(t, 140)
432 defer mt2.db.Close()
433 for i := 0; i < 8; i++ {
434 k := big.NewInt(int64(i))
435 v := big.NewInt(0)
436 if err := mt2.Add(k, v); err != nil {
437 t.Fatal(err)
438 }
439 }
440 assert.Equal(t, mt2.Root(), mt.Root())
441}
442
443func TestDelete3(t *testing.T) {
444 mt := newTestingMerkle(t, 140)
445 defer mt.db.Close()
446
447 err := mt.Add(big.NewInt(1), big.NewInt(1))
448 assert.Nil(t, err)
449
450 err = mt.Add(big.NewInt(2), big.NewInt(2))
451 assert.Nil(t, err)
452
453 assert.Equal(t, "2427629547967522489273866134471574861207714751136138191708011221765688788661", mt.Root().BigInt().String())
454 err = mt.Delete(big.NewInt(1))
455 assert.Nil(t, err)
456 assert.Equal(t, "10822920717809411688334493481050035035708810950159417482558569847174767667301", mt.Root().BigInt().String())
457
458 mt2 := newTestingMerkle(t, 140)
459 defer mt2.db.Close()
460 err = mt2.Add(big.NewInt(2), big.NewInt(2))
461 assert.Nil(t, err)
462 assert.Equal(t, mt2.Root(), mt.Root())
463}
464
465func TestDelete4(t *testing.T) {
466 mt := newTestingMerkle(t, 140)
467 defer mt.db.Close()
468
469 err := mt.Add(big.NewInt(1), big.NewInt(1))
470 assert.Nil(t, err)
471
472 err = mt.Add(big.NewInt(2), big.NewInt(2))
473 assert.Nil(t, err)
474
475 err = mt.Add(big.NewInt(3), big.NewInt(3))
476 assert.Nil(t, err)
477
478 assert.Equal(t, "16614298246517994771186095530428786749320098419259206061045083278756632941513", mt.Root().BigInt().String())
479 err = mt.Delete(big.NewInt(1))
480 assert.Nil(t, err)
481 assert.Equal(t, "6117330520107511783353383870014397665359816230889739699667943862706617498952", mt.Root().BigInt().String())
482
483 mt2 := newTestingMerkle(t, 140)
484 defer mt2.db.Close()
485 err = mt2.Add(big.NewInt(2), big.NewInt(2))
486 assert.Nil(t, err)
487 err = mt2.Add(big.NewInt(3), big.NewInt(3))
488 assert.Nil(t, err)
489 assert.Equal(t, mt2.Root(), mt.Root())
490}
491
492func TestDelete5(t *testing.T) {
493 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 10)
494 assert.Nil(t, err)
495
496 err = mt.Add(big.NewInt(1), big.NewInt(2))
497 assert.Nil(t, err)
498 err = mt.Add(big.NewInt(33), big.NewInt(44))
499 assert.Nil(t, err)
500 assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String())
501
502 err = mt.Delete(big.NewInt(1))
503 assert.Nil(t, err)
504 assert.Equal(t, "12075524681474630909546786277734445038384732558409197537058769521806571391765", mt.Root().BigInt().String())
505
506 mt2 := newTestingMerkle(t, 140)
507 defer mt2.db.Close()
508 err = mt2.Add(big.NewInt(33), big.NewInt(44))
509 assert.Nil(t, err)
510 assert.Equal(t, mt2.Root(), mt.Root())
511}
512
513func TestDeleteNonExistingKeys(t *testing.T) {
514 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 10)
515 assert.Nil(t, err)
516
517 err = mt.Add(big.NewInt(1), big.NewInt(2))
518 assert.Nil(t, err)
519 err = mt.Add(big.NewInt(33), big.NewInt(44))
520 assert.Nil(t, err)
521
522 err = mt.Delete(big.NewInt(33))
523 assert.Nil(t, err)
524 err = mt.Delete(big.NewInt(33))
525 assert.Equal(t, ErrKeyNotFound, err)
526
527 err = mt.Delete(big.NewInt(1))
528 assert.Nil(t, err)
529
530 assert.Equal(t, "0", mt.Root().String())
531
532 err = mt.Delete(big.NewInt(33))
533 assert.Equal(t, ErrKeyNotFound, err)
534}
535
536func TestDumpLeafsImportLeafs(t *testing.T) {
537 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 140)
538 require.Nil(t, err)
539 defer mt.db.Close()
540
541 for i := 0; i < 10; i++ {
542 k := big.NewInt(int64(i))
543 v := big.NewInt(0)
544 err = mt.Add(k, v)
545 require.Nil(t, err)
546 }
547
548 d, err := mt.DumpLeafs(nil)
549 assert.Nil(t, err)
550
551 mt2, err := NewMerkleTree(memory.NewMemoryStorage(), 140)
552 require.Nil(t, err)
553 defer mt2.db.Close()
554 err = mt2.ImportDumpedLeafs(d)
555 assert.Nil(t, err)
556
557 assert.Equal(t, mt.Root(), mt2.Root())
558}
559
560func TestAddAndGetCircomProof(t *testing.T) {
561 mt, err := NewMerkleTree(memory.NewMemoryStorage(), 10)
562 assert.Nil(t, err)
563 assert.Equal(t, "0", mt.Root().String())
564
565 // test vectors generated using https://github.com/iden3/circomlib smt.js
566 _, err = mt.AddAndGetCircomProof(big.NewInt(1), big.NewInt(2))
567 assert.Nil(t, err)
568 assert.Equal(t, "4932297968297298434239270129193057052722409868268166443802652458940273154854", mt.Root().BigInt().String())
569
570 _, err = mt.AddAndGetCircomProof(big.NewInt(33), big.NewInt(44))
571 assert.Nil(t, err)
572 assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String())
573
574 _, err = mt.AddAndGetCircomProof(big.NewInt(1234), big.NewInt(9876))
575 assert.Nil(t, err)
576 assert.Equal(t, "16970503620176669663662021947486532860010370357132361783766545149750777353066", mt.Root().BigInt().String())
577
578 proof, v, err := mt.GenerateProof(big.NewInt(33), nil)
579 assert.Nil(t, err)
580 assert.Equal(t, big.NewInt(44), v)
581
582 assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(33), big.NewInt(44)))
583 assert.True(t, !VerifyProof(mt.Root(), proof, big.NewInt(33), big.NewInt(45)))
584}