Refactor and improve multi-gas price calculations

Author: MishkaRogachev

arbos/constraints/multi_dimensional.go

@@ -93,50 +93,6 @@ func (c *MultiGasConstraint) SetResourceWeights(weights map[uint8]uint64) error
 	return c.sumWeights.Set(total)
 }
 
-// ComputeExponent returns the exponent of the given constraint for the given resource kind.
-func (c *MultiGasConstraint) ComputeExponent(kind uint8) (arbmath.Bips, error) {
-	if _, err := multigas.CheckResourceKind(kind); err != nil {
-		return 0, err
-	}
-
-	weight, err := c.weightedResources[int(kind)].Get()
-	if err != nil {
-		return 0, err
-	}
-	if weight == 0 {
-		return 0, nil
-	}
-
-	backlog, err := c.backlog.Get()
-	if err != nil || backlog == 0 {
-		return 0, err
-	}
-
-	target, err := c.target.Get()
-	if err != nil || target == 0 {
-		return 0, err
-	}
-
-	adjustmentWindow, err := c.adjustmentWindow.Get()
-	if err != nil || adjustmentWindow == 0 {
-		return 0, err
-	}
-
-	sumWeights, err := c.sumWeights.Get()
-	if err != nil || sumWeights == 0 {
-		return 0, err
-	}
-
-	dividend := arbmath.NaturalToBips(
-		arbmath.SaturatingCast[int64](arbmath.SaturatingUMul(backlog, weight)))
-	divisor := arbmath.SaturatingCastToBips(
-		arbmath.SaturatingUMul(uint64(adjustmentWindow),
-			arbmath.SaturatingUMul(target, sumWeights)))
-	exponent := dividend / divisor
-
-	return exponent, nil
-}
-
 // IncrementBacklog increments the constraint backlog based on multi-dimensional gas usage
 func (c *MultiGasConstraint) IncrementBacklog(multiGas multigas.MultiGas) error {
 	totalBacklog, err := c.backlog.Get()
@@ -218,6 +174,10 @@ 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) ResourcesWithWeights() (map[multigas.ResourceKind]uint64, error) {
 	result := make(map[multigas.ResourceKind]uint64)
 	for i := range uint8(multigas.NumResourceKind) {
@@ -231,3 +191,17 @@ func (c *MultiGasConstraint) ResourcesWithWeights() (map[multigas.ResourceKind]u
 	}
 	return result, nil
 }
+
+func (c *MultiGasConstraint) UsedResources() ([]multigas.ResourceKind, error) {
+	var result []multigas.ResourceKind
+	for i := range uint8(multigas.NumResourceKind) {
+		weight, err := c.weightedResources[i].Get()
+		if err != nil {
+			return nil, err
+		}
+		if weight != 0 {
+			result = append(result, multigas.ResourceKind(i))
+		}
+	}
+	return result, nil
+}

arbos/constraints/multi_dimensional_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/offchainlabs/nitro/arbos/burn"
 	"github.com/offchainlabs/nitro/arbos/storage"
-	"github.com/offchainlabs/nitro/util/arbmath"
 )
 
 func TestMultiGasConstraint(t *testing.T) {
@@ -27,11 +26,11 @@ func TestMultiGasConstraint(t *testing.T) {
 	require.Equal(t, uint32(456), window)
 	require.Equal(t, uint64(789), backlog)
 
-	weights := map[uint8]uint64{
+	weightedResources := map[uint8]uint64{
 		uint8(multigas.ResourceKindComputation):   10,
 		uint8(multigas.ResourceKindStorageAccess): 20,
 	}
-	require.NoError(t, c.SetResourceWeights(weights))
+	require.NoError(t, c.SetResourceWeights(weightedResources))
 
 	w1, _ := c.ResourceWeight(uint8(multigas.ResourceKindComputation))
 	w2, _ := c.ResourceWeight(uint8(multigas.ResourceKindStorageAccess))
@@ -44,13 +43,31 @@ func TestMultiGasConstraint(t *testing.T) {
 	require.Equal(t, uint64(10), res[multigas.ResourceKindComputation])
 	require.Equal(t, uint64(20), res[multigas.ResourceKindStorageAccess])
 
+	used, err := c.UsedResources()
+	require.NoError(t, err)
+	require.Len(t, used, 2)
+	require.Contains(t, used, multigas.ResourceKindComputation)
+	require.Contains(t, used, multigas.ResourceKindStorageAccess)
+
+	weights, err := c.SumWeights()
+	require.NoError(t, err)
+	require.Equal(t, uint64(30), weights)
+
 	require.NoError(t, c.Clear())
 	target, _ = c.Target()
 	backlog, _ = c.Backlog()
 	require.Zero(t, target)
 	require.Zero(t, backlog)
 	res, _ = c.ResourcesWithWeights()
 	require.Empty(t, res)
+
+	used, err = c.UsedResources()
+	require.NoError(t, err)
+	require.Len(t, used, 0)
+
+	weights, err = c.SumWeights()
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), weights)
 }
 
 func TestMultiGasConstraintResourceWeightsValidation(t *testing.T) {
@@ -75,7 +92,7 @@ func TestMultiGasConstraintResourceWeightsValidation(t *testing.T) {
 	require.Equal(t, uint64(10), total)
 }
 
-func TestMultiGasConstraintBacklogAggregationAndComputeExponent(t *testing.T) {
+func TestMultiGasConstraintBacklogAggregation(t *testing.T) {
 	sto := storage.NewMemoryBacked(burn.NewSystemBurner(nil, false))
 	c := OpenMultiGasConstraint(sto)
 
@@ -93,25 +110,6 @@ func TestMultiGasConstraintBacklogAggregationAndComputeExponent(t *testing.T) {
 	)
 
 	require.NoError(t, c.IncrementBacklog(mg))
-
-	backlog, err := c.Backlog()
-	require.NoError(t, err)
-	require.Equal(t, uint64(30), backlog) // 1*10 + 2*10 = 30
-
-	compExp, err := c.ComputeExponent(uint8(multigas.ResourceKindComputation))
-	require.NoError(t, err)
-	storExp, err := c.ComputeExponent(uint8(multigas.ResourceKindStorageAccess))
-	require.NoError(t, err)
-
-	// expected: backlog * weight / (A * T * sumWeights)
-	// backlog=30, target=5, window=2, sumWeights=3
-	// computation: (30*1)/(2*5*3) = 1
-	// storage:     (30*2)/(2*5*3) = 2
-	require.Equal(t, arbmath.Bips(10000), compExp)
-	require.Equal(t, arbmath.Bips(20000), storExp)
-
-	// ratio must reflect weights (1:2)
-	require.Equal(t, 2*compExp, storExp)
 }
 
 func TestMultiGasConstraintBacklogGrowth(t *testing.T) {

arbos/l2pricing/l2pricing.go

@@ -5,8 +5,11 @@ package l2pricing
 
 import (
 	"fmt"
+	"math"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/arbitrum/multigas"
+
 	"github.com/offchainlabs/nitro/arbos/constraints"
 	"github.com/offchainlabs/nitro/arbos/storage"
 	"github.com/offchainlabs/nitro/util/arbmath"
@@ -41,7 +44,7 @@ var gasConstraintsKey []byte = []byte{0}
 var multigasConstraintsKey []byte = []byte{1}
 
 const GethBlockGasLimit = 1 << 50
-const MaxExponentBips = arbmath.Bips(85_000)
+const MaxPricingExponentBips = arbmath.Bips(85_000)
 
 func InitializeL2PricingState(sto *storage.Storage) error {
 	_ = sto.SetUint64ByUint64(speedLimitPerSecondOffset, InitialSpeedLimitPerSecondV0)
@@ -164,6 +167,59 @@ func (ps *L2PricingState) setGasConstraintsFromLegacy() error {
 	return ps.AddGasConstraint(target, adjustmentWindow, backlog)
 }
 
+func (ps *L2PricingState) setMultiGasConstraintsFromSingleGasConstraints() error {
+	if err := ps.ClearMultiGasConstraints(); err != nil {
+		return err
+	}
+
+	length, err := ps.GasConstraintsLength()
+	if err != nil {
+		return err
+	}
+
+	for i := range length {
+		c := ps.OpenGasConstraintAt(i)
+
+		target, err := c.Target()
+		if err != nil {
+			return fmt.Errorf("failed to read target from constraint %d: %w", i, err)
+		}
+		window, err := c.AdjustmentWindow()
+		if err != nil {
+			return fmt.Errorf("failed to read adjustment window from constraint %d: %w", i, err)
+		}
+		backlog, err := c.Backlog()
+		if err != nil {
+			return fmt.Errorf("failed to read backlog from constraint %d: %w", i, err)
+		}
+
+		// NOTE: this code kept for pricing algorithm without wight normalization
+		//
+		// resourceWeights := make(map[uint8]uint64, len(FeeRelevantResourceKinds))
+		// for _, kind := range FeeRelevantResourceKinds {
+		// 	resourceWeights[uint8(kind)] = 1
+		// }
+		resourceWeights := map[uint8]uint64{uint8(multigas.ResourceKindComputation): 1}
+
+		var uint32Window uint32
+		if window > math.MaxUint32 {
+			uint32Window = math.MaxUint32
+		} else {
+			uint32Window = uint32(window)
+		}
+
+		if err := ps.AddMultiGasConstraint(
+			target,
+			uint32Window,
+			backlog,
+			resourceWeights,
+		); err != nil {
+			return fmt.Errorf("failed to add multi-gas constraint %d: %w", i, err)
+		}
+	}
+	return nil
+}
+
 func (ps *L2PricingState) AddGasConstraint(target uint64, adjustmentWindow uint64, backlog uint64) error {
 	subStorage, err := ps.gasConstraints.Push()
 	if err != nil {
@@ -240,17 +296,6 @@ func (ps *L2PricingState) AddMultiGasConstraint(
 	if err := constraint.SetResourceWeights(resourceWeights); err != nil {
 		return fmt.Errorf("failed to set resource weights: %w", err)
 	}
-
-	for kind := range resourceWeights {
-		exp, err := constraint.ComputeExponent(kind)
-		if err != nil {
-			return fmt.Errorf("failed to compute exponent for resource kind %v: %w", kind, err)
-		}
-		if exp > MaxExponentBips {
-			return fmt.Errorf("resource kind %v has exponent %v bips exceeding max of %v bips", kind, exp, MaxExponentBips)
-		}
-	}
-
 	return nil
 }
 

arbos/l2pricing/l2pricing_test.go

@@ -221,33 +221,42 @@ func TestMultiGasConstraints(t *testing.T) {
 	}
 }
 
-func TestMultiGasConstraintExponentSafety(t *testing.T) {
+func TestMultiGasConstraintsExponents(t *testing.T) {
 	pricing := PricingForTest(t)
 
-	weights := map[uint8]uint64{
-		uint8(multigas.ResourceKindComputation): 1,
-	}
-	// backlog=100, target=100, A=10 -> exponent = (100*1)/(10*100*1) = 0.01 -> safe
+	// backlog=100, target=100, A=10 -> exponent = (100*1)/(10*100*1) = 1000 bips
 	err := pricing.AddMultiGasConstraint(
 		100,
 		10,
 		100,
-		weights,
+		map[uint8]uint64{
+			uint8(multigas.ResourceKindComputation): 1,
+		},
 	)
-	if err != nil {
-		t.Fatalf("expected valid constraint, got error: %v", err)
-	}
+	Require(t, err)
 
-	// backlog very large -> exponent blows past MaxExponentBips
+	// backlog=200, target=40, A=20 -> exponent = (200*1)/(20*40*1) = 2500 bips
 	err = pricing.AddMultiGasConstraint(
-		1,
-		1,
-		1_000_000_000_000,
-		weights,
+		40,
+		20,
+		200,
+		map[uint8]uint64{
+			uint8(multigas.ResourceKindStorageAccess): 2,
+		},
 	)
+	Require(t, err)
+
+	exps, err := pricing.CalcMultiGasConstraintsExponents()
+	Require(t, err)
+
+	expected := arbmath.Bips(1000)
+	if exps[multigas.ResourceKindComputation] != expected {
+		t.Fatalf("wrong exponent: got %v, want %v", exps[multigas.ResourceKindComputation], expected)
+	}
 
-	if err == nil {
-		t.Fatalf("expected AddMultiGasConstraint to reject unsafe exponent, but got no error")
+	expected = arbmath.Bips(2500)
+	if exps[multigas.ResourceKindStorageAccess] != expected {
+		t.Fatalf("wrong exponent: got %v, want %v", exps[multigas.ResourceKindStorageAccess], expected)
 	}
 }