Add ACP-224 Fee Manager Precompile

graft/subnet-evm/commontype/BUILD.bazel

@@ -4,6 +4,7 @@ load("//.bazel:defs.bzl", "graft_go_test")
 go_library(
     name = "commontype",
     srcs = [
+        "acp224_fee_config.go",
         "fee_config.go",
         "test_fee_config.go",
     ],
@@ -17,7 +18,13 @@ go_library(
 
 graft_go_test(
     name = "commontype_test",
-    srcs = ["fee_config_test.go"],
+    srcs = [
+        "acp224_fee_config_test.go",
+        "fee_config_test.go",
+    ],
     embed = [":commontype"],
-    deps = ["@com_github_stretchr_testify//require"],
+    deps = [
+        "//utils",
+        "@com_github_stretchr_testify//require",
+    ],
 )

graft/subnet-evm/commontype/acp224_fee_config.go

@@ -0,0 +1,111 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package commontype
+
+import (
+	"encoding/binary"
+	"errors"
+
+	"github.com/ava-labs/libevm/common"
+)
+
+const MinTargetGasACP224 uint64 = 1_000_000
+
+// DefaultACP224FeeConfig returns a copy of the default ACP-224 fee
+// config.
+//
+// The default values are:
+//   - TargetGas: 1_000_000
+//   - MinGasPrice: 1
+//   - TimeToDouble: 60
+func DefaultACP224FeeConfig() ACP224FeeConfig {
+	return ACP224FeeConfig{
+		TargetGas:    1_000_000,
+		MinGasPrice:  1,
+		TimeToDouble: 60,
+	}
+}
+
+var (
+	ErrMinGasPriceTooLow = errors.New("minGasPrice must be greater than 0")
+
+	errTargetGasMustBeZero    = errors.New("targetGas must be 0 when validatorTargetGas is true")
+	errTargetGasTooLowACP224  = errors.New("targetGas must be at least MinTargetGasACP224")
+	errTimeToDoubleTooLow     = errors.New("timeToDouble must be greater than 0")
+	errTimeToDoubleMustBeZero = errors.New("timeToDouble must be 0 when staticPricing is true")
+)
+
+// ACP224FeeConfig specifies the parameters for the ACP-224 dynamic gas limit mechanism.
+// See [ACP224FeeConfig.Verify] for validation constraints between fields.
+type ACP224FeeConfig struct {
+	ValidatorTargetGas bool   `json:"validatorTargetGas,omitempty"` // when true, validators control targetGas via node preferences
+	TargetGas          uint64 `json:"targetGas"`                    // target gas consumption per second
+	StaticPricing      bool   `json:"staticPricing,omitempty"`      // when true, gas price is always minGasPrice
+	MinGasPrice        uint64 `json:"minGasPrice"`                  // minimum gas price in wei
+	TimeToDouble       uint64 `json:"timeToDouble"`                 // seconds for gas price to double at max capacity
+}
+
+// Verify returns an error if the config violates any field constraints.
+func (a *ACP224FeeConfig) Verify() error {
+	switch {
+	case a.MinGasPrice == 0:
+		return ErrMinGasPriceTooLow
+	case a.ValidatorTargetGas && a.TargetGas != 0:
+		return errTargetGasMustBeZero
+	case !a.ValidatorTargetGas && a.TargetGas < MinTargetGasACP224:
+		return errTargetGasTooLowACP224
+	case a.StaticPricing && a.TimeToDouble != 0:
+		return errTimeToDoubleMustBeZero
+	case !a.StaticPricing && a.TimeToDouble == 0:
+		return errTimeToDoubleTooLow
+	default:
+		return nil
+	}
+}
+
+// Pack encodes the fee config into a single common.Hash (32 bytes).
+//
+// Layout (26 bytes used, 6 bytes padding):
+//
+//	h[0]     ValidatorTargetGas (bool)
+//	h[1:9]   TargetGas          (uint64)
+//	h[9]     StaticPricing      (bool)
+//	h[10:18] MinGasPrice        (uint64)
+//	h[18:26] TimeToDouble       (uint64)
+func (a *ACP224FeeConfig) Pack() common.Hash {
+	var h common.Hash
+	put := binary.BigEndian.PutUint64
+
+	if a.ValidatorTargetGas {
+		h[0] = 1
+	}
+	put(h[1:], a.TargetGas)
+	if a.StaticPricing {
+		h[9] = 1
+	}
+	put(h[10:], a.MinGasPrice)
+	put(h[18:], a.TimeToDouble)
+	return h
+}
+
+// UnpackFrom decodes a packed common.Hash into the fee config fields.
+// See [ACP224FeeConfig.Pack] for the byte layout.
+func (a *ACP224FeeConfig) UnpackFrom(h common.Hash) {
+	u64 := binary.BigEndian.Uint64
+
+	a.ValidatorTargetGas = h[0] != 0
+	a.TargetGas = u64(h[1:])
+	a.StaticPricing = h[9] != 0
+	a.MinGasPrice = u64(h[10:])
+	a.TimeToDouble = u64(h[18:])
+}
+
+// Equal returns true if both configs are nil or have identical field values.
+func (a *ACP224FeeConfig) Equal(other *ACP224FeeConfig) bool {
+	if a == nil || other == nil {
+		return a == other
+	}
+
+	return *a == *other
+}

graft/subnet-evm/commontype/acp224_fee_config_test.go

@@ -0,0 +1,181 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package commontype
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils"
+)
+
+func TestACP224FeeConfigVerify(t *testing.T) {
+	tests := []struct {
+		name   string
+		config ACP224FeeConfig
+		want   error
+	}{
+		{
+			name:   "valid config",
+			config: DefaultACP224FeeConfig(),
+		},
+		{
+			name: "valid with validatorTargetGas",
+			config: ACP224FeeConfig{
+				ValidatorTargetGas: true,
+				MinGasPrice:        1,
+				TimeToDouble:       60,
+			},
+		},
+		{
+			name: "valid with staticPricing",
+			config: ACP224FeeConfig{
+				TargetGas:     MinTargetGasACP224,
+				StaticPricing: true,
+				MinGasPrice:   1,
+			},
+		},
+		{
+			name: "valid with both validatorTargetGas and staticPricing",
+			config: ACP224FeeConfig{
+				ValidatorTargetGas: true,
+				StaticPricing:      true,
+				MinGasPrice:        1,
+			},
+		},
+		{
+			name: "minGasPrice zero",
+			config: ACP224FeeConfig{
+				TargetGas:    MinTargetGasACP224,
+				TimeToDouble: 60,
+			},
+			want: ErrMinGasPriceTooLow,
+		},
+		{
+			name: "targetGas must be zero when validatorTargetGas is true",
+			config: ACP224FeeConfig{
+				ValidatorTargetGas: true,
+				TargetGas:          MinTargetGasACP224,
+				MinGasPrice:        1,
+				TimeToDouble:       60,
+			},
+			want: errTargetGasMustBeZero,
+		},
+		{
+			name: "targetGas below minimum",
+			config: ACP224FeeConfig{
+				TargetGas:    MinTargetGasACP224 - 1,
+				MinGasPrice:  1,
+				TimeToDouble: 60,
+			},
+			want: errTargetGasTooLowACP224,
+		},
+		{
+			name: "targetGas at minimum boundary",
+			config: ACP224FeeConfig{
+				TargetGas:    MinTargetGasACP224,
+				MinGasPrice:  1,
+				TimeToDouble: 1,
+			},
+		},
+		{
+			name: "timeToDouble must be zero when staticPricing is true",
+			config: ACP224FeeConfig{
+				TargetGas:     MinTargetGasACP224,
+				StaticPricing: true,
+				MinGasPrice:   1,
+				TimeToDouble:  60,
+			},
+			want: errTimeToDoubleMustBeZero,
+		},
+		{
+			name: "timeToDouble must be positive when staticPricing is false",
+			config: ACP224FeeConfig{
+				TargetGas:   MinTargetGasACP224,
+				MinGasPrice: 1,
+			},
+			want: errTimeToDoubleTooLow,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.Verify()
+			require.ErrorIs(t, err, tt.want, "Verify")
+		})
+	}
+}
+
+func FuzzACP224FeeConfigPacking(f *testing.F) {
+	for _, v := range []bool{true, false} {
+		for _, s := range []bool{true, false} {
+			for t := range uint64(3) {
+				for m := range uint64(3) {
+					for d := range uint64(3) {
+						f.Add(v, s, t, m, d)
+					}
+				}
+			}
+		}
+	}
+
+	f.Fuzz(func(t *testing.T, validator, static bool, target, minGas, double uint64) {
+		in := &ACP224FeeConfig{validator, target, static, minGas, double}
+		got := new(ACP224FeeConfig)
+		got.UnpackFrom(in.Pack())
+		require.Equalf(t, *in, *got, "%T.UnpackFrom(%[1]T.Pack()) round trip", in)
+	})
+}
+
+func TestACP224FeeConfigEqual(t *testing.T) {
+	tests := []struct {
+		name string
+		a    *ACP224FeeConfig
+		b    *ACP224FeeConfig
+		want bool
+	}{
+		{
+			name: "both equal",
+			a:    utils.PointerTo(DefaultACP224FeeConfig()),
+			b: utils.PointerTo(
+				DefaultACP224FeeConfig()),
+			want: true,
+		},
+		{
+			name: "different targetGas",
+			a:    utils.PointerTo(DefaultACP224FeeConfig()),
+			b: func() *ACP224FeeConfig {
+				c := DefaultACP224FeeConfig()
+				c.TargetGas = 20_000_000
+				return &c
+			}(),
+			want: false,
+		},
+		{
+			name: "other nil",
+			a:    utils.PointerTo(DefaultACP224FeeConfig()),
+			b:    nil,
+			want: false,
+		},
+		{
+			name: "receiver nil",
+			a:    nil,
+			b:    utils.PointerTo(DefaultACP224FeeConfig()),
+			want: false,
+		},
+		{
+			name: "both nil",
+			a:    nil,
+			b:    nil,
+			want: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, tt.a.Equal(tt.b), "Equal()")
+		})
+	}
+}

