Add handshake codec

accounts/abi/bind/precompilebind/precompile_config_template.go

@@ -11,6 +11,8 @@ const tmplSourcePrecompileConfigGo = `
 package {{.Package}}
 
 import (
+	"errors"
+
 	"github.com/ava-labs/subnet-evm/precompile/precompileconfig"
 	{{- if .Contract.AllowList}}
 	"github.com/ava-labs/subnet-evm/precompile/allowlist"
@@ -26,9 +28,13 @@ var _ precompileconfig.Config = &Config{}
 // adds specific configuration for {{.Contract.Type}}.
 type Config struct {
 	{{- if .Contract.AllowList}}
-	allowlist.AllowListConfig
+	// Serialize allowList to let nodes exchange information about their
+	// precompile configs
+	allowlist.AllowListConfig ` + "`" + `serialize:"true"` + "`" + `
 	{{- end}}
-	precompileconfig.Upgrade
+	// Serialize the Upgrade config to let nodes exchange information about
+	// their precompile configs
+	precompileconfig.Upgrade ` + "`" + `serialize:"true"` + "`" + `
 	// CUSTOM CODE STARTS HERE
 	// Add your own custom fields for Config here
 }
@@ -48,6 +54,14 @@ func NewConfig(blockTimestamp *uint64{{if .Contract.AllowList}}, admins []common
 	}
 }
 
+func (c * Config) ToBytes() ([]byte, error) {
+	return nil, errors.New("implement ToBytes() method")
+}
+
+func (c * Config) FromBytes(bytes []byte) error {
+	return errors.New("implement FromBytes() method")
+}
+
 // NewDisableConfig returns config for a network upgrade at [blockTimestamp]
 // that disables {{.Contract.Type}}.
 func NewDisableConfig(blockTimestamp *uint64) *Config {

commontype/fee_config.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ava-labs/avalanchego/utils/wrappers"
 	"github.com/ava-labs/subnet-evm/utils"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -144,6 +145,57 @@ func (f *FeeConfig) checkByteLens() error {
 	return nil
 }
 
+func (c *FeeConfig) getBigIntToSerialize() []**big.Int {
+	return []**big.Int{
+		&c.GasLimit, &c.MinBaseFee, &c.TargetGas, &c.BaseFeeChangeDenominator,
+		&c.MinBlockGasCost, &c.MaxBlockGasCost, &c.BlockGasCostStep,
+	}
+}
+
+func (c *FeeConfig) ToBytesWithPacker(p *wrappers.Packer) error {
+	for _, bigint := range c.getBigIntToSerialize() {
+		p.PackBool(*bigint == nil)
+		if p.Err != nil {
+			return p.Err
+		}
+		if bigint != nil {
+			p.PackBytes((*bigint).Bytes())
+			if p.Err != nil {
+				return p.Err
+			}
+		}
+	}
+	p.PackLong(c.TargetBlockRate)
+	if p.Err != nil {
+		return p.Err
+	}
+
+	return nil
+}
+
+func (c *FeeConfig) FromBytesWithPacker(p *wrappers.Packer) error {
+	for _, bigint := range c.getBigIntToSerialize() {
+		isNil := p.UnpackBool()
+		if p.Err != nil {
+			return p.Err
+		}
+		if isNil {
+			continue
+		}
+		*bigint = big.NewInt(0).SetBytes(p.UnpackBytes())
+		if p.Err != nil {
+			return p.Err
+		}
+	}
+
+	c.TargetBlockRate = p.UnpackLong()
+	if p.Err != nil {
+		return p.Err
+	}
+
+	return nil
+}
+
 func isBiggerThanHashLen(bigint *big.Int) bool {
 	buf := bigint.Bytes()
 	isBigger := len(buf) > common.HashLength

params/config_test.go

@@ -328,3 +328,75 @@ func TestChainConfigMarshalWithUpgrades(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, config, unmarshalled)
 }
+
+func TestChainConfigMarshalWithUpgradesAndOptionalUpgrade(t *testing.T) {
+	config := ChainConfigWithUpgradesJSON{
+		ChainConfig: ChainConfig{
+			ChainID:             big.NewInt(1),
+			FeeConfig:           DefaultFeeConfig,
+			AllowFeeRecipients:  false,
+			HomesteadBlock:      big.NewInt(0),
+			EIP150Block:         big.NewInt(0),
+			EIP155Block:         big.NewInt(0),
+			EIP158Block:         big.NewInt(0),
+			ByzantiumBlock:      big.NewInt(0),
+			ConstantinopleBlock: big.NewInt(0),
+			PetersburgBlock:     big.NewInt(0),
+			IstanbulBlock:       big.NewInt(0),
+			MuirGlacierBlock:    big.NewInt(0),
+			MandatoryNetworkUpgrades: MandatoryNetworkUpgrades{
+				SubnetEVMTimestamp: utils.NewUint64(0),
+				DUpgradeTimestamp:  utils.NewUint64(0),
+			},
+			GenesisPrecompiles: Precompiles{},
+		},
+		UpgradeConfig: UpgradeConfig{
+			PrecompileUpgrades: []PrecompileUpgrade{
+				{
+					Config: txallowlist.NewConfig(utils.NewUint64(100), nil, nil, nil),
+				},
+			},
+		},
+	}
+	result, err := json.Marshal(&config)
+	require.NoError(t, err)
+	expectedJSON := `{
+		"chainId": 1,
+		"feeConfig": {
+			"gasLimit": 8000000,
+			"targetBlockRate": 2,
+			"minBaseFee": 25000000000,
+			"targetGas": 15000000,
+			"baseFeeChangeDenominator": 36,
+			"minBlockGasCost": 0,
+			"maxBlockGasCost": 1000000,
+			"blockGasCostStep": 200000
+		},
+		"homesteadBlock": 0,
+		"eip150Block": 0,
+		"eip155Block": 0,
+		"eip158Block": 0,
+		"byzantiumBlock": 0,
+		"constantinopleBlock": 0,
+		"petersburgBlock": 0,
+		"istanbulBlock": 0,
+		"muirGlacierBlock": 0,
+		"subnetEVMTimestamp": 0,
+		"dUpgradeTimestamp": 0,
+		"upgrades": {
+			"precompileUpgrades": [
+				{
+					"txAllowListConfig": {
+						"blockTimestamp": 100
+					}
+				}
+			]
+		}
+	}`
+	require.JSONEq(t, expectedJSON, string(result))
+
+	var unmarshalled ChainConfigWithUpgradesJSON
+	err = json.Unmarshal(result, &unmarshalled)
+	require.NoError(t, err)
+	require.Equal(t, config, unmarshalled)
+}

params/network_upgrades.go

@@ -64,16 +64,17 @@ func (m *MandatoryNetworkUpgrades) mandatoryForkOrder() []fork {
 	}
 }
 
-// OptionalNetworkUpgrades includes overridable and optional Subnet-EVM network upgrades.
-// These can be specified in genesis and upgrade configs.
-// Timestamps can be different for each subnet network.
-// TODO: once we add the first optional upgrade here, we should uncomment TestVMUpgradeBytesOptionalNetworkUpgrades
-type OptionalNetworkUpgrades struct{}
+type OptionalNetworkUpgrades struct {
+	// This is an example of a configuration.
+	//FeatureConfig *uint64 `json:"test,omitempty" serialize:"true,nullable"`
+}
 
 func (n *OptionalNetworkUpgrades) CheckOptionalCompatible(newcfg *OptionalNetworkUpgrades, time uint64) *ConfigCompatError {
 	return nil
 }
 
 func (n *OptionalNetworkUpgrades) optionalForkOrder() []fork {
-	return []fork{}
+	return []fork{
+		// {name: "foo", timestamp: n.FooBar},
+	}
 }

params/state_upgrade.go

@@ -16,18 +16,18 @@ import (
 // StateUpgrade describes the modifications to be made to the state during
 // a state upgrade.
 type StateUpgrade struct {
-	BlockTimestamp *uint64 `json:"blockTimestamp,omitempty"`
+	BlockTimestamp *uint64 `json:"blockTimestamp,omitempty" serialize:"true"`
 
 	// map from account address to the modification to be made to the account.
-	StateUpgradeAccounts map[common.Address]StateUpgradeAccount `json:"accounts"`
+	StateUpgradeAccounts map[common.Address]StateUpgradeAccount `json:"accounts" serialize:"true"`
 }
 
 // StateUpgradeAccount describes the modifications to be made to an account during
 // a state upgrade.
 type StateUpgradeAccount struct {
-	Code          hexutil.Bytes               `json:"code,omitempty"`
-	Storage       map[common.Hash]common.Hash `json:"storage,omitempty"`
-	BalanceChange *math.HexOrDecimal256       `json:"balanceChange,omitempty"`
+	Code          hexutil.Bytes               `json:"code,omitempty" serialize:"true"`
+	Storage       map[common.Hash]common.Hash `json:"storage,omitempty" serialize:"true"`
+	BalanceChange *math.HexOrDecimal256       `json:"balanceChange,omitempty" serialize:"true"`
 }
 
 func (s *StateUpgrade) Equal(other *StateUpgrade) bool {

plugin/evm/message/handshake/codec.go

@@ -0,0 +1,43 @@
+// (c) 2019-2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package handshake
+
+import (
+	"errors"
+
+	"github.com/ava-labs/avalanchego/codec"
+	"github.com/ava-labs/avalanchego/codec/linearcodec"
+	"github.com/ava-labs/avalanchego/utils/units"
+	"github.com/ava-labs/avalanchego/utils/wrappers"
+)
+
+const (
+	Version        = uint16(0)
+	maxMessageSize = 1 * units.MiB
+)
+
+var (
+	ErrInvalidVersion   = errors.New("invalid version")
+	ErrUnknowPrecompile = errors.New("unknown precompile config")
+	Codec               codec.Manager
+)
+
+func init() {
+	Codec = codec.NewManager(maxMessageSize)
+	c := linearcodec.NewDefault()
+
+	errs := wrappers.Errs{}
+	errs.Add(
+		c.RegisterType(networkUpgradeConfigMessage{}),
+
+		Codec.RegisterCodec(Version, c),
+	)
+
+	if errs.Errored() {
+		panic(errs.Err)
+	}
+}

plugin/evm/message/handshake/upgrade_config_message.go

@@ -0,0 +1,115 @@
+// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package handshake
+
+import (
+	"github.com/ava-labs/subnet-evm/params"
+	"github.com/ava-labs/subnet-evm/precompile/modules"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+type rawPrecompileUpgrade struct {
+	Key   string `serialize:"true"`
+	Bytes []byte `serialize:"true"`
+}
+
+type networkUpgradeConfigMessage struct {
+	OptionalNetworkUpgrades *params.OptionalNetworkUpgrades `serialize:"true,nullable"`
+	// Config for modifying state as a network upgrade.
+	StateUpgrades []params.StateUpgrade `serialize:"true"`
+	// Config for enabling and disabling precompiles as network upgrades.
+	PrecompileUpgrades []rawPrecompileUpgrade `serialize:"true"`
+}
+
+type UpgradeConfigMessage struct {
+	bytes []byte
+	hash  common.Hash
+}
+
+func (u *UpgradeConfigMessage) Bytes() []byte {
+	return u.bytes
+}
+
+func (u *UpgradeConfigMessage) ID() common.Hash {
+	return u.hash
+}
+
+// Attempts to parse a networkUpgradeConfigMessage from a []byte
+//
+// This function attempts to parse a stream of bytes as a
+// networkUpgradeConfigMessage (as serialized from
+// UpgradeConfigToNetworkMessage).
+//
+// The function returns a reference of *params.UpgradeConfig
+func NewUpgradeConfigMessageFromBytes(bytes []byte) (*params.UpgradeConfig, error) {
+	var config networkUpgradeConfigMessage
+	version, err := Codec.Unmarshal(bytes, &config)
+	if err != nil {
+		return nil, err
+	}
+	if version != Version {
+		return nil, ErrInvalidVersion
+	}
+
+	var PrecompileUpgrades []params.PrecompileUpgrade
+	for _, precompileUpgrade := range config.PrecompileUpgrades {
+		module, ok := modules.GetPrecompileModule(precompileUpgrade.Key)
+		if !ok {
+			return nil, ErrUnknowPrecompile
+		}
+		preCompile := module.MakeConfig()
+		err := preCompile.FromBytes(precompileUpgrade.Bytes)
+		if err != nil {
+			return nil, err
+		}
+		PrecompileUpgrades = append(PrecompileUpgrades, params.PrecompileUpgrade{Config: preCompile})
+	}
+
+	return &params.UpgradeConfig{
+		OptionalNetworkUpgrades: config.OptionalNetworkUpgrades,
+		StateUpgrades:           config.StateUpgrades,
+		PrecompileUpgrades:      PrecompileUpgrades,
+	}, nil
+}
+
+// Wraps an instance of *params.UpgradeConfig
+//
+// This function returns the serialized UpgradeConfig, ready to be send over to
+// other peers. The struct also includes a hash of the content, ready to be used
+// as part of the handshake protocol.
+//
+// Since params.UpgradeConfig should never change without a node reloading, it
+// is safe to call this function once and store its output globally to re-use
+// multiple times
+func NewUpgradeConfigMessage(config *params.UpgradeConfig) (*UpgradeConfigMessage, error) {
+	PrecompileUpgrades := make([]rawPrecompileUpgrade, 0)
+	for _, precompileConfig := range config.PrecompileUpgrades {
+		bytes, err := precompileConfig.Config.ToBytes()
+		if err != nil {
+			return nil, err
+		}
+		PrecompileUpgrades = append(PrecompileUpgrades, rawPrecompileUpgrade{
+			Key:   precompileConfig.Key(),
+			Bytes: bytes,
+		})
+	}
+
+	wrappedConfig := networkUpgradeConfigMessage{
+		OptionalNetworkUpgrades: config.OptionalNetworkUpgrades,
+		StateUpgrades:           config.StateUpgrades,
+		PrecompileUpgrades:      PrecompileUpgrades,
+	}
+
+	bytes, err := Codec.Marshal(Version, wrappedConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	hash := crypto.Keccak256Hash(bytes)
+	return &UpgradeConfigMessage{
+		bytes: bytes,
+		hash:  hash,
+	}, nil
+}