Adjust pricing formula with weight normalisation by max

Author: MishkaRogachev

arbos/l2pricing/l2pricing.go

@@ -201,8 +201,15 @@ func (ps *L2PricingState) setMultiGasConstraintsFromSingleGasConstraints() error
 			return fmt.Errorf("failed to read backlog from constraint %d: %w", i, err)
 		}
 
-		// Transfer with only computation resource weight to match single-gas constraint scale.
-		weights := map[uint8]uint64{uint8(multigas.ResourceKindComputation): 1}
+		// Transfer to multi-gas constraint with equal weights
+		weights := map[uint8]uint64{
+			uint8(multigas.ResourceKindComputation):     1,
+			uint8(multigas.ResourceKindHistoryGrowth):   1,
+			uint8(multigas.ResourceKindStorageAccess):   1,
+			uint8(multigas.ResourceKindStorageGrowth):   1,
+			uint8(multigas.ResourceKindL2Calldata):      1,
+			uint8(multigas.ResourceKindWasmComputation): 1,
+		}
 
 		var adjustmentWindow uint32
 		if window > math.MaxUint32 {

arbos/l2pricing/model.go

@@ -305,14 +305,14 @@ func (ps *L2PricingState) CalcMultiGasConstraintsExponents() ([multigas.NumResou
 			if err != nil {
 				return [multigas.NumResourceKind]arbmath.Bips{}, err
 			}
-			sumWeights, err := constraint.SumWeights()
+			maxWeight, err := constraint.MaxWeight()
 			if err != nil {
 				return [multigas.NumResourceKind]arbmath.Bips{}, err
 			}
 
 			divisor := arbmath.SaturatingCastToBips(
 				arbmath.SaturatingUMul(uint64(adjustmentWindow),
-					arbmath.SaturatingUMul(target, sumWeights)))
+					arbmath.SaturatingUMul(target, maxWeight)))
 
 			usedResources, err := constraint.UsedResources()
 			if err != nil {

arbos/l2pricing/multi_gas_constraint.go

@@ -21,7 +21,7 @@ const (
 	targetOffset uint64 = iota
 	adjustmentWindowOffset
 	backlogOffset
-	sumWeightsOffset
+	maxWeightOffset
 	weightedResourcesBaseOffset
 )
 
@@ -31,7 +31,7 @@ type MultiGasConstraint struct {
 	target            storage.StorageBackedUint64
 	adjustmentWindow  storage.StorageBackedUint32
 	backlog           storage.StorageBackedUint64
-	sumWeights        storage.StorageBackedUint64
+	maxWeight         storage.StorageBackedUint64
 	weightedResources [multigas.NumResourceKind]storage.StorageBackedUint64
 }
 
@@ -41,7 +41,7 @@ func OpenMultiGasConstraint(sto *storage.Storage) *MultiGasConstraint {
 		target:           sto.OpenStorageBackedUint64(targetOffset),
 		adjustmentWindow: sto.OpenStorageBackedUint32(adjustmentWindowOffset),
 		backlog:          sto.OpenStorageBackedUint64(backlogOffset),
-		sumWeights:       sto.OpenStorageBackedUint64(sumWeightsOffset),
+		maxWeight:        sto.OpenStorageBackedUint64(maxWeightOffset),
 	}
 	for i := range int(multigas.NumResourceKind) {
 		// #nosec G115 safe: NumResourceKind < 2^32
@@ -62,7 +62,7 @@ func (c *MultiGasConstraint) Clear() error {
 	if err := c.backlog.Clear(); err != nil {
 		return err
 	}
-	if err := c.sumWeights.Clear(); err != nil {
+	if err := c.maxWeight.Clear(); err != nil {
 		return err
 	}
 	for i := range int(multigas.NumResourceKind) {
@@ -75,12 +75,14 @@ func (c *MultiGasConstraint) Clear() error {
 
 // SetResourceWeights assigns per-resource weight multipliers for this constraint.
 func (c *MultiGasConstraint) SetResourceWeights(weights map[uint8]uint64) error {
-	var total uint64
+	var maxWeight uint64
 	for kind, weight := range weights {
 		if _, err := multigas.CheckResourceKind(kind); err != nil {
 			return err
 		}
-		total = arbmath.SaturatingUAdd(total, weight)
+		if weight > maxWeight {
+			maxWeight = weight
+		}
 	}
 	for i := range int(multigas.NumResourceKind) {
 		// #nosec G115 safe: NumResourceKind < 2^32
@@ -89,7 +91,7 @@ func (c *MultiGasConstraint) SetResourceWeights(weights map[uint8]uint64) error
 			return err
 		}
 	}
-	return c.sumWeights.Set(total)
+	return c.maxWeight.Set(maxWeight)
 }
 
 // GrowBacklog adds the resource usage in multiGas to this constraint's backlog.
@@ -156,8 +158,8 @@ func (c *MultiGasConstraint) ResourceWeight(kind uint8) (uint64, error) {
 	return c.weightedResources[kind].Get()
 }
 
-func (c *MultiGasConstraint) SumWeights() (uint64, error) {
-	return c.sumWeights.Get()
+func (c *MultiGasConstraint) MaxWeight() (uint64, error) {
+	return c.maxWeight.Get()
 }
 
 func (c *MultiGasConstraint) ResourcesWithWeights() (map[multigas.ResourceKind]uint64, error) {

arbos/l2pricing/multi_gas_constraint_test.go

@@ -52,9 +52,9 @@ func TestMultiGasConstraint(t *testing.T) {
 	require.Contains(t, used, multigas.ResourceKindComputation)
 	require.Contains(t, used, multigas.ResourceKindStorageAccess)
 
-	weights, err := c.SumWeights()
+	maxWeight, err := c.MaxWeight()
 	require.NoError(t, err)
-	require.Equal(t, uint64(30), weights)
+	require.Equal(t, uint64(20), maxWeight)
 
 	require.NoError(t, c.Clear())
 	target, _ = c.Target()
@@ -68,9 +68,9 @@ func TestMultiGasConstraint(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, used, 0)
 
-	weights, err = c.SumWeights()
+	maxWeight, err = c.MaxWeight()
 	require.NoError(t, err)
-	require.Equal(t, uint64(0), weights)
+	require.Equal(t, uint64(0), maxWeight)
 }
 
 func TestMultiGasConstraintResourceWeightsValidation(t *testing.T) {
@@ -90,9 +90,9 @@ func TestMultiGasConstraintResourceWeightsValidation(t *testing.T) {
 	}
 	require.NoError(t, c.SetResourceWeights(valid))
 
-	total, err := c.sumWeights.Get()
+	maxWeight, err := c.maxWeight.Get()
 	require.NoError(t, err)
-	require.Equal(t, uint64(10), total)
+	require.Equal(t, uint64(7), maxWeight)
 }
 
 func TestMultiGasConstraintBacklogAggregation(t *testing.T) {