try fixing concurrencies!!11

pkg/crypto/protocol/proof_path.go

@@ -2,29 +2,27 @@ package protocol
 
 import (
 	"crypto/sha256"
-
-	"github.com/pokt-network/smt"
 )
 
 // SMT specification used for the proof verification.
-var (
-	newHasher = sha256.New
-	SmtSpec   smt.TrieSpec
-)
+// var (
+// 	newHasher = sha256.New
+// 	// SmtSpec   smt.TrieSpec
+// )
 
-func init() {
-	// Use a spec that does not prehash values in the smst. This returns a nil value
-	// hasher for the proof verification in order to avoid hashing the value twice.
-	SmtSpec = smt.NewTrieSpec(
-		newHasher(), true,
-		smt.WithValueHasher(nil),
-	)
-}
+// func init() {
+// 	// Use a spec that does not prehash values in the smst. This returns a nil value
+// 	// hasher for the proof verification in order to avoid hashing the value twice.
+// 	SmtSpec = smt.NewTrieSpec(
+// 		newHasher(), true,
+// 		smt.WithValueHasher(nil),
+// 	)
+// }
 
 // GetPathForProof computes the path to be used for proof validation by hashing
 // the block hash and session id.
 func GetPathForProof(blockHash []byte, sessionId string) []byte {
-	hasher := newHasher()
+	hasher := sha256.New()
 	if _, err := hasher.Write(append(blockHash, []byte(sessionId)...)); err != nil {
 		panic(err)
 	}

x/proof/keeper/proof_validation.go

@@ -31,6 +31,7 @@ package keeper
 import (
 	"bytes"
 	"context"
+	"crypto/sha256"
 	"fmt"
 
 	cosmostelemetry "github.com/cosmos/cosmos-sdk/telemetry"
@@ -105,15 +106,20 @@ func (k Keeper) EnsureWellFormedProof(ctx context.Context, proof *types.Proof) e
 		return types.ErrProofInvalidProof.Wrapf("failed to unmarshal sparse compact merkle closest proof: %s", err)
 	}
 
+	smtSpec := smt.NewTrieSpec(
+		sha256.New(), true,
+		smt.WithValueHasher(nil),
+	)
+
 	// SparseCompactMerkeClosestProof does not implement GetValueHash, so we need to decompact it.
-	sparseMerkleClosestProof, err := smt.DecompactClosestProof(sparseCompactMerkleClosestProof, &protocol.SmtSpec)
+	sparseMerkleClosestProof, err := smt.DecompactClosestProof(sparseCompactMerkleClosestProof, &smtSpec)
 	if err != nil {
 		logger.Error(fmt.Sprintf("failed to decompact sparse merkle closest proof due to error: %v", err))
 		return types.ErrProofInvalidProof.Wrapf("failed to decompact sparse erkle closest proof: %s", err)
 	}
 
 	// Get the relay request and response from the proof.GetClosestMerkleProof.
-	relayBz := sparseMerkleClosestProof.GetValueHash(&protocol.SmtSpec)
+	relayBz := sparseMerkleClosestProof.GetValueHash(&smtSpec)
 	relay := &servicetypes.Relay{}
 	if err = k.cdc.Unmarshal(relayBz, relay); err != nil {
 		logger.Error(fmt.Sprintf("failed to unmarshal relay due to error: %v", err))
@@ -229,16 +235,21 @@ func (k Keeper) EnsureValidProofSignaturesAndClosestPath(
 		return types.ErrProofInvalidProof.Wrapf("failed to unmarshal sparse compact merkle closest proof: %s", err)
 	}
 
+	smtSpec := smt.NewTrieSpec(
+		sha256.New(), true,
+		smt.WithValueHasher(nil),
+	)
+
 	// SparseCompactMerkeClosestProof was intentionally compacted to reduce its onchain state size
 	// so it must be decompacted rather than just retrieving the value via GetValueHash (not implemented).
-	sparseMerkleClosestProof, err := smt.DecompactClosestProof(sparseCompactMerkleClosestProof, &protocol.SmtSpec)
+	sparseMerkleClosestProof, err := smt.DecompactClosestProof(sparseCompactMerkleClosestProof, &smtSpec)
 	if err != nil {
 		logger.Error(fmt.Sprintf("failed to decompact sparse merkle closest proof due to error: %v", err))
 		return types.ErrProofInvalidProof.Wrapf("failed to decompact sparse merkle closest proof: %s", err)
 	}
 
 	// Get the relay request and response from the proof.GetClosestMerkleProof.
-	relayBz := sparseMerkleClosestProof.GetValueHash(&protocol.SmtSpec)
+	relayBz := sparseMerkleClosestProof.GetValueHash(&smtSpec)
 	relay := &servicetypes.Relay{}
 	if err = k.cdc.Unmarshal(relayBz, relay); err != nil {
 		logger.Error(fmt.Sprintf("failed to unmarshal relay due to error: %v", err))
@@ -451,7 +462,13 @@ func verifyClosestProof(
 	proof *smt.SparseMerkleClosestProof,
 	claimRootHash []byte,
 ) error {
-	valid, err := smt.VerifyClosestProof(proof, claimRootHash, &protocol.SmtSpec)
+
+	smtSpec := smt.NewTrieSpec(
+		sha256.New(), true,
+		smt.WithValueHasher(nil),
+	)
+
+	valid, err := smt.VerifyClosestProof(proof, claimRootHash, &smtSpec)
 	if err != nil {
 		return err
 	}

x/proof/keeper/proof_validation_test.go

@@ -2,6 +2,7 @@ package keeper_test
 
 import (
 	"context"
+	"crypto/sha256"
 	"encoding/hex"
 	"testing"
 
@@ -607,14 +608,19 @@ func TestEnsureValidProof_Error(t *testing.T) {
 					expectedMerkleProofPath,
 				)
 
+				smtSpec := smt.NewTrieSpec(
+					sha256.New(), true,
+					smt.WithValueHasher(nil),
+				)
+
 				// Extract relayHash to check below that it's difficulty is insufficient
 				err = sparseCompactMerkleClosestProof.Unmarshal(proof.ClosestMerkleProof)
 				require.NoError(t, err)
 				var sparseMerkleClosestProof *smt.SparseMerkleClosestProof
-				sparseMerkleClosestProof, err = smt.DecompactClosestProof(sparseCompactMerkleClosestProof, &protocol.SmtSpec)
+				sparseMerkleClosestProof, err = smt.DecompactClosestProof(sparseCompactMerkleClosestProof, &smtSpec)
 				require.NoError(t, err)
 
-				relayBz := sparseMerkleClosestProof.GetValueHash(&protocol.SmtSpec)
+				relayBz := sparseMerkleClosestProof.GetValueHash(&smtSpec)
 				relayHashArr := protocol.GetRelayHashFromBytes(relayBz)
 				relayHash := relayHashArr[:]