diff --git a/go.mod b/go.mod index 8633609..e1030da 100644 --- a/go.mod +++ b/go.mod @@ -5,7 +5,7 @@ go 1.14 require ( github.com/cockroachdb/pebble v0.0.0-20200814004841-77c18adb0ee3 github.com/iden3/go-iden3-core v0.0.8 - github.com/iden3/go-iden3-crypto v0.0.6-0.20200723082457-29a66457f0bf + github.com/iden3/go-iden3-crypto v0.0.6-0.20200819064831-09d161e9f670 github.com/sirupsen/logrus v1.5.0 github.com/stretchr/testify v1.6.1 github.com/syndtr/goleveldb v1.0.1-0.20190923125748-758128399b1d diff --git a/go.sum b/go.sum index 4e72d12..83250bd 100644 --- a/go.sum +++ b/go.sum @@ -134,6 +134,10 @@ github.com/iden3/go-iden3-core v0.0.8/go.mod h1:URNjIhMql6sEbWubIGrjJdw5wHCE1Pk1 github.com/iden3/go-iden3-crypto v0.0.5/go.mod h1:XKw1oDwYn2CIxKOtr7m/mL5jMn4mLOxAxtZBRxQBev8= github.com/iden3/go-iden3-crypto v0.0.6-0.20200723082457-29a66457f0bf h1:/7L5dEqctuzJY2g8OEQct+1Y+n2sMKyd4JoYhw2jy1s= github.com/iden3/go-iden3-crypto v0.0.6-0.20200723082457-29a66457f0bf/go.mod h1:XKw1oDwYn2CIxKOtr7m/mL5jMn4mLOxAxtZBRxQBev8= +github.com/iden3/go-iden3-crypto v0.0.6-0.20200818162919-3364756c2ca6 h1:8B0nnJejnuZZYmbg1MkyrbeQWGkhHTXOyTEU+htfpR8= +github.com/iden3/go-iden3-crypto v0.0.6-0.20200818162919-3364756c2ca6/go.mod h1:oBgthFLboAWi9feaBUFy7OxEcyn9vA1khHSL/WwWFyg= +github.com/iden3/go-iden3-crypto v0.0.6-0.20200819064831-09d161e9f670 h1:gNBFu/WnRfNn+xywE04fgCWSHlb6wr0nIIll9i4R2fc= +github.com/iden3/go-iden3-crypto v0.0.6-0.20200819064831-09d161e9f670/go.mod h1:oBgthFLboAWi9feaBUFy7OxEcyn9vA1khHSL/WwWFyg= github.com/iden3/go-wasm3 v0.0.1/go.mod h1:j+TcAB94Dfrjlu5kJt83h2OqAU+oyNUTwNZnQyII1sI= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/influxdata/influxdb v1.2.3-0.20180221223340-01288bdb0883/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY= @@ -286,6 +290,7 @@ golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527 h1:uYVVQ9WP/Ds2ROhcaGPeIdVq0RIXVLwsHlnvJ+cT1So= golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 h1:DYfZAGf2WMFjMxbgTjaC+2HC7NkNAQs+6Q8b9WEB/F4= golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= diff --git a/merkletree.go b/merkletree.go index dfd927b..43271fe 100644 --- a/merkletree.go +++ b/merkletree.go @@ -199,8 +199,10 @@ func (mt *MerkleTree) Add(k, v *big.Int) error { return nil } +// AddAndGetCircomProof does an Add, and returns a CircomProcessorProof func (mt *MerkleTree) AddAndGetCircomProof(k, v *big.Int) (*CircomProcessorProof, error) { var cp CircomProcessorProof + cp.Fnc = 2 cp.OldRoot = mt.rootKey gettedK, gettedV, siblings, err := mt.Get(k) if err != nil && err != ErrKeyNotFound { @@ -300,7 +302,8 @@ func (mt *MerkleTree) addLeaf(tx db.Tx, newLeaf *Node, key *Hash, // We need to push newLeaf down until its path diverges from n's path return mt.pushLeaf(tx, newLeaf, n, lvl, path, pathOldLeaf) case NodeTypeMiddle: - // We need to go deeper, continue traversing the tree, left or right depending on path + // We need to go deeper, continue traversing the tree, left or + // right depending on path var newNodeMiddle *Node if path[lvl] { nextKey, err = mt.addLeaf(tx, newLeaf, n.ChildR, lvl+1, path) // go right @@ -385,7 +388,8 @@ func (mt *MerkleTree) Get(k *big.Int) (*big.Int, *big.Int, []*Hash, error) { } // Update updates the value of a specified key in the MerkleTree, and updates -// the path from the leaf to the Root with the new values. +// the path from the leaf to the Root with the new values. Returns the +// CircomProcessorProof. func (mt *MerkleTree) Update(k, v *big.Int) (*CircomProcessorProof, error) { // verify that the MerkleTree is writable if !mt.writable { @@ -411,6 +415,7 @@ func (mt *MerkleTree) Update(k, v *big.Int) (*CircomProcessorProof, error) { path := getPath(mt.maxLevels, kHash[:]) var cp CircomProcessorProof + cp.Fnc = 1 cp.OldRoot = mt.rootKey cp.OldKey = kHash cp.NewKey = kHash @@ -753,6 +758,7 @@ func (p *Proof) AllSiblings() []*Hash { return SiblingsFromProof(p) } +// CircomSiblingsFromSiblings returns the full siblings compatible with circom func CircomSiblingsFromSiblings(siblings []*Hash, levels int) []*Hash { // Add the rest of empty levels to the siblings for i := len(siblings); i < levels; i++ { @@ -760,13 +766,10 @@ func CircomSiblingsFromSiblings(siblings []*Hash, levels int) []*Hash { } siblings = append(siblings, &HashZero) // add extra level for circom compatibility return siblings - // siblingsBigInt := make([]*big.Int, len(siblings)) - // for i, sibling := range siblings { - // siblingsBigInt[i] = sibling.BigInt() - // } } -// AllSiblingsCircom returns all the siblings of the proof. This function is used to generate the siblings input for the circom circuits. +// AllSiblingsCircom returns all the siblings of the proof. This function is +// used to generate the siblings input for the circom circuits. func (p *Proof) AllSiblingsCircom(levels int) []*big.Int { siblings := p.AllSiblings() // Add the rest of empty levels to the siblings @@ -781,6 +784,8 @@ func (p *Proof) AllSiblingsCircom(levels int) []*big.Int { return siblingsBigInt } +// CircomProcessorProof defines the ProcessorProof compatible with circom. Is +// the data of the proof between the transition from one state to another. type CircomProcessorProof struct { OldRoot *Hash NewRoot *Hash @@ -790,9 +795,11 @@ type CircomProcessorProof struct { NewKey *Hash NewValue *Hash IsOld0 bool - // Fnc int // 0: NOP, 1: Update, 2: Insert, 3: Delete + Fnc int // 0: NOP, 1: Update, 2: Insert, 3: Delete } +// String returns a human readable string representation of the +// CircomProcessorProof func (p CircomProcessorProof) String() string { buf := bytes.NewBufferString("{") fmt.Fprintf(buf, " OldRoot: %v,\n", p.OldRoot) @@ -812,6 +819,8 @@ func (p CircomProcessorProof) String() string { return buf.String() } +// CircomVerifierProof defines the VerifierProof compatible with circom. Is the +// data of the proof that a certain leaf exists in the MerkleTree. type CircomVerifierProof struct { Root *Hash Siblings []*big.Int @@ -820,9 +829,12 @@ type CircomVerifierProof struct { IsOld0 bool Key *Hash Value *Hash - Fnc int + Fnc int // 0: inclusion, 1: non inclusion } +// GenerateCircomVerifierProof returns the CircomVerifierProof for a certain +// key in the MerkleTree. If the rootKey is nil, the current merkletree root +// is used. func (mt *MerkleTree) GenerateCircomVerifierProof(k *big.Int, rootKey *Hash) (*CircomVerifierProof, error) { p, v, err := mt.GenerateProof(k, rootKey) if err != nil || err != ErrKeyNotFound { @@ -833,13 +845,12 @@ func (mt *MerkleTree) GenerateCircomVerifierProof(k *big.Int, rootKey *Hash) (*C cp.Siblings = p.AllSiblingsCircom(mt.maxLevels) cp.OldKey = &HashZero cp.OldValue = &HashZero - // cp.IsOld cp.Key = NewHashFromBigInt(k) cp.Value = NewHashFromBigInt(v) if p.Existence { cp.Fnc = 0 // inclusion } else { - cp.Fnc = 1 // not inclusion + cp.Fnc = 1 // non inclusion } return &cp, nil diff --git a/merkletree_test.go b/merkletree_test.go index ecabfce..d121dcd 100644 --- a/merkletree_test.go +++ b/merkletree_test.go @@ -56,15 +56,15 @@ func TestNewTree(t *testing.T) { // test vectors generated using https://github.com/iden3/circomlib smt.js err = mt.Add(big.NewInt(1), big.NewInt(2)) assert.Nil(t, err) - assert.Equal(t, "4932297968297298434239270129193057052722409868268166443802652458940273154854", mt.Root().BigInt().String()) + assert.Equal(t, "6449712043256457369579901840927028403950625973089336675272087704159094984964", mt.Root().BigInt().String()) err = mt.Add(big.NewInt(33), big.NewInt(44)) assert.Nil(t, err) - assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String()) + assert.Equal(t, "11404118908468506234838877883514126008995570353394659302846433035311596046064", mt.Root().BigInt().String()) err = mt.Add(big.NewInt(1234), big.NewInt(9876)) assert.Nil(t, err) - assert.Equal(t, "16970503620176669663662021947486532860010370357132361783766545149750777353066", mt.Root().BigInt().String()) + assert.Equal(t, "12841932325181810040554102151615400973767747666110051836366805309524360490677", mt.Root().BigInt().String()) proof, v, err := mt.GenerateProof(big.NewInt(33), nil) assert.Nil(t, err) @@ -96,7 +96,7 @@ func TestAddDifferentOrder(t *testing.T) { } assert.Equal(t, mt1.Root().Hex(), mt2.Root().Hex()) - assert.Equal(t, "0967b777d660e54aa3a0f0f3405bb962504d3d69d6b930146cd212dff9913bee", mt1.Root().Hex()) + assert.Equal(t, "0630b27c6f8c7d36d144369ab1ac408552b544ebe96ad642bad6a94a96258e26", mt1.Root().Hex()) } func TestAddRepeatedIndex(t *testing.T) { @@ -249,12 +249,12 @@ func TestSiblingsFromProof(t *testing.T) { siblings := SiblingsFromProof(proof) assert.Equal(t, 6, len(siblings)) - assert.Equal(t, "23db1f6fb07af47d7715f18960548c215fc7a2e6d25cb4a7eb82c9d3cf69bc26", siblings[0].Hex()) - assert.Equal(t, "2156e64dedcb76719ec732414dd6a8aa4348dafb24c19351a68fbc4158bb7fba", siblings[1].Hex()) - assert.Equal(t, "04a8e9b34d5a8b55268ca96b0b8c7c5aaef4f606ec3437ec67e4152d9b323913", siblings[2].Hex()) - assert.Equal(t, "0ff484133e0d25deb4a7c0cb46d90432e00fcc280948c2fab6fed9476f1e26b2", siblings[3].Hex()) - assert.Equal(t, "015dff482e87eb2046b8f5323049afd05f8dd8554e2c9aa1ef28991cf205c9b6", siblings[4].Hex()) - assert.Equal(t, "1e4da486ad68b07acec1406bed5a60732de5ff72d63910f7afbb491f953a8769", siblings[5].Hex()) + assert.Equal(t, "2f59aeef9e5b881609aa56940dba76b5cb1440a794f4eb03ad5e5958dd8b475b", siblings[0].Hex()) + assert.Equal(t, "2eb29ffbded0987f36a62aecddf748d2b9bf28326300bfa15e474e0a12abe8c1", siblings[1].Hex()) + assert.Equal(t, "0c6ee1298933d073a390cc3d267a8a4d5a7df65a126d3fdc5a16b9c28afddaf4", siblings[2].Hex()) + assert.Equal(t, "1575898b0b4e7802a6be130e7b76ede64fe42079b6852eba6af985bd46a34aa9", siblings[3].Hex()) + assert.Equal(t, "1d15b701c1fd521841120980c5cbfa86f15b1f22bf1d3079ed0d0314751d7954", siblings[4].Hex()) + assert.Equal(t, "1ee00f37756159cfefaa0bce02779460b449a049165f3bb9fef81105bc285d43", siblings[5].Hex()) } func TestVerifyProofCases(t *testing.T) { @@ -275,7 +275,7 @@ func TestVerifyProofCases(t *testing.T) { } assert.Equal(t, proof.Existence, true) assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(4), big.NewInt(0))) - assert.Equal(t, "000300000000000000000000000000000000000000000000000000000000000728ea2b267d2a9436657f20b5827285175e030f58c07375535106903b16621630b9104d995843c7cffa685009a1b28dcd371022a3b27b3a4d6987f7c8b39b0f2fffc165330710754ca0fc24451bdd5d5f82a05f42f1427fbdf17879c0b84be60f", hex.EncodeToString(proof.Bytes())) + assert.Equal(t, "0003000000000000000000000000000000000000000000000000000000000007a6d6b46fefe213a6b579844a1bb7ab5c2db4a13f8662d9c5e729c36728f42730211ddfcc8d30ebd157d1d6912769b8e4abdca41e5dc2b57b026a361c091a8c14c748530e61bf8ea80c987657c3d24b134ece1ef8e2d4bd3f74437bf4392a6b1e", hex.EncodeToString(proof.Bytes())) for i := 8; i < 32; i++ { proof, _, err = mt.GenerateProof(big.NewInt(int64(i)), nil) @@ -292,7 +292,7 @@ func TestVerifyProofCases(t *testing.T) { assert.Equal(t, proof.Existence, false) // assert.True(t, proof.nodeAux == nil) assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(12), big.NewInt(0))) - assert.Equal(t, "030300000000000000000000000000000000000000000000000000000000000728ea2b267d2a9436657f20b5827285175e030f58c07375535106903b16621630b9104d995843c7cffa685009a1b28dcd371022a3b27b3a4d6987f7c8b39b0f2fffc165330710754ca0fc24451bdd5d5f82a05f42f1427fbdf17879c0b84be60f04000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(proof.Bytes())) + assert.Equal(t, "0303000000000000000000000000000000000000000000000000000000000007a6d6b46fefe213a6b579844a1bb7ab5c2db4a13f8662d9c5e729c36728f42730211ddfcc8d30ebd157d1d6912769b8e4abdca41e5dc2b57b026a361c091a8c14c748530e61bf8ea80c987657c3d24b134ece1ef8e2d4bd3f74437bf4392a6b1e04000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(proof.Bytes())) // Non-existence proof, diff. node aux proof, _, err = mt.GenerateProof(big.NewInt(10), nil) @@ -302,7 +302,7 @@ func TestVerifyProofCases(t *testing.T) { assert.Equal(t, proof.Existence, false) assert.True(t, proof.NodeAux != nil) assert.True(t, VerifyProof(mt.Root(), proof, big.NewInt(10), big.NewInt(0))) - assert.Equal(t, "030300000000000000000000000000000000000000000000000000000000000728ea2b267d2a9436657f20b5827285175e030f58c07375535106903b1662163097fcf8f911b271df196e0a75667b8a4f3024ef39f87201ed2b7cda349ba202296b7aeba35dc19ab0d4f65e175536c9952a90b6de18c3205611c3cd4fb408f01602000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(proof.Bytes())) + assert.Equal(t, "0303000000000000000000000000000000000000000000000000000000000007a6d6b46fefe213a6b579844a1bb7ab5c2db4a13f8662d9c5e729c36728f42730e667e2ca15909c4a23beff18e3cc74348fbd3c1a4c765a5bbbca126c9607a42b77e008a73926f1280f8531b139dc1cacf8d83fcec31d405f5c51b7cbddfe152902000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(proof.Bytes())) } func TestVerifyProofFalse(t *testing.T) { @@ -352,23 +352,23 @@ func TestGraphViz(t *testing.T) { expected := `digraph hierarchy { node [fontname=Monospace,fontsize=10,shape=box] -"60195538..." -> {"19759736..." "18893277..."} -"19759736..." -> {"16152312..." "43945008..."} -"16152312..." -> {"empty0" "13952255..."} +"16053348..." -> {"19137630..." "14119616..."} +"19137630..." -> {"19543983..." "19746229..."} +"19543983..." -> {"empty0" "65773153..."} "empty0" [style=dashed,label=0]; -"13952255..." -> {"61769925..." "empty1"} +"65773153..." -> {"73498412..." "empty1"} "empty1" [style=dashed,label=0]; -"61769925..." -> {"92723289..." "empty2"} +"73498412..." -> {"53169236..." "empty2"} "empty2" [style=dashed,label=0]; -"92723289..." -> {"21082735..." "82784818..."} -"21082735..." [style=filled]; -"82784818..." [style=filled]; -"43945008..." [style=filled]; -"18893277..." -> {"19855703..." "17718670..."} -"19855703..." -> {"11499909..." "15828714..."} -"11499909..." [style=filled]; -"15828714..." [style=filled]; -"17718670..." [style=filled]; +"53169236..." -> {"73522717..." "34811870..."} +"73522717..." [style=filled]; +"34811870..." [style=filled]; +"19746229..." [style=filled]; +"14119616..." -> {"19419204..." "15569531..."} +"19419204..." -> {"78154875..." "34589916..."} +"78154875..." [style=filled]; +"34589916..." [style=filled]; +"15569531..." [style=filled]; } ` w := bytes.NewBufferString("") @@ -384,22 +384,22 @@ func TestDelete(t *testing.T) { // test vectors generated using https://github.com/iden3/circomlib smt.js err = mt.Add(big.NewInt(1), big.NewInt(2)) assert.Nil(t, err) - assert.Equal(t, "4932297968297298434239270129193057052722409868268166443802652458940273154854", mt.Root().BigInt().String()) + assert.Equal(t, "6449712043256457369579901840927028403950625973089336675272087704159094984964", mt.Root().BigInt().String()) err = mt.Add(big.NewInt(33), big.NewInt(44)) assert.Nil(t, err) - assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String()) + assert.Equal(t, "11404118908468506234838877883514126008995570353394659302846433035311596046064", mt.Root().BigInt().String()) err = mt.Add(big.NewInt(1234), big.NewInt(9876)) assert.Nil(t, err) - assert.Equal(t, "16970503620176669663662021947486532860010370357132361783766545149750777353066", mt.Root().BigInt().String()) + assert.Equal(t, "12841932325181810040554102151615400973767747666110051836366805309524360490677", mt.Root().BigInt().String()) // mt.PrintGraphViz(nil) err = mt.Delete(big.NewInt(33)) // mt.PrintGraphViz(nil) assert.Nil(t, err) - assert.Equal(t, "12820263606494630162816839760750120928463716794691735985748071431547370997091", mt.Root().BigInt().String()) + assert.Equal(t, "16195585003843604118922861401064871511855368913846540536604351220077317790615", mt.Root().BigInt().String()) err = mt.Delete(big.NewInt(1234)) assert.Nil(t, err) @@ -453,10 +453,10 @@ func TestDelete3(t *testing.T) { err = mt.Add(big.NewInt(2), big.NewInt(2)) assert.Nil(t, err) - assert.Equal(t, "2427629547967522489273866134471574861207714751136138191708011221765688788661", mt.Root().BigInt().String()) + assert.Equal(t, "6701939280963330813043570145125351311131831356446202146710280245621673558344", mt.Root().BigInt().String()) err = mt.Delete(big.NewInt(1)) assert.Nil(t, err) - assert.Equal(t, "10822920717809411688334493481050035035708810950159417482558569847174767667301", mt.Root().BigInt().String()) + assert.Equal(t, "10304354743004778619823249005484018655542356856535590307973732141291410579841", mt.Root().BigInt().String()) mt2 := newTestingMerkle(t, 140) defer mt2.db.Close() @@ -478,10 +478,10 @@ func TestDelete4(t *testing.T) { err = mt.Add(big.NewInt(3), big.NewInt(3)) assert.Nil(t, err) - assert.Equal(t, "16614298246517994771186095530428786749320098419259206061045083278756632941513", mt.Root().BigInt().String()) + assert.Equal(t, "6989694633650442615746486460134957295274675622748484439660143938730686550248", mt.Root().BigInt().String()) err = mt.Delete(big.NewInt(1)) assert.Nil(t, err) - assert.Equal(t, "6117330520107511783353383870014397665359816230889739699667943862706617498952", mt.Root().BigInt().String()) + assert.Equal(t, "1192610901536912535888866440319084773171371421781091005185759505381507049136", mt.Root().BigInt().String()) mt2 := newTestingMerkle(t, 140) defer mt2.db.Close() @@ -500,11 +500,11 @@ func TestDelete5(t *testing.T) { assert.Nil(t, err) err = mt.Add(big.NewInt(33), big.NewInt(44)) assert.Nil(t, err) - assert.Equal(t, "13563340744765267202993741297198970774200042973817962221376874695587906013050", mt.Root().BigInt().String()) + assert.Equal(t, "11404118908468506234838877883514126008995570353394659302846433035311596046064", mt.Root().BigInt().String()) err = mt.Delete(big.NewInt(1)) assert.Nil(t, err) - assert.Equal(t, "12075524681474630909546786277734445038384732558409197537058769521806571391765", mt.Root().BigInt().String()) + assert.Equal(t, "12802904154263054831102426711825443668153853847661287611768065280921698471037", mt.Root().BigInt().String()) mt2 := newTestingMerkle(t, 140) defer mt2.db.Close() @@ -569,7 +569,7 @@ func TestAddAndGetCircomProof(t *testing.T) { cpp, err := mt.AddAndGetCircomProof(big.NewInt(1), big.NewInt(2)) assert.Nil(t, err) assert.Equal(t, "0", cpp.OldRoot.String()) - assert.Equal(t, "49322979...", cpp.NewRoot.String()) + assert.Equal(t, "64497120...", cpp.NewRoot.String()) assert.Equal(t, "0", cpp.OldKey.String()) assert.Equal(t, "0", cpp.OldValue.String()) assert.Equal(t, "1", cpp.NewKey.String()) @@ -579,8 +579,8 @@ func TestAddAndGetCircomProof(t *testing.T) { cpp, err = mt.AddAndGetCircomProof(big.NewInt(33), big.NewInt(44)) assert.Nil(t, err) - assert.Equal(t, "49322979...", cpp.OldRoot.String()) - assert.Equal(t, "13563340...", cpp.NewRoot.String()) + assert.Equal(t, "64497120...", cpp.OldRoot.String()) + assert.Equal(t, "11404118...", cpp.NewRoot.String()) assert.Equal(t, "1", cpp.OldKey.String()) assert.Equal(t, "2", cpp.OldValue.String()) assert.Equal(t, "33", cpp.NewKey.String()) @@ -590,14 +590,14 @@ func TestAddAndGetCircomProof(t *testing.T) { cpp, err = mt.AddAndGetCircomProof(big.NewInt(55), big.NewInt(66)) assert.Nil(t, err) - assert.Equal(t, "13563340...", cpp.OldRoot.String()) - assert.Equal(t, "21716426...", cpp.NewRoot.String()) + assert.Equal(t, "11404118...", cpp.OldRoot.String()) + assert.Equal(t, "18284203...", cpp.NewRoot.String()) assert.Equal(t, "0", cpp.OldKey.String()) assert.Equal(t, "0", cpp.OldValue.String()) assert.Equal(t, "55", cpp.NewKey.String()) assert.Equal(t, "66", cpp.NewValue.String()) assert.Equal(t, true, cpp.IsOld0) - assert.Equal(t, "[0 34319575... 0 0 0 0 0 0 0 0 0]", fmt.Sprintf("%v", cpp.Siblings)) + assert.Equal(t, "[0 42948778... 0 0 0 0 0 0 0 0 0]", fmt.Sprintf("%v", cpp.Siblings)) // fmt.Println(cpp) } @@ -619,12 +619,12 @@ func TestUpdateCircomProcessorProof(t *testing.T) { // test vectors generated using https://github.com/iden3/circomlib smt.js cpp, err := mt.Update(big.NewInt(10), big.NewInt(1024)) assert.Nil(t, err) - assert.Equal(t, "57072083...", cpp.OldRoot.String()) - assert.Equal(t, "11191558...", cpp.NewRoot.String()) + assert.Equal(t, "14895645...", cpp.OldRoot.String()) + assert.Equal(t, "75223641...", cpp.NewRoot.String()) assert.Equal(t, "10", cpp.OldKey.String()) assert.Equal(t, "20", cpp.OldValue.String()) assert.Equal(t, "10", cpp.NewKey.String()) assert.Equal(t, "1024", cpp.NewValue.String()) assert.Equal(t, false, cpp.IsOld0) - assert.Equal(t, "[12331503... 70994311... 88639181... 20174344... 0 0 0 0 0 0 0]", fmt.Sprintf("%v", cpp.Siblings)) + assert.Equal(t, "[19625419... 46910949... 18399594... 20473908... 0 0 0 0 0 0 0]", fmt.Sprintf("%v", cpp.Siblings)) } diff --git a/utils.go b/utils.go index 87d10d7..175bdf2 100644 --- a/utils.go +++ b/utils.go @@ -1,58 +1,34 @@ package merkletree import ( - "fmt" "math/big" "github.com/iden3/go-iden3-crypto/poseidon" ) -// HashElems performs a poseidon hash over the array of ElemBytes. -// Uses poseidon.Hash to be compatible with the circom circuits -// implementations. -// The maxim slice input size is poseidon.T +// HashElems performs a poseidon hash over the array of ElemBytes, currently we +// are using 2 elements. Uses poseidon.Hash to be compatible with the circom +// circuits implementations. func HashElems(elems ...*big.Int) (*Hash, error) { - if len(elems) > poseidon.T { - return nil, fmt.Errorf("HashElems input can not be bigger than %v", poseidon.T) - } - - bi, err := BigIntsToPoseidonInput(elems...) - if err != nil { - return nil, err - } - - poseidonHash, err := poseidon.Hash(bi) + poseidonHash, err := poseidon.Hash(elems) if err != nil { return nil, err } return NewHashFromBigInt(poseidonHash), nil } -// HashElemsKey performs a poseidon hash over the array of ElemBytes. +// HashElemsKey performs a poseidon hash over the array of ElemBytes, currently +// we are using 2 elements. func HashElemsKey(key *big.Int, elems ...*big.Int) (*Hash, error) { - if len(elems) > poseidon.T-1 { - return nil, fmt.Errorf("HashElemsKey input can not be bigger than %v", poseidon.T-1) - } if key == nil { key = new(big.Int).SetInt64(0) } - bi, err := BigIntsToPoseidonInput(elems...) - if err != nil { - return nil, err - } - copy(bi[len(elems):], []*big.Int{key}) + bi := make([]*big.Int, 3) + copy(bi[:], elems) + bi[2] = key poseidonHash, err := poseidon.Hash(bi) if err != nil { return nil, err } return NewHashFromBigInt(poseidonHash), nil } - -// BigIntsToPoseidonInput takes *big.Ints and returns a fixed-length array of the size `poseidon.T` -func BigIntsToPoseidonInput(bigints ...*big.Int) ([poseidon.T]*big.Int, error) { - z := big.NewInt(0) - b := [poseidon.T]*big.Int{z, z, z, z, z, z} - copy(b[:poseidon.T], bigints[:]) - - return b, nil -}