Add ACP-224 Fee Manager Precompile

go.work.sum

@@ -912,7 +912,9 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/automaxprocs v1.5.2 h1:2LxUOGiR3O6tw8ui5sZa2LAaHnsviZdVOUZw4fvbnME=
 go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=

graft/subnet-evm/commontype/BUILD.bazel

@@ -10,6 +10,7 @@ go_library(
     name = "commontype",
     srcs = [
         "fee_config.go",
+        "gas_price_config.go",
         "test_fee_config.go",
     ],
     importpath = "github.com/ava-labs/avalanchego/graft/subnet-evm/commontype",
@@ -21,7 +22,15 @@ go_library(
 
 graft_go_test(
     name = "commontype_test",
-    srcs = ["fee_config_test.go"],
+    srcs = [
+        "fee_config_test.go",
+        "gas_price_config_test.go",
+    ],
+    data = glob(["testdata/**"]),
     embed = [":commontype"],
-    deps = ["@com_github_stretchr_testify//require"],
+    deps = [
+        "//utils",
+        "@com_github_ava_labs_libevm//common",
+        "@com_github_stretchr_testify//require",
+    ],
 )

graft/subnet-evm/commontype/gas_price_config.go

@@ -0,0 +1,112 @@
+// 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 MinTargetGas uint64 = 1_000_000
+
+// DefaultGasPriceConfig returns a default gas price config for the dynamic
+// gas limit mechanism.
+//
+// The default values are:
+//   - TargetGas: 1_000_000
+//   - MinGasPrice: 1
+//   - TimeToDouble: 60
+func DefaultGasPriceConfig() GasPriceConfig {
+	return GasPriceConfig{
+		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")
+	errTargetGasBelowMin      = errors.New("targetGas must be at least MinTargetGas")
+	errTimeToDoubleTooLow     = errors.New("timeToDouble must be greater than 0")
+	errTimeToDoubleMustBeZero = errors.New("timeToDouble must be 0 when staticPricing is true")
+)
+
+// GasPriceConfig specifies the parameters for the dynamic gas limit and
+// gas price mechanism.
+// See [GasPriceConfig.Verify] for validation constraints between fields.
+type GasPriceConfig struct {
+	ValidatorTargetGas bool   `json:"validatorTargetGas"` // when true, validators control targetGas via node preferences
+	TargetGas          uint64 `json:"targetGas"`          // target gas consumption per second
+	StaticPricing      bool   `json:"staticPricing"`      // 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 *GasPriceConfig) Verify() error {
+	switch {
+	case a.MinGasPrice == 0:
+		return ErrMinGasPriceTooLow
+	case a.ValidatorTargetGas && a.TargetGas != 0:
+		return errTargetGasMustBeZero
+	case !a.ValidatorTargetGas && a.TargetGas < MinTargetGas:
+		return errTargetGasBelowMin
+	case a.StaticPricing && a.TimeToDouble != 0:
+		return errTimeToDoubleMustBeZero
+	case !a.StaticPricing && a.TimeToDouble == 0:
+		return errTimeToDoubleTooLow
+	default:
+		return nil
+	}
+}
+
+// Pack encodes the gas price 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 *GasPriceConfig) 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 gas price config fields.
+// See [GasPriceConfig.Pack] for the byte layout.
+func (a *GasPriceConfig) 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 *GasPriceConfig) Equal(other *GasPriceConfig) bool {
+	if a == nil || other == nil {
+		return a == other
+	}
+
+	return *a == *other
+}

graft/subnet-evm/commontype/gas_price_config_test.go

@@ -0,0 +1,220 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package commontype
+
+import (
+	"math"
+	"testing"
+
+	"github.com/ava-labs/libevm/common"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils"
+)
+
+func TestGasPriceConfigVerify(t *testing.T) {
+	tests := []struct {
+		name   string
+		config GasPriceConfig
+		want   error
+	}{
+		{
+			name:   "valid config",
+			config: DefaultGasPriceConfig(),
+		},
+		{
+			name: "valid with validatorTargetGas",
+			config: GasPriceConfig{
+				ValidatorTargetGas: true,
+				MinGasPrice:        1,
+				TimeToDouble:       60,
+			},
+		},
+		{
+			name: "valid with staticPricing",
+			config: GasPriceConfig{
+				TargetGas:     MinTargetGas,
+				StaticPricing: true,
+				MinGasPrice:   1,
+			},
+		},
+		{
+			name: "valid with both validatorTargetGas and staticPricing",
+			config: GasPriceConfig{
+				ValidatorTargetGas: true,
+				StaticPricing:      true,
+				MinGasPrice:        1,
+			},
+		},
+		{
+			name: "minGasPrice zero",
+			config: GasPriceConfig{
+				TargetGas:    MinTargetGas,
+				TimeToDouble: 60,
+			},
+			want: ErrMinGasPriceTooLow,
+		},
+		{
+			name: "targetGas must be zero when validatorTargetGas is true",
+			config: GasPriceConfig{
+				ValidatorTargetGas: true,
+				TargetGas:          MinTargetGas,
+				MinGasPrice:        1,
+				TimeToDouble:       60,
+			},
+			want: errTargetGasMustBeZero,
+		},
+		{
+			name: "targetGas below minimum",
+			config: GasPriceConfig{
+				TargetGas:    MinTargetGas - 1,
+				MinGasPrice:  1,
+				TimeToDouble: 60,
+			},
+			want: errTargetGasBelowMin,
+		},
+		{
+			name: "targetGas at minimum boundary",
+			config: GasPriceConfig{
+				TargetGas:    MinTargetGas,
+				MinGasPrice:  1,
+				TimeToDouble: 1,
+			},
+		},
+		{
+			name: "timeToDouble must be zero when staticPricing is true",
+			config: GasPriceConfig{
+				TargetGas:     MinTargetGas,
+				StaticPricing: true,
+				MinGasPrice:   1,
+				TimeToDouble:  60,
+			},
+			want: errTimeToDoubleMustBeZero,
+		},
+		{
+			name: "timeToDouble must be positive when staticPricing is false",
+			config: GasPriceConfig{
+				TargetGas:   MinTargetGas,
+				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")
+		})
+	}
+}
+
+// TestGasPriceConfigPackFormat asserts exact packed bytes for known configs.
+// This catches backward-incompatible format changes that round-trip tests miss.
+func TestGasPriceConfigPackFormat(t *testing.T) {
+	tests := []struct {
+		name   string
+		config GasPriceConfig
+		want   common.Hash
+	}{
+		{
+			name:   "default config",
+			config: DefaultGasPriceConfig(),
+			want:   common.HexToHash("0x0000000000000f4240000000000000000001000000000000003c000000000000"),
+		},
+		{
+			name: "all flags true and max uint64",
+			config: GasPriceConfig{
+				ValidatorTargetGas: true,
+				TargetGas:          math.MaxUint64,
+				StaticPricing:      true,
+				MinGasPrice:        math.MaxUint64,
+				TimeToDouble:       math.MaxUint64,
+			},
+			want: common.HexToHash("0x01ffffffffffffffff01ffffffffffffffffffffffffffffffff000000000000"),
+		},
+		{
+			name: "validatorTargetGas mode",
+			config: GasPriceConfig{
+				ValidatorTargetGas: true,
+				MinGasPrice:        1,
+				TimeToDouble:       60,
+			},
+			want: common.HexToHash("0x010000000000000000000000000000000001000000000000003c000000000000"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, tt.config.Pack(), "Pack")
+		})
+	}
+}
+
+func FuzzGasPriceConfigPacking(f *testing.F) {
+	f.Add(false, false, uint64(0), uint64(0), uint64(0))
+	f.Add(true, true, uint64(math.MaxUint64), uint64(math.MaxUint64), uint64(math.MaxUint64))
+	f.Add(false, false, MinTargetGas, uint64(1), uint64(60))
+	f.Add(true, false, uint64(0), uint64(1), uint64(60))
+	f.Add(false, true, MinTargetGas, uint64(1), uint64(0))
+	f.Add(true, true, uint64(0), uint64(1), uint64(0))
+
+	f.Fuzz(func(t *testing.T, validator, static bool, target, minGas, double uint64) {
+		in := &GasPriceConfig{validator, target, static, minGas, double}
+		got := new(GasPriceConfig)
+		got.UnpackFrom(in.Pack())
+		require.Equalf(t, *in, *got, "%T.UnpackFrom(%[1]T.Pack()) round trip", in)
+		require.Truef(t, got.Equal(in), "%T.Equal([packed original])", got)
+	})
+}
+
+func TestGasPriceConfigEqual(t *testing.T) {
+	tests := []struct {
+		name string
+		a    *GasPriceConfig
+		b    *GasPriceConfig
+		want bool
+	}{
+		{
+			name: "both equal",
+			a:    utils.PointerTo(DefaultGasPriceConfig()),
+			b:    utils.PointerTo(DefaultGasPriceConfig()),
+			want: true,
+		},
+		{
+			name: "different targetGas",
+			a:    utils.PointerTo(DefaultGasPriceConfig()),
+			b: func() *GasPriceConfig {
+				c := DefaultGasPriceConfig()
+				c.TargetGas++
+				return &c
+			}(),
+			want: false,
+		},
+		{
+			name: "other nil",
+			a:    utils.PointerTo(DefaultGasPriceConfig()),
+			b:    nil,
+			want: false,
+		},
+		{
+			name: "receiver nil",
+			a:    nil,
+			b:    utils.PointerTo(DefaultGasPriceConfig()),
+			want: false,
+		},
+		{
+			name: "both nil",
+			a:    nil,
+			b:    nil,
+			want: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equalf(t, tt.want, tt.a.Equal(tt.b), "%T(%+v).Equal(%+v)", tt.a, tt.a, tt.b)
+		})
+	}
+}

graft/subnet-evm/commontype/testdata/fuzz/FuzzGasPriceConfigPacking/03eeae4f73409617

@@ -0,0 +1,6 @@
+go test fuzz v1
+bool(true)
+bool(false)
+uint64(6148914691236517205)
+uint64(12297829382473034410)
+uint64(6148914691236517205)

graft/subnet-evm/commontype/testdata/fuzz/FuzzGasPriceConfigPacking/6148d56c0c7926ba

@@ -0,0 +1,6 @@
+go test fuzz v1
+bool(true)
+bool(true)
+uint64(9223372036854775808)
+uint64(9223372036854775807)
+uint64(4294967296)

graft/subnet-evm/commontype/testdata/fuzz/FuzzGasPriceConfigPacking/913ddfe768f28110

@@ -0,0 +1,6 @@
+go test fuzz v1
+bool(true)
+bool(false)
+uint64(1)
+uint64(1)
+uint64(1)

graft/subnet-evm/commontype/testdata/fuzz/FuzzGasPriceConfigPacking/b727bde1998d0574

@@ -0,0 +1,6 @@
+go test fuzz v1
+bool(false)
+bool(false)
+uint64(1000002)
+uint64(1)
+uint64(60)