eth/protocols/snap: fix snap sync failure on empty storage range (#28306

)

This change addresses an issue in snap sync, specifically when the entire sync process can be halted due to an encountered empty storage range.

Currently, on the snap sync client side, the response to an empty (partial) storage range is discarded as a non-delivery. However, this response can be a valid response, when the particular range requested does not contain any slots.

For instance, consider a large contract where the entire key space is divided into 16 chunks, and there are no available slots in the last chunk [0xf] -> [end]. When the node receives a request for this particular range, the response includes:

    The proof with origin [0xf]
    A nil storage slot set

If we simply discard this response, the finalization of the last range will be skipped, halting the entire sync process indefinitely. The test case TestSyncWithUnevenStorage can reproduce the scenario described above.

In addition, this change also defines the common variables MaxAddress and MaxHash.

cmd/clef/main.go

@@ -1206,7 +1206,7 @@ func GenDoc(ctx *cli.Context) error {
  URL: accounts.URL{Path: ".. ignored .."},
  },
  {
- Address: common.HexToAddress("0xffffffffffffffffffffffffffffffffffffffff"),
+ Address: common.MaxAddress,
  },
  }})
  }

cmd/devp2p/internal/ethtest/snap.go

@@ -58,7 +58,7 @@ type accRangeTest struct {
 func (s *Suite) TestSnapGetAccountRange(t *utesting.T) {
  var (
  root = s.chain.RootAt(999)
- ffHash = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+ ffHash = common.MaxHash
  zero = common.Hash{}
  firstKeyMinus1 = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf29")
  firstKey = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a")
@@ -125,7 +125,7 @@ type stRangesTest struct {
 // TestSnapGetStorageRanges various forms of GetStorageRanges requests.
 func (s *Suite) TestSnapGetStorageRanges(t *utesting.T) {
  var (
- ffHash = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+ ffHash = common.MaxHash
  zero = common.Hash{}
  firstKey = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a")
  secondKey = common.HexToHash("0x09e47cd5056a689e708f22fe1f932709a320518e444f5f7d8d46a3da523d6606")

common/types.go

@@ -44,6 +44,12 @@ const (
 var (
  hashT = reflect.TypeOf(Hash{})
  addressT = reflect.TypeOf(Address{})
+
+ // MaxAddress represents the maximum possible address value.
+ MaxAddress = HexToAddress("0xffffffffffffffffffffffffffffffffffffffff")
+
+ // MaxHash represents the maximum possible hash value.
+ MaxHash = HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
 )
 
 // Hash represents the 32 byte Keccak256 hash of arbitrary data.

core/state_processor_test.go

@@ -132,7 +132,7 @@ func TestStateProcessorErrors(t *testing.T) {
  )
 
  defer blockchain.Stop()
- bigNumber := new(big.Int).SetBytes(common.FromHex("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
+ bigNumber := new(big.Int).SetBytes(common.MaxHash.Bytes())
  tooBigNumber := new(big.Int).Set(bigNumber)
  tooBigNumber.Add(tooBigNumber, common.Big1)
  for i, tt := range []struct {

eth/protocols/snap/handler.go

@@ -367,7 +367,7 @@ func ServiceGetStorageRangesQuery(chain *core.BlockChain, req *GetStorageRangesP
  if len(req.Origin) > 0 {
  origin, req.Origin = common.BytesToHash(req.Origin), nil
  }
- var limit = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+ var limit = common.MaxHash
  if len(req.Limit) > 0 {
  limit, req.Limit = common.BytesToHash(req.Limit), nil
  }

eth/protocols/snap/range.go

@@ -67,7 +67,7 @@ func (r *hashRange) End() common.Hash {
  // If the end overflows (non divisible range), return a shorter interval
  next, overflow := new(uint256.Int).AddOverflow(r.current, r.step)
  if overflow {
- return common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+ return common.MaxHash
  }
  return next.SubUint64(next, 1).Bytes32()
 }

eth/protocols/snap/range_test.go

@@ -45,7 +45,7 @@ func TestHashRanges(t *testing.T) {
  common.HexToHash("0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
  common.HexToHash("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
  common.HexToHash("0xbfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
- common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+ common.MaxHash,
  },
  },
  // Split a divisible part of the hash range up into 2 chunks
@@ -58,7 +58,7 @@ func TestHashRanges(t *testing.T) {
  },
  ends: []common.Hash{
  common.HexToHash("0x8fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
- common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+ common.MaxHash,
  },
  },
  // Split the entire hash range into a non divisible 3 chunks
@@ -73,7 +73,7 @@ func TestHashRanges(t *testing.T) {
  ends: []common.Hash{
  common.HexToHash("0x5555555555555555555555555555555555555555555555555555555555555555"),
  common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"),
- common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+ common.MaxHash,
  },
  },
  // Split a part of hash range into a non divisible 3 chunks
@@ -88,7 +88,7 @@ func TestHashRanges(t *testing.T) {
  ends: []common.Hash{
  common.HexToHash("0x6aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
  common.HexToHash("0xb555555555555555555555555555555555555555555555555555555555555555"),
- common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+ common.MaxHash,
  },
  },
  // Split a part of hash range into a non divisible 3 chunks, but with a
@@ -108,7 +108,7 @@ func TestHashRanges(t *testing.T) {
  ends: []common.Hash{
  common.HexToHash("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5"),
  common.HexToHash("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb"),
- common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+ common.MaxHash,
  },
  },
  }

eth/protocols/snap/sync.go

@@ -798,7 +798,7 @@ func (s *Syncer) loadSyncStatus() {
  last := common.BigToHash(new(big.Int).Add(next.Big(), step))
  if i == accountConcurrency-1 {
  // Make sure we don't overflow if the step is not a proper divisor
- last = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+ last = common.MaxHash
  }
  batch := ethdb.HookedBatch{
  Batch: s.db.NewBatch(),
@@ -1874,7 +1874,7 @@ func (s *Syncer) processAccountResponse(res *accountResponse) {
  return
  }
  // Some accounts are incomplete, leave as is for the storage and contract
- // task assigners to pick up and fill.
+ // task assigners to pick up and fill
 }
 
 // processBytecodeResponse integrates an already validated bytecode response
@@ -2624,7 +2624,7 @@ func (s *Syncer) OnStorage(peer SyncPeer, id uint64, hashes [][]common.Hash, slo
  // the requested data. For storage range queries that means the state being
  // retrieved was either already pruned remotely, or the peer is not yet
  // synced to our head.
- if len(hashes) == 0 {
+ if len(hashes) == 0 && len(proof) == 0 {
  logger.Debug("Peer rejected storage request")
  s.statelessPeers[peer.ID()] = struct{}{}
  s.lock.Unlock()
@@ -2636,6 +2636,13 @@ func (s *Syncer) OnStorage(peer SyncPeer, id uint64, hashes [][]common.Hash, slo
  // Reconstruct the partial tries from the response and verify them
  var cont bool
 
+ // If a proof was attached while the response is empty, it indicates that the
+ // requested range specified with 'origin' is empty. Construct an empty state
+ // response locally to finalize the range.
+ if len(hashes) == 0 && len(proof) > 0 {
+ hashes = append(hashes, []common.Hash{})
+ slots = append(slots, [][]byte{})
+ }
  for i := 0; i < len(hashes); i++ {
  // Convert the keys and proofs into an internal format
  keys := make([][]byte, len(hashes[i]))