Change p2p sync logic

Author: kirugan

blockchain/blockchain.go

@@ -371,11 +371,17 @@ func (b *Blockchain) Store(block *core.Block, blockCommitments *core.BlockCommit
 			return err
 		}
 
-		// todo only for <0.13.2 blocks
-		if err := StoreP2PHash(txn, block, stateUpdate.StateDiff); err != nil {
+		blockVer, err := core.ParseBlockVersion(block.ProtocolVersion)
+		if err != nil {
 			return err
 		}
 
+		if blockVer.LessThan(core.Ver0_13_2) {
+			if err := StoreP2PHash(txn, block, stateUpdate.StateDiff); err != nil {
+				return err
+			}
+		}
+
 		if err := StoreBlockCommitments(txn, block.Number, blockCommitments); err != nil {
 			return err
 		}
@@ -399,23 +405,13 @@ func (b *Blockchain) VerifyBlock(block *core.Block) error {
 }
 
 func StoreP2PHash(txn db.Transaction, block *core.Block, stateDiff *core.StateDiff) error {
-	originalParentHash := block.ParentHash
-	if block.Number > 0 {
-		prevP2PHash, err := blockP2PHashByNumber(txn, block.Number-1)
-		if err != nil {
-			return err
-		}
-		block.ParentHash = prevP2PHash
-	}
-
-	numBytes := core.MarshalBlockNumber(block.Number)
 	hash, _, err := core.Post0132Hash(block, stateDiff)
 	if err != nil {
 		return err
 	}
-	block.ParentHash = originalParentHash
 
 	hashBytes := hash.Bytes()
+	numBytes := core.MarshalBlockNumber(block.Number)
 	return txn.Set(db.P2PHash.Key(numBytes), hashBytes[:])
 }
 
@@ -684,7 +680,7 @@ func (b *Blockchain) SanityCheckNewHeight(block *core.Block, stateUpdate *core.S
 		return nil, err
 	}
 
-	return core.VerifyBlockHash(block, b.network, stateUpdate.StateDiff, force0132Hash)
+	return core.VerifyBlockHash(block, b.network, stateUpdate.StateDiff)
 }
 
 type txAndReceiptDBKey struct {

cmd/juno/dbcmd.go

@@ -194,7 +194,7 @@ func getNetwork(head *core.Block, stateDiff *core.StateDiff) string {
 	}
 
 	for _, network := range networks {
-		if _, err := core.VerifyBlockHash(head, network, stateDiff, false); err == nil {
+		if _, err := core.VerifyBlockHash(head, network, stateDiff); err == nil {
 			return network.Name
 		}
 	}

core/block.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"slices"
 
-	"github.com/Masterminds/semver/v3"
 	"github.com/NethermindEth/juno/core/crypto"
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/utils"
@@ -74,7 +73,7 @@ type BlockCommitments struct {
 
 // VerifyBlockHash verifies the block hash. Due to bugs in Starknet alpha, not all blocks have
 // verifiable hashes.
-func VerifyBlockHash(b *Block, network *utils.Network, stateDiff *StateDiff, force0132Hash bool) (*BlockCommitments, error) {
+func VerifyBlockHash(b *Block, network *utils.Network, stateDiff *StateDiff) (*BlockCommitments, error) {
 	if len(b.Transactions) != len(b.Receipts) {
 		return nil, fmt.Errorf("len of transactions: %v do not match len of receipts: %v",
 			len(b.Transactions), len(b.Receipts))
@@ -92,9 +91,6 @@ func VerifyBlockHash(b *Block, network *utils.Network, stateDiff *StateDiff, for
 	unverifiableRange := metaInfo.UnverifiableRange
 
 	skipVerification := unverifiableRange != nil && b.Number >= unverifiableRange[0] && b.Number <= unverifiableRange[1] //nolint:gocritic
-	if force0132Hash {
-		skipVerification = false
-	}
 	if !skipVerification {
 		if err := VerifyTransactions(b.Transactions, network, b.ProtocolVersion); err != nil {
 			return nil, err
@@ -112,7 +108,7 @@ func VerifyBlockHash(b *Block, network *utils.Network, stateDiff *StateDiff, for
 			overrideSeq = fallbackSeq
 		}
 
-		hash, commitments, err := blockHash(b, stateDiff, network, overrideSeq, force0132Hash)
+		hash, commitments, err := blockHash(b, stateDiff, network, overrideSeq)
 		if err != nil {
 			return nil, err
 		}
@@ -143,22 +139,15 @@ func BlockHash(b *Block) (*felt.Felt, error) {
 }
 
 // blockHash computes the block hash, with option to override sequence address
-func blockHash(b *Block, stateDiff *StateDiff, network *utils.Network,
-	overrideSeqAddr *felt.Felt, force0132Hash bool) (*felt.Felt, *BlockCommitments, error) {
+func blockHash(b *Block, stateDiff *StateDiff, network *utils.Network, overrideSeqAddr *felt.Felt) (*felt.Felt, *BlockCommitments, error) {
 	metaInfo := network.BlockHashMetaInfo
 
-	usePre0132Hash := !force0132Hash
-	if usePre0132Hash {
-		blockVer, err := ParseBlockVersion(b.ProtocolVersion)
-		if err != nil {
-			return nil, nil, err
-		}
-
-		v0_13_2 := semver.MustParse("0.13.2")
-		usePre0132Hash = blockVer.LessThan(v0_13_2)
+	blockVer, err := ParseBlockVersion(b.ProtocolVersion)
+	if err != nil {
+		return nil, nil, err
 	}
 
-	if usePre0132Hash {
+	if blockVer.LessThan(Ver0_13_2) {
 		if b.Number < metaInfo.First07Block {
 			return pre07Hash(b, network.L2ChainIDFelt())
 		}

core/block_test.go

@@ -180,7 +180,7 @@ func TestBlockHash(t *testing.T) {
 			block, err := gw.BlockByNumber(context.Background(), tc.number)
 			require.NoError(t, err)
 
-			commitments, err := core.VerifyBlockHash(block, &tc.chain, nil, false)
+			commitments, err := core.VerifyBlockHash(block, &tc.chain, nil)
 			assert.NoError(t, err)
 			assert.NotNil(t, commitments)
 		})
@@ -198,7 +198,7 @@ func TestBlockHash(t *testing.T) {
 		mainnetBlock1.Hash = h1
 
 		expectedErr := "can not verify hash in block header"
-		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet, nil, false)
+		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet, nil)
 		assert.EqualError(t, err, expectedErr)
 		assert.Nil(t, commitments)
 	})
@@ -209,7 +209,7 @@ func TestBlockHash(t *testing.T) {
 		block119802, err := goerliGW.BlockByNumber(context.Background(), 119802)
 		require.NoError(t, err)
 
-		commitments, err := core.VerifyBlockHash(block119802, &utils.Goerli, nil, false)
+		commitments, err := core.VerifyBlockHash(block119802, &utils.Goerli, nil)
 		assert.NoError(t, err)
 		assert.NotNil(t, commitments)
 	})
@@ -223,7 +223,7 @@ func TestBlockHash(t *testing.T) {
 		expectedErr := fmt.Sprintf("len of transactions: %v do not match len of receipts: %v",
 			len(mainnetBlock1.Transactions), len(mainnetBlock1.Receipts))
 
-		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet, nil, false)
+		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet, nil)
 		assert.EqualError(t, err, expectedErr)
 		assert.Nil(t, commitments)
 	})
@@ -237,7 +237,7 @@ func TestBlockHash(t *testing.T) {
 			"transaction hash (%v) at index: %v does not match receipt's hash (%v)",
 			mainnetBlock1.Transactions[1].Hash().String(), 1,
 			mainnetBlock1.Receipts[1].TransactionHash)
-		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet, nil, false)
+		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet, nil)
 		assert.EqualError(t, err, expectedErr)
 		assert.Nil(t, commitments)
 	})
@@ -261,7 +261,7 @@ func Test0132BlockHash(t *testing.T) {
 			su, err := gw.StateUpdate(context.Background(), test.blockNum)
 			require.NoError(t, err)
 
-			c, err := core.VerifyBlockHash(b, &utils.SepoliaIntegration, su.StateDiff, false)
+			c, err := core.VerifyBlockHash(b, &utils.SepoliaIntegration, su.StateDiff)
 			require.NoError(t, err)
 			assert.NotNil(t, c)
 		})

core/transaction.go

@@ -7,7 +7,6 @@ import (
 	"math/big"
 	"runtime"
 	"slices"
-	"strings"
 	"sync"
 
 	"github.com/Masterminds/semver/v3"
@@ -690,21 +689,6 @@ func transactionCommitmentPoseidon(transactions []Transaction) (*felt.Felt, erro
 	})
 }
 
