Add Proof size limit to sync client

x/merkledb/history.go

@@ -97,27 +97,32 @@ func (th *trieHistory) getValueChanges(startRoot, endRoot ids.ID, start, end []b
 	}
 
 	// [lastStartRootChange] is the latest appearance of [startRoot]
-	// which came before [lastEndRootChange].
-	var lastStartRootChange *changeSummaryAndIndex
-	th.history.DescendLessOrEqual(
-		lastEndRootChange,
-		func(item *changeSummaryAndIndex) bool {
-			if item == lastEndRootChange {
-				return true // Skip first iteration
-			}
-			if item.rootID == startRoot {
-				lastStartRootChange = item
-				return false
-			}
-			return true
-		},
-	)
-
-	// There's no change resulting in [startRoot] before the latest change resulting in [endRoot].
-	if lastStartRootChange == nil {
+	lastStartRootChange, ok := th.lastChanges[startRoot]
+	if !ok {
 		return nil, ErrStartRootNotFound
 	}
 
+	// if lastStartRootChange is after the lastEndRootChange, then attempt to find an entry that comes before lastEndRootChange
+	if lastStartRootChange.index > lastEndRootChange.index {
+		th.history.DescendLessOrEqual(
+			lastEndRootChange,
+			func(item *changeSummaryAndIndex) bool {
+				if item == lastEndRootChange {
+					return true // Skip first iteration
+				}
+				if item.rootID == startRoot {
+					lastStartRootChange = item
+					return false
+				}
+				return true
+			},
+		)
+		// There's no change resulting in [startRoot] before the latest change resulting in [endRoot].
+		if lastStartRootChange.index > lastEndRootChange.index {
+			return nil, ErrStartRootNotFound
+		}
+	}
+
 	// Keep changes sorted so the largest can be removed in order to stay within the maxLength limit.
 	sortedKeys := btree.NewG(
 		2,

x/sync/README.md

@@ -0,0 +1,4 @@
+## TODOs
+
+- [ ] Handle errors on proof requests.  Currently, any errors that occur server side are not sent back to the client.
+- [ ] Handle missing roots in change proofs by returning a range proof instead of failing

x/sync/client.go

@@ -28,7 +28,8 @@ var (
 	_ Client = &client{}
 
 	errInvalidRangeProof = errors.New("failed to verify range proof")
-	errTooManyLeaves     = errors.New("response contains more than requested leaves")
+	errTooManyKeys       = errors.New("response contains more than requested keys")
+	errTooManyBytes      = errors.New("response contains more than requested bytes")
 )
 
 // Client synchronously fetches data from the network to fulfill state sync requests.
@@ -76,15 +77,19 @@ func NewClient(config *ClientConfig) Client {
 // The returned change proof is verified.
 func (c *client) GetChangeProof(ctx context.Context, req *ChangeProofRequest, db *merkledb.Database) (*merkledb.ChangeProof, error) {
 	parseFn := func(ctx context.Context, responseBytes []byte) (*merkledb.ChangeProof, error) {
+		if len(responseBytes) > int(req.BytesLimit) {
+			return nil, fmt.Errorf("%w: (%d) > %d)", errTooManyBytes, len(responseBytes), req.BytesLimit)
+		}
+
 		changeProof := &merkledb.ChangeProof{}
 		if _, err := merkledb.Codec.DecodeChangeProof(responseBytes, changeProof); err != nil {
 			return nil, err
 		}
 
 		// Ensure the response does not contain more than the requested number of leaves
 		// and the start and end roots match the requested roots.
-		if len(changeProof.KeyValues)+len(changeProof.DeletedKeys) > int(req.Limit) {
-			return nil, fmt.Errorf("%w: (%d) > %d)", errTooManyLeaves, len(changeProof.KeyValues), req.Limit)
+		if len(changeProof.KeyValues)+len(changeProof.DeletedKeys) > int(req.KeyLimit) {
+			return nil, fmt.Errorf("%w: (%d) > %d)", errTooManyKeys, len(changeProof.KeyValues), req.KeyLimit)
 		}
 
 		if err := changeProof.Verify(ctx, db, req.Start, req.End, req.EndingRoot); err != nil {
@@ -100,14 +105,18 @@ func (c *client) GetChangeProof(ctx context.Context, req *ChangeProofRequest, db
 // The returned range proof is verified.
 func (c *client) GetRangeProof(ctx context.Context, req *RangeProofRequest) (*merkledb.RangeProof, error) {
 	parseFn := func(ctx context.Context, responseBytes []byte) (*merkledb.RangeProof, error) {
+		if len(responseBytes) > int(req.BytesLimit) {
+			return nil, fmt.Errorf("%w: (%d) > %d)", errTooManyBytes, len(responseBytes), req.BytesLimit)
+		}
+
 		rangeProof := &merkledb.RangeProof{}
 		if _, err := merkledb.Codec.DecodeRangeProof(responseBytes, rangeProof); err != nil {
 			return nil, err
 		}
 
 		// Ensure the response does not contain more than the maximum requested number of leaves.
-		if len(rangeProof.KeyValues) > int(req.Limit) {
-			return nil, fmt.Errorf("%w: (%d) > %d)", errTooManyLeaves, len(rangeProof.KeyValues), req.Limit)
+		if len(rangeProof.KeyValues) > int(req.KeyLimit) {
+			return nil, fmt.Errorf("%w: (%d) > %d)", errTooManyKeys, len(rangeProof.KeyValues), req.KeyLimit)
 		}
 
 		if err := rangeProof.Verify(