sae: Support oscillating MinPrice configs

vms/saevm/gastime/BUILD.bazel

@@ -42,12 +42,9 @@ go_test(
         "//vms/saevm/proxytime",
         "@com_github_arr4n_shed//testerr",
         "@com_github_ava_labs_libevm//core/types",
-        "@com_github_ava_labs_libevm//params",
         "@com_github_google_go_cmp//cmp",
         "@com_github_google_go_cmp//cmp/cmpopts",
         "@com_github_stretchr_testify//assert",
         "@com_github_stretchr_testify//require",
-        "@org_golang_x_text//language",
-        "@org_golang_x_text//message",
     ],
 )

vms/saevm/gastime/acp176.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/ava-labs/avalanchego/vms/components/gas"
 	"github.com/ava-labs/avalanchego/vms/saevm/hook"
+	"github.com/ava-labs/avalanchego/vms/saevm/intmath"
 )
 
 // BeforeBlock is intended to be called before processing a block, with the
@@ -26,56 +27,71 @@ func (tm *Time) BeforeBlock(hooks hook.Points, h *types.Header) {
 // 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, 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()
-	tm.SetTarget(target)
 
-	cfg, err := newConfig(hookCfg)
+	target, hookCfg := hooks.GasConfigAfter(h)
+	c, 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)
 
+	tm.setGasPriceConfig(target, c)
 	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
+func (tm *Time) setGasPriceConfig(target gas.Gas, c config) {
+	// x := x * (K' * T') / (K * T)
+	oldK := tm.excessScalingFactor() // K * T
+
+	tm.target = clampTarget(target)
+	tm.Time.SetRate(rateOf(tm.target))
+	tm.config = c
+
+	newK := tm.excessScalingFactor() // K' * T'
+	scaled, _, err := intmath.MulDivCeil(tm.excess, newK, oldK)
+	if err != nil {
+		scaled = math.MaxUint64
 	}
+	tm.excess = scaled
 
-	k := tm.excessScalingFactor()
+	if c.staticPricing {
+		tm.excess = 0
+	}
 
-	// The price function is monotonic non-decreasing so binary search is appropriate.
-	lo, hi := gas.Gas(0), gas.Gas(math.MaxUint64)
+	// x := max(x, ln(minPrice) * K' * T')
+	minExcess := priceExcess(c.minPrice, newK)
+	tm.excess = max(tm.excess, minExcess)
+}
+
+// priceExcess returns the lowest excess that produces p, if one exists. If the
+// integer approximation in [calculatePrice] skips over p, it returns the
+// maximum excess where the price is less than p.
+//
+// Mathematically, it returns ln(p) * k.
+func priceExcess(p gas.Price, k gas.Gas) gas.Gas {
+	if p <= 1 {
+		return 0
+	}
+	// Binary search for the minimum x where calculatePrice(x, k) >= minPrice.
+	//
+	// calculatePrice(0, k) == 1, and minPrice > 1, so lo > 0.
+	lo, hi := gas.Gas(1), gas.Gas(math.MaxUint64)
 	for lo < hi {
 		mid := lo + (hi-lo)/2
-		if gas.CalculatePrice(tm.config.minPrice, mid, k) >= targetPrice {
+		if calculatePrice(mid, k) >= p {
 			hi = mid
 		} else {
 			lo = mid + 1
 		}
 	}
-	return lo
+	// Ensure [Time.Price] can return minPrice even if the approximation can't
+	// represent it.
+	if calculatePrice(lo, k) == p {
+		return lo
+	}
+	return lo - 1
+}
+
+// calculatePrice returns an integer approximation of e^(x/k).
+func calculatePrice(x, k gas.Gas) gas.Price {
+	return gas.CalculatePrice(1, x, k)
 }