Add version to rlp ResourceConstraints

Author: MishkaRogachev

arbos/constraints/storage.go

@@ -4,11 +4,15 @@
 package constraints
 
 import (
+	"fmt"
 	"io"
 
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
+// Version of the RLP serialization format for ResourceConstraints.
+const ResourceConstraintsVersion uint8 = 1
+
 // storageBytes defines the interface for ArbOS storage.
 type storageBytes interface {
 	Get() ([]byte, error)
@@ -27,19 +31,25 @@ func NewStorageResourceConstraints(storage storageBytes) *StorageResourceConstra
 	}
 }
 
-type resourceConstraintRLP struct {
+type rlpResourceConstraint struct {
 	Resources    []ResourceWeight
 	Period       PeriodSecs
 	TargetPerSec uint64
 	Backlog      uint64
 }
 
+// rlpConstraints is the RLP-encoded wrapper used for persistence.
+type rlpConstraints struct {
+	Version     uint8
+	Constraints []*ResourceConstraint
+}
+
 // EncodeRLP encodes ResourceConstraint deterministically,
 // ensuring the fixed-length weights array is preserved.
 func (c *ResourceConstraint) EncodeRLP(w io.Writer) error {
 	weights := make([]ResourceWeight, len(c.Resources.weights))
 	copy(weights, c.Resources.weights[:])
-	return rlp.Encode(w, resourceConstraintRLP{
+	return rlp.Encode(w, rlpResourceConstraint{
 		Resources:    weights,
 		Period:       c.Period,
 		TargetPerSec: c.TargetPerSec,
@@ -50,7 +60,7 @@ func (c *ResourceConstraint) EncodeRLP(w io.Writer) error {
 // DecodeRLP decodes ResourceConstraint deterministically,
 // padding or truncating the weights slice to the correct array length.
 func (c *ResourceConstraint) DecodeRLP(s *rlp.Stream) error {
-	var raw resourceConstraintRLP
+	var raw rlpResourceConstraint
 	if err := s.Decode(&raw); err != nil {
 		return err
 	}
@@ -79,18 +89,20 @@ func (src *StorageResourceConstraints) Load() (*ResourceConstraints, error) {
 		return NewResourceConstraints(), nil
 	}
 
-	var list []*ResourceConstraint
-	if err := rlp.DecodeBytes(data, &list); err != nil {
+	var payload rlpConstraints
+	if err := rlp.DecodeBytes(data, &payload); err != nil {
 		return nil, err
 	}
+	if payload.Version != ResourceConstraintsVersion {
+		return nil, fmt.Errorf("unsupported constraints version %d", payload.Version)
+	}
 
 	rc := NewResourceConstraints()
-	for _, c := range list {
+	for _, c := range payload.Constraints {
 		rc.Set(c.Resources, c.Period, c.TargetPerSec)
 		ptr := rc.Get(c.Resources, c.Period)
 		ptr.Backlog = c.Backlog
 	}
-
 	return rc, nil
 }
 
@@ -106,7 +118,12 @@ func (src *StorageResourceConstraints) Write(rc *ResourceConstraints) error {
 		return src.storage.Set(nil)
 	}
 
-	data, err := rlp.EncodeToBytes(list)
+	payload := rlpConstraints{
+		Version:     ResourceConstraintsVersion,
+		Constraints: list,
+	}
+
+	data, err := rlp.EncodeToBytes(&payload)
 	if err != nil {
 		return err
 	}

arbos/constraints/storage_test.go

@@ -108,6 +108,42 @@ func TestStorageResourceConstraintsRLPRoundTrip(t *testing.T) {
 	}
 }
 
+func TestStorageResourceConstraintsRLPBacklogPersistence(t *testing.T) {
+	rc := NewResourceConstraints()
+	res := EmptyResourceSet().
+		WithResource(multigas.ResourceKindComputation, 1)
+	rc.Set(res, PeriodSecs(30), 10_000_000)
+	ptr := rc.Get(res, PeriodSecs(30))
+	ptr.Backlog = 12345 // initial backlog value
+
+	store := &mockStorageBytes{}
+	src := NewStorageResourceConstraints(store)
+
+	require.NoError(t, src.Write(rc))
+	require.Greater(t, len(store.buf), 0, "storage should contain RLP bytes after Write")
+
+	loaded, err := src.Load()
+	require.NoError(t, err, "Load() failed")
+	require.Equal(t, 1, len(loaded.constraints), "expected one constraint")
+
+	for got := range loaded.All() {
+		require.Equal(t, uint64(12345), got.Backlog,
+			"initial backlog not persisted correctly")
+	}
+
+	ptr.Backlog = 99999
+	require.NoError(t, src.Write(rc), "Write() after backlog update failed")
+
+	loaded2, err := src.Load()
+	require.NoError(t, err, "Load() after backlog update failed")
+	require.Equal(t, 1, len(loaded2.constraints), "expected one constraint")
+
+	for got := range loaded2.All() {
+		require.Equal(t, uint64(99999), got.Backlog,
+			"updated backlog not persisted correctly")
+	}
+}
+
 func TestStorageResourceConstraintsEmptyLoad(t *testing.T) {
 	store := &mockStorageBytes{}
 	src := NewStorageResourceConstraints(store)