Add resource constraints to ArbOS storage

Author: MishkaRogachev

arbos/arbosState/arbosstate.go

@@ -25,6 +25,7 @@ import (
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbos/blockhash"
 	"github.com/offchainlabs/nitro/arbos/burn"
+	"github.com/offchainlabs/nitro/arbos/constraints"
 	"github.com/offchainlabs/nitro/arbos/features"
 	"github.com/offchainlabs/nitro/arbos/l1pricing"
 	"github.com/offchainlabs/nitro/arbos/l2pricing"
@@ -49,6 +50,7 @@ type ArbosState struct {
 	networkFeeAccount      storage.StorageBackedAddress
 	l1PricingState         *l1pricing.L1PricingState
 	l2PricingState         *l2pricing.L2PricingState
+	resourceConstraints    *constraints.StorageResourceConstraints
 	retryableState         *retryables.RetryableState
 	addressTable           *addressTable.AddressTable
 	chainOwners            *addressSet.AddressSet
@@ -79,13 +81,16 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error)
 	if arbosVersion == 0 {
 		return nil, ErrUninitializedArbOS
 	}
+	constraintsStorage := backingStorage.OpenStorageBackedBytes(constraintsSubspace)
+
 	return &ArbosState{
 		arbosVersion:           arbosVersion,
 		upgradeVersion:         backingStorage.OpenStorageBackedUint64(uint64(upgradeVersionOffset)),
 		upgradeTimestamp:       backingStorage.OpenStorageBackedUint64(uint64(upgradeTimestampOffset)),
 		networkFeeAccount:      backingStorage.OpenStorageBackedAddress(uint64(networkFeeAccountOffset)),
 		l1PricingState:         l1pricing.OpenL1PricingState(backingStorage.OpenCachedSubStorage(l1PricingSubspace), arbosVersion),
 		l2PricingState:         l2pricing.OpenL2PricingState(backingStorage.OpenCachedSubStorage(l2PricingSubspace)),
+		resourceConstraints:    constraints.NewStorageResourceConstraints(&constraintsStorage),
 		retryableState:         retryables.OpenRetryableState(backingStorage.OpenCachedSubStorage(retryablesSubspace), stateDB),
 		addressTable:           addressTable.Open(backingStorage.OpenCachedSubStorage(addressTableSubspace)),
 		chainOwners:            addressSet.OpenAddressSet(backingStorage.OpenCachedSubStorage(chainOwnerSubspace)),
@@ -187,6 +192,7 @@ var (
 	programsSubspace         SubspaceID = []byte{8}
 	featuresSubspace         SubspaceID = []byte{9}
 	nativeTokenOwnerSubspace SubspaceID = []byte{10}
+	constraintsSubspace      SubspaceID = []byte{11}
 )
 
 var PrecompileMinArbOSVersions = make(map[common.Address]uint64)

arbos/constraints/constraints.go

@@ -5,9 +5,11 @@
 package constraints
 
 import (
+	"io"
 	"iter"
 
 	"github.com/ethereum/go-ethereum/arbitrum/multigas"
+	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/offchainlabs/nitro/util/arbmath"
 )
@@ -151,3 +153,102 @@ 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,3 +222,69 @@ 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")
+}