-// ParseBlockVersion computes the block version, defaulting to "0.0.0" for empty strings
-func ParseBlockVersion(protocolVersion string) (*semver.Version, error) {
-	if protocolVersion == "" {
-		return semver.NewVersion("0.0.0")
-	}
-
-	sep := "."
-	digits := strings.Split(protocolVersion, sep)
-	// pad with 3 zeros in case version has less than 3 digits
-	digits = append(digits, []string{"0", "0", "0"}...)
-
-	// get first 3 digits only
-	return semver.NewVersion(strings.Join(digits[:3], sep))
-}
-
 // eventCommitmentPoseidon computes the event commitment for a block.
 func eventCommitmentPoseidon(receipts []*TransactionReceipt) (*felt.Felt, error) {
 	var commitment *felt.Felt

core/version.go

@@ -0,0 +1,23 @@
+package core
+
+import (
+	"github.com/Masterminds/semver/v3"
+	"strings"
+)
+
+var Ver0_13_2 = semver.MustParse("0.13.2")
+
+// ParseBlockVersion computes the block version, defaulting to "0.0.0" for empty strings
+func ParseBlockVersion(protocolVersion string) (*semver.Version, error) {
+	if protocolVersion == "" {
+		return semver.NewVersion("0.0.0")
+	}
+
+	sep := "."
+	digits := strings.Split(protocolVersion, sep)
+	// pad with 3 zeros in case version has less than 3 digits
+	digits = append(digits, []string{"0", "0", "0"}...)
+
+	// get first 3 digits only
+	return semver.NewVersion(strings.Join(digits[:3], sep))
+}

migration/migration.go

@@ -538,7 +538,7 @@ func calculateBlockCommitments(txn db.Transaction, network *utils.Network) error
 		}
 
 		workerPool.Go(func() error {
-			commitments, err := core.VerifyBlockHash(block, network, nil, false)
+			commitments, err := core.VerifyBlockHash(block, network, nil)
 			if err != nil {
 				return err
 			}

node/node.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/NethermindEth/juno/core"
 	"net/url"
 	"reflect"
 	"runtime"
@@ -131,15 +132,15 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 		return nil, fmt.Errorf("get head block from database: %v", err)
 	}
 	if head != nil {
-		//stateUpdate, err := chain.StateUpdateByNumber(head.Number)
-		//if err != nil {
-		//	return nil, err
-		//}
+		stateUpdate, err := chain.StateUpdateByNumber(head.Number)
+		if err != nil {
+			return nil, err
+		}
 
 		// We assume that there is at least one transaction in the block or that it is a pre-0.7 block.
-		//if _, err = core.VerifyBlockHash(head, &cfg.Network, stateUpdate.StateDiff, false); err != nil {
-		//	return nil, errors.New("unable to verify latest block hash; are the database and --network option compatible?")
-		//}
+		if _, err = core.VerifyBlockHash(head, &cfg.Network, stateUpdate.StateDiff); err != nil {
+			return nil, errors.New("unable to verify latest block hash; are the database and --network option compatible?")
+		}
 	}
 
 	if cfg.VersionedConstantsFile != "" {

p2p/starknet/handlers.go

@@ -180,14 +180,6 @@ func (h *Handler) updateHashes(block *core.Block) error {
 	}
 	block.Hash = p2pHash
 
-	if block.Number > 0 {
-		prevP2PHash, err := h.bcReader.BlockP2PHashByNumber(block.Number - 1)
-		if err != nil {
-			return err
-		}
-		block.ParentHash = prevP2PHash
-	}
-
 	return nil
 }
 

p2p/sync.go

@@ -356,14 +356,44 @@ func (s *syncService) adaptAndSanityCheckBlock(ctx context.Context, header *spec
 				}
 			}()
 
