From 78443365e497c25e5806f8be51d85c20c97f3666 Mon Sep 17 00:00:00 2001 From: Dmitry K Date: Mon, 27 Jan 2025 16:35:41 -0800 Subject: [PATCH] try fixing concurrencies!!11 --- pkg/crypto/protocol/proof_path.go | 28 ++++++++++++------------- x/proof/keeper/proof_validation.go | 27 +++++++++++++++++++----- x/proof/keeper/proof_validation_test.go | 10 +++++++-- 3 files changed, 43 insertions(+), 22 deletions(-) diff --git a/pkg/crypto/protocol/proof_path.go b/pkg/crypto/protocol/proof_path.go index 61f7e23ce..ffc790668 100644 --- a/pkg/crypto/protocol/proof_path.go +++ b/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) } diff --git a/x/proof/keeper/proof_validation.go b/x/proof/keeper/proof_validation.go index 897e3ed16..ddfa351fd 100644 --- a/x/proof/keeper/proof_validation.go +++ b/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 } diff --git a/x/proof/keeper/proof_validation_test.go b/x/proof/keeper/proof_validation_test.go index 349dcd59c..ca00d4c62 100644 --- a/x/proof/keeper/proof_validation_test.go +++ b/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[:]