cerc-io/laconicd-deprecated
19
0
Fork 1
Code Issues 21 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

upgrade to ethermint v0.21.0 #99

Closed
0xmuralik wants to merge 384 commits from murali/update-fork into main
pull from: murali/update-fork
merge into: cerc-io:main
Conversation 1 Commits 384 Files Changed 309 +279 -179
5 changed files with 279 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 44486cc632 - Show all commits

26
x/evm/migrations/v4/migrate.go
View File

@ -4,6 +4,8 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
sdk "github.com/cosmos/cosmos-sdk/types"
v4types "github.com/evmos/ethermint/x/evm/migrations/v4/types"
"github.com/evmos/ethermint/x/evm/types"
)
@ -17,19 +19,33 @@ func MigrateStore(
cdc codec.BinaryCodec,
) error {
var params types.Params
legacySubspace.GetParamSetIfExists(ctx, &params)
if err := params.Validate(); err != nil {
return err
}
bz, err := cdc.Marshal(&params)
if err != nil {
return err
}
chainCfgBz := cdc.MustMarshal(&params.ChainConfig)
extraEIPsBz := cdc.MustMarshal(&v4types.ExtraEIPs{EIPs: params.ExtraEIPs})
store := ctx.KVStore(storeKey)
store.Set(types.KeyPrefixParams, bz)
store.Set(types.ParamStoreKeyEVMDenom, []byte(params.EvmDenom))
store.Set(types.ParamStoreKeyExtraEIPs, extraEIPsBz)
store.Set(types.ParamStoreKeyChainConfig, chainCfgBz)
if params.AllowUnprotectedTxs {
store.Set(types.ParamStoreKeyAllowUnprotectedTxs, []byte{0x01})
}
if params.EnableCall {
store.Set(types.ParamStoreKeyEnableCall, []byte{0x01})
}
if params.EnableCreate {
store.Set(types.ParamStoreKeyEnableCreate, []byte{0x01})
}
return nil
}

40
x/evm/migrations/v4/migrate_test.go
View File

