Improve retryable tests and return back GasConstraintsMaxNum

Author: MishkaRogachev

arbos/l2pricing/l2pricing.go

@@ -46,6 +46,10 @@ var multigasConstraintsKey []byte = []byte{1}
 
 const GethBlockGasLimit = 1 << 50
 
+// Number of single-gas constraints limited because of retryable redeem gas cost calculation.
+// The limit is ignored starting from ArbOS version 60.
+const GasConstraintsMaxNum = 20
+
 // MaxPricingExponentBips caps the basefee growth: exp(8.5) ~= x5,000 min base fee.
 const MaxPricingExponentBips = arbmath.Bips(85_000)
 

precompiles/ArbOwner.go

@@ -462,6 +462,13 @@ func (con ArbOwner) SetGasBacklog(c ctx, evm mech, backlog uint64) error {
 
 // SetGasPricingConstraints sets the gas pricing constraints used by the multi-constraint pricing model
 func (con ArbOwner) SetGasPricingConstraints(c ctx, evm mech, constraints [][3]uint64) error {
+	if c.State.ArbOSVersion() < params.ArbosVersion_60 {
+		limit := l2pricing.GasConstraintsMaxNum
+		if len(constraints) > limit {
+			return fmt.Errorf("too many constraints. Max: %d", limit)
+		}
+	}
+
 	err := c.State.L2PricingState().ClearGasConstraints()
 	if err != nil {
 		return fmt.Errorf("failed to clear existing constraints: %w", err)

precompiles/ArbRetryableTx.go

@@ -100,17 +100,17 @@ func (con ArbRetryableTx) Redeem(c ctx, evm mech, ticketId bytes32) (bytes32, er
 	gasCostToReturnResult := params.CopyGas
 
 	// `redeem` must prepay the gas needed by the trailing call to
-	// L2PricingState().AddToGasPool(). BacklogUpdateCost() returns
-	// that amount based on the storage read/write mix used by AddToGasPool().
-	gasPoolUpdateCost := uint64(0)
+	// L2PricingState().ShrinkBacklog(). BacklogUpdateCost() returns
+	// that amount based on the storage read/write mix used by ShrinkBacklog().
+	backlogUpdateCost := uint64(0)
 	if c.State.L2PricingState().ArbosVersion >= params.ArbosVersion_60 {
 		// Charge static price for any pricer starting from ArbOS 60
-		gasPoolUpdateCost = l2pricing.ArbOS60StaticBacklogUpdateCost
+		backlogUpdateCost = l2pricing.ArbOS60StaticBacklogUpdateCost
 	} else {
-		gasPoolUpdateCost = c.State.L2PricingState().BacklogUpdateCost()
+		backlogUpdateCost = c.State.L2PricingState().BacklogUpdateCost()
 	}
 
-	futureGasCosts := eventCost + gasCostToReturnResult + gasPoolUpdateCost
+	futureGasCosts := eventCost + gasCostToReturnResult + backlogUpdateCost
 	if c.GasLeft() < futureGasCosts {
 		return hash{}, c.Burn(multigas.ResourceKindComputation, futureGasCosts) // this will error
 	}
@@ -139,7 +139,7 @@ func (con ArbRetryableTx) Redeem(c ctx, evm mech, ticketId bytes32) (bytes32, er
 
 	// Add the gasToDonate back to the gas pool: the retryable attempt will then consume it.
 	// This ensures that the gas pool has enough gas to run the retryable attempt.
-	// Starting from ArbOS 60, we don't charge gas for the AddToGasPool call here
+	// Starting from ArbOS 60, we don't charge gas for the ShrinkBacklog call here
 	if c.State.L2PricingState().ArbosVersion >= params.ArbosVersion_60 {
 		err = c.WithUnmeteredGasAccounting(func() error {
 			return c.State.L2PricingState().ShrinkBacklog(gasToDonate, multigas.ComputationGas(gasToDonate))

precompiles/ArbRetryableTx_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbos"
 	"github.com/offchainlabs/nitro/arbos/burn"
@@ -102,7 +103,15 @@ func testRetryableRedeem(t *testing.T, evm *vm.EVM, precompileCtx *Context) {
 	}
 }
 
-func TestRetryableRedeem(t *testing.T) {
+func overrideStateArbOSVersion(evm *vm.EVM, arbosVersion uint64) error {
+	versionSlot := uint64(0)
+	version := new(big.Int).SetUint64(arbosVersion)
+	burner := burn.NewSystemBurner(nil, false)
+	sto := storage.NewGeth(evm.StateDB, burner)
+	return sto.SetByUint64(versionSlot, common.BigToHash(version))
+}
+
+func TestRetryableRedeemLegacy(t *testing.T) {
 	evm := newMockEVMForTesting()
 	precompileCtx := testContext(common.Address{}, evm)
 
@@ -116,19 +125,33 @@ func TestRetryableRedeem(t *testing.T) {
 	testRetryableRedeem(t, evm, precompileCtx)
 }
 
-func TestRetryableRedeemWithSingleGasConstraints(t *testing.T) {
+func TestRetryableRedeemLegacyArbOS60(t *testing.T) {
 	evm := newMockEVMForTesting()
+	err := overrideStateArbOSVersion(evm, params.ArbosVersion_60)
+	Require(t, err)
+
 	precompileCtx := testContext(common.Address{}, evm)
 
-	for i := range 20 {
-		// #nosec G115
-		target0 := uint64((i + 1) * 1000000)
-		// #nosec G115
-		window0 := uint64((i + 1) * 10)
-		// #nosec G115
-		backlog0 := uint64((i + 1) * 500000)
+	model, err := precompileCtx.State.L2PricingState().GasModelToUse()
+	Require(t, err)
 
-		err := precompileCtx.State.L2PricingState().AddGasConstraint(target0, window0, backlog0)
+	if model != l2pricing.GasModelLegacy {
+		Fail(t, "should use legacy model")
+	}
+
+	testRetryableRedeem(t, evm, precompileCtx)
+}
+
+func TestRetryableRedeemWithGasConstraints(t *testing.T) {
+	evm := newMockEVMForTesting()
+	precompileCtx := testContext(common.Address{}, evm)
+
+	for i := range uint64(l2pricing.GasConstraintsMaxNum) {
+		target := (i + 1) * 1000000
+		window := (i + 1) * 10
+		backlog := (i + 1) * 500000
+
+		err := precompileCtx.State.L2PricingState().AddGasConstraint(target, window, backlog)
 		Require(t, err)
 	}
 
@@ -142,19 +165,39 @@ func TestRetryableRedeemWithSingleGasConstraints(t *testing.T) {
 	testRetryableRedeem(t, evm, precompileCtx)
 }
 
-func TestRetryableRedeemWithMultiGasConstraints(t *testing.T) {
+func TestRetryableRedeemWithGasConstraintsArbOS60(t *testing.T) {
 	evm := newMockEVMForTesting()
+	err := overrideStateArbOSVersion(evm, params.ArbosVersion_60)
+	Require(t, err)
+
 	precompileCtx := testContext(common.Address{}, evm)
-	precompileCtx.State.L2PricingState().ArbosVersion = l2pricing.ArbosMultiGasConstraintsVersion
 
-	// Override default ArbOS varsion in the database
-	versionSlot := uint64(0)
-	version := new(big.Int).SetUint64(l2pricing.ArbosMultiGasConstraintsVersion)
-	burner := burn.NewSystemBurner(nil, false)
-	sto := storage.NewGeth(evm.StateDB, burner)
-	err := sto.SetByUint64(versionSlot, common.BigToHash(version))
+	for i := range uint64(100) {
+		target := (i + 1) * 1000000
+		window := (i + 1) * 10
+		backlog := (i + 1) * 500000
+
+		err := precompileCtx.State.L2PricingState().AddGasConstraint(target, window, backlog)
+		Require(t, err)
+	}
+
+	model, err := precompileCtx.State.L2PricingState().GasModelToUse()
 	Require(t, err)
 
+	if model != l2pricing.GasModelSingleGasConstraints {
+		Fail(t, "should use single-gas constraints model")
+	}
+
+	testRetryableRedeem(t, evm, precompileCtx)
+}
+
+func TestRetryableRedeemWithMultiGasConstraints(t *testing.T) {
+	evm := newMockEVMForTesting()
+	err := overrideStateArbOSVersion(evm, l2pricing.ArbosMultiGasConstraintsVersion)
+	Require(t, err)
+
+	precompileCtx := testContext(common.Address{}, evm)
+
 	for i := range 100 {
 		// #nosec G115
 		target := uint64((i + 1) * 1000000)