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,8 +28,12 @@ var _ precompileconfig.Config = &Config{}
 // adds specific configuration for {{.Contract.Type}}.
 type Config struct {
 	{{- if .Contract.AllowList}}
+	// Serialize allowList to let nodes exchange information about their
+	// precompile configs
 	allowlist.AllowListConfig
 	{{- end}}
+	// Serialize the Upgrade config to let nodes exchange information about
+	// their precompile configs
 	precompileconfig.Upgrade
 	// 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) MarshalBinary() ([]byte, error) {
+	return nil, errors.New("implement MarshalBinary() method")
+}
+
+func (c * Config) UnmarshalBinary(bytes []byte) error {
+	return errors.New("implement UnmarshalBinary() method")
+}
+
 // NewDisableConfig returns config for a network upgrade at [blockTimestamp]
 // that disables {{.Contract.Type}}.
 func NewDisableConfig(blockTimestamp *uint64) *Config {

accounts/abi/bind/precompilebind/precompile_config_test_template.go

@@ -13,6 +13,7 @@ package {{.Package}}
 import (
 	"testing"
 
+	"github.com/ava-labs/subnet-evm/params"
 	"github.com/ava-labs/subnet-evm/precompile/precompileconfig"
 	"github.com/ava-labs/subnet-evm/precompile/testutils"
 	"github.com/ava-labs/subnet-evm/utils"
@@ -22,6 +23,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	{{- end}}
 	"go.uber.org/mock/gomock"
+	"github.com/stretchr/testify/require"
 )
 
 // TestVerify tests the verification of Config.
@@ -61,6 +63,35 @@ func TestVerify(t *testing.T) {
 	{{- end}}
 }
 
+func TestSerialize(t *testing.T) {
+	var t0 uint64 = 2
+	var t1 uint64 = 1001
+
+	config := params.UpgradeConfig{
+		PrecompileUpgrades: []params.PrecompileUpgrade{
+			{
+				Config: NewConfig(&t0,
+				{{- if .Contract.AllowList}}
+				[]common.Address{
+					common.BytesToAddress(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020")),
+					common.BytesToAddress(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000030")),
+				}, []common.Address{
+					common.BytesToAddress(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")),
+				}, []common.Address{
+					common.BytesToAddress(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000050")),
+				},
+				{{- end}}
+				), // enable at genesis
+			},
+			{
+				Config: NewDisableConfig(&t1), // disable at timestamp 1
+			},
+		},
+	}
+	require.NotNil(t, config)
+	//params.AssertConfigHashesAndSerialization(t, &config)
+}
+
 // TestEqual tests the equality of Config with other precompile configs.
 func TestEqual(t *testing.T) {
 	{{- if .Contract.AllowList}}

commontype/fee_config.go

@@ -7,7 +7,9 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ava-labs/avalanchego/utils/wrappers"
 	"github.com/ava-labs/subnet-evm/utils"
+	"github.com/docker/docker/pkg/units"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -144,6 +146,65 @@ 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) MarshalBinary() ([]byte, error) {
+	p := wrappers.Packer{
+		Bytes:   []byte{},
+		MaxSize: 1 * units.MiB,
+	}
+
+	for _, bigint := range c.getBigIntToSerialize() {
+		p.PackBool(*bigint == nil)
+		if p.Err != nil {
+			return nil, p.Err
+		}
+		if bigint != nil {
+			p.PackBytes((*bigint).Bytes())
+			if p.Err != nil {
+				return nil, p.Err
+			}
+		}
+	}
+	p.PackLong(c.TargetBlockRate)
+	if p.Err != nil {
+		return nil, p.Err
+	}
+
+	return p.Bytes, nil
+}
+
+func (c *FeeConfig) UnmarshalBinary(data []byte) error {
+	p := wrappers.Packer{
+		Bytes: data,
+	}
+	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.go

@@ -27,17 +27,23 @@
 package params
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
+	"testing"
 
 	"github.com/ava-labs/avalanchego/snow"
+	"github.com/ava-labs/avalanchego/utils/wrappers"
 	"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/docker/docker/pkg/units"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/stretchr/testify/require"
 )
 
 const maxJSONLen = 64 * 1024 * 1024 // 64MB
@@ -67,6 +73,17 @@ var (
 		MaxBlockGasCost:  big.NewInt(1_000_000),
 		BlockGasCostStep: big.NewInt(200_000),
 	}
+
+	// For UpgradeConfig Marshal/Unmarshal
+	magicHeader              = []byte{0xff}
+	sectionHeaderSizes       = 1
+	precompileHeader         = []byte{0xaa}
+	stateUpdateHeader        = []byte{0xc8}
+	endHeader                = []byte{0}
+	ErrIncorrectHeader       = errors.New("invalid magic header")
+	ErrMalformedConfigHeader = errors.New("malformed config header")
+	ErrUnknowPrecompile      = errors.New("unknown precompile config")
+	MaxMessageSize           = 1 * units.MiB
 )
 
 var (
@@ -171,6 +188,142 @@ type UpgradeConfig struct {
 	PrecompileUpgrades []PrecompileUpgrade `json:"precompileUpgrades,omitempty"`
 }
 
+func (c *UpgradeConfig) Hash() (common.Hash, error) {
+	bytes, err := c.MarshalBinary()
+	if err != nil {
+		return common.Hash{}, err
+	}
+	return crypto.Keccak256Hash(bytes), nil
+}
+
+func (c *UpgradeConfig) MarshalBinary() ([]byte, error) {
+	p := wrappers.Packer{
+		Bytes:   []byte{},
+		MaxSize: MaxMessageSize,
+	}
+	p.PackFixedBytes(magicHeader)
+	if p.Err != nil {
+		return nil, p.Err
+	}
+
+	p.PackBool(c.OptionalNetworkUpgrades == nil)
+	if p.Err != nil {
+		return nil, p.Err
+	}
+	if c.OptionalNetworkUpgrades != nil {
+		bytes, err := c.OptionalNetworkUpgrades.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+		p.PackBytes(bytes)
+		if p.Err != nil {
+			return nil, p.Err
+		}
+	}
+
+	for _, precompileConfig := range c.PrecompileUpgrades {
+		bytes, err := precompileConfig.Config.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+		p.PackFixedBytes(precompileHeader)
+		if p.Err != nil {
+			return nil, p.Err
+		}
+		p.PackStr(precompileConfig.Key())
+		if p.Err != nil {
+			return nil, p.Err
+		}
+		p.PackBytes(bytes)
+		if p.Err != nil {
+			return nil, p.Err
+		}
+	}
+
+	for _, config := range c.StateUpgrades {
+		bytes, err := config.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+		p.PackFixedBytes(stateUpdateHeader)
+		if p.Err != nil {
+			return nil, p.Err
+		}
+		p.PackBytes(bytes)
+		if p.Err != nil {
+			return nil, p.Err
+		}
+	}
+
+	p.PackFixedBytes(endHeader)
+
+	return p.Bytes, nil
+}
+
+func (c *UpgradeConfig) UnmarshalBinary(data []byte) error {
+	p := wrappers.Packer{
+		Bytes: data,
+	}
+	if !bytes.Equal(p.UnpackFixedBytes(sectionHeaderSizes), magicHeader) {
+		return ErrIncorrectHeader
+	}
+	if p.Err != nil {
+		return p.Err
+	}
+
+	isNil := p.UnpackBool()
+	if !isNil {
+		c.OptionalNetworkUpgrades = &OptionalNetworkUpgrades{}
+		bytes := p.UnpackBytes()
+		if p.Err != nil {
+			return p.Err
+		}
+		if err := c.OptionalNetworkUpgrades.UnmarshalBinary(bytes); err != nil {
+			return nil
+		}
+	}
+
+	for {
+		header := p.UnpackFixedBytes(sectionHeaderSizes)
+		if p.Err != nil {
+			return p.Err
+		}
+		if bytes.Equal(header, precompileHeader) {
+			key := p.UnpackStr()
+			if p.Err != nil {
+				return p.Err
+			}
+			config := p.UnpackBytes()
+			if p.Err != nil {
+				return p.Err
+			}
+			module, ok := modules.GetPrecompileModule(key)
+			if !ok {
+				return ErrUnknowPrecompile
+			}
+			preCompile := module.MakeConfig()
+			err := preCompile.UnmarshalBinary(config)
+			if err != nil {
+				return err
+			}
+			c.PrecompileUpgrades = append(c.PrecompileUpgrades, PrecompileUpgrade{Config: preCompile})
+		} else if bytes.Equal(header, stateUpdateHeader) {
+			config := p.UnpackBytes()
+			stateUpgrade := StateUpgrade{}
+			if err := stateUpgrade.UnmarshalBinary(config); err != nil {
+				return err
+			}
+			c.StateUpgrades = append(c.StateUpgrades, stateUpgrade)
+		} else if bytes.Equal(header, endHeader) {
+			break
+		} else {
+			return ErrMalformedConfigHeader
+		}
+	}
+
+	return nil
+}
+
 // AvalancheContext provides Avalanche specific context directly into the EVM.
 type AvalancheContext struct {
 	SnowCtx *snow.Context
@@ -865,3 +1018,36 @@ func (c *ChainConfig) ToWithUpgradesJSON() *ChainConfigWithUpgradesJSON {
 		UpgradeConfig: c.UpgradeConfig,
 	}
 }
+
+// Checks if messages have the same hash
+//
+// `message` is the simulation of a configuration being parsed from the local
+// config. `message2` is parsing a message being exchanged through the network
+// (a foreign config), and `message3` is the the deserialization and
+// serialization of the foreign config. All 3 instances should have the same
+// hashing, depite maybe not being identical (some configurations may be in a
+// different order, but our hashing algorithm is resilient to those changes,
+// thanks for our serialization library, which produces always the same output.
+func AssertConfigHashesAndSerialization(t *testing.T, originalConfig *UpgradeConfig) {
+	bytes, err := originalConfig.MarshalBinary()
+	require.NoError(t, err)
+
+	deserializedConfig := UpgradeConfig{}
+	require.NoError(t, deserializedConfig.UnmarshalBinary(bytes))
+
+	twiceDeserialized := UpgradeConfig{}
+	newBytes, err := deserializedConfig.MarshalBinary()
+	require.NoError(t, err)
+	require.NoError(t, twiceDeserialized.UnmarshalBinary(newBytes))
+
+	hash1, err := originalConfig.Hash()
+	require.NoError(t, err)
+	hash2, err := deserializedConfig.Hash()
+	require.NoError(t, err)
+	hash3, err := twiceDeserialized.Hash()
+	require.NoError(t, err)
+
+	require.Equal(t, deserializedConfig, twiceDeserialized)
+	require.Equal(t, hash1, hash2)
+	require.Equal(t, hash2, hash3)
+}