refactor: remove params dependency on modules

accounts/abi/bind/precompilebind/precompile_config_template.go

@@ -15,9 +15,9 @@ import (
 	{{- if .Contract.AllowList}}
 	"github.com/ava-labs/subnet-evm/precompile/allowlist"
 
-	"github.com/ethereum/go-ethereum/common"
 	{{- end}}
-
+
+	"github.com/ethereum/go-ethereum/common"
 )
 
 var _ precompileconfig.Config = &Config{}
@@ -63,6 +63,10 @@ func NewDisableConfig(blockTimestamp *uint64) *Config {
 // This should be the same key as used in the precompile module.
 func (*Config) Key() string { return ConfigKey }
 
+// Address returns the address for the {{.Contract.Type}} precompileconfig.
+// This should be the same key as used in the precompile module.
+func (*Config) Address() common.Address { return ContractAddress }
+
 // Verify tries to verify Config and returns an error accordingly.
 func (c *Config) Verify(chainConfig precompileconfig.ChainConfig) error {
 	{{- if .Contract.AllowList}}

core/rawdb/accessors_metadata.go

@@ -35,6 +35,14 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rlp"
+
+	// This side-effect import goes against recommendations for not using blank
+	// imports in libraries: https://google.github.io/styleguide/go/decisions#import-blank-import-_
+	// This is deliberate because the ReadChainConfig() method only logs errors
+	// and doesn't bubble them up; this caused hours of problems in development!
+	// The described cons of using a blank import here are _far_ outweighed by
+	// the benefits.
+	_ "github.com/ava-labs/subnet-evm/params/paramsjson" // registers JSON unmarshalers to avoid circular dependency
 )
 
 // ReadDatabaseVersion retrieves the version number of the database.

eth/tracers/internal/tracetest/calltrace_test.go

@@ -45,6 +45,8 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/rlp"
+
+	_ "github.com/ava-labs/subnet-evm/params/paramsjson" // registers JSON unmarshalers to avoid circular dependency
 )
 
 type callContext struct {

params/config.go

@@ -36,7 +36,6 @@ import (
 	"github.com/ava-labs/avalanchego/utils/constants"
 	"github.com/ava-labs/avalanchego/version"
 	"github.com/ava-labs/subnet-evm/commontype"
-	"github.com/ava-labs/subnet-evm/precompile/modules"
 	"github.com/ava-labs/subnet-evm/precompile/precompileconfig"
 	"github.com/ava-labs/subnet-evm/utils"
 	"github.com/ethereum/go-ethereum/common"
@@ -751,27 +750,29 @@ func (c *ChainConfig) rules(num *big.Int, timestamp uint64) Rules {
 // Rules returns the Avalanche modified rules to support Avalanche
 // network upgrades
 func (c *ChainConfig) Rules(blockNum *big.Int, timestamp uint64) Rules {
-	rules := c.rules(blockNum, timestamp)
-
-	rules.AvalancheRules = c.GetAvalancheRules(timestamp)
-
-	// Initialize the stateful precompiles that should be enabled at [blockTimestamp].
-	rules.ActivePrecompiles = make(map[common.Address]precompileconfig.Config)
-	rules.Predicaters = make(map[common.Address]precompileconfig.Predicater)
-	rules.AccepterPrecompiles = make(map[common.Address]precompileconfig.Accepter)
-	for _, module := range modules.RegisteredModules() {
-		if config := c.getActivePrecompileConfig(module.Address, timestamp); config != nil && !config.IsDisabled() {
-			rules.ActivePrecompiles[module.Address] = config
-			if predicater, ok := config.(precompileconfig.Predicater); ok {
-				rules.Predicaters[module.Address] = predicater
-			}
-			if precompileAccepter, ok := config.(precompileconfig.Accepter); ok {
-				rules.AccepterPrecompiles[module.Address] = precompileAccepter
-			}
+	r := c.rules(blockNum, timestamp)
+	r.AvalancheRules = c.GetAvalancheRules(timestamp)
+
+	r.ActivePrecompiles = make(map[common.Address]precompileconfig.Config)
+	r.Predicaters = make(map[common.Address]precompileconfig.Predicater)
+	r.AccepterPrecompiles = make(map[common.Address]precompileconfig.Accepter)
+
+	for _, addr := range c.allPrecompileAddresses() {
+		cfg := c.getActivePrecompileConfig(addr, timestamp)
+		if cfg == nil || cfg.IsDisabled() {
+			continue
+		}
+		r.ActivePrecompiles[addr] = cfg
+
+		if p, ok := cfg.(precompileconfig.Predicater); ok {
+			r.Predicaters[addr] = p
+		}
+		if a, ok := cfg.(precompileconfig.Accepter); ok {
+			r.AccepterPrecompiles[addr] = a
 		}
 	}
 
-	return rules
+	return r
 }
 
 // GetFeeConfig returns the original FeeConfig contained in the genesis ChainConfig.

params/config_extra.go

@@ -31,26 +31,6 @@ type AvalancheContext struct {
 	SnowCtx *snow.Context
 }
 
-// UnmarshalJSON parses the JSON-encoded data and stores the result in the
-// object pointed to by c.
-// This is a custom unmarshaler to handle the Precompiles field.
-// Precompiles was presented as an inline object in the JSON.
-// This custom unmarshaler ensures backwards compatibility with the old format.
-func (c *ChainConfig) UnmarshalJSON(data []byte) error {
-	// Alias ChainConfig to avoid recursion
-	type _ChainConfig ChainConfig
-	tmp := _ChainConfig{}
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-
-	// At this point we have populated all fields except PrecompileUpgrade
-	*c = ChainConfig(tmp)
-
-	// Unmarshal inlined PrecompileUpgrade
-	return json.Unmarshal(data, &c.GenesisPrecompiles)
-}
-
 // MarshalJSON returns the JSON encoding of c.
 // This is a custom marshaler to handle the Precompiles field.
 func (c ChainConfig) MarshalJSON() ([]byte, error) {
@@ -119,25 +99,6 @@ func (cu ChainConfigWithUpgradesJSON) MarshalJSON() ([]byte, error) {
 	return mergedJSON, nil
 }
 
-func (cu *ChainConfigWithUpgradesJSON) UnmarshalJSON(input []byte) error {
-	var cc ChainConfig
-	if err := json.Unmarshal(input, &cc); err != nil {
-		return err
-	}
-
-	type upgrades struct {
-		UpgradeConfig UpgradeConfig `json:"upgrades"`
-	}
-
-	var u upgrades
-	if err := json.Unmarshal(input, &u); err != nil {
-		return err
-	}
-	cu.ChainConfig = cc
-	cu.UpgradeConfig = u.UpgradeConfig
-	return nil
-}
-
 // ToWithUpgradesJSON converts the ChainConfig to ChainConfigWithUpgradesJSON with upgrades explicitly displayed.
 // ChainConfig does not include upgrades in its JSON output.
 // This is a workaround for showing upgrades in the JSON output.

params/config_test.go

@@ -24,7 +24,7 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-package params
+package params_test
 
 import (
 	"encoding/json"
@@ -39,7 +39,11 @@ import (
 	"github.com/ava-labs/subnet-evm/precompile/contracts/txallowlist"
 	"github.com/ava-labs/subnet-evm/utils"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	. "github.com/ava-labs/subnet-evm/params"
+	_ "github.com/ava-labs/subnet-evm/params/paramsjson" // registers JSON unmarshalers to avoid circular dependency
 )
 
 func TestCheckCompatible(t *testing.T) {
@@ -211,8 +215,8 @@ func TestConfigUnmarshalJSON(t *testing.T) {
 		}
 	}
 	`)
-	c := ChainConfig{}
-	err := json.Unmarshal(config, &c)
+	c := &ChainConfig{}
+	err := json.Unmarshal(config, c)
 	require.NoError(err)
 
 	require.Equal(c.ChainID, big.NewInt(43214))
@@ -230,14 +234,14 @@ func TestConfigUnmarshalJSON(t *testing.T) {
 	// Marshal and unmarshal again and check that the result is the same
 	marshaled, err := json.Marshal(c)
 	require.NoError(err)
-	c2 := ChainConfig{}
-	err = json.Unmarshal(marshaled, &c2)
+	c2 := &ChainConfig{}
+	err = json.Unmarshal(marshaled, c2)
 	require.NoError(err)
 	require.Equal(c, c2)
 }
 
 func TestActivePrecompiles(t *testing.T) {
-	config := ChainConfig{
+	config := &ChainConfig{
 		UpgradeConfig: UpgradeConfig{
 			PrecompileUpgrades: []PrecompileUpgrade{
 				{
@@ -251,10 +255,10 @@ func TestActivePrecompiles(t *testing.T) {
 	}
 
 	rules0 := config.Rules(common.Big0, 0)
-	require.True(t, rules0.IsPrecompileEnabled(nativeminter.Module.Address))
+	assert.True(t, rules0.IsPrecompileEnabled(nativeminter.Module.Address))
 
 	rules1 := config.Rules(common.Big0, 1)
-	require.False(t, rules1.IsPrecompileEnabled(nativeminter.Module.Address))
+	assert.False(t, rules1.IsPrecompileEnabled(nativeminter.Module.Address))
 }
 
 func TestChainConfigMarshalWithUpgrades(t *testing.T) {

params/json.go

@@ -0,0 +1,82 @@
+package params
+
+import (
+	"fmt"
+)
+
+// A JSONUnmarshaler is a type-safe function for unmarshalling a JSON buffer
+// into a specific type.
+type JSONUnmarshaler[T any] func([]byte, T) error
+
+var jsonUmarshalers struct {
+	cc JSONUnmarshaler[*ChainConfig]
+	cu JSONUnmarshaler[*ChainConfigWithUpgradesJSON]
+	uc JSONUnmarshaler[*UpgradeConfig]
+	pu JSONUnmarshaler[*PrecompileUpgrade]
+}
+
+// MustRegisterJSONUnmarshalers registers the JSON unmarshalling functions for
+// various types. This allows their unmarshalling behaviour to be injected by
+// the [params/paramsjson] package, which can't be directly imported as it would
+// result in a circular dependency.
+//
+// This function SHOULD NOT be called directly. Instead, blank import the
+// [params/paramsjson] package, which registers unmarshalers in its init()
+// function.
+//
+// MustRegisterJSONUnmarshalers panics if any functions are nil or if called
+// more than once.
+func MustRegisterJSONUnmarshalers(
+	cc JSONUnmarshaler[*ChainConfig],
+	cu JSONUnmarshaler[*ChainConfigWithUpgradesJSON],
+	uc JSONUnmarshaler[*UpgradeConfig],
+	pu JSONUnmarshaler[*PrecompileUpgrade],
+) {
+	if jsonUmarshalers.cc != nil {
+		panic("JSON unmarshalers already registered")
+	}
+	panicIfNil(cc)
+	panicIfNil(cu)
+	panicIfNil(uc)
+	panicIfNil(pu)
+
+	jsonUmarshalers.cc = cc
+	jsonUmarshalers.cu = cu
+	jsonUmarshalers.uc = uc
+	jsonUmarshalers.pu = pu
+}
+
+func panicIfNil[T any](fn JSONUnmarshaler[T]) {
+	if fn == nil {
+		panic(fmt.Sprintf("registering nil %T", fn))
+	}
+}
+
+func unmarshalJSON[T any](u JSONUnmarshaler[T], data []byte, v T) error {
+	if u == nil {
+		return fmt.Errorf(`%T is nil; did you remember to import _ "github.com/ava-labs/subnet-evm/params/paramsjson"`, u)
+	}
+	return u(data, v)
+}
+
+// UnmarshalJSON parses the JSON-encoded data and stores the result in the
+// object pointed to by c.
+// This is a custom unmarshaler to handle the Precompiles field.
+// Precompiles was presented as an inline object in the JSON.
+// This custom unmarshaler ensures backwards compatibility with the old format.
+// TODO(arr4n) update this method comment DO NOT MERGE
+func (c *ChainConfig) UnmarshalJSON(data []byte) error {
+	return unmarshalJSON(jsonUmarshalers.cc, data, c)
+}
+
+func (cu *ChainConfigWithUpgradesJSON) UnmarshalJSON(data []byte) error {
+	return unmarshalJSON(jsonUmarshalers.cu, data, cu)
+}
+
+func (u *UpgradeConfig) UnmarshalJSON(data []byte) error {
+	return unmarshalJSON(jsonUmarshalers.uc, data, u)
+}
+
+func (u *PrecompileUpgrade) UnmarshalJSON(data []byte) error {
+	return unmarshalJSON(jsonUmarshalers.pu, data, u)
+}