feat: Make minPrice and excessScalingFactor Configurable (#80)

This PR makes minPrice and excessScalingFactor Configurable, also adds a
static pricing mode. These parameters will be required by ACP-224, which
intends to set these via a system contract.

Closes: #77

---------

Signed-off-by: Ceyhun Onur <ceyhunonur54@gmail.com>
Co-authored-by: Arran Schlosberg <519948+ARR4N@users.noreply.github.com>

Author: ceyonur

blocks/block_test.go

@@ -71,7 +71,7 @@ func newChain(tb testing.TB, db ethdb.Database, xdb saedb.ExecutionResults, star
 			// The target and excess are irrelevant for the purposes of
 			// [newChain], and non-zero sub-second time for genesis is
 			// unnecessary.
-			h := &hookstest.Stub{Target: 1}
+			h := hookstest.NewStub(1)
 			require.NoError(tb, b.MarkSynchronous(h, db, xdb, 0), "MarkSynchronous()")
 		}
 

blocks/blockstest/blocks.go

@@ -133,7 +133,7 @@ func NewGenesis(tb testing.TB, db ethdb.Database, xdb saedb.ExecutionResults, co
 	require.NoErrorf(tb, tdb.Commit(hash, true), "%T.Commit(core.SetupGenesisBlock(...))", tdb)
 
 	b := NewBlock(tb, gen.ToBlock(), nil, nil)
-	h := &hookstest.Stub{Target: conf.gasTarget}
+	h := hookstest.NewStub(conf.gasTarget)
 	require.NoErrorf(tb, b.MarkSynchronous(h, db, xdb, conf.gasExcess), "%T.MarkSynchronous()", b)
 	return b
 }

blocks/execution_test.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/ava-labs/avalanchego/utils/logging"
+	"github.com/ava-labs/avalanchego/vms/components/gas"
 	"github.com/ava-labs/libevm/common"
 	"github.com/ava-labs/libevm/core/rawdb"
 	"github.com/ava-labs/libevm/core/types"
@@ -24,6 +25,7 @@ import (
 
 	"github.com/ava-labs/strevm/cmputils"
 	"github.com/ava-labs/strevm/gastime"
+	"github.com/ava-labs/strevm/hook"
 	"github.com/ava-labs/strevm/saedb"
 	"github.com/ava-labs/strevm/saetest"
 )
@@ -61,7 +63,8 @@ func TestMarkExecuted(t *testing.T) {
 	xdb := saetest.NewExecutionResultsDB()
 
 	settles := newBlock(t, newEthBlock(0, 0, nil), nil, nil)
-	settles.markExecutedForTests(t, db, xdb, gastime.New(time.Unix(0, 0), 1, 0))
+	tm := mustNewGasTime(t, time.Unix(0, 0), 1, 0, gastime.DefaultGasPriceConfig())
+	settles.markExecutedForTests(t, db, xdb, tm)
 	b := newBlock(t, ethB, nil, settles)
 
 	t.Run("before_MarkExecuted", func(t *testing.T) {
@@ -94,7 +97,7 @@ func TestMarkExecuted(t *testing.T) {
 		}
 	})
 
-	gasTime := gastime.New(time.Unix(42, 0), 1e6, 42)
+	gasTime := mustNewGasTime(t, time.Unix(42, 0), 1e6, 42, gastime.DefaultGasPriceConfig())
 	wallTime := time.Unix(42, 100)
 	stateRoot := common.Hash{'s', 't', 'a', 't', 'e'}
 	baseFee := uint256.NewInt(314159)
@@ -191,3 +194,10 @@ func TestMarkExecuted(t *testing.T) {
 type selfAsHasher common.Hash
 
 func (h selfAsHasher) Hash() common.Hash { return common.Hash(h) }
+
+func mustNewGasTime(tb testing.TB, at time.Time, target, excess gas.Gas, gasPriceConfig hook.GasPriceConfig) *gastime.Time {
+	tb.Helper()
+	tm, err := gastime.New(at, target, excess, gasPriceConfig)
+	require.NoError(tb, err, "gastime.New()")
+	return tm
+}

blocks/settlement.go

@@ -91,12 +91,20 @@ func (b *Block) MarkSynchronous(hooks hook.Points, db ethdb.Database, xdb saedb.
 	// itself. As the only reason to pass receipts here is for later settlement
 	// in another block, there is no need to pass anything meaningful as it
 	// would also require them to be received as an argument to MarkSynchronous.
+	target, cfg := hooks.GasConfigAfter(b.Header())
+	execTime, err := gastime.New(
+		PreciseTime(hooks, b.Header()),
+		// Target, excess, and config _after_ are a requirement of
+		// [Block.MarkExecuted].
+		target,
+		excessAfter,
+		cfg,
+	)
+	if err != nil {
+		return err
+	}
 	e := &executionResults{
-		byGas: *gastime.New(
-			PreciseTime(hooks, b.Header()),
-			hooks.GasTargetAfter(b.Header()), // target _after_ is a requirement of [Block.MarkExecuted]
-			excessAfter,
-		),
+		byGas:         *execTime.Clone(),
 		receiptRoot:   ethB.ReceiptHash(),
 		stateRootPost: ethB.Root(),
 	}

blocks/settlement_test.go

@@ -59,7 +59,8 @@ func TestSettlementInvariants(t *testing.T) {
 	db := rawdb.NewMemoryDatabase()
 	xdb := saetest.NewExecutionResultsDB()
 	for _, b := range []*Block{b, parent, lastSettled} {
-		b.markExecutedForTests(t, db, xdb, gastime.New(preciseTime(b.Header(), 0), 1, 0))
+		tm := mustNewGasTime(t, preciseTime(b.Header(), 0), 1, 0, gastime.DefaultGasPriceConfig())
+		b.markExecutedForTests(t, db, xdb, tm)
 	}
 
 	t.Run("before_MarkSettled", func(t *testing.T) {
@@ -226,7 +227,7 @@ func TestLastToSettleAt(t *testing.T) {
 		}
 	})
 
-	tm := gastime.New(time.Unix(0, 0), 5 /*target*/, 0)
+	tm := mustNewGasTime(t, time.Unix(0, 0), 5 /*target*/, 0, gastime.DefaultGasPriceConfig())
 	require.Equal(t, gas.Gas(10), tm.Rate())
 
 	requireTime := func(t *testing.T, sec uint64, numerator gas.Gas) {
@@ -365,7 +366,7 @@ func TestLastToSettleAt(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			settleAt := time.Unix(int64(tt.settleAt), 0) //nolint:gosec // Hard-coded, non-overflowing values
-			got, gotOK, err := LastToSettleAt(&hookstest.Stub{}, settleAt, tt.parent)
+			got, gotOK, err := LastToSettleAt(hookstest.NewStub(0), settleAt, tt.parent)
 			if err != nil || gotOK != tt.wantOK {
 				t.Fatalf("LastToSettleAt(%d, [parent height %d]) got (_, %t, %v); want (_, %t, nil)", tt.settleAt, tt.parent.Height(), gotOK, err, tt.wantOK)
 			}

blocks/time.go

@@ -31,9 +31,8 @@ func preciseTime(hdr *types.Header, subSec time.Duration) time.Time { //nolint:s
 // GasTime is the gas equivalent of [PreciseTime], deriving the gas rate from
 // the parent header and the hooks.
 func GasTime(hooks hook.Points, hdr, parent *types.Header) *proxytime.Time[gas.Gas] {
-	rate := gastime.SafeRateOfTarget(
-		hooks.GasTargetAfter(parent),
-	)
+	target, _ := hooks.GasConfigAfter(parent)
+	rate := gastime.SafeRateOfTarget(target)
 	tm := proxytime.New(hdr.Time, rate)
 	tm.Tick(gastime.SubSecond(hooks, hdr, rate))
 	return tm

blocks/time_test.go

@@ -32,12 +32,9 @@ func TestGasTime(t *testing.T) {
 	)
 	rate := gastime.SafeRateOfTarget(target)
 
-	hooks := &hookstest.Stub{
-		Now: func() time.Time {
-			return time.Unix(unix, nanos)
-		},
-		Target: target,
-	}
+	hooks := hookstest.NewStub(target, hookstest.WithNow(func() time.Time {
+		return time.Unix(unix, nanos)
+	}))
 	parent := &types.Header{
 		Number: big.NewInt(1),
 	}
@@ -69,12 +66,9 @@ func FuzzTimeExtraction(f *testing.F) {
 			t.Skip("Zero target")
 		}
 
-		hooks := &hookstest.Stub{
-			Now: func() time.Time {
-				return time.Unix(unix, subSec)
-			},
-			Target: gas.Gas(target),
-		}
+		hooks := hookstest.NewStub(gas.Gas(target), hookstest.WithNow(func() time.Time {
+			return time.Unix(unix, subSec)
+		}))
 		parent := &types.Header{
 			Number: big.NewInt(1),
 		}

gasprice/estimator_test.go

@@ -291,8 +291,10 @@ func TestFeeHistory(t *testing.T) {
 	cfg := DefaultConfig()
 	cfg.HistoryMaxBlocksFromHead = 1
 	cfg.HistoryMaxBlocks = 2
+	gt, err := gastime.New(time.Now(), 1, math.MaxUint64, gastime.DefaultGasPriceConfig())
+	require.NoError(t, err)
 	bounds := &blocks.WorstCaseBounds{
-		LatestEndTime: gastime.New(time.Now(), 1, math.MaxUint64),
+		LatestEndTime: gt,
 	}
 	type (
 		blockSpec []*types.Transaction

gastime/acp176.go

@@ -5,6 +5,7 @@ package gastime
 
 import (
 	"fmt"
+	"math"
 
 	"github.com/ava-labs/avalanchego/vms/components/gas"
 	"github.com/ava-labs/libevm/core/types"
@@ -21,13 +22,62 @@ func (tm *Time) BeforeBlock(hooks hook.Points, h *types.Header) {
 	)
 }
 
-// AfterBlock is intended to be called after processing a block, with the target
-// sourced from [hook.Points] and [types.Header].
+// AfterBlock is intended to be called after processing a block, with the
+// target and gas configuration sourced from [hook.Points] and [types.Header].
 func (tm *Time) AfterBlock(used gas.Gas, hooks hook.Points, h *types.Header) error {
 	tm.Tick(used)
-	target := hooks.GasTargetAfter(h)
+	target, hookCfg := hooks.GasConfigAfter(h)
+	// Although [Time.SetTarget] scales the excess by the same factor as the
+	// change in target, it rounds when necessary, which might alter the price
+	// by a negligible amount. We therefore take a price snapshot beforehand
+	// otherwise we'd call [Time.findExcessForPrice] with a different value,
+	// which makes it extremely hard to test.
+	p := tm.Price()
 	if err := tm.SetTarget(target); err != nil {
 		return fmt.Errorf("%T.SetTarget() after block: %w", tm, err)
 	}
+
+	cfg, err := newConfig(hookCfg)
+	if err != nil {
+		return fmt.Errorf("%T.newConfig() after block: %w", tm, err)
+	}
+	if cfg.equals(tm.config) {
+		return nil
+	}
+	tm.config = cfg
+	tm.excess = tm.findExcessForPrice(p)
+
 	return nil
 }
+
+// findExcessForPrice uses binary search over uint64 to find the smallest excess
+// value that produces targetPrice with the current [config]. This maintains
+// price continuity under a change in [config], with the following scenarios:
+//
+//   - K changes (via TargetToExcessScaling): Scale excess to maintain current price
+//   - StaticPricing is true: Set excess to 0, enabling fixed price mode
+//   - M decreases: Scale excess to maintain current price
+//   - M increases AND current price >= new M: Scale excess to maintain current price
+//   - M increases AND current price < new M: Price bumps to new M (excess becomes 0)
+func (tm *Time) findExcessForPrice(targetPrice gas.Price) gas.Gas {
+	// We return 0 in case targetPrice < minPrice because we should at least maintain the minimum price
+	// by setting the excess to 0. ( P = M * e^(0 / K) = M )
+	// Note: Even though we return 0 for excess it won't avoid accumulating excess in the long run.
+	if targetPrice <= tm.config.minPrice || tm.config.staticPricing {
+		return 0
+	}
+
+	k := tm.excessScalingFactor()
+
+	// The price function is monotonic non-decreasing so binary search is appropriate.
+	lo, hi := gas.Gas(0), gas.Gas(math.MaxUint64)
+	for lo < hi {
+		mid := lo + (hi-lo)/2
+		if gas.CalculatePrice(tm.config.minPrice, mid, k) >= targetPrice {
+			hi = mid
+		} else {
+			lo = mid + 1
+		}
+	}
+	return lo
+}