graft/subnet-evm/precompile/contracts/acp224feemanager/BUILD.bazel

@@ -0,0 +1,49 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("//.bazel:defs.bzl", "graft_go_test")
+
+go_library(
+    name = "acp224feemanager",
+    srcs = [
+        "config.go",
+        "contract.go",
+        "event.go",
+        "module.go",
+    ],
+    embedsrcs = ["IACP224FeeManager.abi"],
+    importpath = "github.com/ava-labs/avalanchego/graft/subnet-evm/precompile/contracts/acp224feemanager",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//graft/subnet-evm/commontype",
+        "//graft/subnet-evm/precompile/allowlist",
+        "//graft/subnet-evm/precompile/contract",
+        "//graft/subnet-evm/precompile/modules",
+        "//graft/subnet-evm/precompile/precompileconfig",
+        "@com_github_ava_labs_libevm//accounts/abi",
+        "@com_github_ava_labs_libevm//common",
+        "@com_github_ava_labs_libevm//core/types",
+        "@com_github_ava_labs_libevm//core/vm",
+    ],
+)
+
+graft_go_test(
+    name = "acp224feemanager_test",
+    srcs = [
+        "config_test.go",
+        "contract_test.go",
+    ],
+    embed = [":acp224feemanager"],
+    deps = [
+        "//graft/subnet-evm/commontype",
+        "//graft/subnet-evm/core/extstate",
+        "//graft/subnet-evm/precompile/allowlist",
+        "//graft/subnet-evm/precompile/allowlist/allowlisttest",
+        "//graft/subnet-evm/precompile/contract",
+        "//graft/subnet-evm/precompile/precompileconfig",
+        "//graft/subnet-evm/precompile/precompiletest",
+        "//utils",
+        "@com_github_ava_labs_libevm//common",
+        "@com_github_ava_labs_libevm//core/vm",
+        "@com_github_stretchr_testify//require",
+        "@org_uber_go_mock//gomock",
+    ],
+)

graft/subnet-evm/precompile/contracts/acp224feemanager/IACP224FeeManager.sol

@@ -10,12 +10,14 @@ interface IACP224FeeManager is IAllowList {
     /// @notice Configuration parameters for the dynamic fee mechanism
     /// @dev Fields are ordered so each mode flag precedes the parameter(s) it governs,
     ///      reducing the risk of mis-ordering arguments.
+    ///      uint256 fields (targetGas, minGasPrice, timeToDouble) MUST fit in uint64.
+    ///      Values exceeding uint64 range will be rejected by the precompile.
     struct FeeConfig {
         bool validatorTargetGas; // When true, validators control targetGas via node preferences
-        uint256 targetGas; // Target gas consumption per second (T)
+        uint256 targetGas; // Target gas consumption per second (T) MUST fit in uint64.
         bool staticPricing; // When true, gas price is always minGasPrice
-        uint256 minGasPrice; // Minimum gas price in wei (M)
-        uint256 timeToDouble; // Seconds for gas price to double at max capacity
+        uint256 minGasPrice; // Minimum gas price in wei (M) MUST fit in uint64.
+        uint256 timeToDouble; // Seconds for gas price to double at max capacity MUST fit in uint64.
     }
 
     /// @notice Emitted when fee configuration is updated