remove the hasher argument from the SMT node constructors

Signed-off-by: Jim Zhang <jim.zhang@kaleido.io>

Author: jimthematrix

go-sdk/integration-test/common/smt.go

@@ -41,7 +41,7 @@ func BuildMerkleProofs(inputCommitments []*big.Int, db core.Storage, t *testing.
 func AddCommitmentToMerkleTree(mt core.SparseMerkleTree, commitment *big.Int, t *testing.T) {
 	idx, _ := node.NewNodeIndexFromBigInt(commitment, &hash.PoseidonHasher{})
 	utxo := node.NewIndexOnly(idx)
-	n, err := node.NewLeafNode(utxo, nil, &hash.PoseidonHasher{})
+	n, err := node.NewLeafNode(utxo, nil)
 	assert.NoError(t, err)
 	err = mt.AddLeaf(n)
 	assert.NoError(t, err)

go-sdk/integration-test/db_test.go

@@ -67,7 +67,7 @@ func (s *SqliteTestSuite) TestSqliteStorage() {
 	salt1 := crypto.NewSalt()
 
 	utxo1 := node.NewNonFungible(tokenId, uriString, sender.PublicKey, salt1, hasher)
-	n1, err := node.NewLeafNode(utxo1, nil, hasher)
+	n1, err := node.NewLeafNode(utxo1, nil)
 	assert.NoError(s.T(), err)
 	err = mt.AddLeaf(n1)
 	assert.NoError(s.T(), err)
@@ -120,7 +120,7 @@ func TestPostgresStorage(t *testing.T) {
 	salt1 := crypto.NewSalt()
 
 	utxo1 := node.NewNonFungible(tokenId, tokenUri, sender.PublicKey, salt1, hasher)
-	n1, err := node.NewLeafNode(utxo1, nil, hasher)
+	n1, err := node.NewLeafNode(utxo1, nil)
 	assert.NoError(t, err)
 	err = mt.AddLeaf(n1)
 	assert.NoError(t, err)

go-sdk/integration-test/e2e_anon_nullifier_test.go

@@ -81,7 +81,7 @@ func (s *E2ETestSuite) TestZeto_anon_nullifier_locked_SuccessfulProving() {
 
 	for i, value := range s.regularTest.InputValues {
 		utxo := node.NewFungible(value, s.sender.PublicKey, s.regularTest.InputSalts[i], hasher)
-		n, err := node.NewLeafNode(utxo, senderEthAddress, hasher)
+		n, err := node.NewLeafNode(utxo, senderEthAddress)
 		assert.NoError(s.T(), err)
 		err = mt.AddLeaf(n)
 		assert.NoError(s.T(), err)

go-sdk/integration-test/e2e_nf_anon_nullifier_test.go

@@ -56,7 +56,7 @@ func (s *E2ETestSuite) TestZeto_nf_anon_nullifier_SuccessfulProving() {
 	mt, err := smt.NewMerkleTree(s.db, common.MAX_HEIGHT)
 	assert.NoError(s.T(), err)
 	utxo1 := node.NewNonFungible(tokenId, uriString, sender.PublicKey, salt1, hasher)
-	n1, err := node.NewLeafNode(utxo1, nil, hasher)
+	n1, err := node.NewLeafNode(utxo1, nil)
 	assert.NoError(s.T(), err)
 	err = mt.AddLeaf(n1)
 	assert.NoError(s.T(), err)

go-sdk/integration-test/smt_test.go

@@ -82,7 +82,7 @@ func testConcurrentInsertion(t *testing.T, alice *babyjub.PublicKey, values []in
 		go func(i, v int) {
 			salt, _ := new(big.Int).SetString(salts[i], 16)
 			utxo := node.NewFungible(big.NewInt(int64(v)), alice, salt, hasher)
-			n, err := node.NewLeafNode(utxo, nil, hasher)
+			n, err := node.NewLeafNode(utxo, nil)
 			assert.NoError(t, err)
 			err = mt.AddLeaf(n)
 			assert.NoError(t, err)

go-sdk/internal/sparse-merkle-tree/node/fungible.go

@@ -50,6 +50,10 @@ func (f *fungibleNode) CalculateIndex() (core.NodeIndex, error) {
 	return NewNodeIndexFromBigInt(hash, f.hasher)
 }
 
+func (f *fungibleNode) GetHasher() apicore.Hasher {
+	return f.hasher
+}
+
 // the "Owner" is the private key that must be properly hashed and trimmed to be
 // compatible with the BabyJub curve.
 // Reference: https://github.com/iden3/circomlib/blob/master/test/babyjub.js#L103
@@ -77,3 +81,7 @@ func (f *fungibleNullifierNode) CalculateIndex() (core.NodeIndex, error) {
 	}
 	return NewNodeIndexFromBigInt(hash, f.hasher)
 }
+
+func (f *fungibleNullifierNode) GetHasher() apicore.Hasher {
+	return f.hasher
+}

go-sdk/internal/sparse-merkle-tree/node/node.go

@@ -33,7 +33,10 @@ var ZERO_INDEX, _ = NewNodeIndexFromBigInt(big.NewInt(0), &hash.PoseidonHasher{}
 // nodeIndex is a wrapper around []byte to implement the NodeIndex interface.
 // it's a 256-bit number. the path from the root node to a leaf node is determined
 // by the index's bits. 0 means go left, 1 means go right.
-type nodeIndex [32]byte
+type nodeIndex struct {
+	index  [32]byte
+	hasher apicore.Hasher
+}
 
 // node is an implementation of the Node interface
 type node struct {
@@ -54,7 +57,7 @@ func NewEmptyNode() core.Node {
 
 // the value parameter is optional. if "nil", the index hash is used in the
 // place of the value when calculating the node reference hash (aka "node key").
-func NewLeafNode(s core.Indexable, v *big.Int, hasher apicore.Hasher) (core.Node, error) {
+func NewLeafNode(s core.Indexable, v *big.Int) (core.Node, error) {
 	n := &node{nodeType: core.NodeTypeLeaf, state: s}
 	idx, err := n.state.CalculateIndex()
 	if err != nil {
@@ -73,11 +76,11 @@ func NewLeafNode(s core.Indexable, v *big.Int, hasher apicore.Hasher) (core.Node
 		hValue = hKey
 	}
 	elements := []*big.Int{hKey, hValue, big.NewInt(1)}
-	hash, err := hasher.Hash(elements)
+	hash, err := s.GetHasher().Hash(elements)
 	if err != nil {
 		return nil, err
 	}
-	n.refKey, err = NewNodeIndexFromBigInt(hash, hasher)
+	n.refKey, err = NewNodeIndexFromBigInt(hash, s.GetHasher())
 	return n, err
 }
 
@@ -123,14 +126,14 @@ func NewNodeIndexFromBigInt(i *big.Int, hasher apicore.Hasher) (core.NodeIndex,
 	if !hasher.CheckInRange(i) {
 		return nil, ErrNodeIndexTooLarge
 	}
-	idx := new(nodeIndex)
-	copy(idx[:], swapEndianness(i.Bytes()))
+	idx := &nodeIndex{hasher: hasher}
+	copy(idx.index[:], swapEndianness(i.Bytes()))
 	return idx, nil
 }
 
 // NewNodeIndexFromHex creates a new NodeIndex from a hex string that
 // represents the index in big-endian format.
-func NewNodeIndexFromHex(h string) (core.NodeIndex, error) {
+func NewNodeIndexFromHex(h string, hasher apicore.Hasher) (core.NodeIndex, error) {
 	h = strings.TrimPrefix(h, "0x")
 	b, err := hex.DecodeString(h)
 	if err != nil {
@@ -139,17 +142,17 @@ func NewNodeIndexFromHex(h string) (core.NodeIndex, error) {
 	if len(b) != INDEX_BYTES_LEN {
 		return nil, ErrNodeBytesBadSize
 	}
-	idx := new(nodeIndex)
-	copy(idx[:], b)
+	idx := &nodeIndex{hasher: hasher}
+	copy(idx.index[:], b)
 	return idx, nil
 }
 
 func (idx *nodeIndex) BigInt() *big.Int {
-	return new(big.Int).SetBytes(swapEndianness(idx[:]))
+	return new(big.Int).SetBytes(swapEndianness(idx.index[:]))
 }
 
 func (idx *nodeIndex) Hex() string {
-	return hex.EncodeToString(idx[:])
+	return hex.EncodeToString(idx.index[:])
 }
 
 func (idx *nodeIndex) IsZero() bool {
@@ -160,6 +163,10 @@ func (idx *nodeIndex) Equal(other core.NodeRef) bool {
 	return idx.BigInt().Cmp(other.BigInt()) == 0
 }
 
+func (idx *nodeIndex) GetHasher() apicore.Hasher {
+	return idx.hasher
+}
+
 // getPath returns the binary path, from the root to the leaf.
 func (idx *nodeIndex) ToPath(levels int) []bool {
 	path := make([]bool, levels)
@@ -173,7 +180,7 @@ func (idx *nodeIndex) IsBitOne(pos uint) bool {
 	if pos >= 256 {
 		return false
 	}
-	return (idx[pos/8] & (1 << (pos % 8))) != 0
+	return (idx.index[pos/8] & (1 << (pos % 8))) != 0
 }
 
 // swapEndianness swaps the order of the bytes in the byte array of a node index.

go-sdk/internal/sparse-merkle-tree/node/node_test.go

@@ -24,29 +24,31 @@ import (
 	"github.com/hyperledger-labs/zeto/go-sdk/internal/crypto/hash"
 	"github.com/hyperledger-labs/zeto/go-sdk/internal/sparse-merkle-tree/utils"
 	"github.com/hyperledger-labs/zeto/go-sdk/pkg/sparse-merkle-tree/core"
+	apicore "github.com/hyperledger-labs/zeto/go-sdk/pkg/utxo/core"
 	"github.com/iden3/go-iden3-crypto/poseidon"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeIndex(t *testing.T) {
-	idx0, _ := NewNodeIndexFromBigInt(big.NewInt(0), &hash.PoseidonHasher{})
+	hasher := &hash.PoseidonHasher{}
+	idx0, _ := NewNodeIndexFromBigInt(big.NewInt(0), hasher)
 	assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000000", idx0.Hex())
-	idx1, _ := NewNodeIndexFromBigInt(big.NewInt(1), &hash.PoseidonHasher{})
+	idx1, _ := NewNodeIndexFromBigInt(big.NewInt(1), hasher)
 	assert.Equal(t, "0100000000000000000000000000000000000000000000000000000000000000", idx1.Hex())
-	idx2, _ := NewNodeIndexFromBigInt(big.NewInt(10), &hash.PoseidonHasher{})
+	idx2, _ := NewNodeIndexFromBigInt(big.NewInt(10), hasher)
 	assert.Equal(t, "0a00000000000000000000000000000000000000000000000000000000000000", idx2.Hex())
 
-	idx3, _ := NewNodeIndexFromBigInt(big.NewInt(12345678), &hash.PoseidonHasher{})
+	idx3, _ := NewNodeIndexFromBigInt(big.NewInt(12345678), hasher)
 	assert.Equal(t, "4e61bc0000000000000000000000000000000000000000000000000000000000", idx3.Hex())
 
 	v4, _ := new(big.Int).SetString("4932297968297298434239270129193057052722409868268166443802652458940273154854", 10)
-	idx4, _ := NewNodeIndexFromBigInt(v4, &hash.PoseidonHasher{})
+	idx4, _ := NewNodeIndexFromBigInt(v4, hasher)
 	assert.Equal(t, "265baaf161e875c372d08e50f52abddc01d32efc93e90290bb8b3d9ceb94e70a", idx4.Hex())
 	expectedBytes4 := []byte{38, 91, 170, 241, 97, 232, 117, 195, 114, 208, 142, 80, 245, 42, 189, 220, 1, 211, 46, 252, 147, 233, 2, 144, 187, 139, 61, 156, 235, 148, 231, 10}
 	rawIndex4 := idx4.(*nodeIndex)
-	assert.Equal(t, expectedBytes4, rawIndex4[:])
+	assert.Equal(t, expectedBytes4, rawIndex4.index[:])
 
-	idx5, err := NewNodeIndexFromHex("265baaf161e875c372d08e50f52abddc01d32efc93e90290bb8b3d9ceb94e70a")
+	idx5, err := NewNodeIndexFromHex("265baaf161e875c372d08e50f52abddc01d32efc93e90290bb8b3d9ceb94e70a", hasher)
 	assert.NoError(t, err)
 	assert.Equal(t, 0, v4.Cmp(idx5.BigInt()))
 }
@@ -63,7 +65,7 @@ func TestNewEmptyNode(t *testing.T) {
 func TestNewLeafNode(t *testing.T) {
 	idx, _ := NewNodeIndexFromBigInt(big.NewInt(10), &hash.PoseidonHasher{})
 	i := utils.NewIndexOnly(idx)
-	node, err := NewLeafNode(i, nil, &hash.PoseidonHasher{})
+	node, err := NewLeafNode(i, nil)
 	assert.NoError(t, err)
 	assert.Equal(t, node.Type(), core.NodeTypeLeaf)
 	assert.Equal(t, node.Index(), idx)
@@ -76,9 +78,9 @@ func TestNewLeafNode(t *testing.T) {
 }
 
 func TestNewLeafNodeKeccak256(t *testing.T) {
-	idx, _ := NewNodeIndexFromBigInt(big.NewInt(10), &hash.PoseidonHasher{})
+	idx, _ := NewNodeIndexFromBigInt(big.NewInt(10), &hash.Keccak256Hasher{})
 	i := utils.NewIndexOnly(idx)
-	node, err := NewLeafNode(i, nil, &hash.Keccak256Hasher{})
+	node, err := NewLeafNode(i, nil)
 	assert.NoError(t, err)
 	assert.Equal(t, node.Type(), core.NodeTypeLeaf)
 	assert.Equal(t, node.Index(), idx)
@@ -93,7 +95,7 @@ func TestNewLeafNodeKeccak256(t *testing.T) {
 func TestNewLeafNodeWithValue(t *testing.T) {
 	idx, _ := NewNodeIndexFromBigInt(big.NewInt(10), &hash.PoseidonHasher{})
 	i := utils.NewIndexOnly(idx)
-	node, err := NewLeafNode(i, big.NewInt(12345), &hash.PoseidonHasher{})
+	node, err := NewLeafNode(i, big.NewInt(12345))
 	assert.NoError(t, err)
 	assert.Equal(t, node.Type(), core.NodeTypeLeaf)
 	assert.Equal(t, node.Index(), idx)
@@ -125,8 +127,11 @@ type badIndex struct{}
 func (f *badIndex) CalculateIndex() (core.NodeIndex, error) {
 	return nil, errors.New("Bang!")
 }
+func (f *badIndex) GetHasher() apicore.Hasher {
+	return &hash.PoseidonHasher{}
+}
 
 func TestNewLeafNodeFail(t *testing.T) {
-	_, err := NewLeafNode(&badIndex{}, nil, &hash.PoseidonHasher{})
+	_, err := NewLeafNode(&badIndex{}, nil)
 	assert.EqualError(t, err, "Bang!")
 }

go-sdk/internal/sparse-merkle-tree/node/nonfungible.go

@@ -52,6 +52,10 @@ func (f *nonFungibleNode) CalculateIndex() (core.NodeIndex, error) {
 	return NewNodeIndexFromBigInt(hash, f.hasher)
 }
 
+func (f *nonFungibleNode) GetHasher() apicore.Hasher {
+	return f.hasher
+}
+
 // the "Owner" is the private key that must be properly hashed and trimmed to be
 // compatible with the BabyJub curve.
 // Reference: https://github.com/iden3/circomlib/blob/master/test/babyjub.js#L103
@@ -81,3 +85,7 @@ func (f *nonFungibleNullifierNode) CalculateIndex() (core.NodeIndex, error) {
 	}
 	return NewNodeIndexFromBigInt(hash, f.hasher)
 }
+
+func (f *nonFungibleNullifierNode) GetHasher() apicore.Hasher {
+	return f.hasher
+}

go-sdk/internal/sparse-merkle-tree/smt/merkletree.go

@@ -176,7 +176,7 @@ func (mt *sparseMerkleTree) generateProof(key *big.Int, rootKey core.NodeRef) (c
 				return p, value, nil
 			}
 			// We found a leaf whose entry didn't match the node index
-			p.existingNode, err = node.NewLeafNode(utils.NewIndexOnly(idx), n.Value(), mt.hasher)
+			p.existingNode, err = node.NewLeafNode(utils.NewIndexOnly(idx), n.Value())
 			if err != nil {
 				return nil, nil, err
 			}