+			stateDiff := p2p2core.AdaptStateDiff(stateReader, contractDiffs, classes)
+
+			blockVer, err := core.ParseBlockVersion(coreBlock.ProtocolVersion)
+			if err != nil {
+				bodyCh <- blockBody{err: fmt.Errorf("failed to parse block version: %w", err)}
+				return
+			}
+
+			if blockVer.LessThan(core.Ver0_13_2) {
+				expectedHash, _, err := core.Post0132Hash(coreBlock, stateDiff)
+				if err != nil {
+					bodyCh <- blockBody{err: fmt.Errorf("failed to compute p2p hash: %w", err)}
+					return
+				}
+
+				if !coreBlock.Hash.Equal(expectedHash) {
+					err = fmt.Errorf("received p2p hash %v doesn't match expected %v", coreBlock.Hash, expectedHash)
+					bodyCh <- blockBody{err: err}
+					return
+				}
+
+				// todo comment
+				coreBlock.Hash, err = core.BlockHash(coreBlock)
+				if err != nil {
+					bodyCh <- blockBody{err: fmt.Errorf("failed to generate block hash: %w", err)}
+					return
+				}
+			}
+
 			stateUpdate := &core.StateUpdate{
 				BlockHash: coreBlock.Hash,
 				NewRoot:   coreBlock.GlobalStateRoot,
 				OldRoot:   prevBlockRoot,
-				StateDiff: p2p2core.AdaptStateDiff(stateReader, contractDiffs, classes),
+				StateDiff: stateDiff,
 			}
 
-			commitments, err := s.blockchain.SanityCheckNewHeight(coreBlock, stateUpdate, newClasses, true)
+			fmt.Printf("For block %d hash is %v, parent hash is %v\n", coreBlock.Number, coreBlock.Hash, coreBlock.ParentHash)
+			commitments, err := s.blockchain.SanityCheckNewHeight(coreBlock, stateUpdate, newClasses, false)
 			if err != nil {
 				bodyCh <- blockBody{err: fmt.Errorf("sanity check error: %v for block number: %v", err, coreBlock.Number)}
 				return