@ -5,13 +5,14 @@ import (
"github.com/stretchr/testify/require"
"github.com/evmos/ethermint/x/evm/types"
"github.com/cosmos/cosmos-sdk/testutil"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/evmos/ethermint/app"
"github.com/evmos/ethermint/encoding"
v4 "github.com/evmos/ethermint/x/evm/migrations/v4"
"github.com/evmos/ethermint/x/evm/types"
v4types "github.com/evmos/ethermint/x/evm/migrations/v4/types"
)
type mockSubspace struct {
@ -38,9 +39,36 @@ func TestMigrate(t *testing.T) {
legacySubspace := newMockSubspace(types.DefaultParams())
require.NoError(t, v4.MigrateStore(ctx, storeKey, legacySubspace, cdc))
paramsBz := kvStore.Get(types.KeyPrefixParams)
var params types.Params
cdc.MustUnmarshal(paramsBz, &params)
// Get all the new parameters from the kvStore
var evmDenom string
bz := kvStore.Get(types.ParamStoreKeyEVMDenom)
evmDenom = string(bz)
require.Equal(t, params, legacySubspace.ps)
allowUnprotectedTx := kvStore.Has(types.ParamStoreKeyAllowUnprotectedTxs)
enableCreate := kvStore.Has(types.ParamStoreKeyEnableCreate)
enableCall := kvStore.Has(types.ParamStoreKeyEnableCall)
var chainCfg v4types.V4ChainConfig
bz = kvStore.Get(types.ParamStoreKeyChainConfig)
cdc.MustUnmarshal(bz, &chainCfg)
var extraEIPs v4types.ExtraEIPs
bz = kvStore.Get(types.ParamStoreKeyExtraEIPs)
cdc.MustUnmarshal(bz, &extraEIPs)
require.Equal(t, []int64(nil), extraEIPs.EIPs)
params := v4types.V4Params{
EvmDenom: evmDenom,
AllowUnprotectedTxs: allowUnprotectedTx,
EnableCreate: enableCreate,
EnableCall: enableCall,
V4ChainConfig: chainCfg,
ExtraEIPs: extraEIPs,
}
require.Equal(t, legacySubspace.ps.EnableCall, params.EnableCall)
require.Equal(t, legacySubspace.ps.EnableCreate, params.EnableCreate)
require.Equal(t, legacySubspace.ps.AllowUnprotectedTxs, params.AllowUnprotectedTxs)
require.Equal(t, legacySubspace.ps.ExtraEIPs, params.ExtraEIPs.EIPs)
require.EqualValues(t, legacySubspace.ps.ChainConfig, params.V4ChainConfig)
}

383
x/evm/migrations/v4/types/evm.pb.go generated
View File

@ -34,7 +34,7 @@ type V4Params struct {
// enable_call toggles V4State transitions that use the vm.Call function
EnableCall bool `protobuf:"varint,3,opt,name=enable_call,json=enableCall,proto3" json:"enable_call,omitempty" yaml:"enable_call"`
// extra_eips defines the additional EIPs for the vm.Config
// repeated int64 extra_eips = 4 [(gogoproto.customname) = "V4ExtraEIPs", (gogoproto.moretags) = "yaml:\"extra_eips\""];
ExtraEIPs ExtraEIPs `protobuf:"bytes,4,opt,name=extra_eips,json=extraEips,proto3" json:"extra_eips" yaml:"extra_eips"`
// chain_config defines the EVM chain configuration parameters
V4ChainConfig V4ChainConfig `protobuf:"bytes,5,opt,name=chain_config,json=V4ChainConfig,proto3" json:"chain_config" yaml:"chain_config"`
// allow_unprotected_txs defines if replay-protected (i.e non EIP155
@ -96,6 +96,13 @@ func (m *V4Params) GetEnableCall() bool {
return false
}
func (m *V4Params) GetExtraEIPs() ExtraEIPs {
if m != nil {
return m.ExtraEIPs
}
return ExtraEIPs{}
}
func (m *V4Params) GetV4ChainConfig() V4ChainConfig {
if m != nil {
return m.V4ChainConfig
@ -110,24 +117,24 @@ func (m *V4Params) GetAllowUnprotectedTxs() bool {
return false
}
// V4ExtraEIPs represents extra EIPs for the vm.Config
type V4ExtraEIPs struct {
// ExtraEIPs represents extra EIPs for the vm.Config
type ExtraEIPs struct {
// eips defines the additional EIPs for the vm.Config
EIPs []int64 `protobuf:"varint,1,rep,packed,name=extra_eips,json=V4ExtraEIPs,proto3" json:"extra_eips,omitempty" yaml:"eips"`
EIPs []int64 `protobuf:"varint,1,rep,packed,name=eips,proto3" json:"eips,omitempty" yaml:"eips"`
}
func (m *V4ExtraEIPs) Reset() { *m = V4ExtraEIPs{} }
func (m *V4ExtraEIPs) String() string { return proto.CompactTextString(m) }
func (*V4ExtraEIPs) ProtoMessage() {}
func (*V4ExtraEIPs) Descriptor() ([]byte, []int) {
func (m *ExtraEIPs) Reset() { *m = ExtraEIPs{} }
func (m *ExtraEIPs) String() string { return proto.CompactTextString(m) }
func (*ExtraEIPs) ProtoMessage() {}
func (*ExtraEIPs) Descriptor() ([]byte, []int) {
return fileDescriptor_d21ecc92c8c8583e, []int{1}
}
func (m *V4ExtraEIPs) XXX_Unmarshal(b []byte) error {
func (m *ExtraEIPs) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *V4ExtraEIPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *ExtraEIPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_V4ExtraEIPs.Marshal(b, m, deterministic)
return xxx_messageInfo_ExtraEIPs.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@ -137,19 +144,19 @@ func (m *V4ExtraEIPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return b[:n], nil
}
}
func (m *V4ExtraEIPs) XXX_Merge(src proto.Message) {
xxx_messageInfo_V4ExtraEIPs.Merge(m, src)
func (m *ExtraEIPs) XXX_Merge(src proto.Message) {
xxx_messageInfo_ExtraEIPs.Merge(m, src)
}
func (m *V4ExtraEIPs) XXX_Size() int {
func (m *ExtraEIPs) XXX_Size() int {
return m.Size()
}
func (m *V4ExtraEIPs) XXX_DiscardUnknown() {
xxx_messageInfo_V4ExtraEIPs.DiscardUnknown(m)
func (m *ExtraEIPs) XXX_DiscardUnknown() {
xxx_messageInfo_ExtraEIPs.DiscardUnknown(m)
}
var xxx_messageInfo_V4ExtraEIPs proto.InternalMessageInfo
var xxx_messageInfo_ExtraEIPs proto.InternalMessageInfo
func (m *V4ExtraEIPs) GetEIPs() []int64 {
func (m *ExtraEIPs) GetEIPs() []int64 {
if m != nil {
return m.EIPs
}
@ -302,28 +309,28 @@ func (m *V4State) GetValue() string {
return ""
}
// V4TransactionV4Logs define the V4Logs generated from a transaction execution
// TransactionV4Logs define the V4Logs generated from a transaction execution
// with a given hash. It it used for import/export data as transactions are not
// persisted on blockchain V4State after an upgrade.
type V4TransactionV4Logs struct {
type TransactionV4Logs struct {
// hash of the transaction
Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
// V4Logs is an array of V4Logs for the given transaction hash
V4Logs []*V4Log `protobuf:"bytes,2,rep,name=V4Logs,proto3" json:"V4Logs,omitempty"`
}
func (m *V4TransactionV4Logs) Reset() { *m = V4TransactionV4Logs{} }
func (m *V4TransactionV4Logs) String() string { return proto.CompactTextString(m) }
func (*V4TransactionV4Logs) ProtoMessage() {}
func (*V4TransactionV4Logs) Descriptor() ([]byte, []int) {
func (m *TransactionV4Logs) Reset() { *m = TransactionV4Logs{} }
func (m *TransactionV4Logs) String() string { return proto.CompactTextString(m) }
func (*TransactionV4Logs) ProtoMessage() {}
func (*TransactionV4Logs) Descriptor() ([]byte, []int) {
return fileDescriptor_d21ecc92c8c8583e, []int{4}
}
func (m *V4TransactionV4Logs) XXX_Unmarshal(b []byte) error {
func (m *TransactionV4Logs) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *V4TransactionV4Logs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *TransactionV4Logs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_V4TransactionV4Logs.Marshal(b, m, deterministic)
return xxx_messageInfo_TransactionV4Logs.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@ -333,26 +340,26 @@ func (m *V4TransactionV4Logs) XXX_Marshal(b []byte, deterministic bool) ([]byte,
return b[:n], nil
}
}
func (m *V4TransactionV4Logs) XXX_Merge(src proto.Message) {
xxx_messageInfo_V4TransactionV4Logs.Merge(m, src)
func (m *TransactionV4Logs) XXX_Merge(src proto.Message) {
xxx_messageInfo_TransactionV4Logs.Merge(m, src)
}
func (m *V4TransactionV4Logs) XXX_Size() int {
func (m *TransactionV4Logs) XXX_Size() int {
return m.Size()
}
func (m *V4TransactionV4Logs) XXX_DiscardUnknown() {
xxx_messageInfo_V4TransactionV4Logs.DiscardUnknown(m)
func (m *TransactionV4Logs) XXX_DiscardUnknown() {
xxx_messageInfo_TransactionV4Logs.DiscardUnknown(m)
}
var xxx_messageInfo_V4TransactionV4Logs proto.InternalMessageInfo
var xxx_messageInfo_TransactionV4Logs proto.InternalMessageInfo
func (m *V4TransactionV4Logs) GetHash() string {
func (m *TransactionV4Logs) GetHash() string {
if m != nil {
return m.Hash
}
return ""
}
func (m *V4TransactionV4Logs) GetV4Logs() []*V4Log {
func (m *TransactionV4Logs) GetV4Logs() []*V4Log {
if m != nil {
return m.V4Logs
}
@ -494,7 +501,7 @@ type V4TxResult struct {
Bloom []byte `protobuf:"bytes,2,opt,name=bloom,proto3" json:"bloom,omitempty"`
// tx_V4Logs contains the transaction hash and the proto-compatible ethereum
// V4Logs.
TxV4Logs V4TransactionV4Logs `protobuf:"bytes,3,opt,name=tx_V4Logs,json=txV4Logs,proto3" json:"tx_V4Logs" yaml:"tx_V4Logs"`
TxV4Logs TransactionV4Logs `protobuf:"bytes,3,opt,name=tx_V4Logs,json=txV4Logs,proto3" json:"tx_V4Logs" yaml:"tx_V4Logs"`
// ret defines the bytes from the execution.
Ret []byte `protobuf:"bytes,4,opt,name=ret,proto3" json:"ret,omitempty"`
// reverted flag is set to true when the call has been reverted
@ -716,10 +723,10 @@ func (m *V4TraceConfig) GetTracerJsonConfig() string {
func init() {
proto.RegisterType((*V4Params)(nil), "ethermint.evm.v1.V4Params")
proto.RegisterType((*V4ExtraEIPs)(nil), "ethermint.evm.v1.V4ExtraEIPs")
proto.RegisterType((*ExtraEIPs)(nil), "ethermint.evm.v1.ExtraEIPs")
proto.RegisterType((*V4ChainConfig)(nil), "ethermint.evm.v1.V4ChainConfig")
proto.RegisterType((*V4State)(nil), "ethermint.evm.v1.V4State")
proto.RegisterType((*V4TransactionV4Logs)(nil), "ethermint.evm.v1.V4TransactionV4Logs")
proto.RegisterType((*TransactionV4Logs)(nil), "ethermint.evm.v1.TransactionV4Logs")
proto.RegisterType((*V4Log)(nil), "ethermint.evm.v1.V4Log")
proto.RegisterType((*V4TxResult)(nil), "ethermint.evm.v1.V4TxResult")
proto.RegisterType((*V4AccessTuple)(nil), "ethermint.evm.v1.V4AccessTuple")
@ -729,109 +736,110 @@ func init() {
func init() { proto.RegisterFile("ethermint/evm/v1/evm.proto", fileDescriptor_d21ecc92c8c8583e) }
var fileDescriptor_d21ecc92c8c8583e = []byte{
// 1626 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xdd, 0x6e, 0xe3, 0xc6,
0x15, 0xf6, 0x0f, 0x6d, 0x53, 0x23, 0x59, 0xe2, 0x8e, 0xb5, 0x5e, 0x65, 0x17, 0x35, 0x5d, 0x5e,
0x14, 0x2e, 0x90, 0x58, 0xb1, 0x13, 0xb7, 0x8b, 0x04, 0x2d, 0xb0, 0xf2, 0x3a, 0x89, 0xdd, 0xed,
0xd6, 0x18, 0x3b, 0x28, 0x50, 0xa0, 0x20, 0x46, 0xe4, 0x84, 0x62, 0x4c, 0x72, 0x84, 0x99, 0xa1,
0x56, 0x6a, 0xfb, 0x00, 0x05, 0x7a, 0xd3, 0x27, 0x28, 0xf2, 0x34, 0x45, 0xd0, 0xab, 0x5c, 0x16,
0xbd, 0x20, 0x0a, 0xef, 0x9d, 0x2f, 0xf5, 0x04, 0xc5, 0xfc, 0x88, 0xfa, 0xb1, 0xd1, 0xd6, 0xba,
0xf2, 0x7c, 0xe7, 0x9c, 0xf9, 0xbe, 0x39, 0x67, 0xce, 0x78, 0x86, 0x02, 0xcf, 0x89, 0xe8, 0x11,
0x96, 0xc6, 0x99, 0x68, 0x93, 0x41, 0xda, 0x1e, 0x1c, 0xc9, 0x3f, 0x87, 0x7d, 0x46, 0x05, 0x85,
0x4e, 0xe9, 0x3b, 0x94, 0xc6, 0xc1, 0xd1, 0xf3, 0x66, 0x44, 0x23, 0xaa, 0x9c, 0x6d, 0x39, 0xd2,
0x71, 0xde, 0xdf, 0xd7, 0xc0, 0xe6, 0x25, 0x66, 0x38, 0xe5, 0xf0, 0x08, 0x54, 0xc8, 0x20, 0xf5,
0x43, 0x92, 0xd1, 0xb4, 0xb5, 0xba, 0xbf, 0x7a, 0x50, 0xe9, 0x34, 0xc7, 0x85, 0xeb, 0x8c, 0x70,
0x9a, 0x7c, 0xe6, 0x95, 0x2e, 0x0f, 0xd9, 0x64, 0x90, 0xbe, 0x96, 0x43, 0xf8, 0x0b, 0xb0, 0x4d,
0x32, 0xdc, 0x4d, 0x88, 0x1f, 0x30, 0x82, 0x05, 0x69, 0xad, 0xed, 0xaf, 0x1e, 0xd8, 0x9d, 0xd6,
0xb8, 0x70, 0x9b, 0x66, 0xda, 0xac, 0xdb, 0x43, 0x35, 0x8d, 0x4f, 0x15, 0x84, 0x3f, 0x07, 0xd5,
0x89, 0x1f, 0x27, 0x49, 0x6b, 0x5d, 0x4d, 0xde, 0x1d, 0x17, 0x2e, 0x9c, 0x9f, 0x8c, 0x93, 0xc4,
0x43, 0xc0, 0x4c, 0xc5, 0x49, 0x02, 0x7f, 0x0f, 0x6a, 0x41, 0x0f, 0xc7, 0x99, 0x1f, 0xd0, 0xec,
0x9b, 0x38, 0x6a, 0x6d, 0xec, 0xaf, 0x1e, 0x54, 0x8f, 0x7f, 0x74, 0xb8, 0x98, 0xf4, 0xe1, 0xa9,
0x8c, 0x3a, 0x55, 0x41, 0x9d, 0x17, 0xdf, 0x17, 0xee, 0xca, 0xb8, 0x70, 0x77, 0x34, 0xf9, 0x2c,
0x81, 0x87, 0xaa, 0xc1, 0x34, 0x12, 0x1e, 0x83, 0xa7, 0x38, 0x49, 0xe8, 0x3b, 0x3f, 0xcf, 0x64,
0x95, 0x48, 0x20, 0x48, 0xe8, 0x8b, 0x21, 0x6f, 0x6d, 0xca, 0x15, 0xa2, 0x1d, 0xe5, 0xfc, 0x7a,
0xea, 0xbb, 0x1e, 0x72, 0xef, 0x14, 0x54, 0xce, 0x86, 0x82, 0xe1, 0xb3, 0xf3, 0x4b, 0x0e, 0x7f,
0x06, 0x00, 0x91, 0xc0, 0x27, 0x71, 0x9f, 0xb7, 0x56, 0xf7, 0xd7, 0x0f, 0xd6, 0x3b, 0xcf, 0x6e,
0x0b, 0xd7, 0x92, 0xde, 0x71, 0xe1, 0x56, 0x4d, 0x7e, 0x71, 0x9f, 0x7b, 0xa8, 0xa2, 0x42, 0xcf,
0xe4, 0xf8, 0x6f, 0x4f, 0x40, 0x75, 0x66, 0xc9, 0x30, 0x05, 0x8d, 0x1e, 0x4d, 0x09, 0x17, 0x04,
0x87, 0x7e, 0x37, 0xa1, 0xc1, 0x8d, 0xd9, 0x98, 0xd7, 0xff, 0x2a, 0xdc, 0x9f, 0x44, 0xb1, 0xe8,
0xe5, 0xdd, 0xc3, 0x80, 0xa6, 0xed, 0x80, 0xf2, 0x94, 0x72, 0xf3, 0xe7, 0x23, 0x1e, 0xde, 0xb4,
0xc5, 0xa8, 0x4f, 0xf8, 0xe1, 0x79, 0x26, 0xc6, 0x85, 0xbb, 0xab, 0xe5, 0x16, 0xa8, 0x3c, 0x54,
0x2f, 0x2d, 0x1d, 0x69, 0x80, 0x23, 0x50, 0x0f, 0x31, 0xf5, 0xbf, 0xa1, 0xec, 0xc6, 0xa8, 0xad,
0x29, 0xb5, 0xab, 0xff, 0x5f, 0xed, 0xb6, 0x70, 0x6b, 0xaf, 0x5f, 0xfd, 0xe6, 0x0b, 0xca, 0x6e,
0x14, 0xe7, 0xb8, 0x70, 0x9f, 0x6a, 0xf5, 0x79, 0x66, 0x0f, 0xd5, 0x42, 0x4c, 0xcb, 0x30, 0xf8,
0x5b, 0xe0, 0x94, 0x01, 0x3c, 0xef, 0xf7, 0x29, 0x13, 0xa6, 0x1f, 0x3e, 0xba, 0x2d, 0xdc, 0xba,
0xa1, 0xbc, 0xd2, 0x9e, 0x71, 0xe1, 0x3e, 0x5b, 0x20, 0x35, 0x73, 0x3c, 0x54, 0x37, 0xb4, 0x26,
0x14, 0x72, 0x50, 0x23, 0x71, 0xff, 0xe8, 0xe4, 0x63, 0x93, 0x91, 0xa5, 0x32, 0xba, 0x7c, 0x54,
0x46, 0xd5, 0xb3, 0xf3, 0xcb, 0xa3, 0x93, 0x8f, 0x27, 0x09, 0xed, 0x94, 0xbb, 0x57, 0xd2, 0x7a,
0xa8, 0xaa, 0xa1, 0xce, 0xe6, 0x1c, 0x18, 0xe8, 0xf7, 0x30, 0xef, 0xa9, 0xf6, 0xac, 0x74, 0x0e,
0x6e, 0x0b, 0x17, 0x68, 0xa6, 0xaf, 0x30, 0xef, 0x4d, 0xf7, 0xa5, 0x3b, 0xfa, 0x03, 0xce, 0x44,
0x9c, 0xa7, 0x13, 0x2e, 0xa0, 0x27, 0xcb, 0xa8, 0x72, 0xfd, 0x27, 0x66, 0xfd, 0x9b, 0x4b, 0xaf,
0xff, 0xe4, 0xa1, 0xf5, 0x9f, 0xcc, 0xaf, 0x5f, 0xc7, 0x94, 0xa2, 0x2f, 0x8d, 0xe8, 0xd6, 0xd2,
0xa2, 0x2f, 0x1f, 0x12, 0x7d, 0x39, 0x2f, 0xaa, 0x63, 0x64, 0xb3, 0x2f, 0x54, 0xa2, 0x65, 0x2f,
0xdf, 0xec, 0xf7, 0x8a, 0x5a, 0x2f, 0x2d, 0x5a, 0xee, 0x4f, 0xa0, 0x19, 0xd0, 0x8c, 0x0b, 0x69,
0xcb, 0x68, 0x3f, 0x21, 0x46, 0xb3, 0xa2, 0x34, 0xcf, 0x1f, 0xa5, 0xf9, 0xc2, 0xfc, 0x4b, 0x79,
0x80, 0xcf, 0x43, 0x3b, 0xf3, 0x66, 0xad, 0xde, 0x07, 0x4e, 0x9f, 0x08, 0xc2, 0x78, 0x37, 0x67,
0x91, 0x51, 0x06, 0x4a, 0xf9, 0xec, 0x51, 0xca, 0xe6, 0x1c, 0x2c, 0x72, 0x79, 0xa8, 0x31, 0x35,
0x69, 0xc5, 0x6f, 0x41, 0x3d, 0x96, 0xcb, 0xe8, 0xe6, 0x89, 0xd1, 0xab, 0x2a, 0xbd, 0xd3, 0x47,
0xe9, 0x99, 0xc3, 0x3c, 0xcf, 0xe4, 0xa1, 0xed, 0x89, 0x41, 0x6b, 0xe5, 0x00, 0xa6, 0x79, 0xcc,
0xfc, 0x28, 0xc1, 0x41, 0x4c, 0x98, 0xd1, 0xab, 0x29, 0xbd, 0x2f, 0x1f, 0xa5, 0xf7, 0x81, 0xd6,
0xbb, 0xcf, 0xe6, 0x21, 0x47, 0x1a, 0xbf, 0xd4, 0x36, 0x2d, 0x1b, 0x82, 0x5a, 0x97, 0xb0, 0x24,
0xce, 0x8c, 0xe0, 0xb6, 0x12, 0x7c, 0xf5, 0x28, 0x41, 0xd3, 0xa7, 0xb3, 0x3c, 0x1e, 0xaa, 0x6a,
0x58, 0xaa, 0x24, 0x34, 0x0b, 0xe9, 0x44, 0xe5, 0xc9, 0xf2, 0x2a, 0xb3, 0x3c, 0x1e, 0xaa, 0x6a,
0xa8, 0x55, 0x86, 0x60, 0x07, 0x33, 0x46, 0xdf, 0x2d, 0xd4, 0x10, 0x2a, 0xb1, 0xaf, 0x1e, 0x25,
0xf6, 0x5c, 0x8b, 0x3d, 0x40, 0xe7, 0xa1, 0x27, 0xca, 0x3a, 0x57, 0xc5, 0x1c, 0xc0, 0x88, 0xe1,
0xd1, 0x82, 0x70, 0x73, 0xf9, 0xcd, 0xbb, 0xcf, 0xe6, 0x21, 0x47, 0x1a, 0xe7, 0x64, 0xff, 0x08,
0x9a, 0x29, 0x61, 0x11, 0xf1, 0x33, 0x22, 0x78, 0x3f, 0x89, 0x85, 0x11, 0x7e, 0xba, 0xfc, 0x79,
0x7c, 0x88, 0xcf, 0x43, 0x50, 0x99, 0xdf, 0x1a, 0x6b, 0x79, 0x38, 0x78, 0x0f, 0x67, 0x51, 0x0f,
0xc7, 0x46, 0x76, 0x77, 0xf9, 0xc3, 0x31, 0xcf, 0xe4, 0xa1, 0xed, 0x89, 0xa1, 0xec, 0x9f, 0x00,
0x67, 0x41, 0x3e, 0xe9, 0x9f, 0x67, 0xcb, 0xf7, 0xcf, 0x2c, 0x8f, 0x7c, 0xc3, 0x28, 0xa8, 0x54,
0x2e, 0x2c, 0xbb, 0xee, 0x34, 0x2e, 0x2c, 0xbb, 0xe1, 0x38, 0x17, 0x96, 0xed, 0x38, 0x4f, 0x2e,
0x2c, 0x7b, 0xc7, 0x69, 0xa2, 0xed, 0x11, 0x4d, 0xa8, 0x3f, 0xf8, 0x44, 0x4f, 0x42, 0x55, 0xf2,
0x0e, 0x73, 0xf3, 0x3f, 0x12, 0xd5, 0x03, 0x2c, 0x70, 0x32, 0xe2, 0xa6, 0x54, 0xc8, 0xd1, 0x05,
0x9c, 0xb9, 0xb5, 0xdb, 0x60, 0xe3, 0x4a, 0xc8, 0xa7, 0x9b, 0x03, 0xd6, 0x6f, 0xc8, 0x48, 0xbf,
0x46, 0x90, 0x1c, 0xc2, 0x26, 0xd8, 0x18, 0xe0, 0x24, 0xd7, 0x6f, 0xc0, 0x0a, 0xd2, 0xc0, 0xbb,
0x04, 0x8d, 0x6b, 0x86, 0x33, 0x8e, 0x03, 0x11, 0xd3, 0xec, 0x0d, 0x8d, 0x38, 0x84, 0xc0, 0x52,
0xb7, 0xa2, 0x9e, 0xab, 0xc6, 0xf0, 0xa7, 0xc0, 0x4a, 0x68, 0xc4, 0x5b, 0x6b, 0xfb, 0xeb, 0x07,
0xd5, 0xe3, 0xa7, 0xf7, 0x1f, 0x72, 0x6f, 0x68, 0x84, 0x54, 0x88, 0xf7, 0x8f, 0x35, 0xb0, 0xfe,
0x86, 0x46, 0xb0, 0x05, 0xb6, 0x70, 0x18, 0x32, 0xc2, 0xb9, 0x61, 0x9a, 0x40, 0xb8, 0x0b, 0x36,
0x05, 0xed, 0xc7, 0x81, 0xa6, 0xab, 0x20, 0x83, 0xa4, 0x70, 0x88, 0x05, 0x56, 0xef, 0x8a, 0x1a,
0x52, 0x63, 0x78, 0x0c, 0x6a, 0x2a, 0x33, 0x3f, 0xcb, 0xd3, 0x2e, 0x61, 0xea, 0x79, 0x60, 0x75,
0x1a, 0x77, 0x85, 0x5b, 0x55, 0xf6, 0xb7, 0xca, 0x8c, 0x66, 0x01, 0xfc, 0x10, 0x6c, 0x89, 0xe1,
0xec, 0xcd, 0xbe, 0x73, 0x57, 0xb8, 0x0d, 0x31, 0x4d, 0x53, 0x5e, 0xdc, 0x68, 0x53, 0x0c, 0xd5,
0x05, 0xde, 0x06, 0xb6, 0x18, 0xfa, 0x71, 0x16, 0x92, 0xa1, 0xba, 0xbc, 0xad, 0x4e, 0xf3, 0xae,
0x70, 0x9d, 0x99, 0xf0, 0x73, 0xe9, 0x43, 0x5b, 0x62, 0xa8, 0x06, 0xf0, 0x43, 0x00, 0xf4, 0x92,
0x94, 0x82, 0xbe, 0x7a, 0xb7, 0xef, 0x0a, 0xb7, 0xa2, 0xac, 0x8a, 0x7b, 0x3a, 0x84, 0x1e, 0xd8,
0xd0, 0xdc, 0xb6, 0xe2, 0xae, 0xdd, 0x15, 0xae, 0x9d, 0xd0, 0x48, 0x73, 0x6a, 0x97, 0x2c, 0x15,
0x23, 0x29, 0x1d, 0x90, 0x50, 0xdd, 0x6e, 0x36, 0x9a, 0x40, 0xef, 0x2f, 0x6b, 0xc0, 0xbe, 0x1e,
0x22, 0xc2, 0xf3, 0x44, 0xc0, 0x2f, 0x80, 0x13, 0xd0, 0x4c, 0x30, 0x1c, 0x08, 0x7f, 0xae, 0xb4,
0x9d, 0x17, 0xd3, 0x9b, 0x66, 0x31, 0xc2, 0x43, 0x8d, 0x89, 0xe9, 0x95, 0xa9, 0x7f, 0x13, 0x6c,
0x74, 0x13, 0x4a, 0x53, 0xd5, 0x09, 0x35, 0xa4, 0x01, 0x44, 0xaa, 0x6a, 0x6a, 0x97, 0xd7, 0xd5,
0x73, 0xfd, 0xc7, 0xf7, 0x77, 0x79, 0xa1, 0x55, 0x3a, 0xbb, 0xe6, 0xc9, 0x5e, 0xd7, 0xda, 0x66,
0xbe, 0x27, 0x6b, 0xab, 0x5a, 0xc9, 0x01, 0xeb, 0x8c, 0x08, 0xb5, 0x69, 0x35, 0x24, 0x87, 0xf0,
0x39, 0xb0, 0x19, 0x19, 0x10, 0x26, 0x48, 0xa8, 0x36, 0xc7, 0x46, 0x25, 0x86, 0x1f, 0x00, 0x3b,
0xc2, 0xdc, 0xcf, 0x39, 0x09, 0xf5, 0x4e, 0xa0, 0xad, 0x08, 0xf3, 0xaf, 0x39, 0x09, 0x3f, 0xb3,
0xfe, 0xfc, 0x9d, 0xbb, 0xe2, 0x61, 0x50, 0x7d, 0x15, 0x04, 0x84, 0xf3, 0xeb, 0xbc, 0x9f, 0x90,
0xff, 0xd2, 0x61, 0xc7, 0xa0, 0xc6, 0x05, 0x65, 0x38, 0x22, 0xfe, 0x0d, 0x19, 0x99, 0x3e, 0xd3,
0x5d, 0x63, 0xec, 0xbf, 0x22, 0x23, 0x8e, 0x66, 0x81, 0x91, 0xf8, 0xce, 0x02, 0xd5, 0x6b, 0x86,
0x03, 0x62, 0x5e, 0xf8, 0xb2, 0x57, 0x25, 0x64, 0x46, 0xc2, 0x20, 0xa9, 0x2d, 0xe2, 0x94, 0xd0,
0x5c, 0x98, 0xf3, 0x34, 0x81, 0x72, 0x06, 0x23, 0x64, 0x48, 0x02, 0x55, 0x46, 0x0b, 0x19, 0x04,
0x4f, 0xc0, 0x76, 0x18, 0x73, 0xf5, 0xc1, 0xc4, 0x05, 0x0e, 0x6e, 0x74, 0xfa, 0x1d, 0xe7, 0xae,
0x70, 0x6b, 0xc6, 0x71, 0x25, 0xed, 0x68, 0x0e, 0xc1, 0xcf, 0x41, 0x63, 0x3a, 0x4d, 0xad, 0x56,
0x7f, 0xe5, 0x74, 0xe0, 0x5d, 0xe1, 0xd6, 0xcb, 0x50, 0xe5, 0x41, 0x0b, 0x58, 0xee, 0x74, 0x48,
0xba, 0x79, 0xa4, 0x9a, 0xcf, 0x46, 0x1a, 0x48, 0x6b, 0x12, 0xa7, 0xb1, 0x50, 0xcd, 0xb6, 0x81,
0x34, 0x80, 0x9f, 0x83, 0x0a, 0x1d, 0x10, 0xc6, 0xe2, 0x90, 0x70, 0xf5, 0xd4, 0xf9, 0x5f, 0x1f,
0x6c, 0x68, 0x1a, 0x2f, 0x93, 0x33, 0x1f, 0x83, 0x29, 0x49, 0x29, 0x1b, 0xa9, 0xb7, 0x8b, 0x49,
0x4e, 0x3b, 0x7e, 0xad, 0xec, 0x68, 0x0e, 0xc1, 0x0e, 0x80, 0x66, 0x1a, 0x23, 0x22, 0x67, 0x99,
0xaf, 0xce, 0x7f, 0x4d, 0xcd, 0x55, 0xa7, 0x50, 0x7b, 0x91, 0x72, 0xbe, 0xc6, 0x02, 0xa3, 0x7b,
0x16, 0xf8, 0x4b, 0x00, 0xf5, 0x9e, 0xf8, 0xdf, 0x72, 0x5a, 0x7e, 0x71, 0xea, 0xa7, 0x85, 0xd2,
0xd7, 0x5e, 0xb3, 0x66, 0x47, 0xa3, 0x0b, 0x4e, 0x4d, 0x16, 0x17, 0x96, 0x6d, 0x39, 0x1b, 0x17,
0x96, 0xbd, 0xe5, 0xd8, 0x65, 0xfd, 0x4c, 0x16, 0x68, 0x67, 0x82, 0x67, 0x96, 0xd7, 0x79, 0xfb,
0xfd, 0xed, 0xde, 0xea, 0x0f, 0xb7, 0x7b, 0xab, 0xff, 0xbe, 0xdd, 0x5b, 0xfd, 0xeb, 0xfb, 0xbd,
0x95, 0x1f, 0xde, 0xef, 0xad, 0xfc, 0xf3, 0xfd, 0xde, 0xca, 0xef, 0x3e, 0x9d, 0xb9, 0x1f, 0xc8,
0x40, 0x5e, 0x0f, 0xd3, 0x5f, 0x00, 0x86, 0xea, 0x37, 0x80, 0x34, 0x8e, 0x18, 0x96, 0xc7, 0x87,
0xb7, 0x07, 0x9f, 0xea, 0x1b, 0xa3, 0xbb, 0xa9, 0xbe, 0xf4, 0x3f, 0xf9, 0x4f, 0x00, 0x00, 0x00,
0xff, 0xff, 0xd3, 0xe8, 0x0d, 0x45, 0x2f, 0x10, 0x00, 0x00,
// 1644 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0x4f, 0x6f, 0xe3, 0xc6,
0x15, 0xb7, 0x2d, 0xda, 0xa6, 0x46, 0xb2, 0x44, 0x8f, 0xb5, 0x5e, 0x65, 0x17, 0x35, 0x5d, 0x1e,
0x02, 0x17, 0x4d, 0xec, 0xd8, 0x81, 0xd1, 0x45, 0x82, 0x16, 0x5d, 0xed, 0x3a, 0x89, 0xdd, 0x6d,
0x6a, 0x8c, 0x1d, 0x14, 0x28, 0x50, 0x10, 0x23, 0x72, 0x42, 0x31, 0x26, 0x39, 0xc2, 0xcc, 0x50,
0x2b, 0xb5, 0xfd, 0x00, 0x05, 0x7a, 0xe9, 0x27, 0x28, 0x72, 0xee, 0x27, 0x09, 0x7a, 0xda, 0x63,
0xd1, 0x03, 0x51, 0x78, 0x6f, 0x3e, 0xea, 0x13, 0x14, 0xf3, 0x47, 0xd4, 0x1f, 0x1b, 0x6d, 0xad,
0x93, 0xe7, 0xf7, 0xde, 0x9b, 0xdf, 0x6f, 0xde, 0x9b, 0x37, 0x9e, 0xa1, 0xc0, 0x33, 0x22, 0x7a,
0x84, 0xa5, 0x71, 0x26, 0x8e, 0xc8, 0x20, 0x3d, 0x1a, 0x1c, 0xcb, 0x3f, 0x87, 0x7d, 0x46, 0x05,
0x85, 0x4e, 0xe9, 0x3b, 0x94, 0xc6, 0xc1, 0xf1, 0xb3, 0x56, 0x44, 0x23, 0xaa, 0x9c, 0x47, 0x72,
0xa4, 0xe3, 0xbc, 0xbf, 0x57, 0xc0, 0xc6, 0x25, 0x66, 0x38, 0xe5, 0xf0, 0x18, 0x54, 0xc9, 0x20,
0xf5, 0x43, 0x92, 0xd1, 0xb4, 0xbd, 0xba, 0xbf, 0x7a, 0x50, 0xed, 0xb4, 0xc6, 0x85, 0xeb, 0x8c,
0x70, 0x9a, 0x7c, 0xe6, 0x95, 0x2e, 0x0f, 0xd9, 0x64, 0x90, 0xbe, 0x96, 0x43, 0xf8, 0x73, 0xb0,
0x45, 0x32, 0xdc, 0x4d, 0x88, 0x1f, 0x30, 0x82, 0x05, 0x69, 0xaf, 0xed, 0xaf, 0x1e, 0xd8, 0x9d,
0xf6, 0xb8, 0x70, 0x5b, 0x66, 0xda, 0xac, 0xdb, 0x43, 0x75, 0x8d, 0x5f, 0x29, 0x08, 0x7f, 0x06,
0x6a, 0x13, 0x3f, 0x4e, 0x92, 0x76, 0x45, 0x4d, 0xde, 0x1d, 0x17, 0x2e, 0x9c, 0x9f, 0x8c, 0x93,
0xc4, 0x43, 0xc0, 0x4c, 0xc5, 0x49, 0x02, 0xbb, 0x00, 0x90, 0xa1, 0x60, 0xd8, 0x27, 0x71, 0x9f,
0xb7, 0xad, 0xfd, 0xd5, 0x83, 0xda, 0xc9, 0xf3, 0xc3, 0xc5, 0x94, 0x0f, 0xcf, 0x64, 0xcc, 0xd9,
0xf9, 0x25, 0xef, 0x7c, 0xf8, 0x43, 0xe1, 0xae, 0xdc, 0x16, 0x6e, 0xb5, 0x34, 0x8d, 0x0b, 0x77,
0xdb, 0xa8, 0x94, 0x4c, 0x1e, 0xaa, 0x2a, 0x70, 0x16, 0xf7, 0x39, 0xfc, 0x3d, 0xa8, 0x07, 0x3d,
0x1c, 0x67, 0x7e, 0x40, 0xb3, 0x6f, 0xe3, 0xa8, 0xbd, 0xae, 0x54, 0x7e, 0x74, 0x5f, 0xe5, 0x95,
0x8c, 0x7a, 0xa5, 0x82, 0x3a, 0xcf, 0xa5, 0xce, 0xb8, 0x70, 0x77, 0x34, 0xf5, 0x2c, 0x81, 0x87,
0x6a, 0xc1, 0x34, 0x12, 0x9e, 0x80, 0x27, 0x38, 0x49, 0xe8, 0x5b, 0x3f, 0xcf, 0xe4, 0x4e, 0x90,
0x40, 0x90, 0xd0, 0x17, 0x43, 0xde, 0xde, 0x90, 0x55, 0x40, 0x3b, 0xca, 0xf9, 0xcd, 0xd4, 0x77,
0x3d, 0xe4, 0xde, 0x0b, 0x30, 0x5d, 0x3f, 0xfc, 0x29, 0xb0, 0x54, 0xf6, 0xab, 0xfb, 0x95, 0x83,
0x4a, 0xe7, 0xe9, 0x6d, 0xe1, 0x5a, 0x26, 0xaf, 0x9a, 0xc9, 0x4b, 0x65, 0xa4, 0x82, 0xbc, 0xbf,
0x6d, 0x83, 0xda, 0xcc, 0x3a, 0x61, 0x0a, 0x9a, 0x3d, 0x9a, 0x12, 0x2e, 0x08, 0x0e, 0xfd, 0x6e,
0x42, 0x83, 0x1b, 0xb3, 0xe3, 0xaf, 0xff, 0x55, 0xb8, 0x1f, 0x46, 0xb1, 0xe8, 0xe5, 0xdd, 0xc3,
0x80, 0xa6, 0x47, 0x01, 0xe5, 0x29, 0xe5, 0xe6, 0xcf, 0xc7, 0x3c, 0xbc, 0x39, 0x12, 0xa3, 0x3e,
0xe1, 0x87, 0xe7, 0x99, 0x18, 0x17, 0xee, 0xae, 0x56, 0x5a, 0xa0, 0xf2, 0x50, 0xa3, 0xb4, 0x74,
0xa4, 0x01, 0x8e, 0x40, 0x23, 0xc4, 0xd4, 0xff, 0x96, 0xb2, 0x1b, 0xa3, 0xb6, 0xa6, 0xd4, 0xae,
0xfe, 0x7f, 0xb5, 0xdb, 0xc2, 0xad, 0xbf, 0x7e, 0xf9, 0x9b, 0x2f, 0x28, 0xbb, 0x51, 0x9c, 0xe3,
0xc2, 0x7d, 0xa2, 0xd5, 0xe7, 0x99, 0x3d, 0x54, 0x0f, 0x31, 0x2d, 0xc3, 0xe0, 0x6f, 0x81, 0x53,
0x06, 0xf0, 0xbc, 0xdf, 0xa7, 0x4c, 0x98, 0x46, 0xfb, 0xf8, 0xb6, 0x70, 0x1b, 0x86, 0xf2, 0x4a,
0x7b, 0xc6, 0x85, 0xfb, 0x74, 0x81, 0xd4, 0xcc, 0xf1, 0x50, 0xc3, 0xd0, 0x9a, 0x50, 0xc8, 0x41,
0x9d, 0xc4, 0xfd, 0xe3, 0xd3, 0x4f, 0x4c, 0x46, 0x96, 0xca, 0xe8, 0xf2, 0x51, 0x19, 0xd5, 0xce,
0xce, 0x2f, 0x8f, 0x4f, 0x3f, 0x99, 0x24, 0xb4, 0x53, 0x6e, 0x5c, 0x49, 0xeb, 0xa1, 0x9a, 0x86,
0x3a, 0x9b, 0x73, 0x60, 0xa0, 0xdf, 0xc3, 0xbc, 0xa7, 0x7a, 0xb2, 0xda, 0x39, 0xb8, 0x2d, 0x5c,
0xa0, 0x99, 0xbe, 0xc2, 0xbc, 0x37, 0xdd, 0x97, 0xee, 0xe8, 0x0f, 0x38, 0x13, 0x71, 0x9e, 0x4e,
0xb8, 0x80, 0x9e, 0x2c, 0xa3, 0xca, 0xf5, 0x9f, 0x9a, 0xf5, 0x6f, 0x2c, 0xbd, 0xfe, 0xd3, 0x87,
0xd6, 0x7f, 0x3a, 0xbf, 0x7e, 0x1d, 0x53, 0x8a, 0xbe, 0x30, 0xa2, 0x9b, 0x4b, 0x8b, 0xbe, 0x78,
0x48, 0xf4, 0xc5, 0xbc, 0xa8, 0x8e, 0x91, 0xcd, 0xbe, 0x50, 0x89, 0xb6, 0xbd, 0x7c, 0xb3, 0xdf,
0x2b, 0x6a, 0xa3, 0xb4, 0x68, 0xb9, 0x3f, 0x81, 0x56, 0x40, 0x33, 0x2e, 0xa4, 0x2d, 0xa3, 0xfd,
0x84, 0x18, 0xcd, 0xaa, 0xd2, 0x3c, 0x7f, 0x94, 0xe6, 0x73, 0xf3, 0x7f, 0xe4, 0x01, 0x3e, 0x0f,
0xed, 0xcc, 0x9b, 0xb5, 0x7a, 0x1f, 0x38, 0x7d, 0x22, 0x08, 0xe3, 0xdd, 0x9c, 0x45, 0x46, 0x19,
0x28, 0xe5, 0xb3, 0x47, 0x29, 0x9b, 0x73, 0xb0, 0xc8, 0xe5, 0xa1, 0xe6, 0xd4, 0xa4, 0x15, 0xbf,
0x03, 0x8d, 0x58, 0x2e, 0xa3, 0x9b, 0x27, 0x46, 0xaf, 0xa6, 0xf4, 0x5e, 0x3d, 0x4a, 0xcf, 0x1c,
0xe6, 0x79, 0x26, 0x0f, 0x6d, 0x4d, 0x0c, 0x5a, 0x2b, 0x07, 0x30, 0xcd, 0x63, 0xe6, 0x47, 0x09,
0x0e, 0x62, 0xc2, 0x8c, 0x5e, 0x5d, 0xe9, 0x7d, 0xf9, 0x28, 0xbd, 0x0f, 0xb4, 0xde, 0x7d, 0x36,
0x0f, 0x39, 0xd2, 0xf8, 0xa5, 0xb6, 0x69, 0xd9, 0x10, 0xd4, 0xbb, 0x84, 0x25, 0x71, 0x66, 0x04,
0xb7, 0x94, 0xe0, 0xcb, 0x47, 0x09, 0x9a, 0x3e, 0x9d, 0xe5, 0xf1, 0x50, 0x4d, 0xc3, 0x52, 0x25,
0xa1, 0x59, 0x48, 0x27, 0x2a, 0xdb, 0xcb, 0xab, 0xcc, 0xf2, 0x78, 0xa8, 0xa6, 0xa1, 0x56, 0x19,
0x82, 0x1d, 0xcc, 0x18, 0x7d, 0xbb, 0x50, 0x43, 0xa8, 0xc4, 0xbe, 0x7a, 0x94, 0xd8, 0x33, 0x2d,
0xf6, 0x00, 0x9d, 0x87, 0xb6, 0x95, 0x75, 0xae, 0x8a, 0x39, 0x80, 0x11, 0xc3, 0xa3, 0x05, 0xe1,
0xd6, 0xf2, 0x9b, 0x77, 0x9f, 0xcd, 0x43, 0x8e, 0x34, 0xce, 0xc9, 0xfe, 0x11, 0xb4, 0x52, 0xc2,
0x22, 0xe2, 0x67, 0x44, 0xf0, 0x7e, 0x12, 0x0b, 0x23, 0xfc, 0x64, 0xf9, 0xf3, 0xf8, 0x10, 0x9f,
0x87, 0xa0, 0x32, 0x7f, 0x6d, 0xac, 0xe5, 0xe1, 0xe0, 0x3d, 0x9c, 0x45, 0x3d, 0x1c, 0x1b, 0xd9,
0xdd, 0xe5, 0x0f, 0xc7, 0x3c, 0x93, 0x87, 0xb6, 0x26, 0x86, 0xb2, 0x7f, 0x02, 0x9c, 0x05, 0xf9,
0xa4, 0x7f, 0x9e, 0x2e, 0xdf, 0x3f, 0xb3, 0x3c, 0xf2, 0xe1, 0xa2, 0xa0, 0x52, 0xb9, 0xb0, 0xec,
0x86, 0xd3, 0xbc, 0xb0, 0xec, 0xa6, 0xe3, 0x5c, 0x58, 0xb6, 0xe3, 0x6c, 0x5f, 0x58, 0xf6, 0x8e,
0xd3, 0x42, 0x5b, 0x23, 0x9a, 0x50, 0x7f, 0xf0, 0xa9, 0x9e, 0x84, 0x6a, 0xe4, 0x2d, 0xe6, 0xe6,
0x7f, 0x24, 0x6a, 0x04, 0x58, 0xe0, 0x64, 0xc4, 0x4d, 0xa9, 0x90, 0xa3, 0x0b, 0x38, 0x73, 0x6b,
0x1f, 0x81, 0xf5, 0x2b, 0x21, 0xdf, 0x84, 0x0e, 0xa8, 0xdc, 0x90, 0x91, 0x7e, 0x8d, 0x20, 0x39,
0x84, 0x2d, 0xb0, 0x3e, 0xc0, 0x49, 0xae, 0x1f, 0x97, 0x55, 0xa4, 0x81, 0x77, 0x09, 0x9a, 0xd7,
0x0c, 0x67, 0x1c, 0x07, 0x22, 0xa6, 0xd9, 0x1b, 0x1a, 0x71, 0x08, 0x81, 0xa5, 0x6e, 0x45, 0x3d,
0x57, 0x8d, 0xe1, 0x4f, 0x80, 0x95, 0xd0, 0x88, 0xb7, 0xd7, 0xf6, 0x2b, 0x07, 0xb5, 0x93, 0x27,
0xf7, 0x5f, 0x6f, 0x6f, 0x68, 0x84, 0x54, 0x88, 0xf7, 0x8f, 0x35, 0x50, 0x79, 0x43, 0x23, 0xd8,
0x06, 0x9b, 0x38, 0x0c, 0x19, 0xe1, 0xdc, 0x30, 0x4d, 0x20, 0xdc, 0x05, 0x1b, 0x82, 0xf6, 0xe3,
0x40, 0xd3, 0x55, 0x91, 0x41, 0x52, 0x38, 0xc4, 0x02, 0xab, 0x77, 0x45, 0x1d, 0xa9, 0x31, 0x3c,
0x01, 0x75, 0x95, 0x99, 0x9f, 0xe5, 0x69, 0x97, 0x30, 0xf5, 0x3c, 0xb0, 0x3a, 0xcd, 0xbb, 0xc2,
0xad, 0x29, 0xfb, 0xd7, 0xca, 0x8c, 0x66, 0x01, 0xfc, 0x08, 0x6c, 0x8a, 0xe1, 0xec, 0xcd, 0xbe,
0x73, 0x57, 0xb8, 0x4d, 0x31, 0x4d, 0x53, 0x5e, 0xdc, 0x68, 0x43, 0x0c, 0xd5, 0x05, 0x7e, 0x04,
0x6c, 0x31, 0xf4, 0xe3, 0x2c, 0x24, 0x43, 0x75, 0x79, 0x5b, 0x9d, 0xd6, 0x5d, 0xe1, 0x3a, 0x33,
0xe1, 0xe7, 0xd2, 0x87, 0x36, 0xc5, 0x50, 0x0d, 0xe0, 0x47, 0x00, 0xe8, 0x25, 0x29, 0x05, 0x7d,
0xf5, 0x6e, 0xdd, 0x15, 0x6e, 0x55, 0x59, 0x15, 0xf7, 0x74, 0x08, 0x3d, 0xb0, 0xae, 0xb9, 0x6d,
0xc5, 0x5d, 0xbf, 0x2b, 0x5c, 0x3b, 0xa1, 0x91, 0xe6, 0xd4, 0x2e, 0x59, 0x2a, 0x46, 0x52, 0x3a,
0x20, 0xa1, 0xba, 0xdd, 0x6c, 0x34, 0x81, 0xde, 0x5f, 0xd6, 0x80, 0x7d, 0x3d, 0x44, 0x84, 0xe7,
0x89, 0x80, 0x5f, 0x00, 0x27, 0xa0, 0x99, 0x60, 0x38, 0x10, 0xfe, 0x5c, 0x69, 0x3b, 0xcf, 0xa7,
0x37, 0xcd, 0x62, 0x84, 0x87, 0x9a, 0x13, 0xd3, 0x4b, 0x53, 0xff, 0x16, 0x58, 0xef, 0x26, 0x94,
0xa6, 0xaa, 0x13, 0xea, 0x48, 0x03, 0x88, 0x54, 0xd5, 0xd4, 0x2e, 0x57, 0xd4, 0x1b, 0xfd, 0xc7,
0xf7, 0x77, 0x79, 0xa1, 0x55, 0x3a, 0xbb, 0xe6, 0x9d, 0xde, 0xd0, 0xda, 0x66, 0xbe, 0x27, 0x6b,
0xab, 0x5a, 0xc9, 0x01, 0x15, 0x46, 0x84, 0xda, 0xb4, 0x3a, 0x92, 0x43, 0xf8, 0x0c, 0xd8, 0x8c,
0x0c, 0x08, 0x13, 0x24, 0x54, 0x9b, 0x63, 0xa3, 0x12, 0xc3, 0x0f, 0x80, 0x1d, 0x61, 0xee, 0xe7,
0x9c, 0x84, 0x7a, 0x27, 0xd0, 0x66, 0x84, 0xf9, 0x37, 0x9c, 0x84, 0x9f, 0x59, 0x7f, 0xfe, 0xde,
0x5d, 0xf1, 0x30, 0xa8, 0xbd, 0x0c, 0x02, 0xc2, 0xf9, 0x75, 0xde, 0x4f, 0xc8, 0x7f, 0xe9, 0xb0,
0x13, 0x50, 0xe7, 0x82, 0x32, 0x1c, 0x11, 0xff, 0x86, 0x8c, 0x4c, 0x9f, 0xe9, 0xae, 0x31, 0xf6,
0x5f, 0x91, 0x11, 0x47, 0xb3, 0xc0, 0x48, 0x7c, 0x6f, 0x81, 0xda, 0x35, 0xc3, 0x01, 0x31, 0x2f,
0x7c, 0xd9, 0xab, 0x12, 0x32, 0x23, 0x61, 0x90, 0xd4, 0x16, 0x71, 0x4a, 0x68, 0x2e, 0xcc, 0x79,
0x9a, 0x40, 0x39, 0x83, 0x11, 0x32, 0x24, 0x81, 0x2a, 0xa3, 0x85, 0x0c, 0x82, 0xa7, 0x60, 0x2b,
0x8c, 0xb9, 0xfa, 0x12, 0xe3, 0x02, 0x07, 0x37, 0x3a, 0xfd, 0x8e, 0x73, 0x57, 0xb8, 0x75, 0xe3,
0xb8, 0x92, 0x76, 0x34, 0x87, 0xe0, 0xe7, 0xa0, 0x39, 0x9d, 0xa6, 0x56, 0xab, 0x3f, 0x6d, 0x3a,
0xf0, 0xae, 0x70, 0x1b, 0x65, 0xa8, 0xf2, 0xa0, 0x05, 0x2c, 0x77, 0x3a, 0x24, 0xdd, 0x3c, 0x52,
0xcd, 0x67, 0x23, 0x0d, 0xa4, 0x35, 0x89, 0xd3, 0x58, 0xa8, 0x66, 0x5b, 0x47, 0x1a, 0xc0, 0xcf,
0x41, 0x95, 0x0e, 0x08, 0x63, 0x71, 0x48, 0xb8, 0x7a, 0xea, 0xfc, 0xaf, 0xaf, 0x34, 0x34, 0x8d,
0x97, 0xc9, 0x99, 0xaf, 0xcc, 0x94, 0xa4, 0x94, 0x8d, 0xd4, 0xdb, 0xc5, 0x24, 0xa7, 0x1d, 0xbf,
0x56, 0x76, 0x34, 0x87, 0x60, 0x07, 0x40, 0x33, 0x8d, 0x11, 0x91, 0xb3, 0xcc, 0x57, 0xe7, 0xbf,
0xae, 0xe6, 0xaa, 0x53, 0xa8, 0xbd, 0x48, 0x39, 0x5f, 0x63, 0x81, 0xd1, 0x3d, 0x0b, 0xfc, 0x05,
0x80, 0x7a, 0x4f, 0xfc, 0xef, 0x38, 0x2d, 0x3f, 0x33, 0xf5, 0xd3, 0x42, 0xe9, 0x6b, 0xaf, 0x59,
0xb3, 0xa3, 0xd1, 0x05, 0xa7, 0x26, 0x8b, 0x0b, 0xcb, 0xb6, 0x9c, 0xf5, 0x0b, 0xcb, 0xde, 0x74,
0xec, 0xb2, 0x7e, 0x26, 0x0b, 0xb4, 0x33, 0xc1, 0x33, 0xcb, 0xeb, 0xfc, 0xf2, 0x87, 0xdb, 0xbd,
0xd5, 0x77, 0xb7, 0x7b, 0xab, 0xff, 0xbe, 0xdd, 0x5b, 0xfd, 0xeb, 0xfb, 0xbd, 0x95, 0x77, 0xef,
0xf7, 0x56, 0xfe, 0xf9, 0x7e, 0x6f, 0xe5, 0x77, 0xb3, 0xf7, 0x03, 0x19, 0xc8, 0xeb, 0x61, 0xfa,
0xd3, 0xc2, 0x50, 0xfd, 0xb8, 0xa0, 0xee, 0x88, 0xee, 0x86, 0xfa, 0xd1, 0xe0, 0xd3, 0xff, 0x04,
0x00, 0x00, 0xff, 0xff, 0x68, 0xce, 0x8e, 0x23, 0x7a, 0x10, 0x00, 0x00,
}
func (m *V4Params) Marshal() (dAtA []byte, err error) {
@ -874,6 +882,16 @@ func (m *V4Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
i--
dAtA[i] = 0x2a
{
size, err := m.ExtraEIPs.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintEvm(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if m.EnableCall {
i--
if m.EnableCall {
@ -904,7 +922,7 @@ func (m *V4Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *V4ExtraEIPs) Marshal() (dAtA []byte, err error) {
func (m *ExtraEIPs) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -914,32 +932,32 @@ func (m *V4ExtraEIPs) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *V4ExtraEIPs) MarshalTo(dAtA []byte) (int, error) {
func (m *ExtraEIPs) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *V4ExtraEIPs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *ExtraEIPs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.EIPs) > 0 {
dAtA3 := make([]byte, len(m.EIPs)*10)
var j2 int
dAtA4 := make([]byte, len(m.EIPs)*10)
var j3 int
for _, num1 := range m.EIPs {
num := uint64(num1)
for num >= 1<<7 {
dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j2++
j3++
}
dAtA3[j2] = uint8(num)
j2++
dAtA4[j3] = uint8(num)
j3++
}
i -= j2
copy(dAtA[i:], dAtA3[:j2])
i = encodeVarintEvm(dAtA, i, uint64(j2))
i -= j3
copy(dAtA[i:], dAtA4[:j3])
i = encodeVarintEvm(dAtA, i, uint64(j3))
i--
dAtA[i] = 0xa
}
@ -1239,7 +1257,7 @@ func (m *V4State) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *V4TransactionV4Logs) Marshal() (dAtA []byte, err error) {
func (m *TransactionV4Logs) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -1249,12 +1267,12 @@ func (m *V4TransactionV4Logs) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *V4TransactionV4Logs) MarshalTo(dAtA []byte) (int, error) {
func (m *TransactionV4Logs) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *V4TransactionV4Logs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *TransactionV4Logs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
@ -1619,6 +1637,8 @@ func (m *V4Params) Size() (n int) {
if m.EnableCall {
n += 2
}
l = m.ExtraEIPs.Size()
n += 1 + l + sovEvm(uint64(l))
l = m.V4ChainConfig.Size()
n += 1 + l + sovEvm(uint64(l))
if m.AllowUnprotectedTxs {
@ -1627,7 +1647,7 @@ func (m *V4Params) Size() (n int) {
return n
}
func (m *V4ExtraEIPs) Size() (n int) {
func (m *ExtraEIPs) Size() (n int) {
if m == nil {
return 0
}
@ -1744,7 +1764,7 @@ func (m *V4State) Size() (n int) {
return n
}
func (m *V4TransactionV4Logs) Size() (n int) {
func (m *TransactionV4Logs) Size() (n int) {
if m == nil {
return 0
}
@ -2007,6 +2027,39 @@ func (m *V4Params) Unmarshal(dAtA []byte) error {
}
}
m.EnableCall = bool(v != 0)
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExtraEIPs", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvm
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthEvm
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthEvm
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ExtraEIPs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field V4ChainConfig", wireType)
@ -2081,7 +2134,7 @@ func (m *V4Params) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *V4ExtraEIPs) Unmarshal(dAtA []byte) error {
func (m *ExtraEIPs) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -2104,10 +2157,10 @@ func (m *V4ExtraEIPs) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: V4ExtraEIPs: wiretype end group for non-group")
return fmt.Errorf("proto: ExtraEIPs: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: V4ExtraEIPs: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: ExtraEIPs: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@ -3035,7 +3088,7 @@ func (m *V4State) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *V4TransactionV4Logs) Unmarshal(dAtA []byte) error {
func (m *TransactionV4Logs) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -3058,10 +3111,10 @@ func (m *V4TransactionV4Logs) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: V4TransactionV4Logs: wiretype end group for non-group")
return fmt.Errorf("proto: TransactionV4Logs: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: V4TransactionV4Logs: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: TransactionV4Logs: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@ -4179,4 +4232,4 @@ var (
ErrInvalidLengthEvm = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowEvm = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupEvm = fmt.Errorf("proto: unexpected end of group")
)
)

5
x/evm/migrations/v5/migrate.go
View File

@ -31,6 +31,11 @@ func MigrateStore(
extraEIPsBz := store.Get(types.ParamStoreKeyExtraEIPs)
cdc.MustUnmarshal(extraEIPsBz, &extraEIPs)
// revert ExtraEIP change for Evmos testnet
if ctx.ChainID() == "evmos_9000-4" {
extraEIPs.EIPs = []int64{}
}
chainCfgBz := store.Get(types.ParamStoreKeyChainConfig)
cdc.MustUnmarshal(chainCfgBz, &chainConfig)

4
x/evm/types/params.go
View File

@ -35,8 +35,6 @@ var (
DefaultEnableCreate = true
// DefaultEnableCall enables contract calls (i.e true)
DefaultEnableCall = true
// DefaultExtraEIPs defines the set of activateable Ethereum Improvement Proposals
DefaultExtraEIPs = AvailableExtraEIPs
)
// AvailableExtraEIPs define the list of all EIPs that can be enabled by the
@ -66,7 +64,7 @@ func DefaultParams() Params {
EnableCreate: DefaultEnableCreate,
EnableCall: DefaultEnableCall,
ChainConfig: DefaultChainConfig(),
ExtraEIPs: DefaultExtraEIPs,
ExtraEIPs: nil,
AllowUnprotectedTxs: DefaultAllowUnprotectedTxs,
}
}