add initial precompile configs and handle them

accounts/abi/bind/precompile_template.go

@@ -195,6 +195,20 @@ func (c *{{.Contract.Type}}Config) Contract() StatefulPrecompiledContract {
 	return {{.Contract.Type}}Precompile
 }
 
+// Verify tries to verify {{.Contract.Type}}Config and returns an error accordingly.
+func (c *{{.Contract.Type}}Config) Verify() error {
+	{{if .Contract.AllowList}}
+	// Verify AllowList first
+	if err := c.AllowListConfig.Verify(); err != nil {
+		return err
+	}
+	{{end}}
+	// CUSTOM CODE STARTS HERE
+	// Add your own custom verify code for {{.Contract.Type}}Config here
+	// and return an error accordingly
+	return nil
+}
+
 {{if .Contract.AllowList}}
 // Get{{.Contract.Type}}AllowListStatus returns the role of [address] for the {{.Contract.Type}} list.
 func Get{{.Contract.Type}}AllowListStatus(stateDB StateDB, address common.Address) AllowListRole {
@@ -203,6 +217,10 @@ func Get{{.Contract.Type}}AllowListStatus(stateDB StateDB, address common.Addres
 
 // Set{{.Contract.Type}}AllowListStatus sets the permissions of [address] to [role] for the
 // {{.Contract.Type}} list. Assumes [role] has already been verified as valid.
+// This stores the [role] in the contract storage with address [{{.Contract.Type}}Address]
+// and [address] hash. It means that any reusage of the [address] key for different value
+// conflicts with the same slot [role] is stored.
+// Precompile implementations must use a different key than [address] for their storage.
 func Set{{.Contract.Type}}AllowListStatus(stateDB StateDB, address common.Address, role AllowListRole) {
 	setAllowListRole(stateDB, {{.Contract.Type}}Address, address, role)
 }

commontype/fee_config.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ava-labs/subnet-evm/utils"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -81,6 +82,22 @@ func (f *FeeConfig) Verify() error {
 	return f.checkByteLens()
 }
 
+// Equal checks if given [other] is same with this FeeConfig.
+func (f *FeeConfig) Equal(other *FeeConfig) bool {
+	if other == nil {
+		return false
+	}
+
+	return utils.BigNumEqual(f.GasLimit, other.GasLimit) &&
+		f.TargetBlockRate == other.TargetBlockRate &&
+		utils.BigNumEqual(f.MinBaseFee, other.MinBaseFee) &&
+		utils.BigNumEqual(f.TargetGas, other.TargetGas) &&
+		utils.BigNumEqual(f.BaseFeeChangeDenominator, other.BaseFeeChangeDenominator) &&
+		utils.BigNumEqual(f.MinBlockGasCost, other.MinBlockGasCost) &&
+		utils.BigNumEqual(f.MaxBlockGasCost, other.MaxBlockGasCost) &&
+		utils.BigNumEqual(f.BlockGasCostStep, other.BlockGasCostStep)
+}
+
 // checkByteLens checks byte lengths against common.HashLen (32 bytes) and returns error
 func (f *FeeConfig) checkByteLens() error {
 	if isBiggerThanHashLen(f.GasLimit) {

commontype/fee_config_test.go

@@ -0,0 +1,140 @@
+// (c) 2019-2022, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package commontype
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var validFeeConfig = FeeConfig{
+	GasLimit:        big.NewInt(8_000_000),
+	TargetBlockRate: 2, // in seconds
+
+	MinBaseFee:               big.NewInt(25_000_000_000),
+	TargetGas:                big.NewInt(15_000_000),
+	BaseFeeChangeDenominator: big.NewInt(36),
+
+	MinBlockGasCost:  big.NewInt(0),
+	MaxBlockGasCost:  big.NewInt(1_000_000),
+	BlockGasCostStep: big.NewInt(200_000),
+}
+
+func TestVerify(t *testing.T) {
+	tests := []struct {
+		name          string
+		config        *FeeConfig
+		expectedError string
+	}{
+		{
+			name:          "invalid GasLimit in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.GasLimit = big.NewInt(0); return &c }(),
+			expectedError: "gasLimit = 0 cannot be less than or equal to 0",
+		},
+		{
+			name:          "invalid TargetBlockRate in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.TargetBlockRate = 0; return &c }(),
+			expectedError: "targetBlockRate = 0 cannot be less than or equal to 0",
+		},
+		{
+			name:          "invalid MinBaseFee in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.MinBaseFee = big.NewInt(-1); return &c }(),
+			expectedError: "minBaseFee = -1 cannot be less than 0",
+		},
+		{
+			name:          "invalid TargetGas in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.TargetGas = big.NewInt(0); return &c }(),
+			expectedError: "targetGas = 0 cannot be less than or equal to 0",
+		},
+		{
+			name:          "invalid BaseFeeChangeDenominator in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.BaseFeeChangeDenominator = big.NewInt(0); return &c }(),
+			expectedError: "baseFeeChangeDenominator = 0 cannot be less than or equal to 0",
+		},
+		{
+			name:          "invalid MinBlockGasCost in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.MinBlockGasCost = big.NewInt(-1); return &c }(),
+			expectedError: "minBlockGasCost = -1 cannot be less than 0",
+		},
+		{
+			name:          "valid FeeConfig",
+			config:        &validFeeConfig,
+			expectedError: "",
+		},
+		{
+			name: "MinBlockGasCost bigger than MaxBlockGasCost in FeeConfig",
+			config: func() *FeeConfig {
+				c := validFeeConfig
+				c.MinBlockGasCost = big.NewInt(2)
+				c.MaxBlockGasCost = big.NewInt(1)
+				return &c
+			}(),
+			expectedError: "minBlockGasCost = 2 cannot be greater than maxBlockGasCost = 1",
+		},
+		{
+			name:          "invalid BlockGasCostStep in FeeConfig",
+			config:        func() *FeeConfig { c := validFeeConfig; c.BlockGasCostStep = big.NewInt(-1); return &c }(),
+			expectedError: "blockGasCostStep = -1 cannot be less than 0",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.config.Verify()
+			if test.expectedError == "" {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), test.expectedError)
+			}
+		})
+	}
+}
+
+func TestEqual(t *testing.T) {
+	tests := []struct {
+		name     string
+		a        *FeeConfig
+		b        *FeeConfig
+		expected bool
+	}{
+		{
+			name: "equal",
+			a:    &validFeeConfig,
+			b: &FeeConfig{
+				GasLimit:        big.NewInt(8_000_000),
+				TargetBlockRate: 2, // in seconds
+
+				MinBaseFee:               big.NewInt(25_000_000_000),
+				TargetGas:                big.NewInt(15_000_000),
+				BaseFeeChangeDenominator: big.NewInt(36),
+
+				MinBlockGasCost:  big.NewInt(0),
+				MaxBlockGasCost:  big.NewInt(1_000_000),
+				BlockGasCostStep: big.NewInt(200_000),
+			},
+			expected: true,
+		},
+		{
+			name:     "not equal",
+			a:        &validFeeConfig,
+			b:        func() *FeeConfig { c := validFeeConfig; c.GasLimit = big.NewInt(1); return &c }(),
+			expected: false,
+		},
+		{
+			name:     "not equal nil",
+			a:        &validFeeConfig,
+			b:        nil,
+			expected: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			require.Equal(t, test.expected, test.a.Equal(test.b))
+		})
+	}
+}

core/genesis_test.go

@@ -183,7 +183,7 @@ func TestStatefulPrecompilesConfigure(t *testing.T) {
 		"allow list enabled in genesis": {
 			getConfig: func() *params.ChainConfig {
 				config := *params.TestChainConfig
-				config.ContractDeployerAllowListConfig = precompile.NewContractDeployerAllowListConfig(big.NewInt(0), []common.Address{addr})
+				config.ContractDeployerAllowListConfig = precompile.NewContractDeployerAllowListConfig(big.NewInt(0), []common.Address{addr}, nil)
 				return &config
 			},
 			assertState: func(t *testing.T, sdb *state.StateDB) {

core/state_processor_test.go

@@ -332,7 +332,7 @@ func TestBadTxAllowListBlock(t *testing.T) {
 				SubnetEVMTimestamp: big.NewInt(0),
 			},
 			PrecompileUpgrade: params.PrecompileUpgrade{
-				TxAllowListConfig: precompile.NewTxAllowListConfig(big.NewInt(0), []common.Address{}),
+				TxAllowListConfig: precompile.NewTxAllowListConfig(big.NewInt(0), nil, nil),
 			},
 		}
 		signer     = types.LatestSigner(config)