Finalise resource management precomiles implementation

Author: MishkaRogachev

arbos/constraints/constraints.go

@@ -16,35 +16,65 @@ import (
 // Going over the target for this given period will increase the gas price.
 type PeriodSecs uint32
 
+// ResourceWeight is a multiplier applied to a resource’s gas usage when computing backlog.
 type ResourceWeight uint64
 
-// ResourceSet tracks resource weights for constraint calculation.
-type ResourceSet struct {
+// WeightedResourceSet tracks resource weights for constraint calculation.
+type WeightedResourceSet struct {
 	weights [multigas.NumResourceKind]ResourceWeight
 }
 
+// ResourceSet represents presence of each resource kind.
+type ResourceSet struct {
+	kinds [multigas.NumResourceKind]bool
+}
+
 const MaxResourceWeight = 1_000_000 // 1e6
 
-// EmptyResourceSet creates a new set with all weights initialized to zero.
-func EmptyResourceSet() ResourceSet {
-	return ResourceSet{
+// NewWeightedResourceSet creates a new weighted set with all weights initialized to zero.
+func NewWeightedResourceSet() WeightedResourceSet {
+	return WeightedResourceSet{
 		weights: [multigas.NumResourceKind]ResourceWeight{},
 	}
 }
 
 // WithResource sets the weight for a single resource.
-func (s ResourceSet) WithResource(resource multigas.ResourceKind, weight ResourceWeight) ResourceSet {
+func (s WeightedResourceSet) WithResource(resource multigas.ResourceKind, weight ResourceWeight) WeightedResourceSet {
 	s.weights[resource] = weight
 	return s
 }
 
 // HasResource returns true if the resource has a non-zero weight in the set.
-func (s ResourceSet) HasResource(resource multigas.ResourceKind) bool {
+func (s WeightedResourceSet) HasResource(resource multigas.ResourceKind) bool {
 	return s.weights[resource] != 0
 }
 
+// WithoutWeights returns resources set without weights
+func (s WeightedResourceSet) WithoutWeights() ResourceSet {
+	var rs ResourceSet
+	for i, weight := range s.weights {
+		if weight > 0 {
+			rs.kinds[i] = true
+		}
+	}
+	return rs
+}
+
+// EmptyResourceSet creates a new empty resource set.
+func EmptyResourceSet() ResourceSet {
+	return ResourceSet{
+		kinds: [multigas.NumResourceKind]bool{},
+	}
+}
+
+// WithResource returns a copy of the set with the given resource weight updated.
+func (s ResourceSet) WithResource(resource multigas.ResourceKind) ResourceSet {
+	s.kinds[resource] = true
+	return s
+}
+
 // All returns all resources with non-zero weights.
-func (s ResourceSet) All() iter.Seq2[multigas.ResourceKind, ResourceWeight] {
+func (s WeightedResourceSet) All() iter.Seq2[multigas.ResourceKind, ResourceWeight] {
 	return func(yield func(multigas.ResourceKind, ResourceWeight) bool) {
 		for i, weight := range s.weights {
 			if weight != 0 {
@@ -60,7 +90,7 @@ func (s ResourceSet) All() iter.Seq2[multigas.ResourceKind, ResourceWeight] {
 
 // ResourceConstraint defines the max gas target per second for the given period for a single resource.
 type ResourceConstraint struct {
-	Resources    ResourceSet
+	Resources    WeightedResourceSet
 	Period       PeriodSecs
 	TargetPerSec uint64
 	Backlog      uint64
@@ -114,10 +144,10 @@ func NewResourceConstraints() *ResourceConstraints {
 // Set adds or updates the given resource constraint.
 // The set of resources and the period are the key that defines the constraint.
 func (rc *ResourceConstraints) Set(
-	resources ResourceSet, periodSecs PeriodSecs, targetPerSec uint64,
+	resources WeightedResourceSet, periodSecs PeriodSecs, targetPerSec uint64,
 ) {
 	key := constraintKey{
-		resources: resources,
+		resources: resources.WithoutWeights(),
 		period:    periodSecs,
 	}
 	constraint := &ResourceConstraint{

arbos/constraints/constraints_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func TestResourceSetWithResource(t *testing.T) {
-	s := EmptyResourceSet().
+	s := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1).
 		WithResource(multigas.ResourceKindStorageAccess, 2)
 	for resource, weight := range s.All() {
@@ -23,7 +23,7 @@ func TestResourceSetWithResource(t *testing.T) {
 }
 
 func TestResourceSetGetResources(t *testing.T) {
-	s := EmptyResourceSet().
+	s := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1).
 		WithResource(multigas.ResourceKindStorageAccess, 1)
 
@@ -41,20 +41,22 @@ func TestResourceSetGetResources(t *testing.T) {
 }
 
 func TestOverrideResourceWeights(t *testing.T) {
-	s := EmptyResourceSet().
+	s := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1).
 		WithResource(multigas.ResourceKindStorageAccess, 2)
 	require.Equal(t, ResourceWeight(1), s.weights[multigas.ResourceKindComputation])
 	require.Equal(t, ResourceWeight(2), s.weights[multigas.ResourceKindStorageAccess])
+	used := s.WithoutWeights()
 
 	s = s.WithResource(multigas.ResourceKindComputation, 3).
-		WithResource(multigas.ResourceKindStorageAccess, 0)
+		WithResource(multigas.ResourceKindStorageAccess, 10)
 	require.Equal(t, ResourceWeight(3), s.weights[multigas.ResourceKindComputation])
-	require.False(t, s.HasResource(multigas.ResourceKindStorageAccess))
+	require.Equal(t, ResourceWeight(10), s.weights[multigas.ResourceKindStorageAccess])
+	require.Equal(t, used, s.WithoutWeights())
 }
 
 func TestAddToBacklog(t *testing.T) {
-	resources := EmptyResourceSet().
+	resources := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1).
 		WithResource(multigas.ResourceKindStorageAccess, 1)
 	c := &ResourceConstraint{
@@ -78,7 +80,7 @@ func TestAddToBacklog(t *testing.T) {
 }
 
 func TestAddToBacklogWithWeights(t *testing.T) {
-	resources := EmptyResourceSet().
+	resources := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 2).
 		WithResource(multigas.ResourceKindStorageAccess, 3)
 	c := &ResourceConstraint{
@@ -125,14 +127,14 @@ func TestNewResourceConstraints(t *testing.T) {
 
 func TestSetResourceConstraints(t *testing.T) {
 	rc := NewResourceConstraints()
-	resources := EmptyResourceSet().
+	resources := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1)
 	periodSecs := PeriodSecs(10)
 	targetPerSec := uint64(100)
 
 	rc.Set(resources, periodSecs, targetPerSec)
 
-	constraint := rc.Get(resources, periodSecs)
+	constraint := rc.Get(resources.WithoutWeights(), periodSecs)
 	require.NotNil(t, constraint)
 	require.Equal(t, resources, constraint.Resources)
 	require.Equal(t, periodSecs, constraint.Period)
@@ -141,57 +143,57 @@ func TestSetResourceConstraints(t *testing.T) {
 
 func TestGetResourceConstraints(t *testing.T) {
 	rc := NewResourceConstraints()
-	resources := EmptyResourceSet().
+	resources := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1)
 	periodSecs := PeriodSecs(10)
 	targetPerSec := uint64(100)
 
 	rc.Set(resources, periodSecs, targetPerSec)
 
 	// Test getting an existing constraint
-	constraint := rc.Get(resources, periodSecs)
+	constraint := rc.Get(resources.WithoutWeights(), periodSecs)
 	require.NotNil(t, constraint)
 	require.Equal(t, resources, constraint.Resources)
 	require.Equal(t, periodSecs, constraint.Period)
 	require.Equal(t, targetPerSec, constraint.TargetPerSec)
 	require.Equal(t, uint64(0), constraint.Backlog)
 
 	// Test getting a non-existent constraint
-	nonExistentResources := EmptyResourceSet().
+	nonExistentResources := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindStorageAccess, 1)
-	constraint = rc.Get(nonExistentResources, periodSecs)
+	constraint = rc.Get(nonExistentResources.WithoutWeights(), periodSecs)
 	require.Nil(t, constraint)
 }
 
 func TestClearResourceConstraints(t *testing.T) {
 	rc := NewResourceConstraints()
-	resources := EmptyResourceSet().
+	resources := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1)
 	periodSecs := PeriodSecs(10)
 	targetPerSec := uint64(100)
 
 	rc.Set(resources, periodSecs, targetPerSec)
 
 	// Ensure the constraint was set
-	constraint := rc.Get(resources, periodSecs)
+	constraint := rc.Get(resources.WithoutWeights(), periodSecs)
 	require.NotNil(t, constraint)
 
 	// Clear the constraint
-	rc.Clear(resources, periodSecs)
+	rc.Clear(resources.WithoutWeights(), periodSecs)
 
 	// Ensure the constraint is gone
-	constraint = rc.Get(resources, periodSecs)
+	constraint = rc.Get(resources.WithoutWeights(), periodSecs)
 	require.Nil(t, constraint)
 }
 
 func TestAllResourceConstraints(t *testing.T) {
 	rc := NewResourceConstraints()
-	resources1 := EmptyResourceSet().
+	resources1 := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1)
 	periodSecs1 := PeriodSecs(10)
 	targetPerSec1 := uint64(100)
 
-	resources2 := EmptyResourceSet().
+	resources2 := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindStorageAccess, 1)
 	periodSecs2 := PeriodSecs(20)
 	targetPerSec2 := uint64(200)

arbos/constraints/storage.go

@@ -100,7 +100,7 @@ func (src *StorageResourceConstraints) Load() (*ResourceConstraints, error) {
 	rc := NewResourceConstraints()
 	for _, c := range payload.Constraints {
 		rc.Set(c.Resources, c.Period, c.TargetPerSec)
-		ptr := rc.Get(c.Resources, c.Period)
+		ptr := rc.Get(c.Resources.WithoutWeights(), c.Period)
 		ptr.Backlog = c.Backlog
 	}
 	return rc, nil
@@ -131,7 +131,7 @@ func (src *StorageResourceConstraints) Write(rc *ResourceConstraints) error {
 }
 
 // SetConstraint adds or updates a resource constraint in storage.
-func (src *StorageResourceConstraints) SetConstraint(resources ResourceSet, periodSecs uint32, targetPerSec uint64) error {
+func (src *StorageResourceConstraints) SetConstraint(resources WeightedResourceSet, periodSecs uint32, targetPerSec uint64) error {
 	rc, err := src.Load()
 	if err != nil {
 		return err

arbos/constraints/storage_test.go

@@ -34,10 +34,10 @@ func TestStorageResourceConstraintsRLPRoundTrip(t *testing.T) {
 			name: "SimpleResourceConstraints",
 			buildFunc: func() *ResourceConstraints {
 				rc := NewResourceConstraints()
-				res := EmptyResourceSet().
+				res := NewWeightedResourceSet().
 					WithResource(multigas.ResourceKindComputation, 1)
 				rc.Set(res, PeriodSecs(10), 5_000_000)
-				rc.Get(res, PeriodSecs(10)).Backlog = 12
+				rc.Get(res.WithoutWeights(), PeriodSecs(10)).Backlog = 12
 				return rc
 			},
 		},
@@ -46,17 +46,17 @@ func TestStorageResourceConstraintsRLPRoundTrip(t *testing.T) {
 			buildFunc: func() *ResourceConstraints {
 				rc := NewResourceConstraints()
 
-				res1 := EmptyResourceSet().
+				res1 := NewWeightedResourceSet().
 					WithResource(multigas.ResourceKindComputation, 1).
 					WithResource(multigas.ResourceKindHistoryGrowth, 2)
 				rc.Set(res1, PeriodSecs(12), 7_000_000)
-				rc.Get(res1, PeriodSecs(12)).Backlog = 42
+				rc.Get(res1.WithoutWeights(), PeriodSecs(12)).Backlog = 42
 
-				res2 := EmptyResourceSet().
+				res2 := NewWeightedResourceSet().
 					WithResource(multigas.ResourceKindWasmComputation, 3).
 					WithResource(multigas.ResourceKindStorageGrowth, 5)
 				rc.Set(res2, PeriodSecs(60), 3_500_000)
-				rc.Get(res2, PeriodSecs(60)).Backlog = 99
+				rc.Get(res2.WithoutWeights(), PeriodSecs(60)).Backlog = 99
 
 				return rc
 			},
@@ -110,10 +110,10 @@ func TestStorageResourceConstraintsRLPRoundTrip(t *testing.T) {
 
 func TestStorageResourceConstraintsRLPBacklogPersistence(t *testing.T) {
 	rc := NewResourceConstraints()
-	res := EmptyResourceSet().
+	res := NewWeightedResourceSet().
 		WithResource(multigas.ResourceKindComputation, 1)
 	rc.Set(res, PeriodSecs(30), 10_000_000)
-	ptr := rc.Get(res, PeriodSecs(30))
+	ptr := rc.Get(res.WithoutWeights(), PeriodSecs(30))
 	ptr.Backlog = 12345 // initial backlog value
 
 	store := &mockStorageBytes{}
@@ -153,3 +153,33 @@ func TestStorageResourceConstraintsEmptyLoad(t *testing.T) {
 	require.NotNil(t, loaded, "Load() returned nil ResourceConstraints")
 	require.Empty(t, loaded.constraints, "Loaded ResourceConstraints should be empty")
 }
+
+func TestStorageDoesNotDependOnWeights(t *testing.T) {
+	store := &mockStorageBytes{}
+	src := NewStorageResourceConstraints(store)
+
+	res1 := NewWeightedResourceSet().
+		WithResource(multigas.ResourceKindComputation, 1).
+		WithResource(multigas.ResourceKindStorageAccess, 2)
+
+	err := src.SetConstraint(res1, 200, 10_000_000)
+	require.NoError(t, err)
+
+	list, err := src.ListConstraints()
+	require.NoError(t, err)
+	require.Len(t, list, 1)
+	require.Equal(t, res1, list[0].Resources)
+
+	res2 := NewWeightedResourceSet().
+		WithResource(multigas.ResourceKindComputation, 50).
+		WithResource(multigas.ResourceKindStorageAccess, 10)
+
+	// with same period should override existing entity
+	err = src.SetConstraint(res2, 200, 1_000_000)
+	require.NoError(t, err)
+
+	list, err = src.ListConstraints()
+	require.NoError(t, err)
+	require.Len(t, list, 1)
+	require.Equal(t, res2, list[0].Resources)
+}

precompiles/ArbGasInfo.go

@@ -287,9 +287,9 @@ func (con ArbGasInfo) GetLastL1PricingSurplus(c ctx, evm mech) (*big.Int, error)
 
 // Lists all resource constraints currently configured in ArbOS.
 func (con ArbGasInfo) ListResourceConstraints(c ctx, evm mech) ([]resourceConstraint, error) {
-	constraints, err := c.State.ResourceConstraints().ListConstraints()
+	rcs, err := c.State.ResourceConstraints().ListConstraints()
 	if err != nil {
 		return nil, err
 	}
-	return fromArbOsResourceConstraints(constraints), nil
+	return fromArbOsResourceConstraints(rcs), nil
 }

precompiles/ArbOwner.go

@@ -456,15 +456,15 @@ func (con ArbOwner) SetCalldataPriceIncrease(c ctx, _ mech, enable bool) error {
 
 // SetResourceConstraint adds or updates a resource constraint with specified resource kinds and weights
 func (con ArbOwner) SetResourceConstraint(c ctx, evm mech, resources []resourceWeight, periodSecs uint32, targetPerSec uint64) error {
-	res, err := toArbOsResourceSet(resources)
+	res, err := toArbOsWeightedResourceSet(resources)
 	if err != nil {
 		return err
 	}
 	return c.State.ResourceConstraints().SetConstraint(res, periodSecs, targetPerSec)
 }
 
 // ClearConstraint removes a resource constraint
-func (con ArbOwner) ClearConstraint(c ctx, evm mech, resources []resourceWeight, periodSecs uint32) error {
+func (con ArbOwner) ClearConstraint(c ctx, evm mech, resources []uint8, periodSecs uint32) error {
 	res, err := toArbOsResourceSet(resources)
 	if err != nil {
 		return err