Polishing and testing StorageResourceConstraints

Author: MishkaRogachev

arbos/arbosState/arbosstate.go

@@ -81,7 +81,7 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error)
 	if arbosVersion == 0 {
 		return nil, ErrUninitializedArbOS
 	}
-	constraintsStorage := backingStorage.OpenStorageBackedBytes(constraintsSubspace)
+	constraintsBytes := backingStorage.OpenStorageBackedBytes(constraintsSubspace)
 
 	return &ArbosState{
 		arbosVersion:           arbosVersion,
@@ -90,7 +90,7 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error)
 		networkFeeAccount:      backingStorage.OpenStorageBackedAddress(uint64(networkFeeAccountOffset)),
 		l1PricingState:         l1pricing.OpenL1PricingState(backingStorage.OpenCachedSubStorage(l1PricingSubspace), arbosVersion),
 		l2PricingState:         l2pricing.OpenL2PricingState(backingStorage.OpenCachedSubStorage(l2PricingSubspace)),
-		resourceConstraints:    constraints.NewStorageResourceConstraints(&constraintsStorage),
+		resourceConstraints:    constraints.NewStorageResourceConstraints(&constraintsBytes),
 		retryableState:         retryables.OpenRetryableState(backingStorage.OpenCachedSubStorage(retryablesSubspace), stateDB),
 		addressTable:           addressTable.Open(backingStorage.OpenCachedSubStorage(addressTableSubspace)),
 		chainOwners:            addressSet.OpenAddressSet(backingStorage.OpenCachedSubStorage(chainOwnerSubspace)),
@@ -530,6 +530,10 @@ func (state *ArbosState) Blockhashes() *blockhash.Blockhashes {
 	return state.blockhashes
 }
 
+func (state *ArbosState) ResourceConstraints() *constraints.StorageResourceConstraints {
+	return state.resourceConstraints
+}
+
 func (state *ArbosState) NetworkFeeAccount() (common.Address, error) {
 	return state.networkFeeAccount.Get()
 }

arbos/constraints/constraints.go

@@ -5,11 +5,9 @@
 package constraints
 
 import (
-	"io"
 	"iter"
 
 	"github.com/ethereum/go-ethereum/arbitrum/multigas"
-	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/offchainlabs/nitro/util/arbmath"
 )
@@ -153,102 +151,3 @@ func (rc *ResourceConstraints) All() iter.Seq[*ResourceConstraint] {
 		}
 	}
 }
-
-// storageBytes defines the interface for ArbOS storage.
-type storageBytes interface {
-	Get() ([]byte, error)
-	Set(val []byte) error
-}
-
-// StorageResourceConstraints defines a storage-backed ResourceConstraints.
-type StorageResourceConstraints struct {
-	storage storageBytes
-}
-
-// NewStorageResourceConstraints creates a new storage-backed ResourceConstraints.
-func NewStorageResourceConstraints(storage storageBytes) *StorageResourceConstraints {
-	return &StorageResourceConstraints{
-		storage: storage,
-	}
-}
-
-type resourceConstraintRLP struct {
-	Resources    []ResourceWeight
-	Period       PeriodSecs
-	TargetPerSec uint64
-	Backlog      uint64
-}
-
-// 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{
-		Resources:    weights,
-		Period:       c.Period,
-		TargetPerSec: c.TargetPerSec,
-		Backlog:      c.Backlog,
-	})
-}
-
-// 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
-	if err := s.Decode(&raw); err != nil {
-		return err
-	}
-	c.Period = raw.Period
-	c.TargetPerSec = raw.TargetPerSec
-	c.Backlog = raw.Backlog
-
-	for i := range c.Resources.weights {
-		if i < len(raw.Resources) {
-			c.Resources.weights[i] = raw.Resources[i]
-		} else {
-			c.Resources.weights[i] = 0
-		}
-	}
-	return nil
-}
-
-// Load decodes ResourceConstraints from storage using RLP.
-// If storage is empty, returns an empty ResourceConstraints.
-func (src *StorageResourceConstraints) Load() (*ResourceConstraints, error) {
-	data, err := src.storage.Get()
-	if err != nil {
-		return nil, err
-	}
-	if len(data) == 0 {
-		return NewResourceConstraints(), nil
-	}
-
-	var list []*ResourceConstraint
-	if err := rlp.DecodeBytes(data, &list); err != nil {
-		return nil, err
-	}
-
-	rc := NewResourceConstraints()
-	for _, c := range list {
-		rc.Set(c.Resources, c.Period, c.TargetPerSec)
-		ptr := rc.Get(c.Resources, c.Period)
-		ptr.Backlog = c.Backlog
-	}
-
-	return rc, nil
-}
-
-// Write encodes ResourceConstraints into storage using RLP.
-func (src *StorageResourceConstraints) Write(rc *ResourceConstraints) error {
-	var list []*ResourceConstraint
-	for c := range rc.All() {
-		list = append(list, c)
-	}
-
-	data, err := rlp.EncodeToBytes(list)
-	if err != nil {
-		return err
-	}
-	return src.storage.Set(data)
-}

arbos/constraints/constraints_test.go

@@ -222,69 +222,3 @@ func TestAllResourceConstraints(t *testing.T) {
 	require.True(t, found1)
 	require.True(t, found2)
 }
