Add handshake codec

accounts/abi/bind/precompilebind/precompile_config_template.go

@@ -12,6 +12,9 @@ package {{.Package}}
 
 import (
 	"github.com/ava-labs/subnet-evm/precompile/precompileconfig"
+	"github.com/ava-labs/avalanchego/utils/wrappers"
+	"github.com/docker/docker/pkg/units"
+
 	{{- if .Contract.AllowList}}
 	"github.com/ava-labs/subnet-evm/precompile/allowlist"
 
@@ -48,6 +51,50 @@ func NewConfig(blockTimestamp *uint64{{if .Contract.AllowList}}, admins []common
 	}
 }
 
+func (c * Config) MarshalBinary() ([]byte, error) {
+	p := wrappers.Packer {
+		Bytes: []byte{},
+		MaxSize: 1 * units.MiB,
+	}
+	{{- if .Contract.AllowList}}
+	allowBytes, err := c.AllowListConfig.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+	p.PackBytes(allowBytes)
+	if p.Err != nil {
+		return nil, p.Err
+	}
+	{{- end}}
+	upgradeBytes, err := c.Upgrade.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+	p.PackBytes(upgradeBytes)
+	return p.Bytes, p.Err
+}
+
+func (c * Config) UnmarshalBinary(bytes []byte) error {
+	p := wrappers.Packer {
+		Bytes: bytes,
+	}
+	{{- if .Contract.AllowList}}
+	allowList := p.UnpackBytes()
+	if p.Err != nil {
+		return p.Err
+	}
+	if err := c.AllowListConfig.UnmarshalBinary(allowList); err != nil {
+		return err
+	}
+	{{- end}}
+	upgrade := p.UnpackBytes()
+	if p.Err != nil {
+		return p.Err
+	}
+
+	return c.Upgrade.UnmarshalBinary(upgrade)
+}
+
 // 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}}
+				),
+			},
+			{
+				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,98 @@ func (f *FeeConfig) checkByteLens() error {
 	return nil
 }
 
+func (c *FeeConfig) MarshalBinary() ([]byte, error) {
+	p := wrappers.Packer{
+		Bytes:   []byte{},
+		MaxSize: 1 * units.MiB,
+	}
+
+	if err := utils.PackBigInt(&p, c.GasLimit); err != nil {
+		return nil, err
+	}
+
+	if err := utils.PackBigInt(&p, c.MinBaseFee); err != nil {
+		return nil, err
+	}
+
+	if err := utils.PackBigInt(&p, c.TargetGas); err != nil {
+		return nil, err
+	}
+
+	if err := utils.PackBigInt(&p, c.BaseFeeChangeDenominator); err != nil {
+		return nil, err
+	}
+
+	if err := utils.PackBigInt(&p, c.MinBlockGasCost); err != nil {
+		return nil, err
+	}
+
+	if err := utils.PackBigInt(&p, c.MaxBlockGasCost); err != nil {
+		return nil, err
+	}
+
+	if err := utils.PackBigInt(&p, c.BlockGasCostStep); err != nil {
+		return nil, 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,
+	}
+
+	var err error
+
+	c.GasLimit, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return err
+	}
+
+	c.MinBaseFee, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return err
+	}
+
+	c.TargetGas, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return err
+	}
+
+	c.BaseFeeChangeDenominator, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return err
+	}
+
+	c.MinBlockGasCost, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return err
+	}
+
+	c.MaxBlockGasCost, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return err
+	}
+
+	c.BlockGasCostStep, err = utils.UnpackBigInt(&p)
+	if err != nil {
+		return 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