From 9e1bf793d300b909b7167c67340fd4896839b9bc Mon Sep 17 00:00:00 2001 From: Maximilian Breithecker <72022235+mbreithecker@users.noreply.github.com> Date: Tue, 18 Apr 2023 11:33:32 +0200 Subject: [PATCH] chore: finalise `v1.1.0` upgrade (#28) Co-authored-by: John Letey --- CHANGELOG.md | 4 +- Makefile | 16 +- app/app.go | 7 +- app/upgrades/v1_1/constants.go | 7 +- app/upgrades/v1_1/types/old_params.pb.go | 843 ++++++++++++++++++ app/upgrades/v1_1/types/old_stakers.pb.go | 839 +++++++++++++++++ app/upgrades/v1_1/upgrade.go | 160 +++- go.mod | 24 +- go.sum | 50 +- proto/kyve/query/v1beta1/query.proto | 8 +- proto/kyve/upgrades/v1beta1/README.md | 13 + proto/kyve/upgrades/v1beta1/old_params.proto | 38 + proto/kyve/upgrades/v1beta1/old_stakers.proto | 38 + 13 files changed, 1988 insertions(+), 59 deletions(-) create mode 100644 app/upgrades/v1_1/types/old_params.pb.go create mode 100644 app/upgrades/v1_1/types/old_stakers.pb.go create mode 100644 proto/kyve/upgrades/v1beta1/README.md create mode 100644 proto/kyve/upgrades/v1beta1/old_params.proto create mode 100644 proto/kyve/upgrades/v1beta1/old_stakers.proto diff --git a/CHANGELOG.md b/CHANGELOG.md index 989f863f..38d07482 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ ### Improvements - [#22](https://github.com/KYVENetwork/chain/pull/22) Various minor code improvements, cleanups, and validations. -- (deps) [#21](https://github.com/KYVENetwork/chain/pull/21) Bump Cosmos SDK to [v0.46.11](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.46.11) ([`v0.46.11-kyve-rc0`](https://github.com/KYVENetwork/cosmos-sdk/releases/tag/v0.46.11-kyve-rc0)). +- (deps) [#21](https://github.com/KYVENetwork/chain/pull/21), [#28](https://github.com/KYVENetwork/chain/pull/28) Bump Cosmos SDK to [v0.46.12](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.46.12) ([`v0.46.12-kyve`](https://github.com/KYVENetwork/cosmos-sdk/releases/tag/v0.46.12-kyve)). - (deps) [#21](https://github.com/KYVENetwork/chain/pull/21) Switch to CometBFT from Informal Systems' Tendermint fork. - (ibc) [#27](https://github.com/KYVENetwork/chain/pull/27) Enable tokens to be sent and received via IBC. @@ -39,12 +39,12 @@ ### State Machine Breaking -- (`x/stakers`) [#23](https://github.com/KYVENetwork/chain/pull/23) Improve metadata by adding `Identity`, `SecurityContact`, `Details` fields, deprecating `Logo`. - (`x/bundles`) [#19](https://github.com/KYVENetwork/chain/pull/19) Migrate `NetworkFee` param to type `sdk.Dec`. - (`x/bundles`) [#22](https://github.com/KYVENetwork/chain/pull/22) Switch to a non-manipulable pseudo-random source seed for uploader selection. - (`x/bundles`) [#26](https://github.com/KYVENetwork/chain/pull/26) Include the timestamp of the block that finalized a bundle. - (`x/delegation`) [#19](https://github.com/KYVENetwork/chain/pull/19) Migrate `VoteSlash`, `UploadSlash`, `TimeoutSlash` params to type `sdk.Dec`. - (`x/stakers`) [#19](https://github.com/KYVENetwork/chain/pull/19) Migrate `Commission` to type `sdk.Dec`. +- (`x/stakers`) [#23](https://github.com/KYVENetwork/chain/pull/23) Improve metadata by adding `Identity`, `SecurityContact`, `Details` fields, deprecating `Logo`. ## [v1.0.0](https://github.com/KYVENetwork/chain/releases/tag/v1.0.0) - 2023-03-10 diff --git a/Makefile b/Makefile index b0da6c4a..e97ab99b 100644 --- a/Makefile +++ b/Makefile @@ -1,19 +1,21 @@ COMMIT := $(shell git log -1 --format='%H') VERSION := v1.0.0 # $(shell echo $(shell git describe --tags) | sed 's/^v//') -DENOM ?= ukyve -TEAM_TGE ?= 2023-03-14T14:03:14 -TEAM_ALLOCATION ?= 165000000000000 -TEAM_FOUNDATION_ADDRESS ?= kyve1xjpl57p7f49y5gueu7rlfytaw9ramcn5zhjy2g -TEAM_BCP_ADDRESS ?= kyve1fnh4kghr25tppskap50zk5j385pt65tyyjaraa +TEAM_ALLOCATION := 165000000000000 ifeq ($(ENV),kaon) $(info 📑 Using Kaon environment...) DENOM := tkyve TEAM_TGE := 2023-02-07T14:00:00 TEAM_FOUNDATION_ADDRESS := kyve1vut528et85755xsncjwl6dx8xakuv26hxgyv0n TEAM_BCP_ADDRESS := kyve1vut528et85755xsncjwl6dx8xakuv26hxgyv0n +else ifeq ($(ENV),mainnet) +$(info 📑 Using mainnet environment...) +DENOM := ukyve +TEAM_TGE := 2023-03-14T14:03:14 +TEAM_FOUNDATION_ADDRESS := kyve1xjpl57p7f49y5gueu7rlfytaw9ramcn5zhjy2g +TEAM_BCP_ADDRESS := kyve1fnh4kghr25tppskap50zk5j385pt65tyyjaraa else -$(info 📑 Using default environment...) +$(error ❌ Please specify a build environment..) endif ldflags = -X github.com/cosmos/cosmos-sdk/version.Name=kyve \ @@ -105,7 +107,7 @@ vet: ### Protobuf ### ############################################################################### -BUF_VERSION=1.15.0 +BUF_VERSION=1.17.0 proto-all: proto-format proto-lint proto-gen diff --git a/app/app.go b/app/app.go index 2418762b..13a00220 100644 --- a/app/app.go +++ b/app/app.go @@ -779,8 +779,13 @@ func NewKYVEApp( v11.CreateUpgradeHandler( app.mm, app.configurator, + appCodec, + keys[bundlesTypes.StoreKey], + keys[delegationTypes.StoreKey], + keys[stakersTypes.StoreKey], app.AccountKeeper, - app.StakersKeeper, + app.ICAControllerKeeper, + app.ICAHostKeeper, app.IBCTransferKeeper, ), ) diff --git a/app/upgrades/v1_1/constants.go b/app/upgrades/v1_1/constants.go index 1b47b53b..a85c01ff 100644 --- a/app/upgrades/v1_1/constants.go +++ b/app/upgrades/v1_1/constants.go @@ -3,7 +3,10 @@ package v1_1 // UpgradeName is the name of this specific software upgrade used on-chain. const UpgradeName = "v1.1.0" -// MainnetChainID is the Chain ID of KYVE mainnet. +// TestnetChainID is the Chain ID of the KYVE testnet (Kaon). +const TestnetChainID = "kaon-1" + +// MainnetChainID is the Chain ID of the KYVE mainnet. const MainnetChainID = "kyve-1" // InvestorAccounts is a list of accounts from our second funding round. @@ -50,6 +53,6 @@ const ( // This is 6-months after KYVE mainnet launch. StartTime = 1694649600 // EndTime - Sep 14th, 2025. - // This is 2 years after StartTime. + // This is 2-years after StartTime. EndTime = 1757808000 ) diff --git a/app/upgrades/v1_1/types/old_params.pb.go b/app/upgrades/v1_1/types/old_params.pb.go new file mode 100644 index 00000000..2e358b67 --- /dev/null +++ b/app/upgrades/v1_1/types/old_params.pb.go @@ -0,0 +1,843 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: kyve/upgrades/v1beta1/old_params.proto + +package types + +import ( + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/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 + +// OldBundlesParams defines the bundles module parameters. +type OldBundlesParams struct { + // upload_timeout ... + UploadTimeout uint64 `protobuf:"varint,1,opt,name=upload_timeout,json=uploadTimeout,proto3" json:"upload_timeout,omitempty"` + // storage_cost ... + StorageCost github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=storage_cost,json=storageCost,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"storage_cost"` + // network_fee ... + NetworkFee string `protobuf:"bytes,3,opt,name=network_fee,json=networkFee,proto3" json:"network_fee,omitempty"` + // max_points ... + MaxPoints uint64 `protobuf:"varint,4,opt,name=max_points,json=maxPoints,proto3" json:"max_points,omitempty"` +} + +func (m *OldBundlesParams) Reset() { *m = OldBundlesParams{} } +func (m *OldBundlesParams) String() string { return proto.CompactTextString(m) } +func (*OldBundlesParams) ProtoMessage() {} +func (*OldBundlesParams) Descriptor() ([]byte, []int) { + return fileDescriptor_c56c36e717e178bb, []int{0} +} +func (m *OldBundlesParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OldBundlesParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OldBundlesParams.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 *OldBundlesParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_OldBundlesParams.Merge(m, src) +} +func (m *OldBundlesParams) XXX_Size() int { + return m.Size() +} +func (m *OldBundlesParams) XXX_DiscardUnknown() { + xxx_messageInfo_OldBundlesParams.DiscardUnknown(m) +} + +var xxx_messageInfo_OldBundlesParams proto.InternalMessageInfo + +func (m *OldBundlesParams) GetUploadTimeout() uint64 { + if m != nil { + return m.UploadTimeout + } + return 0 +} + +func (m *OldBundlesParams) GetNetworkFee() string { + if m != nil { + return m.NetworkFee + } + return "" +} + +func (m *OldBundlesParams) GetMaxPoints() uint64 { + if m != nil { + return m.MaxPoints + } + return 0 +} + +// OldDelegationParams defines the delegation module parameters. +type OldDelegationParams struct { + // unbonding_delegation_time ... + UnbondingDelegationTime uint64 `protobuf:"varint,1,opt,name=unbonding_delegation_time,json=unbondingDelegationTime,proto3" json:"unbonding_delegation_time,omitempty"` + // unbonding_delegation_time ... + RedelegationCooldown uint64 `protobuf:"varint,2,opt,name=redelegation_cooldown,json=redelegationCooldown,proto3" json:"redelegation_cooldown,omitempty"` + // unbonding_delegation_time ... + RedelegationMaxAmount uint64 `protobuf:"varint,3,opt,name=redelegation_max_amount,json=redelegationMaxAmount,proto3" json:"redelegation_max_amount,omitempty"` + // vote_slash ... + VoteSlash string `protobuf:"bytes,4,opt,name=vote_slash,json=voteSlash,proto3" json:"vote_slash,omitempty"` + // upload_slash ... + UploadSlash string `protobuf:"bytes,5,opt,name=upload_slash,json=uploadSlash,proto3" json:"upload_slash,omitempty"` + // timeout_slash ... + TimeoutSlash string `protobuf:"bytes,6,opt,name=timeout_slash,json=timeoutSlash,proto3" json:"timeout_slash,omitempty"` +} + +func (m *OldDelegationParams) Reset() { *m = OldDelegationParams{} } +func (m *OldDelegationParams) String() string { return proto.CompactTextString(m) } +func (*OldDelegationParams) ProtoMessage() {} +func (*OldDelegationParams) Descriptor() ([]byte, []int) { + return fileDescriptor_c56c36e717e178bb, []int{1} +} +func (m *OldDelegationParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OldDelegationParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OldDelegationParams.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 *OldDelegationParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_OldDelegationParams.Merge(m, src) +} +func (m *OldDelegationParams) XXX_Size() int { + return m.Size() +} +func (m *OldDelegationParams) XXX_DiscardUnknown() { + xxx_messageInfo_OldDelegationParams.DiscardUnknown(m) +} + +var xxx_messageInfo_OldDelegationParams proto.InternalMessageInfo + +func (m *OldDelegationParams) GetUnbondingDelegationTime() uint64 { + if m != nil { + return m.UnbondingDelegationTime + } + return 0 +} + +func (m *OldDelegationParams) GetRedelegationCooldown() uint64 { + if m != nil { + return m.RedelegationCooldown + } + return 0 +} + +func (m *OldDelegationParams) GetRedelegationMaxAmount() uint64 { + if m != nil { + return m.RedelegationMaxAmount + } + return 0 +} + +func (m *OldDelegationParams) GetVoteSlash() string { + if m != nil { + return m.VoteSlash + } + return "" +} + +func (m *OldDelegationParams) GetUploadSlash() string { + if m != nil { + return m.UploadSlash + } + return "" +} + +func (m *OldDelegationParams) GetTimeoutSlash() string { + if m != nil { + return m.TimeoutSlash + } + return "" +} + +func init() { + proto.RegisterType((*OldBundlesParams)(nil), "kyve.upgrades.v1beta1.OldBundlesParams") + proto.RegisterType((*OldDelegationParams)(nil), "kyve.upgrades.v1beta1.OldDelegationParams") +} + +func init() { + proto.RegisterFile("kyve/upgrades/v1beta1/old_params.proto", fileDescriptor_c56c36e717e178bb) +} + +var fileDescriptor_c56c36e717e178bb = []byte{ + // 450 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x92, 0xcf, 0x6e, 0xd3, 0x40, + 0x10, 0x87, 0xe3, 0x12, 0x2a, 0x65, 0x93, 0x22, 0x64, 0x5a, 0x35, 0x20, 0xe1, 0x94, 0x22, 0xaa, + 0x5e, 0xb0, 0x15, 0x15, 0x71, 0xe0, 0x46, 0x5a, 0xb8, 0x20, 0xda, 0x62, 0x10, 0x12, 0x5c, 0xac, + 0x8d, 0x77, 0x70, 0xac, 0xac, 0x77, 0x56, 0xde, 0x75, 0x9a, 0xbe, 0x05, 0x2f, 0xc1, 0xbb, 0xf4, + 0xc0, 0xa1, 0x47, 0xc4, 0xa1, 0x42, 0xc9, 0x8b, 0xa0, 0xfd, 0x43, 0x49, 0x4e, 0xb6, 0x7e, 0xf3, + 0xcd, 0x68, 0xbf, 0x9d, 0x25, 0x07, 0xd3, 0xcb, 0x19, 0x24, 0x8d, 0x2c, 0x6a, 0xca, 0x40, 0x25, + 0xb3, 0xe1, 0x18, 0x34, 0x1d, 0x26, 0xc8, 0x59, 0x26, 0x69, 0x4d, 0x2b, 0x15, 0xcb, 0x1a, 0x35, + 0x86, 0x3b, 0x86, 0x8b, 0xff, 0x71, 0xb1, 0xe7, 0x1e, 0x6d, 0x17, 0x58, 0xa0, 0x25, 0x12, 0xf3, + 0xe7, 0xe0, 0xfd, 0x9f, 0x01, 0xb9, 0x7f, 0xc6, 0xd9, 0xa8, 0x11, 0x8c, 0x83, 0x3a, 0xb7, 0x73, + 0xc2, 0x67, 0xe4, 0x5e, 0x23, 0x39, 0x52, 0x96, 0xe9, 0xb2, 0x02, 0x6c, 0x74, 0x3f, 0xd8, 0x0b, + 0x0e, 0xdb, 0xe9, 0x96, 0x4b, 0x3f, 0xb9, 0x30, 0xfc, 0x40, 0x7a, 0x4a, 0x63, 0x4d, 0x0b, 0xc8, + 0x72, 0x54, 0xba, 0xbf, 0xb1, 0x17, 0x1c, 0x76, 0x46, 0xf1, 0xd5, 0xcd, 0xa0, 0xf5, 0xfb, 0x66, + 0x70, 0x50, 0x94, 0x7a, 0xd2, 0x8c, 0xe3, 0x1c, 0xab, 0x24, 0x47, 0x55, 0xa1, 0xf2, 0x9f, 0xe7, + 0x8a, 0x4d, 0x13, 0x7d, 0x29, 0x41, 0xc5, 0x27, 0x90, 0xa7, 0x5d, 0x3f, 0xe3, 0x18, 0x95, 0x0e, + 0x07, 0xa4, 0x2b, 0x40, 0x5f, 0x60, 0x3d, 0xcd, 0xbe, 0x01, 0xf4, 0xef, 0x98, 0x89, 0x29, 0xf1, + 0xd1, 0x5b, 0x80, 0xf0, 0x31, 0x21, 0x15, 0x9d, 0x67, 0x12, 0x4b, 0xa1, 0x55, 0xbf, 0x6d, 0x8f, + 0xd5, 0xa9, 0xe8, 0xfc, 0xdc, 0x06, 0xfb, 0x3f, 0x36, 0xc8, 0x83, 0x33, 0xce, 0x4e, 0x80, 0x43, + 0x41, 0x75, 0x89, 0xc2, 0x1b, 0xbd, 0x22, 0x0f, 0x1b, 0x31, 0x46, 0xc1, 0x4a, 0x51, 0x64, 0xec, + 0xb6, 0x6a, 0xfd, 0xbc, 0xdc, 0xee, 0x2d, 0xf0, 0xbf, 0xdb, 0x98, 0x86, 0x47, 0x64, 0xa7, 0x86, + 0x95, 0x9e, 0x1c, 0x91, 0x33, 0xbc, 0x10, 0xd6, 0xb7, 0x9d, 0x6e, 0xaf, 0x16, 0x8f, 0x7d, 0x2d, + 0x7c, 0x49, 0x76, 0xd7, 0x9a, 0xcc, 0xa1, 0x69, 0x85, 0x8d, 0xd0, 0x56, 0xaa, 0x9d, 0xae, 0xcd, + 0x7c, 0x4f, 0xe7, 0xaf, 0x6d, 0xd1, 0xf8, 0xcd, 0x50, 0x43, 0xa6, 0x38, 0x55, 0x13, 0xeb, 0xd7, + 0x49, 0x3b, 0x26, 0xf9, 0x68, 0x82, 0xf0, 0x09, 0xe9, 0xf9, 0xcd, 0x38, 0xe0, 0xae, 0x05, 0xba, + 0x2e, 0x73, 0xc8, 0x53, 0xb2, 0xe5, 0xb7, 0xe6, 0x99, 0x4d, 0xcb, 0xf4, 0x7c, 0x68, 0xa1, 0xd1, + 0xe9, 0xd5, 0x22, 0x0a, 0xae, 0x17, 0x51, 0xf0, 0x67, 0x11, 0x05, 0xdf, 0x97, 0x51, 0xeb, 0x7a, + 0x19, 0xb5, 0x7e, 0x2d, 0xa3, 0xd6, 0xd7, 0x17, 0x2b, 0x6b, 0x7b, 0xf7, 0xe5, 0xf3, 0x9b, 0x53, + 0x77, 0xf7, 0x49, 0x3e, 0xa1, 0xa5, 0x48, 0xa8, 0x94, 0xab, 0x2f, 0x30, 0x1b, 0xba, 0x45, 0x8e, + 0x37, 0xed, 0x6b, 0x3a, 0xfa, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xea, 0x97, 0x22, 0x23, 0xa4, 0x02, + 0x00, 0x00, +} + +func (m *OldBundlesParams) 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 *OldBundlesParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OldBundlesParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MaxPoints != 0 { + i = encodeVarintOldParams(dAtA, i, uint64(m.MaxPoints)) + i-- + dAtA[i] = 0x20 + } + if len(m.NetworkFee) > 0 { + i -= len(m.NetworkFee) + copy(dAtA[i:], m.NetworkFee) + i = encodeVarintOldParams(dAtA, i, uint64(len(m.NetworkFee))) + i-- + dAtA[i] = 0x1a + } + { + size := m.StorageCost.Size() + i -= size + if _, err := m.StorageCost.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintOldParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.UploadTimeout != 0 { + i = encodeVarintOldParams(dAtA, i, uint64(m.UploadTimeout)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *OldDelegationParams) 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 *OldDelegationParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OldDelegationParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.TimeoutSlash) > 0 { + i -= len(m.TimeoutSlash) + copy(dAtA[i:], m.TimeoutSlash) + i = encodeVarintOldParams(dAtA, i, uint64(len(m.TimeoutSlash))) + i-- + dAtA[i] = 0x32 + } + if len(m.UploadSlash) > 0 { + i -= len(m.UploadSlash) + copy(dAtA[i:], m.UploadSlash) + i = encodeVarintOldParams(dAtA, i, uint64(len(m.UploadSlash))) + i-- + dAtA[i] = 0x2a + } + if len(m.VoteSlash) > 0 { + i -= len(m.VoteSlash) + copy(dAtA[i:], m.VoteSlash) + i = encodeVarintOldParams(dAtA, i, uint64(len(m.VoteSlash))) + i-- + dAtA[i] = 0x22 + } + if m.RedelegationMaxAmount != 0 { + i = encodeVarintOldParams(dAtA, i, uint64(m.RedelegationMaxAmount)) + i-- + dAtA[i] = 0x18 + } + if m.RedelegationCooldown != 0 { + i = encodeVarintOldParams(dAtA, i, uint64(m.RedelegationCooldown)) + i-- + dAtA[i] = 0x10 + } + if m.UnbondingDelegationTime != 0 { + i = encodeVarintOldParams(dAtA, i, uint64(m.UnbondingDelegationTime)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintOldParams(dAtA []byte, offset int, v uint64) int { + offset -= sovOldParams(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *OldBundlesParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UploadTimeout != 0 { + n += 1 + sovOldParams(uint64(m.UploadTimeout)) + } + l = m.StorageCost.Size() + n += 1 + l + sovOldParams(uint64(l)) + l = len(m.NetworkFee) + if l > 0 { + n += 1 + l + sovOldParams(uint64(l)) + } + if m.MaxPoints != 0 { + n += 1 + sovOldParams(uint64(m.MaxPoints)) + } + return n +} + +func (m *OldDelegationParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UnbondingDelegationTime != 0 { + n += 1 + sovOldParams(uint64(m.UnbondingDelegationTime)) + } + if m.RedelegationCooldown != 0 { + n += 1 + sovOldParams(uint64(m.RedelegationCooldown)) + } + if m.RedelegationMaxAmount != 0 { + n += 1 + sovOldParams(uint64(m.RedelegationMaxAmount)) + } + l = len(m.VoteSlash) + if l > 0 { + n += 1 + l + sovOldParams(uint64(l)) + } + l = len(m.UploadSlash) + if l > 0 { + n += 1 + l + sovOldParams(uint64(l)) + } + l = len(m.TimeoutSlash) + if l > 0 { + n += 1 + l + sovOldParams(uint64(l)) + } + return n +} + +func sovOldParams(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozOldParams(x uint64) (n int) { + return sovOldParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *OldBundlesParams) 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 ErrIntOverflowOldParams + } + 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: OldBundlesParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldBundlesParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UploadTimeout", wireType) + } + m.UploadTimeout = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UploadTimeout |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageCost", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + 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 ErrInvalidLengthOldParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.StorageCost.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkFee", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + 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 ErrInvalidLengthOldParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NetworkFee = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxPoints", wireType) + } + m.MaxPoints = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxPoints |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipOldParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthOldParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OldDelegationParams) 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 ErrIntOverflowOldParams + } + 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: OldDelegationParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldDelegationParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegationTime", wireType) + } + m.UnbondingDelegationTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UnbondingDelegationTime |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RedelegationCooldown", wireType) + } + m.RedelegationCooldown = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RedelegationCooldown |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RedelegationMaxAmount", wireType) + } + m.RedelegationMaxAmount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RedelegationMaxAmount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoteSlash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + 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 ErrInvalidLengthOldParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VoteSlash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UploadSlash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + 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 ErrInvalidLengthOldParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UploadSlash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSlash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldParams + } + 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 ErrInvalidLengthOldParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TimeoutSlash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOldParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthOldParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOldParams(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, ErrIntOverflowOldParams + } + 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, ErrIntOverflowOldParams + } + 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, ErrIntOverflowOldParams + } + 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, ErrInvalidLengthOldParams + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupOldParams + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthOldParams + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthOldParams = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOldParams = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupOldParams = fmt.Errorf("proto: unexpected end of group") +) diff --git a/app/upgrades/v1_1/types/old_stakers.pb.go b/app/upgrades/v1_1/types/old_stakers.pb.go new file mode 100644 index 00000000..6ba7a5ce --- /dev/null +++ b/app/upgrades/v1_1/types/old_stakers.pb.go @@ -0,0 +1,839 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: kyve/upgrades/v1beta1/old_stakers.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 + +// OldStaker contains all metadata for a staker +// Every address can only create one staker (itself) +type OldStaker struct { + // address ... + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // commission ... + Commission string `protobuf:"bytes,2,opt,name=commission,proto3" json:"commission,omitempty"` + // moniker ... + Moniker string `protobuf:"bytes,3,opt,name=moniker,proto3" json:"moniker,omitempty"` + // website ... + Website string `protobuf:"bytes,4,opt,name=website,proto3" json:"website,omitempty"` + // logo ... + Logo string `protobuf:"bytes,5,opt,name=logo,proto3" json:"logo,omitempty"` +} + +func (m *OldStaker) Reset() { *m = OldStaker{} } +func (m *OldStaker) String() string { return proto.CompactTextString(m) } +func (*OldStaker) ProtoMessage() {} +func (*OldStaker) Descriptor() ([]byte, []int) { + return fileDescriptor_df012f4fad4151e2, []int{0} +} +func (m *OldStaker) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OldStaker) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OldStaker.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 *OldStaker) XXX_Merge(src proto.Message) { + xxx_messageInfo_OldStaker.Merge(m, src) +} +func (m *OldStaker) XXX_Size() int { + return m.Size() +} +func (m *OldStaker) XXX_DiscardUnknown() { + xxx_messageInfo_OldStaker.DiscardUnknown(m) +} + +var xxx_messageInfo_OldStaker proto.InternalMessageInfo + +func (m *OldStaker) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *OldStaker) GetCommission() string { + if m != nil { + return m.Commission + } + return "" +} + +func (m *OldStaker) GetMoniker() string { + if m != nil { + return m.Moniker + } + return "" +} + +func (m *OldStaker) GetWebsite() string { + if m != nil { + return m.Website + } + return "" +} + +func (m *OldStaker) GetLogo() string { + if m != nil { + return m.Logo + } + return "" +} + +// OldCommissionChangeEntry stores the information for an +// upcoming commission change. A commission change is never +// instant, so delegators have time to redelegate in case +// they don't agree with the new commission. +type OldCommissionChangeEntry struct { + // index is needed for the queue-algorithm which + // processes the commission changes + Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + // staker is the address of the affected staker + Staker string `protobuf:"bytes,2,opt,name=staker,proto3" json:"staker,omitempty"` + // commission is the new commission which will + // be applied after the waiting time is over. + Commission string `protobuf:"bytes,3,opt,name=commission,proto3" json:"commission,omitempty"` + // creation_date is the UNIX-timestamp in seconds + // when the entry was created. + CreationDate int64 `protobuf:"varint,4,opt,name=creation_date,json=creationDate,proto3" json:"creation_date,omitempty"` +} + +func (m *OldCommissionChangeEntry) Reset() { *m = OldCommissionChangeEntry{} } +func (m *OldCommissionChangeEntry) String() string { return proto.CompactTextString(m) } +func (*OldCommissionChangeEntry) ProtoMessage() {} +func (*OldCommissionChangeEntry) Descriptor() ([]byte, []int) { + return fileDescriptor_df012f4fad4151e2, []int{1} +} +func (m *OldCommissionChangeEntry) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OldCommissionChangeEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OldCommissionChangeEntry.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 *OldCommissionChangeEntry) XXX_Merge(src proto.Message) { + xxx_messageInfo_OldCommissionChangeEntry.Merge(m, src) +} +func (m *OldCommissionChangeEntry) XXX_Size() int { + return m.Size() +} +func (m *OldCommissionChangeEntry) XXX_DiscardUnknown() { + xxx_messageInfo_OldCommissionChangeEntry.DiscardUnknown(m) +} + +var xxx_messageInfo_OldCommissionChangeEntry proto.InternalMessageInfo + +func (m *OldCommissionChangeEntry) GetIndex() uint64 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *OldCommissionChangeEntry) GetStaker() string { + if m != nil { + return m.Staker + } + return "" +} + +func (m *OldCommissionChangeEntry) GetCommission() string { + if m != nil { + return m.Commission + } + return "" +} + +func (m *OldCommissionChangeEntry) GetCreationDate() int64 { + if m != nil { + return m.CreationDate + } + return 0 +} + +func init() { + proto.RegisterType((*OldStaker)(nil), "kyve.upgrades.v1beta1.OldStaker") + proto.RegisterType((*OldCommissionChangeEntry)(nil), "kyve.upgrades.v1beta1.OldCommissionChangeEntry") +} + +func init() { + proto.RegisterFile("kyve/upgrades/v1beta1/old_stakers.proto", fileDescriptor_df012f4fad4151e2) +} + +var fileDescriptor_df012f4fad4151e2 = []byte{ + // 311 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0xcb, 0x4a, 0x33, 0x31, + 0x14, 0xc7, 0x3b, 0x5f, 0x2f, 0x1f, 0x0d, 0xba, 0x09, 0x2a, 0x59, 0x05, 0xd1, 0x85, 0xae, 0x26, + 0x14, 0x7d, 0x02, 0x6b, 0x57, 0x42, 0x0b, 0x15, 0x04, 0xdd, 0x94, 0xcc, 0xe4, 0x30, 0x0d, 0x33, + 0x93, 0x0c, 0x49, 0xda, 0xda, 0x87, 0x10, 0x7c, 0x2c, 0x97, 0x5d, 0xba, 0x94, 0xf6, 0x45, 0x64, + 0x32, 0xa9, 0x14, 0xdd, 0xe5, 0x7f, 0x39, 0xe1, 0x77, 0x38, 0xe8, 0x2a, 0x5f, 0x2f, 0x81, 0x2d, + 0xaa, 0xcc, 0x70, 0x01, 0x96, 0x2d, 0x07, 0x09, 0x38, 0x3e, 0x60, 0xba, 0x10, 0x33, 0xeb, 0x78, + 0x0e, 0xc6, 0xc6, 0x95, 0xd1, 0x4e, 0xe3, 0xd3, 0xba, 0x18, 0xef, 0x8b, 0x71, 0x28, 0x5e, 0xbc, + 0x45, 0xa8, 0x3f, 0x29, 0xc4, 0xa3, 0xef, 0x62, 0x82, 0xfe, 0x73, 0x21, 0x0c, 0x58, 0x4b, 0xa2, + 0xf3, 0xe8, 0xba, 0x3f, 0xdd, 0x4b, 0x4c, 0x11, 0x4a, 0x75, 0x59, 0x4a, 0x6b, 0xa5, 0x56, 0xe4, + 0x9f, 0x0f, 0x0f, 0x9c, 0x7a, 0xb2, 0xd4, 0x4a, 0xe6, 0x60, 0x48, 0xbb, 0x99, 0x0c, 0xb2, 0x4e, + 0x56, 0x90, 0x58, 0xe9, 0x80, 0x74, 0x9a, 0x24, 0x48, 0x8c, 0x51, 0xa7, 0xd0, 0x99, 0x26, 0x5d, + 0x6f, 0xfb, 0x77, 0xcd, 0x43, 0x26, 0x85, 0x18, 0xfe, 0xfc, 0x3c, 0x9c, 0x73, 0x95, 0xc1, 0x48, + 0x39, 0xb3, 0xc6, 0x27, 0xa8, 0x2b, 0x95, 0x80, 0x57, 0x0f, 0xd7, 0x99, 0x36, 0x02, 0x9f, 0xa1, + 0x5e, 0xb3, 0x6a, 0xc0, 0x0a, 0xea, 0x17, 0x72, 0xfb, 0x0f, 0xf2, 0x25, 0x3a, 0x4e, 0x0d, 0x70, + 0x27, 0xb5, 0x9a, 0x09, 0x1e, 0xf0, 0xda, 0xd3, 0xa3, 0xbd, 0x79, 0xcf, 0x1d, 0xdc, 0x8d, 0x3f, + 0xb6, 0x34, 0xda, 0x6c, 0x69, 0xf4, 0xb5, 0xa5, 0xd1, 0xfb, 0x8e, 0xb6, 0x36, 0x3b, 0xda, 0xfa, + 0xdc, 0xd1, 0xd6, 0xcb, 0x6d, 0x26, 0xdd, 0x7c, 0x91, 0xc4, 0xa9, 0x2e, 0xd9, 0xc3, 0xf3, 0xd3, + 0x68, 0x0c, 0x6e, 0xa5, 0x4d, 0xce, 0xd2, 0x39, 0x97, 0x8a, 0xf1, 0xaa, 0x3a, 0xbc, 0xca, 0x6c, + 0xc0, 0xdc, 0xba, 0x02, 0x9b, 0xf4, 0xfc, 0x35, 0x6e, 0xbe, 0x03, 0x00, 0x00, 0xff, 0xff, 0x16, + 0x23, 0x0e, 0xb6, 0xb8, 0x01, 0x00, 0x00, +} + +func (m *OldStaker) 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 *OldStaker) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OldStaker) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Logo) > 0 { + i -= len(m.Logo) + copy(dAtA[i:], m.Logo) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Logo))) + i-- + dAtA[i] = 0x2a + } + if len(m.Website) > 0 { + i -= len(m.Website) + copy(dAtA[i:], m.Website) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Website))) + i-- + dAtA[i] = 0x22 + } + if len(m.Moniker) > 0 { + i -= len(m.Moniker) + copy(dAtA[i:], m.Moniker) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Moniker))) + i-- + dAtA[i] = 0x1a + } + if len(m.Commission) > 0 { + i -= len(m.Commission) + copy(dAtA[i:], m.Commission) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Commission))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OldCommissionChangeEntry) 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 *OldCommissionChangeEntry) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OldCommissionChangeEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CreationDate != 0 { + i = encodeVarintOldStakers(dAtA, i, uint64(m.CreationDate)) + i-- + dAtA[i] = 0x20 + } + if len(m.Commission) > 0 { + i -= len(m.Commission) + copy(dAtA[i:], m.Commission) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Commission))) + i-- + dAtA[i] = 0x1a + } + if len(m.Staker) > 0 { + i -= len(m.Staker) + copy(dAtA[i:], m.Staker) + i = encodeVarintOldStakers(dAtA, i, uint64(len(m.Staker))) + i-- + dAtA[i] = 0x12 + } + if m.Index != 0 { + i = encodeVarintOldStakers(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintOldStakers(dAtA []byte, offset int, v uint64) int { + offset -= sovOldStakers(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *OldStaker) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + l = len(m.Commission) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + l = len(m.Moniker) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + l = len(m.Website) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + l = len(m.Logo) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + return n +} + +func (m *OldCommissionChangeEntry) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != 0 { + n += 1 + sovOldStakers(uint64(m.Index)) + } + l = len(m.Staker) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + l = len(m.Commission) + if l > 0 { + n += 1 + l + sovOldStakers(uint64(l)) + } + if m.CreationDate != 0 { + n += 1 + sovOldStakers(uint64(m.CreationDate)) + } + return n +} + +func sovOldStakers(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozOldStakers(x uint64) (n int) { + return sovOldStakers(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *OldStaker) 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 ErrIntOverflowOldStakers + } + 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: OldStaker: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldStaker: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Commission = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Moniker = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Website = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logo", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logo = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOldStakers(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthOldStakers + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OldCommissionChangeEntry) 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 ErrIntOverflowOldStakers + } + 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: OldCommissionChangeEntry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldCommissionChangeEntry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Staker", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Staker = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + 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 ErrInvalidLengthOldStakers + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOldStakers + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Commission = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CreationDate", wireType) + } + m.CreationDate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOldStakers + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CreationDate |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipOldStakers(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthOldStakers + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOldStakers(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, ErrIntOverflowOldStakers + } + 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, ErrIntOverflowOldStakers + } + 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, ErrIntOverflowOldStakers + } + 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, ErrInvalidLengthOldStakers + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupOldStakers + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthOldStakers + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthOldStakers = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOldStakers = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupOldStakers = fmt.Errorf("proto: unexpected end of group") +) diff --git a/app/upgrades/v1_1/upgrade.go b/app/upgrades/v1_1/upgrade.go index 9f917ae0..ed419a82 100644 --- a/app/upgrades/v1_1/upgrade.go +++ b/app/upgrades/v1_1/upgrade.go @@ -1,6 +1,10 @@ package v1_1 import ( + "github.com/KYVENetwork/chain/app/upgrades/v1_1/types" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store/prefix" + storeTypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" @@ -9,11 +13,21 @@ import ( authTypes "github.com/cosmos/cosmos-sdk/x/auth/types" vestingExported "github.com/cosmos/cosmos-sdk/x/auth/vesting/exported" vestingTypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types" + // Bundles + bundlesTypes "github.com/KYVENetwork/chain/x/bundles/types" + // Delegation + delegationTypes "github.com/KYVENetwork/chain/x/delegation/types" // IBC Transfer transferKeeper "github.com/cosmos/ibc-go/v6/modules/apps/transfer/keeper" transferTypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types" + // ICA Controller + icaControllerKeeper "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/controller/keeper" + icaControllerTypes "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/controller/types" + // ICA Host + icaHostKeeper "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/host/keeper" + icaHostTypes "github.com/cosmos/ibc-go/v6/modules/apps/27-interchain-accounts/host/types" // Stakers - stakersKeeper "github.com/KYVENetwork/chain/x/stakers/keeper" + stakersTypes "github.com/KYVENetwork/chain/x/stakers/types" // Upgrade upgradeTypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" ) @@ -21,8 +35,13 @@ import ( func CreateUpgradeHandler( mm *module.Manager, configurator module.Configurator, + cdc codec.BinaryCodec, + bundlesStoreKey storeTypes.StoreKey, + delegationStoreKey storeTypes.StoreKey, + stakersStoreKey storeTypes.StoreKey, accountKeeper authKeeper.AccountKeeper, - stakerKeeper stakersKeeper.Keeper, + icaControllerKeeper icaControllerKeeper.Keeper, + icaHostKeeper icaHostKeeper.Keeper, transferKeeper transferKeeper.Keeper, ) upgradeTypes.UpgradeHandler { return func(ctx sdk.Context, _ upgradeTypes.Plan, vm module.VersionMap) (module.VersionMap, error) { @@ -33,7 +52,16 @@ func CreateUpgradeHandler( } EnableIBCTransfers(ctx, transferKeeper) - MigrateStakerMetadata(ctx, stakerKeeper) + if ctx.ChainID() == TestnetChainID { + InitialiseICAControllerParams(ctx, icaControllerKeeper) + UpdateICAHostParams(ctx, icaHostKeeper) + } + + MigrateBundlesParameters(ctx, cdc, bundlesStoreKey) + MigrateDelegationParameters(ctx, cdc, delegationStoreKey) + + MigrateStakerMetadata(ctx, cdc, stakersStoreKey) + MigrateStakerCommissionEntries(ctx, cdc, stakersStoreKey) return mm.RunMigrations(ctx, configurator, vm) } @@ -64,11 +92,131 @@ func EnableIBCTransfers(ctx sdk.Context, keeper transferKeeper.Keeper) { keeper.SetParams(ctx, params) } +// InitialiseICAControllerParams initialises the parameters of the ICA +// Controller module. This is because when upgrading from IBC v5 to v6 on Kaon +// (our testnet), we didn't initialise the parameters. +func InitialiseICAControllerParams(ctx sdk.Context, keeper icaControllerKeeper.Keeper) { + params := icaControllerTypes.DefaultParams() + keeper.SetParams(ctx, params) +} + +// UpdateICAHostParams updates the parameters of the ICA Host module to allow +// all messages to be called. This configuration is the new default, which +// wasn't updated on Kaon (our testnet). +func UpdateICAHostParams(ctx sdk.Context, keeper icaHostKeeper.Keeper) { + params := icaHostTypes.DefaultParams() + keeper.SetParams(ctx, params) +} + +// MigrateBundlesParameters re-encodes all parameters of the Bundles module +// that were converted to sdk.Dec. +func MigrateBundlesParameters(ctx sdk.Context, cdc codec.BinaryCodec, bundlesStoreKey storeTypes.StoreKey) { + store := ctx.KVStore(bundlesStoreKey) + bz := store.Get(bundlesTypes.ParamsKey) + + var oldParams types.OldBundlesParams + cdc.MustUnmarshal(bz, &oldParams) + + newParams := bundlesTypes.Params{ + UploadTimeout: oldParams.UploadTimeout, + StorageCost: oldParams.StorageCost, + NetworkFee: sdk.MustNewDecFromStr(oldParams.NetworkFee), + MaxPoints: oldParams.MaxPoints, + } + + bz = cdc.MustMarshal(&newParams) + store.Set(bundlesTypes.ParamsKey, bz) +} + +// MigrateDelegationParameters re-encodes all parameters of the Delegation +// module that were converted to sdk.Dec. +func MigrateDelegationParameters(ctx sdk.Context, cdc codec.BinaryCodec, delegationStoreKey storeTypes.StoreKey) { + store := ctx.KVStore(delegationStoreKey) + bz := store.Get(delegationTypes.ParamsKey) + + var oldParams types.OldDelegationParams + cdc.MustUnmarshal(bz, &oldParams) + + newParams := delegationTypes.Params{ + UnbondingDelegationTime: oldParams.UnbondingDelegationTime, + RedelegationCooldown: oldParams.RedelegationCooldown, + RedelegationMaxAmount: oldParams.RedelegationMaxAmount, + VoteSlash: sdk.MustNewDecFromStr(oldParams.VoteSlash), + UploadSlash: sdk.MustNewDecFromStr(oldParams.UploadSlash), + TimeoutSlash: sdk.MustNewDecFromStr(oldParams.TimeoutSlash), + } + + bz = cdc.MustMarshal(&newParams) + store.Set(delegationTypes.ParamsKey, bz) +} + // MigrateStakerMetadata migrates all existing staker metadata. The `Logo` // field has been deprecated and replaced by the `Identity` field. This new // field must be a valid hex string; therefore, must be set to empty for now. -func MigrateStakerMetadata(ctx sdk.Context, keeper stakersKeeper.Keeper) { - for _, staker := range keeper.GetAllStakers(ctx) { - keeper.UpdateStakerMetadata(ctx, staker.Address, staker.Moniker, staker.Website, "", "", "") +func MigrateStakerMetadata(ctx sdk.Context, cdc codec.BinaryCodec, stakerStoreKey storeTypes.StoreKey) { + store := prefix.NewStore(ctx.KVStore(stakerStoreKey), stakersTypes.StakerKeyPrefix) + iterator := sdk.KVStorePrefixIterator(store, []byte{}) + + defer iterator.Close() + oldStakers := make([]types.OldStaker, 0) + + for ; iterator.Valid(); iterator.Next() { + var val types.OldStaker + cdc.MustUnmarshal(iterator.Value(), &val) + oldStakers = append(oldStakers, val) + } + + for _, oldStaker := range oldStakers { + + commission, err := sdk.NewDecFromStr(oldStaker.Commission) + if err != nil { + commission = stakersTypes.DefaultCommission + } + + newStaker := stakersTypes.Staker{ + Address: oldStaker.Address, + Commission: commission, + Moniker: oldStaker.Moniker, + Website: oldStaker.Website, + Identity: "", + SecurityContact: "", + Details: "", + } + + b := cdc.MustMarshal(&newStaker) + store.Set(stakersTypes.StakerKey(newStaker.Address), b) + } +} + +// MigrateStakerCommissionEntries re-encodes all CommissionChangeEntry +// entries from the Stakers module that were converted to sdk.Dec. +func MigrateStakerCommissionEntries(ctx sdk.Context, cdc codec.BinaryCodec, stakerStoreKey storeTypes.StoreKey) { + store := prefix.NewStore(ctx.KVStore(stakerStoreKey), stakersTypes.CommissionChangeEntryKeyPrefix) + iterator := sdk.KVStorePrefixIterator(store, []byte{}) + + defer iterator.Close() + oldCommissionChangeEntries := make([]types.OldCommissionChangeEntry, 0) + + for ; iterator.Valid(); iterator.Next() { + var val types.OldCommissionChangeEntry + cdc.MustUnmarshal(iterator.Value(), &val) + oldCommissionChangeEntries = append(oldCommissionChangeEntries, val) + } + + for _, oldCommissionEntry := range oldCommissionChangeEntries { + commission, err := sdk.NewDecFromStr(oldCommissionEntry.Commission) + if err != nil { + commission = stakersTypes.DefaultCommission + } + + newCommissionChangeEntry := stakersTypes.CommissionChangeEntry{ + Index: oldCommissionEntry.Index, + Staker: oldCommissionEntry.Staker, + Commission: commission, + CreationDate: oldCommissionEntry.CreationDate, + } + + b := cdc.MustMarshal(&newCommissionChangeEntry) + store.Set(stakersTypes.CommissionChangeEntryKey(newCommissionChangeEntry.Index), b) } } diff --git a/go.mod b/go.mod index 5456ed20..a20a2ec5 100644 --- a/go.mod +++ b/go.mod @@ -6,13 +6,13 @@ require ( cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/math v1.0.0-beta.3 github.com/cosmos/cosmos-proto v1.0.0-alpha8 - github.com/cosmos/cosmos-sdk v0.46.11 + github.com/cosmos/cosmos-sdk v0.46.12 github.com/cosmos/gogoproto v1.4.2 github.com/cosmos/ibc-go/v6 v6.1.0 - github.com/ethereum/go-ethereum v1.10.17 + github.com/ethereum/go-ethereum v1.10.22 github.com/gogo/protobuf v1.3.3 github.com/golang/protobuf v1.5.2 - github.com/golangci/golangci-lint v1.52.1 + github.com/golangci/golangci-lint v1.52.2 github.com/grpc-ecosystem/grpc-gateway v1.16.0 github.com/onsi/ginkgo/v2 v2.8.0 github.com/onsi/gomega v1.26.0 @@ -23,7 +23,7 @@ require ( github.com/tendermint/tm-db v0.6.7 google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6 google.golang.org/grpc v1.52.0 - mvdan.cc/gofumpt v0.4.0 + mvdan.cc/gofumpt v0.5.0 ) require ( @@ -197,7 +197,7 @@ require ( github.com/mitchellh/go-homedir v1.1.0 // indirect github.com/mitchellh/go-testing-interface v1.0.0 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect - github.com/moricho/tparallel v0.3.0 // indirect + github.com/moricho/tparallel v0.3.1 // indirect github.com/mtibben/percent v0.2.1 // indirect github.com/nakabonne/nestif v0.3.1 // indirect github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354 // indirect @@ -277,14 +277,14 @@ require ( golang.org/x/crypto v0.5.0 // indirect golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e // indirect golang.org/x/exp/typeparams v0.0.0-20230224173230-c95f2b4c22f2 // indirect - golang.org/x/mod v0.9.0 // indirect - golang.org/x/net v0.8.0 // indirect + golang.org/x/mod v0.10.0 // indirect + golang.org/x/net v0.9.0 // indirect golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783 // indirect golang.org/x/sync v0.1.0 // indirect - golang.org/x/sys v0.6.0 // indirect - golang.org/x/term v0.6.0 // indirect - golang.org/x/text v0.8.0 // indirect - golang.org/x/tools v0.7.0 // indirect + golang.org/x/sys v0.7.0 // indirect + golang.org/x/term v0.7.0 // indirect + golang.org/x/text v0.9.0 // indirect + golang.org/x/tools v0.8.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/api v0.102.0 // indirect google.golang.org/appengine v1.6.7 // indirect @@ -302,7 +302,7 @@ require ( replace ( // use kyve flavored cosmos/cosmos-sdk - github.com/cosmos/cosmos-sdk => github.com/KYVENetwork/cosmos-sdk v0.46.11-kyve-rc0 + github.com/cosmos/cosmos-sdk => github.com/KYVENetwork/cosmos-sdk v0.46.12-kyve // use cosmos flavored gogo/protobuf // https://github.com/cosmos/cosmos-sdk/issues/8469 diff --git a/go.sum b/go.sum index a25429ce..1e6a6a89 100644 --- a/go.sum +++ b/go.sum @@ -90,8 +90,8 @@ github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24 h1:sHglBQTwgx+rW github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24/go.mod h1:4UJr5HIiMZrwgkSPdsjy2uOQExX/WEILpIrO9UPGuXs= github.com/GaijinEntertainment/go-exhaustruct/v2 v2.3.0 h1:+r1rSv4gvYn0wmRjC8X7IAzX8QezqtFV9m0MUHFJgts= github.com/GaijinEntertainment/go-exhaustruct/v2 v2.3.0/go.mod h1:b3g59n2Y+T5xmcxJL+UEG2f8cQploZm1mR/v6BW0mU0= -github.com/KYVENetwork/cosmos-sdk v0.46.11-kyve-rc0 h1:sZKzmsP+IyB6pyxex8YDxLImXk7n+Sy+jwEUT31Q64k= -github.com/KYVENetwork/cosmos-sdk v0.46.11-kyve-rc0/go.mod h1:bG4AkW9bqc8ycrryyKGQEl3YV9BY2wr6HggGq8kvcgM= +github.com/KYVENetwork/cosmos-sdk v0.46.12-kyve h1:bzM7dCbZ3Z3fNZa1b95ib6q1qxesyT3FCSCDSJNdUHg= +github.com/KYVENetwork/cosmos-sdk v0.46.12-kyve/go.mod h1:bG4AkW9bqc8ycrryyKGQEl3YV9BY2wr6HggGq8kvcgM= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww= github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= @@ -349,8 +349,9 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/esimonov/ifshort v1.0.4 h1:6SID4yGWfRae/M7hkVDVVyppy8q/v9OuxNdmjLQStBA= github.com/esimonov/ifshort v1.0.4/go.mod h1:Pe8zjlRrJ80+q2CxHLfEOfTwxCZ4O+MuhcHcfgNWTk0= -github.com/ethereum/go-ethereum v1.10.17 h1:XEcumY+qSr1cZQaWsQs5Kck3FHB0V2RiMHPdTBJ+oT8= github.com/ethereum/go-ethereum v1.10.17/go.mod h1:Lt5WzjM07XlXc95YzrhosmR4J9Ahd6X2wyEV2SvGhk0= +github.com/ethereum/go-ethereum v1.10.22 h1:HbEgsDo1YTGIf4KB/NNpn+XH+PiNJXUZ9ksRxiqWyMc= +github.com/ethereum/go-ethereum v1.10.22/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg= github.com/ettle/strcase v0.1.1 h1:htFueZyVeE1XNnMEfbqp5r67qAN/4r6ya1ysq8Q+Zcw= github.com/ettle/strcase v0.1.1/go.mod h1:hzDLsPC7/lwKyBOywSHEP89nt2pDgdy+No1NBA9o9VY= github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c h1:8ISkoahWXwZR41ois5lSJBSVw4D0OV19Ht/JSTzvSv0= @@ -371,7 +372,7 @@ github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/ github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= -github.com/frankban/quicktest v1.14.3 h1:FJKSZTDHjyhriyC81FLQ0LY93eSai0ZyR/ZIkd3ZUKE= +github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= @@ -511,8 +512,8 @@ github.com/golangci/go-misc v0.0.0-20220329215616-d24fe342adfe h1:6RGUuS7EGotKx6 github.com/golangci/go-misc v0.0.0-20220329215616-d24fe342adfe/go.mod h1:gjqyPShc/m8pEMpk0a3SeagVb0kaqvhscv+i9jI5ZhQ= github.com/golangci/gofmt v0.0.0-20220901101216-f2edd75033f2 h1:amWTbTGqOZ71ruzrdA+Nx5WA3tV1N0goTspwmKCQvBY= github.com/golangci/gofmt v0.0.0-20220901101216-f2edd75033f2/go.mod h1:9wOXstvyDRshQ9LggQuzBCGysxs3b6Uo/1MvYCR2NMs= -github.com/golangci/golangci-lint v1.52.1 h1:TwQtQi5dGE/uFOxYGKwddJo7T9sHsRfTUN00HZMl5Jo= -github.com/golangci/golangci-lint v1.52.1/go.mod h1:wlTh+d/oVlgZC2yCe6nlxrxNAnuhEQC0Zdygoh72Uak= +github.com/golangci/golangci-lint v1.52.2 h1:FrPElUUI5rrHXg1mQ7KxI1MXPAw5lBVskiz7U7a8a1A= +github.com/golangci/golangci-lint v1.52.2/go.mod h1:S5fhC5sHM5kE22/HcATKd1XLWQxX+y7mHj8B5H91Q/0= github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y= github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0 h1:MfyDlzVjl1hoaPzPD4Gpb/QgoRfSBR0jdhwGyAWwMSA= github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0/go.mod h1:66R6K6P6VWk9I95jvqGxkqJxVWGFy9XlDwLwVz1RCFg= @@ -763,7 +764,7 @@ github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -874,8 +875,8 @@ github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3Rllmb github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8= -github.com/moricho/tparallel v0.3.0 h1:8dDx3S3e+jA+xiQXC7O3dvfRTe/J+FYlTDDW01Y7z/Q= -github.com/moricho/tparallel v0.3.0/go.mod h1:leENX2cUv7Sv2qDgdi0D0fCftN8fRC67Bcn8pqzeYNI= +github.com/moricho/tparallel v0.3.1 h1:fQKD4U1wRMAYNngDonW5XupoB/ZGJHdpzrWqgyg9krA= +github.com/moricho/tparallel v0.3.1/go.mod h1:leENX2cUv7Sv2qDgdi0D0fCftN8fRC67Bcn8pqzeYNI= github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg= github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs= github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= @@ -967,7 +968,6 @@ github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc= github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -1046,7 +1046,7 @@ github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRr github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/rs/cors v1.8.2 h1:KCooALfAYGs415Cwu5ABvv9n9509fSiG5SQJn/AQo4U= github.com/rs/cors v1.8.2/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= @@ -1347,8 +1347,8 @@ golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91 golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.9.0 h1:KENHtAZL2y3NLMYZeHY9DW8HW8V+kQyJsY/V9JlKvCs= -golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk= +golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -1410,8 +1410,8 @@ golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= golang.org/x/net v0.3.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ= -golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1531,8 +1531,8 @@ golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= @@ -1541,8 +1541,8 @@ golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/term v0.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw= -golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= +golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1556,8 +1556,8 @@ golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68= -golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -1644,8 +1644,8 @@ golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= golang.org/x/tools v0.4.0/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ= golang.org/x/tools v0.5.0/go.mod h1:N+Kgy78s5I24c24dU8OfWNEotWjutIs8SnJvn5IDq+k= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.7.0 h1:W4OVu8VVOaIO0yzWMNdepAulS7YfoS3Zabrm8DOXXU4= -golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s= +golang.org/x/tools v0.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y= +golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -1822,8 +1822,8 @@ honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9 honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las= honnef.co/go/tools v0.4.3 h1:o/n5/K5gXqk8Gozvs2cnL0F2S1/g1vcGCAx2vETjITw= honnef.co/go/tools v0.4.3/go.mod h1:36ZgoUOrqOk1GxwHhyryEkq8FQWkUO2xGuSMhUCcdvA= -mvdan.cc/gofumpt v0.4.0 h1:JVf4NN1mIpHogBj7ABpgOyZc65/UUOkKQFkoURsz4MM= -mvdan.cc/gofumpt v0.4.0/go.mod h1:PljLOHDeZqgS8opHRKLzp2It2VBuSdteAgqUfzMTxlQ= +mvdan.cc/gofumpt v0.5.0 h1:0EQ+Z56k8tXjj/6TQD25BFNKQXpCvT0rnansIc7Ug5E= +mvdan.cc/gofumpt v0.5.0/go.mod h1:HBeVDtMKRZpXyxFciAirzdKklDlGu8aAy1wEbH5Y9js= mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed h1:WX1yoOaKQfddO/mLzdV4wptyWgoH/6hwLs7QHTixo0I= mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed/go.mod h1:Xkxe497xwlCKkIaQYRfC7CSLworTXY9RMqwhhCm+8Nc= mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b h1:DxJ5nJdkhDlLok9K6qO+5290kphDJbHOQO1DFFFTeBo= diff --git a/proto/kyve/query/v1beta1/query.proto b/proto/kyve/query/v1beta1/query.proto index a63fab18..87ddc414 100644 --- a/proto/kyve/query/v1beta1/query.proto +++ b/proto/kyve/query/v1beta1/query.proto @@ -10,15 +10,15 @@ option go_package = "github.com/KYVENetwork/chain/x/query/types"; /* This query-module servers all queries for the following (KYVE-)modules: bundles, pool, delegation, stakers - + As a lot of request require composition of multiple module-data everything will be served from one single query module. - + The named packages do not implement their own queries (expect for params) - + For simplicity all queries and their objects are in the corresponding proto files - + Messages that are used for across multiple queries are defined here. */ diff --git a/proto/kyve/upgrades/v1beta1/README.md b/proto/kyve/upgrades/v1beta1/README.md new file mode 100644 index 00000000..ee2aee63 --- /dev/null +++ b/proto/kyve/upgrades/v1beta1/README.md @@ -0,0 +1,13 @@ +# Upgrade Types + +When upgrading from `v1.0.0` to `v1.1.0`, a significant amount of internal +Protobuf types changed. This is mainly the change from `string` to `sdk.Dec`. + +Unfortunately, we can't decode strings that don't have the correct zero +padding. Therefore, all affected fields need to be updated manually. This +directory contains all the old Protobuf definitions so that we can correctly +decode the original values. + +These Protobuf definitions are directly built to `app/upgrades/v1_1/types`. + +After the `v1.1.0` upgrade, these definitions can be removed. diff --git a/proto/kyve/upgrades/v1beta1/old_params.proto b/proto/kyve/upgrades/v1beta1/old_params.proto new file mode 100644 index 00000000..4c40c10b --- /dev/null +++ b/proto/kyve/upgrades/v1beta1/old_params.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; + +package kyve.upgrades.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/KYVENetwork/chain/app/upgrades/v1_1/types"; + +// OldBundlesParams defines the bundles module parameters. +message OldBundlesParams { + // upload_timeout ... + uint64 upload_timeout = 1; + // storage_cost ... + string storage_cost = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // network_fee ... + string network_fee = 3; + // max_points ... + uint64 max_points = 4; +} + +// OldDelegationParams defines the delegation module parameters. +message OldDelegationParams { + // unbonding_delegation_time ... + uint64 unbonding_delegation_time = 1; + // unbonding_delegation_time ... + uint64 redelegation_cooldown = 2; + // unbonding_delegation_time ... + uint64 redelegation_max_amount = 3; + // vote_slash ... + string vote_slash = 4; + // upload_slash ... + string upload_slash = 5; + // timeout_slash ... + string timeout_slash = 6; +} diff --git a/proto/kyve/upgrades/v1beta1/old_stakers.proto b/proto/kyve/upgrades/v1beta1/old_stakers.proto new file mode 100644 index 00000000..c40a3001 --- /dev/null +++ b/proto/kyve/upgrades/v1beta1/old_stakers.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; + +package kyve.upgrades.v1beta1; + +option go_package = "github.com/KYVENetwork/chain/app/upgrades/v1_1/types"; + +// OldStaker contains all metadata for a staker +// Every address can only create one staker (itself) +message OldStaker { + // address ... + string address = 1; + // commission ... + string commission = 2; + // moniker ... + string moniker = 3; + // website ... + string website = 4; + // logo ... + string logo = 5; +} + +// OldCommissionChangeEntry stores the information for an +// upcoming commission change. A commission change is never +// instant, so delegators have time to redelegate in case +// they don't agree with the new commission. +message OldCommissionChangeEntry { + // index is needed for the queue-algorithm which + // processes the commission changes + uint64 index = 1; + // staker is the address of the affected staker + string staker = 2; + // commission is the new commission which will + // be applied after the waiting time is over. + string commission = 3; + // creation_date is the UNIX-timestamp in seconds + // when the entry was created. + int64 creation_date = 4; +}