-
-// mockStorageBytes is a simple in-memory implementation of storageBytes.
-type mockStorageBytes struct {
-	buf []byte
-}
-
-func (m *mockStorageBytes) Get() ([]byte, error) { return m.buf, nil }
-func (m *mockStorageBytes) Set(val []byte) error { m.buf = val; return nil }
-
-func TestStorageResourceConstraintsRLPRoundTrip(t *testing.T) {
-	rc := NewResourceConstraints()
-
-	res1 := EmptyResourceSet().
-		WithResource(multigas.ResourceKindComputation, 1).
-		WithResource(multigas.ResourceKindHistoryGrowth, 2)
-	rc.Set(res1, PeriodSecs(12), 7_000_000)
-	rc.Get(res1, PeriodSecs(12)).Backlog = 42
-
-	res2 := EmptyResourceSet().
-		WithResource(multigas.ResourceKindWasmComputation, 3)
-	rc.Set(res2, PeriodSecs(60), 3_500_000)
-	rc.Get(res2, PeriodSecs(60)).Backlog = 99
-
-	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, len(rc.constraints), len(loaded.constraints), "constraint count mismatch")
-
-	for orig := range rc.All() {
-		found := false
-		for got := range loaded.All() {
-			if got.Period != orig.Period ||
-				got.TargetPerSec != orig.TargetPerSec ||
-				got.Backlog != orig.Backlog {
-				continue
-			}
-			eq := true
-			for i := range orig.Resources.weights {
-				if orig.Resources.weights[i] != got.Resources.weights[i] {
-					eq = false
-					break
-				}
-			}
-			if eq {
-				found = true
-				break
-			}
-		}
-		require.Truef(t, found, "missing constraint after Load (period=%d target=%d)", orig.Period, orig.TargetPerSec)
-	}
-}
-
-func TestStorageResourceConstraintsEmptyLoad(t *testing.T) {
-	store := &mockStorageBytes{}
-	src := NewStorageResourceConstraints(store)
-
-	loaded, err := src.Load()
-	require.NoError(t, err, "Load() failed")
-	require.NotNil(t, loaded, "Load() returned nil ResourceConstraints")
-	require.Empty(t, loaded.constraints, "Loaded ResourceConstraints should be empty")
-}

arbos/constraints/storage.go

@@ -0,0 +1,114 @@
+// Copyright 2025, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE.md
+
+package constraints
+
+import (
+	"io"
+
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// storageBytes defines the interface for ArbOS storage.
+type storageBytes interface {
+	Get() ([]byte, error)
+	Set(val []byte) error
+}
+
+// StorageResourceConstraints defines a storage-backed ResourceConstraints.
+type StorageResourceConstraints struct {
+	storage storageBytes
+}
+
+// NewStorageResourceConstraints creates a new storage-backed ResourceConstraints.
+func NewStorageResourceConstraints(storage storageBytes) *StorageResourceConstraints {
+	return &StorageResourceConstraints{
+		storage: storage,
+	}
+}
+
+type resourceConstraintRLP struct {
+	Resources    []ResourceWeight
+	Period       PeriodSecs
+	TargetPerSec uint64
+	Backlog      uint64
+}
+
+// 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{
+		Resources:    weights,
+		Period:       c.Period,
+		TargetPerSec: c.TargetPerSec,
+		Backlog:      c.Backlog,
+	})
+}
+
+// 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
+	if err := s.Decode(&raw); err != nil {
+		return err
+	}
+	c.Period = raw.Period
+	c.TargetPerSec = raw.TargetPerSec
+	c.Backlog = raw.Backlog
+
+	for i := range c.Resources.weights {
+		if i < len(raw.Resources) {
+			c.Resources.weights[i] = raw.Resources[i]
+		} else {
+			c.Resources.weights[i] = 0
+		}
+	}
+	return nil
+}
+
+// Load decodes ResourceConstraints from storage using RLP.
+// If storage is empty, returns an empty ResourceConstraints.
+func (src *StorageResourceConstraints) Load() (*ResourceConstraints, error) {
+	data, err := src.storage.Get()
+	if err != nil {
+		return nil, err
+	}
+	if len(data) == 0 {
+		return NewResourceConstraints(), nil
+	}
+
+	var list []*ResourceConstraint
+	if err := rlp.DecodeBytes(data, &list); err != nil {
+		return nil, err
+	}
+
+	rc := NewResourceConstraints()
+	for _, c := range list {
+		rc.Set(c.Resources, c.Period, c.TargetPerSec)
+		ptr := rc.Get(c.Resources, c.Period)
+		ptr.Backlog = c.Backlog
+	}
+
+	return rc, nil
+}
+
+// Write encodes ResourceConstraints into storage using RLP.
+func (src *StorageResourceConstraints) Write(rc *ResourceConstraints) error {
+	var list []*ResourceConstraint
+	for c := range rc.All() {
+		list = append(list, c)
+	}
+
+	// If there are no constraints, clear the storage instead of writing 0xC0
+	if len(list) == 0 {
+		return src.storage.Set(nil)
+	}
+
+	data, err := rlp.EncodeToBytes(list)
+	if err != nil {
+		return err
+	}
+	return src.storage.Set(data)
+}