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

changelog: v0.12.2 (#1022)

Browse Source 
* changelog: v0.12.2

* fix
This commit is contained in:
Federico Kunze Küllmer 2022-03-30 19:16:37 +02:00 committed by GitHub
parent d19e38833c
commit 4ddc8afd18
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 1019 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CHANGELOG.md
View File

@ -36,6 +36,12 @@ Ref: https://keepachangelog.com/en/1.0.0/
# Changelog
## [v0.12.2] - 2022-03-30
### Bug Fixes
* (feemarket) [tharsis#1021](https://github.com/tharsis/ethermint/pull/1021) Fix fee market migration.
## [v0.12.1] - 2022-03-29
### Bug Fixes
@ -64,7 +70,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
### Improvements
- (rpc) [tharsis#979](https://github.com/tharsis/ethermint/pull/979) Add configurable timeouts to http server
- (rpc) [tharsis#979](https://github.com/tharsis/ethermint/pull/979) Add configurable timeouts to http server
- (rpc) [tharsis#988](https://github.com/tharsis/ethermint/pull/988) json-rpc server always use local rpc client
## [v0.10.1] - 2022-03-04

3
client/testnet.go
View File

@ -208,7 +208,6 @@ func initTestnetFiles(
genBalIterator banktypes.GenesisBalancesIterator,
args initArgs,
) error {
if args.chainID == "" {
args.chainID = fmt.Sprintf("ethermint_%d-1", tmrand.Int63n(9999999999999)+1)
}
@ -377,7 +376,6 @@ func initGenFiles(
genFiles []string,
numValidators int,
) error {
appGenState := mbm.DefaultGenesis(clientCtx.Codec)
// set the accounts in the genesis state
var authGenState authtypes.GenesisState
@ -453,7 +451,6 @@ func collectGenFiles(
nodeIDs []string, valPubKeys []cryptotypes.PubKey, numValidators int,
outputDir, nodeDirPrefix, nodeDaemonHome string, genBalIterator banktypes.GenesisBalancesIterator,
) error {
var appState json.RawMessage
genTime := tmtime.Now()

3
rpc/ethereum/backend/feebackend.go
View File

@ -35,7 +35,8 @@ func (e *EVMBackend) processBlock(
ethBlock *map[string]interface{},
rewardPercentiles []float64,
tendermintBlockResult *tmrpctypes.ResultBlockResults,
targetOneFeeHistory *rpctypes.OneFeeHistory) error {
targetOneFeeHistory *rpctypes.OneFeeHistory,
) error {
blockHeight := tendermintBlock.Block.Height
blockBaseFee, err := e.BaseFee(blockHeight)
if err != nil {

3
tests/importer/chain_ctx.go
View File

@ -97,7 +97,8 @@ func (cc *ChainContext) Finalize(
// consensus rules that happen at finalization (e.g. block rewards).
// TODO: Figure out if this needs to be hooked up to any part of the ABCI?
func (cc *ChainContext) FinalizeAndAssemble(_ ethcons.ChainHeaderReader, _ *ethtypes.Header, _ *ethstate.StateDB, _ []*ethtypes.Transaction,
_ []*ethtypes.Header, _ []*ethtypes.Receipt) (*ethtypes.Block, error) {
_ []*ethtypes.Header, _ []*ethtypes.Receipt,
) (*ethtypes.Block, error) {
return nil, nil
}

17
x/feemarket/keeper/migrations.go
View File

@ -1,13 +1,10 @@
package keeper
import (
"math/big"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// KeyPrefixBaseFeeV1 is the base fee key prefix used in version 1
var KeyPrefixBaseFeeV1 = []byte{2}
v010 "github.com/tharsis/ethermint/x/feemarket/migrations/v010"
)
// Migrator is a struct for handling in-place store migrations.
type Migrator struct {
@ -21,13 +18,7 @@ func NewMigrator(keeper Keeper) Migrator {
}
}
// Migrate1to2 migrates the store from consensus version v1 to v2
func (m Migrator) Migrate1to2(ctx sdk.Context) error {
store := ctx.KVStore(m.keeper.storeKey)
bz := store.Get(KeyPrefixBaseFeeV1)
if len(bz) > 0 {
baseFee := new(big.Int).SetBytes(bz)
m.keeper.SetBaseFee(ctx, baseFee)
}
store.Delete(KeyPrefixBaseFeeV1)
return nil
return v010.MigrateStore(ctx, &m.keeper.paramSpace, m.keeper.storeKey)
}

6
x/feemarket/keeper/migrations_test.go
View File

@ -4,6 +4,7 @@ import (
"math/big"
"github.com/tharsis/ethermint/x/feemarket/keeper"
v010 "github.com/tharsis/ethermint/x/feemarket/migrations/v010"
)
func (suite *KeeperTestSuite) TestMigration1To2() {
@ -11,8 +12,9 @@ func (suite *KeeperTestSuite) TestMigration1To2() {
storeKey := suite.app.GetKey("feemarket")
store := suite.ctx.KVStore(storeKey)
baseFee := big.NewInt(1000)
store.Set(keeper.KeyPrefixBaseFeeV1, baseFee.Bytes())
store.Set(v010.KeyPrefixBaseFeeV1, baseFee.Bytes())
m := keeper.NewMigrator(suite.app.FeeMarketKeeper)
suite.Require().NoError(m.Migrate1to2(suite.ctx))
err := m.Migrate1to2(suite.ctx)
suite.Require().NoError(err)
suite.Require().Equal(baseFee, suite.app.FeeMarketKeeper.GetBaseFee(suite.ctx))
}

74
x/feemarket/migrations/v010/migrate.go Normal file
View File

@ -0,0 +1,74 @@
package v010
import (
"math/big"
sdk "github.com/cosmos/cosmos-sdk/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
v09types "github.com/tharsis/ethermint/x/feemarket/migrations/v09/types"
"github.com/tharsis/ethermint/x/feemarket/types"
)
// KeyPrefixBaseFeeV1 is the base fee key prefix used in version 1
var KeyPrefixBaseFeeV1 = []byte{2}
// MigrateStore migrates the BaseFee value from the store to the params for
// In-Place Store migration logic.
func MigrateStore(ctx sdk.Context, paramstore *paramtypes.Subspace, storeKey sdk.StoreKey) error {
baseFee := types.DefaultParams().BaseFee
store := ctx.KVStore(storeKey)
if !paramstore.HasKeyTable() {
ps := paramstore.WithKeyTable(types.ParamKeyTable())
paramstore = &ps
}
switch {
case store.Has(KeyPrefixBaseFeeV1):
bz := store.Get(KeyPrefixBaseFeeV1)
baseFee = sdk.NewIntFromBigInt(new(big.Int).SetBytes(bz))
case paramstore.Has(ctx, types.ParamStoreKeyNoBaseFee):
paramstore.GetIfExists(ctx, types.ParamStoreKeyBaseFee, &baseFee)
}
var (
noBaseFee bool
baseFeeChangeDenom, elasticityMultiplier uint32
enableHeight int64
)
paramstore.GetIfExists(ctx, types.ParamStoreKeyNoBaseFee, &noBaseFee)
paramstore.GetIfExists(ctx, types.ParamStoreKeyBaseFeeChangeDenominator, &baseFeeChangeDenom)
paramstore.GetIfExists(ctx, types.ParamStoreKeyElasticityMultiplier, &elasticityMultiplier)
paramstore.GetIfExists(ctx, types.ParamStoreKeyEnableHeight, &enableHeight)
params := types.Params{
NoBaseFee: noBaseFee,
BaseFeeChangeDenominator: baseFeeChangeDenom,
ElasticityMultiplier: elasticityMultiplier,
BaseFee: baseFee,
EnableHeight: enableHeight,
}
paramstore.SetParamSet(ctx, &params)
store.Delete(KeyPrefixBaseFeeV1)
return nil
}
// MigrateJSON accepts exported v0.9 x/feemarket genesis state and migrates it to
// v0.10 x/feemarket genesis state. The migration includes:
// - Migrate BaseFee to Params
func MigrateJSON(oldState v09types.GenesisState) types.GenesisState {
return types.GenesisState{
Params: types.Params{
NoBaseFee: oldState.Params.NoBaseFee,
BaseFeeChangeDenominator: oldState.Params.BaseFeeChangeDenominator,
ElasticityMultiplier: oldState.Params.ElasticityMultiplier,
EnableHeight: oldState.Params.EnableHeight,
BaseFee: oldState.BaseFee,
},
BlockGas: oldState.BlockGas,
}
}

46
x/feemarket/migrations/v010/migrate_test.go Normal file
View File

@ -0,0 +1,46 @@
package v010_test
import (
"fmt"
"testing"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/testutil"
sdk "github.com/cosmos/cosmos-sdk/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
"github.com/tharsis/ethermint/encoding"
"github.com/tharsis/ethermint/app"
feemarketkeeper "github.com/tharsis/ethermint/x/feemarket/keeper"
v010 "github.com/tharsis/ethermint/x/feemarket/migrations/v010"
"github.com/tharsis/ethermint/x/feemarket/types"
feemarkettypes "github.com/tharsis/ethermint/x/feemarket/types"
)
func TestMigrateStore(t *testing.T) {
encCfg := encoding.MakeConfig(app.ModuleBasics)
feemarketKey := sdk.NewKVStoreKey(feemarkettypes.StoreKey)
tFeeMarketKey := sdk.NewTransientStoreKey(fmt.Sprintf("%s_test", feemarkettypes.StoreKey))
ctx := testutil.DefaultContext(feemarketKey, tFeeMarketKey)
paramstore := paramtypes.NewSubspace(
encCfg.Marshaler, encCfg.Amino, feemarketKey, tFeeMarketKey, "feemarket",
)
fmKeeper := feemarketkeeper.NewKeeper(encCfg.Marshaler, feemarketKey, paramstore)
fmKeeper.SetParams(ctx, types.DefaultParams())
require.True(t, paramstore.HasKeyTable())
// check that the fee market is not nil
err := v010.MigrateStore(ctx, &paramstore, feemarketKey)
require.NoError(t, err)
require.False(t, ctx.KVStore(feemarketKey).Has(v010.KeyPrefixBaseFeeV1))
params := fmKeeper.GetParams(ctx)
require.False(t, params.BaseFee.IsNil())
baseFee := fmKeeper.GetBaseFee(ctx)
require.NotNil(t, baseFee)
require.Equal(t, baseFee.Int64(), params.BaseFee.Int64())
}

462
x/feemarket/migrations/v09/types/feemarket.pb copy.go Normal file
View File

@ -0,0 +1,462 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: ethermint/feemarket/v1/feemarket.proto
package types
import (
fmt "fmt"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Params defines the EVM module parameters
type Params struct {
// no base fee forces the EIP-1559 base fee to 0 (needed for 0 price calls)
NoBaseFee bool `protobuf:"varint,1,opt,name=no_base_fee,json=noBaseFee,proto3" json:"no_base_fee,omitempty"`
// base fee change denominator bounds the amount the base fee can change
// between blocks.
BaseFeeChangeDenominator uint32 `protobuf:"varint,2,opt,name=base_fee_change_denominator,json=baseFeeChangeDenominator,proto3" json:"base_fee_change_denominator,omitempty"`
// elasticity multiplier bounds the maximum gas limit an EIP-1559 block may
// have.
ElasticityMultiplier uint32 `protobuf:"varint,3,opt,name=elasticity_multiplier,json=elasticityMultiplier,proto3" json:"elasticity_multiplier,omitempty"`
// initial base fee for EIP-1559 blocks.
InitialBaseFee int64 `protobuf:"varint,4,opt,name=initial_base_fee,json=initialBaseFee,proto3" json:"initial_base_fee,omitempty"`
// height at which the base fee calculation is enabled.
EnableHeight int64 `protobuf:"varint,5,opt,name=enable_height,json=enableHeight,proto3" json:"enable_height,omitempty"`
}
func (m *Params) Reset() { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage() {}
func (*Params) Descriptor() ([]byte, []int) {
return fileDescriptor_4feb8b20cf98e6e1, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Params.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Params) XXX_Merge(src proto.Message) {
xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
xxx_messageInfo_Params.DiscardUnknown(m)
}
var xxx_messageInfo_Params proto.InternalMessageInfo
func (m *Params) GetNoBaseFee() bool {
if m != nil {
return m.NoBaseFee
}
return false
}
func (m *Params) GetBaseFeeChangeDenominator() uint32 {
if m != nil {
return m.BaseFeeChangeDenominator
}
return 0
}
func (m *Params) GetElasticityMultiplier() uint32 {
if m != nil {
return m.ElasticityMultiplier
}
return 0
}
func (m *Params) GetInitialBaseFee() int64 {
if m != nil {
return m.InitialBaseFee
}
return 0
}
func (m *Params) GetEnableHeight() int64 {
if m != nil {
return m.EnableHeight
}
return 0
}
func init() {
proto.RegisterType((*Params)(nil), "ethermint.feemarket.v1.Params")
}
func init() {
proto.RegisterFile("ethermint/feemarket/v1/feemarket.proto", fileDescriptor_4feb8b20cf98e6e1)
}
var fileDescriptor_4feb8b20cf98e6e1 = []byte{
// 286 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0xc1, 0x4a, 0x03, 0x31,
0x10, 0x86, 0x1b, 0xab, 0x45, 0xa3, 0x15, 0x59, 0x54, 0x16, 0x84, 0x50, 0x14, 0x64, 0x4f, 0xbb,
0x94, 0x9e, 0xbd, 0x54, 0x91, 0x5e, 0x04, 0xe9, 0xd1, 0x4b, 0xc8, 0xd6, 0x69, 0x33, 0xb8, 0x49,
0x4a, 0x32, 0x2d, 0xf6, 0x2d, 0x7c, 0x2c, 0x8f, 0x3d, 0x7a, 0x94, 0xf6, 0xe8, 0x4b, 0x08, 0x5b,
0xdb, 0x78, 0x9c, 0xff, 0xfb, 0x06, 0x7e, 0x7e, 0x7e, 0x0b, 0xa4, 0xc1, 0x1b, 0xb4, 0x54, 0x8c,
0x01, 0x8c, 0xf2, 0x6f, 0x40, 0xc5, 0xbc, 0x1b, 0x8f, 0x7c, 0xea, 0x1d, 0xb9, 0xe4, 0x72, 0xe7,
0xe5, 0x11, 0xcd, 0xbb, 0xd7, 0x3f, 0x8c, 0xb7, 0x9e, 0x95, 0x57, 0x26, 0x24, 0x82, 0x1f, 0x5b,
0x27, 0x4b, 0x15, 0x40, 0x8e, 0x01, 0x52, 0xd6, 0x61, 0xd9, 0xe1, 0xf0, 0xc8, 0xba, 0xbe, 0x0a,
0xf0, 0x08, 0x90, 0xdc, 0xf1, 0xab, 0x2d, 0x94, 0x23, 0xad, 0xec, 0x04, 0xe4, 0x2b, 0x58, 0x67,
0xd0, 0x2a, 0x72, 0x3e, 0xdd, 0xeb, 0xb0, 0xac, 0x3d, 0x4c, 0xcb, 0x8d, 0x7d, 0x5f, 0x0b, 0x0f,
0x91, 0x27, 0x3d, 0x7e, 0x01, 0x95, 0x0a, 0x84, 0x23, 0xa4, 0x85, 0x34, 0xb3, 0x8a, 0x70, 0x5a,
0x21, 0xf8, 0xb4, 0x59, 0x3f, 0x9e, 0x47, 0xf8, 0xb4, 0x63, 0x49, 0xc6, 0xcf, 0xd0, 0x22, 0xa1,
0xaa, 0x62, 0xb1, 0xfd, 0x0e, 0xcb, 0x9a, 0xc3, 0xd3, 0xbf, 0x7c, 0xdb, 0xee, 0x86, 0xb7, 0xc1,
0xaa, 0xb2, 0x02, 0xa9, 0x01, 0x27, 0x9a, 0xd2, 0x83, 0x5a, 0x3b, 0xd9, 0x84, 0x83, 0x3a, 0xeb,
0x0f, 0x3e, 0x57, 0x82, 0x2d, 0x57, 0x82, 0x7d, 0xaf, 0x04, 0xfb, 0x58, 0x8b, 0xc6, 0x72, 0x2d,
0x1a, 0x5f, 0x6b, 0xd1, 0x78, 0xc9, 0x27, 0x48, 0x7a, 0x56, 0xe6, 0x23, 0x67, 0x0a, 0xd2, 0xca,
0x07, 0x0c, 0x45, 0x9c, 0xf6, 0xfd, 0xdf, 0xb8, 0xb4, 0x98, 0x42, 0x28, 0x5b, 0xf5, 0xac, 0xbd,
0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0x3a, 0xd4, 0xaa, 0x80, 0x01, 0x00, 0x00,
}
func (m *Params) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Params) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.EnableHeight != 0 {
i = encodeVarintFeemarket(dAtA, i, uint64(m.EnableHeight))
i--
dAtA[i] = 0x28
}
if m.InitialBaseFee != 0 {
i = encodeVarintFeemarket(dAtA, i, uint64(m.InitialBaseFee))
i--
dAtA[i] = 0x20
}
if m.ElasticityMultiplier != 0 {
i = encodeVarintFeemarket(dAtA, i, uint64(m.ElasticityMultiplier))
i--
dAtA[i] = 0x18
}
if m.BaseFeeChangeDenominator != 0 {
i = encodeVarintFeemarket(dAtA, i, uint64(m.BaseFeeChangeDenominator))
i--
dAtA[i] = 0x10
}
if m.NoBaseFee {
i--
if m.NoBaseFee {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintFeemarket(dAtA []byte, offset int, v uint64) int {
offset -= sovFeemarket(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *Params) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.NoBaseFee {
n += 2
}
if m.BaseFeeChangeDenominator != 0 {
n += 1 + sovFeemarket(uint64(m.BaseFeeChangeDenominator))
}
if m.ElasticityMultiplier != 0 {
n += 1 + sovFeemarket(uint64(m.ElasticityMultiplier))
}
if m.InitialBaseFee != 0 {
n += 1 + sovFeemarket(uint64(m.InitialBaseFee))
}
if m.EnableHeight != 0 {
n += 1 + sovFeemarket(uint64(m.EnableHeight))
}
return n
}
func sovFeemarket(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozFeemarket(x uint64) (n int) {
return sovFeemarket(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowFeemarket
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Params: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NoBaseFee", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowFeemarket
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.NoBaseFee = bool(v != 0)
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BaseFeeChangeDenominator", wireType)
}
m.BaseFeeChangeDenominator = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowFeemarket
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BaseFeeChangeDenominator |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ElasticityMultiplier", wireType)
}
m.ElasticityMultiplier = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowFeemarket
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ElasticityMultiplier |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field InitialBaseFee", wireType)
}
m.InitialBaseFee = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowFeemarket
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.InitialBaseFee |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field EnableHeight", wireType)
}
m.EnableHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowFeemarket
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.EnableHeight |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipFeemarket(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthFeemarket
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipFeemarket(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowFeemarket
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowFeemarket
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowFeemarket
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthFeemarket
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupFeemarket
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthFeemarket
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthFeemarket = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowFeemarket = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupFeemarket = fmt.Errorf("proto: unexpected end of group")
)

416
x/feemarket/migrations/v09/types/genesis.pb copy.go Normal file
View File

@ -0,0 +1,416 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: ethermint/feemarket/v1/genesis.proto
package types
import (
fmt "fmt"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// GenesisState defines the feemarket module's genesis state.
type GenesisState struct {
// params defines all the paramaters of the module.
Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
// base fee is the exported value from previous software version.
// Zero by default.
BaseFee github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=base_fee,json=baseFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"base_fee"`
// block gas is the amount of gas used on the last block before the upgrade.
// Zero by default.
BlockGas uint64 `protobuf:"varint,3,opt,name=block_gas,json=blockGas,proto3" json:"block_gas,omitempty"`
}
func (m *GenesisState) Reset() { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage() {}
func (*GenesisState) Descriptor() ([]byte, []int) {
return fileDescriptor_6241c21661288629, []int{0}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *GenesisState) XXX_Merge(src proto.Message) {
xxx_messageInfo_GenesisState.Merge(m, src)
}
func (m *GenesisState) XXX_Size() int {
return m.Size()
}
func (m *GenesisState) XXX_DiscardUnknown() {
xxx_messageInfo_GenesisState.DiscardUnknown(m)
}
var xxx_messageInfo_GenesisState proto.InternalMessageInfo
func (m *GenesisState) GetParams() Params {
if m != nil {
return m.Params
}
return Params{}
}
func (m *GenesisState) GetBlockGas() uint64 {
if m != nil {
return m.BlockGas
}
return 0
}
func init() {
proto.RegisterType((*GenesisState)(nil), "ethermint.feemarket.v1.GenesisState")
}
func init() {
proto.RegisterFile("ethermint/feemarket/v1/genesis.proto", fileDescriptor_6241c21661288629)
}
var fileDescriptor_6241c21661288629 = []byte{
// 286 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x31, 0x4b, 0xc3, 0x40,
0x14, 0xc7, 0x73, 0x5a, 0x6a, 0x1b, 0x9d, 0x82, 0x48, 0xa9, 0x70, 0x0d, 0x22, 0x25, 0x8b, 0x77,
0x54, 0x57, 0xa7, 0x0c, 0xd6, 0x6e, 0x12, 0x37, 0x97, 0x72, 0x89, 0xaf, 0x49, 0x88, 0xc9, 0x85,
0x7b, 0x67, 0xd1, 0x6f, 0xe1, 0x87, 0xf1, 0x43, 0x74, 0xec, 0x28, 0x0e, 0x45, 0x92, 0x2f, 0x22,
0xb9, 0x96, 0xb6, 0x83, 0x4e, 0x77, 0xbc, 0xf7, 0xfb, 0xbf, 0x1f, 0xfc, 0xed, 0x4b, 0xd0, 0x09,
0xa8, 0x3c, 0x2d, 0x34, 0x9f, 0x01, 0xe4, 0x42, 0x65, 0xa0, 0xf9, 0x7c, 0xc4, 0x63, 0x28, 0x00,
0x53, 0x64, 0xa5, 0x92, 0x5a, 0x3a, 0x67, 0x5b, 0x8a, 0x6d, 0x29, 0x36, 0x1f, 0xf5, 0x4f, 0x63,
0x19, 0x4b, 0x83, 0xf0, 0xe6, 0xb7, 0xa6, 0xfb, 0xc3, 0x7f, 0x6e, 0xee, 0xa2, 0x86, 0xbb, 0xf8,
0x24, 0xf6, 0xc9, 0x78, 0xed, 0x79, 0xd4, 0x42, 0x83, 0x73, 0x6b, 0xb7, 0x4b, 0xa1, 0x44, 0x8e,
0x3d, 0xe2, 0x12, 0xef, 0xf8, 0x9a, 0xb2, 0xbf, 0xbd, 0xec, 0xc1, 0x50, 0x7e, 0x6b, 0xb1, 0x1a,
0x58, 0xc1, 0x26, 0xe3, 0x4c, 0xec, 0x4e, 0x28, 0x10, 0xa6, 0x33, 0x80, 0xde, 0x81, 0x4b, 0xbc,
0xae, 0xcf, 0x9a, 0xfd, 0xf7, 0x6a, 0x30, 0x8c, 0x53, 0x9d, 0xbc, 0x86, 0x2c, 0x92, 0x39, 0x8f,
0x24, 0xe6, 0x12, 0x37, 0xcf, 0x15, 0x3e, 0x67, 0x5c, 0xbf, 0x97, 0x80, 0x6c, 0x52, 0xe8, 0xe0,
0xa8, 0xc9, 0xdf, 0x01, 0x38, 0xe7, 0x76, 0x37, 0x7c, 0x91, 0x51, 0x36, 0x8d, 0x05, 0xf6, 0x0e,
0x5d, 0xe2, 0xb5, 0x82, 0x8e, 0x19, 0x8c, 0x05, 0xfa, 0xf7, 0x8b, 0x8a, 0x92, 0x65, 0x45, 0xc9,
0x4f, 0x45, 0xc9, 0x47, 0x4d, 0xad, 0x65, 0x4d, 0xad, 0xaf, 0x9a, 0x5a, 0x4f, 0x6c, 0xcf, 0xa3,
0x13, 0xa1, 0x30, 0x45, 0xbe, 0xeb, 0xe2, 0x6d, 0xaf, 0x0d, 0xe3, 0x0c, 0xdb, 0xa6, 0x87, 0x9b,
0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x41, 0xbf, 0x7e, 0x16, 0x85, 0x01, 0x00, 0x00,
}
func (m *GenesisState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.BlockGas != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.BlockGas))
i--
dAtA[i] = 0x18
}
{
size := m.BaseFee.Size()
i -= size
if _, err := m.BaseFee.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
offset -= sovGenesis(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *GenesisState) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = m.Params.Size()
n += 1 + l + sovGenesis(uint64(l))
l = m.BaseFee.Size()
n += 1 + l + sovGenesis(uint64(l))
if m.BlockGas != 0 {
n += 1 + sovGenesis(uint64(m.BlockGas))
}
return n
}
func sovGenesis(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenesisState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BaseFee", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.BaseFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockGas", wireType)
}
m.BlockGas = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BlockGas |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipGenesis(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenesis
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenesis
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenesis
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthGenesis
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupGenesis
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthGenesis
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)

3
x/feemarket/types/keys.go
View File

@ -14,7 +14,8 @@ const (
// prefix bytes for the feemarket persistent store
const (
prefixBlockGasUsed = iota + 1
prefixBlockGasUsed = iota + 1
deprecatedPrefixBaseFee // nolint
)
// KVStore key prefixes