diff --git a/app/app.go b/app/app.go index c2f8491f..537ff5a1 100644 --- a/app/app.go +++ b/app/app.go @@ -12,8 +12,16 @@ import ( authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" "github.com/cosmos/cosmos-sdk/x/staking" + + // staking stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + // multi-staking + multistaking "github.com/realio-tech/multi-staking-module/x/multi-staking" + multistakingkeeper "github.com/realio-tech/multi-staking-module/x/multi-staking/keeper" + multistakingtypes "github.com/realio-tech/multi-staking-module/x/multi-staking/types" + evmante "github.com/evmos/ethermint/app/ante" "github.com/evmos/ethermint/encoding" srvflags "github.com/evmos/ethermint/server/flags" @@ -141,7 +149,7 @@ var ( genutil.AppModuleBasic{}, bank.AppModuleBasic{}, capability.AppModuleBasic{}, - staking.AppModuleBasic{}, + multistaking.AppModuleBasic{}, mint.AppModuleBasic{}, distr.AppModuleBasic{}, gov.NewAppModuleBasic( @@ -177,6 +185,7 @@ var ( ibctransfertypes.ModuleName: {authtypes.Minter, authtypes.Burner}, evmtypes.ModuleName: {authtypes.Minter, authtypes.Burner}, // used for secure addition and subtraction of balance using module account assetmoduletypes.ModuleName: {authtypes.Minter, authtypes.Burner}, + multistakingtypes.ModuleName: {authtypes.Minter, authtypes.Burner}, // this line is used by starport scaffolding # stargate/app/maccPerms } ) @@ -217,22 +226,23 @@ type RealioNetwork struct { memKeys map[string]*storetypes.MemoryStoreKey // keepers - AccountKeeper authkeeper.AccountKeeper - BankKeeper bankkeeper.Keeper - CapabilityKeeper *capabilitykeeper.Keeper - StakingKeeper stakingkeeper.Keeper - SlashingKeeper slashingkeeper.Keeper - MintKeeper mintkeeper.Keeper - DistrKeeper distrkeeper.Keeper - GovKeeper govkeeper.Keeper - CrisisKeeper crisiskeeper.Keeper - UpgradeKeeper upgradekeeper.Keeper - ParamsKeeper paramskeeper.Keeper - FeeGrantKeeper feegrantkeeper.Keeper - AuthzKeeper authzkeeper.Keeper - IBCKeeper *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly - EvidenceKeeper evidencekeeper.Keeper - TransferKeeper ibctransferkeeper.Keeper + AccountKeeper authkeeper.AccountKeeper + BankKeeper bankkeeper.Keeper + CapabilityKeeper *capabilitykeeper.Keeper + StakingKeeper stakingkeeper.Keeper + MultiStakingKeeper multistakingkeeper.Keeper + SlashingKeeper slashingkeeper.Keeper + MintKeeper mintkeeper.Keeper + DistrKeeper distrkeeper.Keeper + GovKeeper govkeeper.Keeper + CrisisKeeper crisiskeeper.Keeper + UpgradeKeeper upgradekeeper.Keeper + ParamsKeeper paramskeeper.Keeper + FeeGrantKeeper feegrantkeeper.Keeper + AuthzKeeper authzkeeper.Keeper + IBCKeeper *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly + EvidenceKeeper evidencekeeper.Keeper + TransferKeeper ibctransferkeeper.Keeper // Ethermint keepers EvmKeeper *evmkeeper.Keeper @@ -289,6 +299,8 @@ func New( assetmoduletypes.StoreKey, // ethermint keys evmtypes.StoreKey, feemarkettypes.StoreKey, + // multi-staking keys + multistakingtypes.StoreKey, // this line is used by starport scaffolding # stargate/app/storeKey ) @@ -376,6 +388,15 @@ func New( stakingtypes.NewMultiStakingHooks(app.DistrKeeper.Hooks(), app.SlashingKeeper.Hooks()), ) + // multi-staking keeper + app.MultiStakingKeeper = *multistakingkeeper.NewKeeper( + appCodec, + app.AccountKeeper, + app.StakingKeeper, + app.BankKeeper, + keys[multistakingtypes.StoreKey], + ) + // realio keeper app.AssetKeeper = *assetmodulekeeper.NewKeeper( appCodec, @@ -460,7 +481,7 @@ func New( mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper), slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), - staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper), + multistaking.NewAppModule(appCodec, app.MultiStakingKeeper, app.StakingKeeper, app.AccountKeeper, app.BankKeeper), upgrade.NewAppModule(app.UpgradeKeeper), evidence.NewAppModule(app.EvidenceKeeper), params.NewAppModule(app.ParamsKeeper), @@ -494,7 +515,7 @@ func New( distrtypes.ModuleName, slashingtypes.ModuleName, evidencetypes.ModuleName, - stakingtypes.ModuleName, + multistakingtypes.ModuleName, ibchost.ModuleName, // no-op modules ibctransfertypes.ModuleName, @@ -516,7 +537,7 @@ func New( app.mm.SetOrderEndBlockers( crisistypes.ModuleName, govtypes.ModuleName, - stakingtypes.ModuleName, + multistakingtypes.ModuleName, evmtypes.ModuleName, feemarkettypes.ModuleName, // no-op modules @@ -550,7 +571,7 @@ func New( authtypes.ModuleName, banktypes.ModuleName, distrtypes.ModuleName, - stakingtypes.ModuleName, + multistakingtypes.ModuleName, vestingtypes.ModuleName, slashingtypes.ModuleName, govtypes.ModuleName, @@ -635,7 +656,7 @@ func New( app.SetAnteHandler(ante.NewAnteHandler(options)) - app.setupUpgradeHandlers() + app.setupUpgradeHandlers(appOpts) if loadLatest { if err := app.LoadLatestVersion(); err != nil { @@ -851,36 +872,3 @@ func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino return paramsKeeper } - -func (app *RealioNetwork) setupUpgradeHandlers() { - //// "v0.7.2" is a coordinated upgrade on testnet to upgrade sdk to v0.46.7 - // planName := "v0.0.0" - // app.UpgradeKeeper.SetUpgradeHandler(planName, func(ctx sdk.Context, _ upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { - // - // return app.mm.RunMigrations(ctx, app.configurator, fromVM) - // }) - // - ////// When a planned update height is reached, the old binary will panic - ////// writing on disk the height and name of the update that triggered it - ////// This will read that value, and execute the preparations for the upgrade. - // upgradeInfo, err := app.UpgradeKeeper.ReadUpgradeInfoFromDisk() - // if err != nil { - // panic(fmt.Errorf("failed to read upgrade info from disk: %w", err)) - //} - // - // if app.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height) { - // return - //} - // - // var storeUpgrades *storetypes.StoreUpgrades - // - // switch upgradeInfo.Name { - // case planName: - // // no store upgrades here - //} - // - // if storeUpgrades != nil { - // // configure store loader that checks if version == upgradeHeight and applies store upgrades - // app.SetStoreLoader(upgradetypes.UpgradeStoreLoader(upgradeInfo.Height, storeUpgrades)) - //} -} diff --git a/app/test_helpers.go b/app/test_helpers.go index fa85ed60..80e896cf 100644 --- a/app/test_helpers.go +++ b/app/test_helpers.go @@ -20,6 +20,7 @@ import ( authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + multistakingtypes "github.com/realio-tech/multi-staking-module/x/multi-staking/types" "github.com/evmos/ethermint/encoding" feemarkettypes "github.com/evmos/ethermint/x/feemarket/types" @@ -40,22 +41,34 @@ var DefaultTestingAppInit func() (ibctesting.TestingApp, map[string]json.RawMess // DefaultConsensusParams defines the default Tendermint consensus params used in // Evmos testing. -var DefaultConsensusParams = &abci.ConsensusParams{ - Block: &abci.BlockParams{ - MaxBytes: 200000, - MaxGas: -1, // no limit - }, - Evidence: &tmproto.EvidenceParams{ - MaxAgeNumBlocks: 302400, - MaxAgeDuration: 504 * time.Hour, // 3 weeks is the max duration - MaxBytes: 10000, - }, - Validator: &tmproto.ValidatorParams{ - PubKeyTypes: []string{ - tmtypes.ABCIPubKeyTypeEd25519, +var ( + DefaultConsensusParams = &abci.ConsensusParams{ + Block: &abci.BlockParams{ + MaxBytes: 200000, + MaxGas: -1, // no limit }, - }, -} + Evidence: &tmproto.EvidenceParams{ + MaxAgeNumBlocks: 302400, + MaxAgeDuration: 504 * time.Hour, // 3 weeks is the max duration + MaxBytes: 10000, + }, + Validator: &tmproto.ValidatorParams{ + PubKeyTypes: []string{ + tmtypes.ABCIPubKeyTypeEd25519, + }, + }, + } + MultiStakingCoinA = multistakingtypes.MultiStakingCoin{ + Denom: "ario", + Amount: sdk.NewIntFromUint64(1000000000000000000), + BondWeight: sdk.MustNewDecFromStr("1.23"), + } + MultiStakingCoinB = multistakingtypes.MultiStakingCoin{ + Denom: "arst", + Amount: sdk.NewIntFromUint64(1000000000000000000), + BondWeight: sdk.MustNewDecFromStr("0.12"), + } +) func init() { feemarkettypes.DefaultMinGasPrice = sdk.ZeroDec() @@ -128,12 +141,41 @@ func GenesisStateWithValSet(app *RealioNetwork, genesisState simapp.GenesisState authGenesis := authtypes.NewGenesisState(authtypes.DefaultParams(), genAccs) genesisState[authtypes.ModuleName] = app.AppCodec().MustMarshalJSON(authGenesis) + // set multi staking genesis state + msCoinAInfo := multistakingtypes.MultiStakingCoinInfo{ + Denom: MultiStakingCoinA.Denom, + BondWeight: MultiStakingCoinA.BondWeight, + } + msCoinBInfo := multistakingtypes.MultiStakingCoinInfo{ + Denom: MultiStakingCoinB.Denom, + BondWeight: MultiStakingCoinB.BondWeight, + } + msCoinInfos := []multistakingtypes.MultiStakingCoinInfo{msCoinAInfo, msCoinBInfo} + validatorMsCoins := make([]multistakingtypes.ValidatorMultiStakingCoin, 0, len(valSet.Validators)) + locks := make([]multistakingtypes.MultiStakingLock, 0, len(valSet.Validators)) + lockCoins := sdk.NewCoins() + validators := make([]stakingtypes.Validator, 0, len(valSet.Validators)) delegations := make([]stakingtypes.Delegation, 0, len(valSet.Validators)) + bondCoins := sdk.NewCoins() + + for i, val := range valSet.Validators { + valMsCoin := MultiStakingCoinA + if i%2 == 1 { + valMsCoin = MultiStakingCoinB + } + + validatorMsCoins = append(validatorMsCoins, multistakingtypes.ValidatorMultiStakingCoin{ + ValAddr: sdk.ValAddress(val.Address).String(), + CoinDenom: valMsCoin.Denom, + }) + + lockId := multistakingtypes.MultiStakingLockID(genAccs[0].GetAddress().String(), sdk.ValAddress(val.Address).String()) + lockRecord := multistakingtypes.NewMultiStakingLock(lockId, valMsCoin) - bondAmt := sdk.DefaultPowerReduction + locks = append(locks, lockRecord) + lockCoins = lockCoins.Add(valMsCoin.ToCoin()) - for _, val := range valSet.Validators { pk, _ := cryptocodec.FromTmPubKeyInterface(val.PubKey) pkAny, _ := codectypes.NewAnyWithValue(pk) validator := stakingtypes.Validator{ @@ -141,7 +183,7 @@ func GenesisStateWithValSet(app *RealioNetwork, genesisState simapp.GenesisState ConsensusPubkey: pkAny, Jailed: false, Status: stakingtypes.Bonded, - Tokens: bondAmt, + Tokens: valMsCoin.BondValue(), DelegatorShares: sdk.OneDec(), Description: stakingtypes.Description{}, UnbondingHeight: int64(0), @@ -149,37 +191,43 @@ func GenesisStateWithValSet(app *RealioNetwork, genesisState simapp.GenesisState Commission: stakingtypes.NewCommission(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()), MinSelfDelegation: sdk.ZeroInt(), } + validators = append(validators, validator) delegations = append(delegations, stakingtypes.NewDelegation(genAccs[0].GetAddress(), val.Address.Bytes(), sdk.OneDec())) + bondCoins = bondCoins.Add(sdk.NewCoin(sdk.DefaultBondDenom, valMsCoin.BondValue())) } // set validators and delegations - stakingparams := stakingtypes.DefaultParams() - stakingparams.BondDenom = types.BaseDenom - stakingGenesis := stakingtypes.NewGenesisState(stakingparams, validators, delegations) - genesisState[stakingtypes.ModuleName] = app.AppCodec().MustMarshalJSON(stakingGenesis) + stakingGenesis := stakingtypes.NewGenesisState(stakingtypes.DefaultParams(), validators, delegations) + + multistakingGenesis := multistakingtypes.GenesisState{ + MultiStakingLocks: locks, + MultiStakingUnlocks: []multistakingtypes.MultiStakingUnlock{}, + MultiStakingCoinInfo: msCoinInfos, + ValidatorMultiStakingCoins: validatorMsCoins, + StakingGenesisState: *stakingGenesis, + } + genesisState[multistakingtypes.ModuleName] = app.AppCodec().MustMarshalJSON(&multistakingGenesis) // set mint genesis mintGenesis := minttypes.DefaultGenesisState() genesisState[minttypes.ModuleName] = app.AppCodec().MustMarshalJSON(mintGenesis) + balances = append(balances, banktypes.Balance{ + Address: authtypes.NewModuleAddress(stakingtypes.BondedPoolName).String(), + Coins: bondCoins, + }) + balances = append(balances, banktypes.Balance{ + Address: authtypes.NewModuleAddress(multistakingtypes.ModuleName).String(), + Coins: lockCoins, + }) + totalSupply := sdk.NewCoins() for _, b := range balances { // add genesis acc tokens to total supply totalSupply = totalSupply.Add(b.Coins...) } - for range delegations { - // add delegated tokens to total supply - totalSupply = totalSupply.Add(sdk.NewCoin(types.BaseDenom, bondAmt)) - } - - // add bonded amount to bonded pool module account - balances = append(balances, banktypes.Balance{ - Address: authtypes.NewModuleAddress(stakingtypes.BondedPoolName).String(), - Coins: sdk.Coins{sdk.NewCoin(types.BaseDenom, bondAmt)}, - }) - // update total supply bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, totalSupply, []banktypes.Metadata{}) genesisState[banktypes.ModuleName] = app.AppCodec().MustMarshalJSON(bankGenesis) diff --git a/app/upgrades.go b/app/upgrades.go new file mode 100644 index 00000000..f2ded4f7 --- /dev/null +++ b/app/upgrades.go @@ -0,0 +1,50 @@ +package app + +import ( + "fmt" + + servertypes "github.com/cosmos/cosmos-sdk/server/types" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + multistakingtypes "github.com/realio-tech/multi-staking-module/x/multi-staking/types" + multistaking "github.com/realiotech/realio-network/app/upgrades/multi-staking" + + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" +) + +func (app *RealioNetwork) setupUpgradeHandlers(appOpts servertypes.AppOptions) { + app.UpgradeKeeper.SetUpgradeHandler( + multistaking.UpgradeName, + multistaking.CreateUpgradeHandler( + app.mm, + app.configurator, + appOpts, + app.AppCodec(), + app.BankKeeper, + app.MultiStakingKeeper, + app.AccountKeeper, + app.keys, + ), + ) + + upgradeInfo, err := app.UpgradeKeeper.ReadUpgradeInfoFromDisk() + if err != nil { + panic(fmt.Errorf("Failed to read upgrade info from disk: %w", err)) + } + + if app.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height) { + return + } + + var storeUpgrades *storetypes.StoreUpgrades + + switch upgradeInfo.Name { + case multistaking.UpgradeName: + storeUpgrades = &storetypes.StoreUpgrades{ + Added: []string{multistakingtypes.ModuleName}, + } + } + + if storeUpgrades != nil { + app.SetStoreLoader(upgradetypes.UpgradeStoreLoader(upgradeInfo.Height, storeUpgrades)) + } +} diff --git a/app/upgrades/multi-staking/constants.go b/app/upgrades/multi-staking/constants.go new file mode 100644 index 00000000..3df593b6 --- /dev/null +++ b/app/upgrades/multi-staking/constants.go @@ -0,0 +1,6 @@ +package multistaking + +const ( + // UpgradeName defines the on-chain upgrade name for the multi-staking upgrade. + UpgradeName = "multistaking" +) diff --git a/app/upgrades/multi-staking/legacy/genesis.pb.go b/app/upgrades/multi-staking/legacy/genesis.pb.go new file mode 100644 index 00000000..0fe081df --- /dev/null +++ b/app/upgrades/multi-staking/legacy/genesis.pb.go @@ -0,0 +1,1017 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: multistaking/v0/genesis.proto + +package legacy + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" + io "io" + math "math" + math_bits "math/bits" + distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types" +) + +// 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 staking module's genesis state. +type GenesisState struct { + // params defines all the paramaters of related to deposit. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + // last_total_power tracks the total amounts of bonded tokens recorded during + // the previous end block. + LastTotalPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"last_total_power"` + // last_validator_powers is a special index that provides a historical list + // of the last-block's bonded validators. + LastValidatorPowers []LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers"` + // delegations defines the validator set at genesis. + Validators []Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"` + // delegations defines the delegations active at genesis. + Delegations []Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations"` + // unbonding_delegations defines the unbonding delegations active at genesis. + UnbondingDelegations []UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations"` + // redelegations defines the redelegations active at genesis. + Redelegations []Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations"` + Exported bool `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,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_37661eee2fa03d2f, []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) GetLastValidatorPowers() []LastValidatorPower { + if m != nil { + return m.LastValidatorPowers + } + return nil +} + +func (m *GenesisState) GetValidators() []Validator { + if m != nil { + return m.Validators + } + return nil +} + +func (m *GenesisState) GetDelegations() []Delegation { + if m != nil { + return m.Delegations + } + return nil +} + +func (m *GenesisState) GetUnbondingDelegations() []UnbondingDelegation { + if m != nil { + return m.UnbondingDelegations + } + return nil +} + +func (m *GenesisState) GetRedelegations() []Redelegation { + if m != nil { + return m.Redelegations + } + return nil +} + +func (m *GenesisState) GetExported() bool { + if m != nil { + return m.Exported + } + return false +} + +// LastValidatorPower required for validator set update logic. +type LastValidatorPower struct { + // address is the address of the validator. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // power defines the power of the validator. + Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty,string"` +} + +func (m *LastValidatorPower) Reset() { *m = LastValidatorPower{} } +func (m *LastValidatorPower) String() string { return proto.CompactTextString(m) } +func (*LastValidatorPower) ProtoMessage() {} +func (*LastValidatorPower) Descriptor() ([]byte, []int) { + return fileDescriptor_37661eee2fa03d2f, []int{1} +} +func (m *LastValidatorPower) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LastValidatorPower) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LastValidatorPower.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 *LastValidatorPower) XXX_Merge(src proto.Message) { + xxx_messageInfo_LastValidatorPower.Merge(m, src) +} +func (m *LastValidatorPower) XXX_Size() int { + return m.Size() +} +func (m *LastValidatorPower) XXX_DiscardUnknown() { + xxx_messageInfo_LastValidatorPower.DiscardUnknown(m) +} + +var xxx_messageInfo_LastValidatorPower proto.InternalMessageInfo + +func init() { + proto.RegisterType((*GenesisState)(nil), "multistaking.v0.GenesisState") + proto.RegisterType((*LastValidatorPower)(nil), "multistaking.v0.LastValidatorPower") +} + +func init() { proto.RegisterFile("multistaking/v0/genesis.proto", fileDescriptor_37661eee2fa03d2f) } + +var fileDescriptor_37661eee2fa03d2f = []byte{ + // 492 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x93, 0x4f, 0x8b, 0xd3, 0x40, + 0x18, 0xc6, 0x13, 0xdb, 0xed, 0xd6, 0xe9, 0xfa, 0x87, 0xb1, 0x8b, 0xb1, 0xb2, 0x69, 0x59, 0x45, + 0x7a, 0x69, 0x52, 0x2a, 0x5e, 0xc4, 0x83, 0x56, 0x41, 0x16, 0x3c, 0x2c, 0x59, 0x5d, 0x44, 0x90, + 0x30, 0x6d, 0x86, 0x74, 0xd8, 0x34, 0x13, 0x66, 0xde, 0xd6, 0xf5, 0x1b, 0x78, 0xf4, 0x23, 0xec, + 0x87, 0xf0, 0x43, 0xec, 0x45, 0x58, 0x3c, 0x89, 0x87, 0x45, 0xda, 0x8b, 0x1f, 0x43, 0x32, 0x93, + 0xd4, 0xb8, 0x73, 0x4a, 0x5e, 0x9e, 0xe7, 0xf9, 0xe5, 0xcd, 0xf0, 0x0c, 0xda, 0x9b, 0x2f, 0x12, + 0x60, 0x12, 0xc8, 0x09, 0x4b, 0x63, 0x7f, 0x39, 0xf4, 0x63, 0x9a, 0x52, 0xc9, 0xa4, 0x97, 0x09, + 0x0e, 0x1c, 0xdf, 0xaa, 0xca, 0xde, 0x72, 0xd8, 0x69, 0xc7, 0x3c, 0xe6, 0x4a, 0xf3, 0xf3, 0x37, + 0x6d, 0xeb, 0x18, 0x94, 0x32, 0xa1, 0xe5, 0x7b, 0x53, 0x2e, 0xe7, 0x5c, 0x86, 0x3a, 0xa7, 0x07, + 0x2d, 0xed, 0x7f, 0xaf, 0xa3, 0x9d, 0xd7, 0xfa, 0x93, 0x47, 0x40, 0x80, 0xe2, 0x27, 0xa8, 0x91, + 0x11, 0x41, 0xe6, 0xd2, 0xb1, 0x7b, 0x76, 0xbf, 0x35, 0xba, 0xeb, 0x5d, 0x59, 0xc1, 0x3b, 0x54, + 0xf2, 0xb8, 0x7e, 0x7e, 0xd9, 0xb5, 0x82, 0xc2, 0x8c, 0xdf, 0xa3, 0xdb, 0x09, 0x91, 0x10, 0x02, + 0x07, 0x92, 0x84, 0x19, 0xff, 0x44, 0x85, 0x73, 0xad, 0x67, 0xf7, 0x77, 0xc6, 0x5e, 0xee, 0xfb, + 0x75, 0xd9, 0x7d, 0x14, 0x33, 0x98, 0x2d, 0x26, 0xde, 0x94, 0xcf, 0x8b, 0x15, 0x8a, 0xc7, 0x40, + 0x46, 0x27, 0x3e, 0x7c, 0xce, 0xa8, 0xf4, 0x0e, 0x52, 0x08, 0x6e, 0xe6, 0x9c, 0xb7, 0x39, 0xe6, + 0x30, 0xa7, 0xe0, 0x8f, 0x68, 0x57, 0x91, 0x97, 0x24, 0x61, 0x11, 0x01, 0x2e, 0x34, 0x5d, 0x3a, + 0xb5, 0x5e, 0xad, 0xdf, 0x1a, 0x3d, 0x30, 0xf6, 0x7b, 0x43, 0x24, 0x1c, 0x97, 0x66, 0xc5, 0x28, + 0x76, 0xbd, 0x93, 0x18, 0x8a, 0xc4, 0xcf, 0x11, 0xda, 0x90, 0xa5, 0x53, 0x57, 0xcc, 0x8e, 0xc1, + 0xdc, 0xa4, 0x0a, 0x54, 0x25, 0x83, 0x5f, 0xa2, 0x56, 0x44, 0x13, 0x1a, 0x13, 0x60, 0x3c, 0x95, + 0xce, 0x96, 0x42, 0xdc, 0x37, 0x10, 0xaf, 0x36, 0x9e, 0x82, 0x51, 0x4d, 0xe1, 0x10, 0xed, 0x2e, + 0xd2, 0x09, 0x4f, 0x23, 0x96, 0xc6, 0x61, 0x15, 0xd7, 0x50, 0xb8, 0x87, 0x06, 0xee, 0x5d, 0xe9, + 0x36, 0xb8, 0xed, 0x85, 0x29, 0x49, 0x7c, 0x80, 0x6e, 0x08, 0x5a, 0x05, 0x6f, 0x2b, 0xf0, 0x9e, + 0x01, 0x0e, 0x2a, 0xae, 0x82, 0xf8, 0x7f, 0x12, 0x77, 0x50, 0x93, 0x9e, 0x66, 0x5c, 0x00, 0x8d, + 0x9c, 0x66, 0xcf, 0xee, 0x37, 0x83, 0xcd, 0xbc, 0x3f, 0x43, 0xd8, 0x3c, 0x7f, 0x3c, 0x42, 0xdb, + 0x24, 0x8a, 0x04, 0x95, 0xba, 0x55, 0xd7, 0xc7, 0xce, 0x8f, 0x6f, 0x83, 0x76, 0x51, 0xc4, 0x17, + 0x5a, 0x39, 0x02, 0xc1, 0xd2, 0x38, 0x28, 0x8d, 0xb8, 0x8d, 0xb6, 0xfe, 0xd5, 0xa8, 0x16, 0xe8, + 0xe1, 0x69, 0xf3, 0xcb, 0x59, 0xd7, 0xfa, 0x73, 0xd6, 0xb5, 0xc6, 0xc7, 0xe7, 0x2b, 0xd7, 0xbe, + 0x58, 0xb9, 0xf6, 0xef, 0x95, 0x6b, 0x7f, 0x5d, 0xbb, 0xd6, 0xc5, 0xda, 0xb5, 0x7e, 0xae, 0x5d, + 0xeb, 0xc3, 0xb3, 0x4a, 0xd3, 0x04, 0x25, 0x09, 0xe3, 0x40, 0xa7, 0x33, 0x5f, 0xfd, 0xe8, 0xa0, + 0xbc, 0x24, 0xa7, 0x57, 0x66, 0x55, 0x40, 0x7f, 0x39, 0x9c, 0x34, 0xd4, 0xc5, 0x78, 0xfc, 0x37, + 0x00, 0x00, 0xff, 0xff, 0x64, 0x86, 0x42, 0xea, 0x9a, 0x03, 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.Exported { + i-- + if m.Exported { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if len(m.Redelegations) > 0 { + for iNdEx := len(m.Redelegations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Redelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + } + if len(m.UnbondingDelegations) > 0 { + for iNdEx := len(m.UnbondingDelegations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.UnbondingDelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } + if len(m.Delegations) > 0 { + for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.LastValidatorPowers) > 0 { + for iNdEx := len(m.LastValidatorPowers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.LastValidatorPowers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + { + size := m.LastTotalPower.Size() + i -= size + if _, err := m.LastTotalPower.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 (m *LastValidatorPower) 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 *LastValidatorPower) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LastValidatorPower) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Power != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.Power)) + i-- + dAtA[i] = 0x10 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address))) + 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.LastTotalPower.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.LastValidatorPowers) > 0 { + for _, e := range m.LastValidatorPowers { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Delegations) > 0 { + for _, e := range m.Delegations { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.UnbondingDelegations) > 0 { + for _, e := range m.UnbondingDelegations { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Redelegations) > 0 { + for _, e := range m.Redelegations { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if m.Exported { + n += 2 + } + return n +} + +func (m *LastValidatorPower) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if m.Power != 0 { + n += 1 + sovGenesis(uint64(m.Power)) + } + 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 LastTotalPower", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastTotalPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastValidatorPowers", 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 + } + m.LastValidatorPowers = append(m.LastValidatorPowers, LastValidatorPower{}) + if err := m.LastValidatorPowers[len(m.LastValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", 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 + } + m.Validators = append(m.Validators, Validator{}) + if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delegations", 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 + } + m.Delegations = append(m.Delegations, Delegation{}) + if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegations", 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 + } + m.UnbondingDelegations = append(m.UnbondingDelegations, UnbondingDelegation{}) + if err := m.UnbondingDelegations[len(m.UnbondingDelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Redelegations", 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 + } + m.Redelegations = append(m.Redelegations, Redelegation{}) + if err := m.Redelegations[len(m.Redelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Exported", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Exported = bool(v != 0) + 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 (m *LastValidatorPower) 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: LastValidatorPower: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LastValidatorPower: 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 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 + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) + } + m.Power = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Power |= int64(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") +) + +type DistrGenesisState struct { + // params defines all the paramaters of the module. + Params distrtypes.Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + // fee_pool defines the fee pool at genesis. + FeePool distrtypes.FeePool `protobuf:"bytes,2,opt,name=fee_pool,json=feePool,proto3" json:"fee_pool"` + // fee_pool defines the delegator withdraw infos at genesis. + DelegatorWithdrawInfos []distrtypes.DelegatorWithdrawInfo `protobuf:"bytes,3,rep,name=delegator_withdraw_infos,json=delegatorWithdrawInfos,proto3" json:"delegator_withdraw_infos"` + // fee_pool defines the previous proposer at genesis. + PreviousProposer string `protobuf:"bytes,4,opt,name=previous_proposer,json=previousProposer,proto3" json:"previous_proposer,omitempty"` + // fee_pool defines the outstanding rewards of all validators at genesis. + OutstandingRewards []distrtypes.ValidatorOutstandingRewardsRecord `protobuf:"bytes,5,rep,name=outstanding_rewards,json=outstandingRewards,proto3" json:"outstanding_rewards"` + // fee_pool defines the accumulated commisions of all validators at genesis. + ValidatorAccumulatedCommissions []distrtypes.ValidatorAccumulatedCommissionRecord `protobuf:"bytes,6,rep,name=validator_accumulated_commissions,json=validatorAccumulatedCommissions,proto3" json:"validator_accumulated_commissions"` + // fee_pool defines the historical rewards of all validators at genesis. + ValidatorHistoricalRewards []ValidatorHistoricalRewardsRecord `protobuf:"bytes,7,rep,name=validator_historical_rewards,json=validatorHistoricalRewards,proto3" json:"validator_historical_rewards"` + // fee_pool defines the current rewards of all validators at genesis. + ValidatorCurrentRewards []ValidatorCurrentRewardsRecord `protobuf:"bytes,8,rep,name=validator_current_rewards,json=validatorCurrentRewards,proto3" json:"validator_current_rewards"` + // fee_pool defines the delegator starting infos at genesis. + DelegatorStartingInfos []DelegatorStartingInfoRecord `protobuf:"bytes,9,rep,name=delegator_starting_infos,json=delegatorStartingInfos,proto3" json:"delegator_starting_infos"` + // fee_pool defines the validator slash events at genesis. + ValidatorSlashEvents []ValidatorSlashEventRecord `protobuf:"bytes,10,rep,name=validator_slash_events,json=validatorSlashEvents,proto3" json:"validator_slash_events"` +} + +type DelegatorStartingInfoRecord struct { + // delegator_address is the address of the delegator. + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"` + // validator_address is the address of the validator. + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + // starting_info defines the starting info of a delegator. + StartingInfo DelegatorStartingInfo `protobuf:"bytes,3,opt,name=starting_info,json=startingInfo,proto3" json:"starting_info"` +} + +type DelegatorStartingInfo struct { + PreviousPeriod string `protobuf:"varint,1,opt,name=previous_period,json=previousPeriod,proto3" json:"previous_period,omitempty"` + Stake github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=stake,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"stake"` + Height string `protobuf:"varint,3,opt,name=height,proto3" json:"creation_height"` +} + +type ValidatorCurrentRewardsRecord struct { + // validator_address is the address of the validator. + ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + // rewards defines the current rewards of a validator. + Rewards ValidatorCurrentRewards `protobuf:"bytes,2,opt,name=rewards,proto3" json:"rewards"` +} + +type ValidatorCurrentRewards struct { + Rewards github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"rewards"` + Period string `protobuf:"varint,2,opt,name=period,proto3" json:"period,omitempty"` +} + +type ValidatorHistoricalRewardsRecord struct { + // validator_address is the address of the validator. + ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + // period defines the period the historical rewards apply to. + Period string `protobuf:"varint,2,opt,name=period,proto3" json:"period,omitempty"` + // rewards defines the historical rewards of a validator. + Rewards distrtypes.ValidatorHistoricalRewards `protobuf:"bytes,3,opt,name=rewards,proto3" json:"rewards"` +} + +type ValidatorSlashEventRecord struct { + // validator_address is the address of the validator. + ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + // height defines the block height at which the slash event occured. + Height string `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + // period is the period of the slash event. + Period string `protobuf:"varint,3,opt,name=period,proto3" json:"period,omitempty"` + // validator_slash_event describes the slash event. + ValidatorSlashEvent ValidatorSlashEvent `protobuf:"bytes,4,opt,name=validator_slash_event,json=validatorSlashEvent,proto3" json:"validator_slash_event"` +} + +type ValidatorSlashEvent struct { + ValidatorPeriod string `protobuf:"varint,1,opt,name=validator_period,json=validatorPeriod,proto3" json:"validator_period,omitempty"` + Fraction github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=fraction,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"fraction"` +} \ No newline at end of file diff --git a/app/upgrades/multi-staking/legacy/staking.pb.go b/app/upgrades/multi-staking/legacy/staking.pb.go new file mode 100644 index 00000000..ce90472f --- /dev/null +++ b/app/upgrades/multi-staking/legacy/staking.pb.go @@ -0,0 +1,6563 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: multistaking/v0/staking.proto + +package legacy + +import ( + bytes "bytes" + compress_gzip "compress/gzip" + fmt "fmt" + types "github.com/tendermint/tendermint/proto/tendermint/types" + _ "github.com/cosmos/cosmos-proto" + types1 "github.com/cosmos/cosmos-sdk/codec/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types2 "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + github_com_cosmos_gogoproto_proto "github.com/cosmos/gogoproto/proto" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor "github.com/cosmos/gogoproto/protoc-gen-gogo/descriptor" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + _ "google.golang.org/protobuf/types/known/durationpb" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + io_ioutil "io/ioutil" + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// 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 + +// HistoricalInfo contains header and validator information for a given block. +// It is stored as part of staking module's state, which persists the `n` most +// recent HistoricalInfo +// (`n` is set by the staking module's `historical_entries` parameter). +type HistoricalInfo struct { + Header types.Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header"` + Valset []Validator `protobuf:"bytes,2,rep,name=valset,proto3" json:"valset"` +} + +func (m *HistoricalInfo) Reset() { *m = HistoricalInfo{} } +func (m *HistoricalInfo) String() string { return proto.CompactTextString(m) } +func (*HistoricalInfo) ProtoMessage() {} +func (*HistoricalInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{0} +} +func (m *HistoricalInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HistoricalInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HistoricalInfo.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 *HistoricalInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_HistoricalInfo.Merge(m, src) +} +func (m *HistoricalInfo) XXX_Size() int { + return m.Size() +} +func (m *HistoricalInfo) XXX_DiscardUnknown() { + xxx_messageInfo_HistoricalInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_HistoricalInfo proto.InternalMessageInfo + +func (m *HistoricalInfo) GetHeader() types.Header { + if m != nil { + return m.Header + } + return types.Header{} +} + +func (m *HistoricalInfo) GetValset() []Validator { + if m != nil { + return m.Valset + } + return nil +} + +// CommissionRates defines the initial commission rates to be used for creating +// a validator. +type CommissionRates struct { + // rate is the commission rate charged to delegators, as a fraction. + Rate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"` + // max_rate defines the maximum commission rate which validator can ever + // charge, as a fraction. + MaxRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate"` + // max_change_rate defines the maximum daily increase of the validator + // commission, as a fraction. + MaxChangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate"` +} + +func (m *CommissionRates) Reset() { *m = CommissionRates{} } +func (*CommissionRates) ProtoMessage() {} +func (m *CommissionRates) String() string { return proto.CompactTextString(m)} +func (*CommissionRates) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{1} +} +func (m *CommissionRates) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommissionRates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommissionRates.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 *CommissionRates) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommissionRates.Merge(m, src) +} +func (m *CommissionRates) XXX_Size() int { + return m.Size() +} +func (m *CommissionRates) XXX_DiscardUnknown() { + xxx_messageInfo_CommissionRates.DiscardUnknown(m) +} + +var xxx_messageInfo_CommissionRates proto.InternalMessageInfo + +// Commission defines commission parameters for a given validator. +type Commission struct { + // commission_rates defines the initial commission rates to be used for + // creating a validator. + CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"` + // update_time is the last time the commission rate was changed. + UpdateTime time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time"` +} + +func (m *Commission) Reset() { *m = Commission{} } +func (*Commission) ProtoMessage() {} +func (m *Commission) String() string { return proto.CompactTextString(m)} +func (*Commission) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{2} +} +func (m *Commission) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Commission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Commission.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 *Commission) XXX_Merge(src proto.Message) { + xxx_messageInfo_Commission.Merge(m, src) +} +func (m *Commission) XXX_Size() int { + return m.Size() +} +func (m *Commission) XXX_DiscardUnknown() { + xxx_messageInfo_Commission.DiscardUnknown(m) +} + +var xxx_messageInfo_Commission proto.InternalMessageInfo + +func (m *Commission) GetUpdateTime() time.Time { + if m != nil { + return m.UpdateTime + } + return time.Time{} +} + +// Description defines a validator description. +type Description struct { + // moniker defines a human-readable name for the validator. + Moniker string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"` + // identity defines an optional identity signature (ex. UPort or Keybase). + Identity string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"` + // website defines an optional website link. + Website string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"` + // security_contact defines an optional email for security contact. + SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty"` + // details define other optional details. + Details string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"` +} + +func (m *Description) Reset() { *m = Description{} } +func (*Description) ProtoMessage() {} +func (m *Description) String() string { return proto.CompactTextString(m)} +func (*Description) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{3} +} +func (m *Description) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Description) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Description.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 *Description) XXX_Merge(src proto.Message) { + xxx_messageInfo_Description.Merge(m, src) +} +func (m *Description) XXX_Size() int { + return m.Size() +} +func (m *Description) XXX_DiscardUnknown() { + xxx_messageInfo_Description.DiscardUnknown(m) +} + +var xxx_messageInfo_Description proto.InternalMessageInfo + +func (m *Description) GetMoniker() string { + if m != nil { + return m.Moniker + } + return "" +} + +func (m *Description) GetIdentity() string { + if m != nil { + return m.Identity + } + return "" +} + +func (m *Description) GetWebsite() string { + if m != nil { + return m.Website + } + return "" +} + +func (m *Description) GetSecurityContact() string { + if m != nil { + return m.SecurityContact + } + return "" +} + +func (m *Description) GetDetails() string { + if m != nil { + return m.Details + } + return "" +} + +// Validator defines a validator, together with the total amount of the +// Validator's bond shares and their exchange rate to coins. Slashing results in +// a decrease in the exchange rate, allowing correct calculation of future +// undelegations without iterating over delegators. When coins are delegated to +// this validator, the validator is credited with a delegation whose number of +// bond shares is based on the amount of coins delegated divided by the current +// exchange rate. Voting power can be calculated as total bonded shares +// multiplied by exchange rate. +type Validator struct { + // operator_address defines the address of the validator's operator; bech + // encoded in JSON. + OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"` + // consensus_pubkey is the consensus public key of the validator, as a + // Protobuf Any. + ConsensusPubkey *types1.Any `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty"` + // jailed defined whether the validator has been jailed from bonded status or + // not. + Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"` + // status is the validator status (bonded/unbonding/unbonded). + Status string `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` + // tokens define the delegated tokens (incl. self-delegation). + Tokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"` + // delegator_shares defines total shares issued to a validator's delegators. + DelegatorShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"delegator_shares"` + // description defines the description terms for the validator. + Description Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description"` + // unbonding_height defines, if unbonding, the height at which this validator + // has begun unbonding. + UnbondingHeight int64 `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty,string"` + // unbonding_time defines, if unbonding, the min time for the validator to + // complete unbonding. + UnbondingTime time.Time `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time"` + // commission defines the commission parameters. + Commission Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"` + // min_self_delegation is the validator's self declared minimum self + // delegation. + // + // Since: cosmos-sdk 0.46 + MinSelfDelegation github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_self_delegation"` + // bond_denom defines the bondable coin denomination. + BondDenom string `protobuf:"bytes,12,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty"` +} + +func (m *Validator) Reset() { *m = Validator{} } +func (m *Validator) String() string { return proto.CompactTextString(m)} +func (*Validator) ProtoMessage() {} +func (*Validator) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{4} +} +func (m *Validator) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Validator.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 *Validator) XXX_Merge(src proto.Message) { + xxx_messageInfo_Validator.Merge(m, src) +} +func (m *Validator) XXX_Size() int { + return m.Size() +} +func (m *Validator) XXX_DiscardUnknown() { + xxx_messageInfo_Validator.DiscardUnknown(m) +} + +var xxx_messageInfo_Validator proto.InternalMessageInfo + +// ValAddresses defines a repeated set of validator addresses. +type ValAddresses struct { + Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` +} + +func (m *ValAddresses) Reset() { *m = ValAddresses{} } +func (*ValAddresses) ProtoMessage() {} +func (*ValAddresses) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{5} +} +func (m *ValAddresses) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValAddresses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValAddresses.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 *ValAddresses) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValAddresses.Merge(m, src) +} +func (m *ValAddresses) XXX_Size() int { + return m.Size() +} +func (m *ValAddresses) XXX_DiscardUnknown() { + xxx_messageInfo_ValAddresses.DiscardUnknown(m) +} + +var xxx_messageInfo_ValAddresses proto.InternalMessageInfo + +func (m *ValAddresses) GetAddresses() []string { + if m != nil { + return m.Addresses + } + return nil +} + +// DVPair is struct that just has a delegator-validator pair with no other data. +// It is intended to be used as a marshalable pointer. For example, a DVPair can +// be used to construct the key to getting an UnbondingDelegation from state. +type DVPair struct { + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"` + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` +} + +func (m *DVPair) Reset() { *m = DVPair{} } +func (*DVPair) ProtoMessage() {} +func (m *DVPair) String() string { return proto.CompactTextString(m)} +func (*DVPair) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{6} +} +func (m *DVPair) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DVPair.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 *DVPair) XXX_Merge(src proto.Message) { + xxx_messageInfo_DVPair.Merge(m, src) +} +func (m *DVPair) XXX_Size() int { + return m.Size() +} +func (m *DVPair) XXX_DiscardUnknown() { + xxx_messageInfo_DVPair.DiscardUnknown(m) +} + +var xxx_messageInfo_DVPair proto.InternalMessageInfo + +// DVPairs defines an array of DVPair objects. +type DVPairs struct { + Pairs []DVPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs"` +} + +func (m *DVPairs) Reset() { *m = DVPairs{} } +func (m *DVPairs) String() string { return proto.CompactTextString(m) } +func (*DVPairs) ProtoMessage() {} +func (*DVPairs) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{7} +} +func (m *DVPairs) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DVPairs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DVPairs.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 *DVPairs) XXX_Merge(src proto.Message) { + xxx_messageInfo_DVPairs.Merge(m, src) +} +func (m *DVPairs) XXX_Size() int { + return m.Size() +} +func (m *DVPairs) XXX_DiscardUnknown() { + xxx_messageInfo_DVPairs.DiscardUnknown(m) +} + +var xxx_messageInfo_DVPairs proto.InternalMessageInfo + +func (m *DVPairs) GetPairs() []DVPair { + if m != nil { + return m.Pairs + } + return nil +} + +// DVVTriplet is struct that just has a delegator-validator-validator triplet +// with no other data. It is intended to be used as a marshalable pointer. For +// example, a DVVTriplet can be used to construct the key to getting a +// Redelegation from state. +type DVVTriplet struct { + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"` + ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty"` + ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty"` +} + +func (m *DVVTriplet) Reset() { *m = DVVTriplet{} } +func (*DVVTriplet) ProtoMessage() {} +func (m *DVVTriplet) String() string { return proto.CompactTextString(m)} +func (*DVVTriplet) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{8} +} +func (m *DVVTriplet) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DVVTriplet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DVVTriplet.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 *DVVTriplet) XXX_Merge(src proto.Message) { + xxx_messageInfo_DVVTriplet.Merge(m, src) +} +func (m *DVVTriplet) XXX_Size() int { + return m.Size() +} +func (m *DVVTriplet) XXX_DiscardUnknown() { + xxx_messageInfo_DVVTriplet.DiscardUnknown(m) +} + +var xxx_messageInfo_DVVTriplet proto.InternalMessageInfo + +// DVVTriplets defines an array of DVVTriplet objects. +type DVVTriplets struct { + Triplets []DVVTriplet `protobuf:"bytes,1,rep,name=triplets,proto3" json:"triplets"` +} + +func (m *DVVTriplets) Reset() { *m = DVVTriplets{} } +func (m *DVVTriplets) String() string { return proto.CompactTextString(m) } +func (*DVVTriplets) ProtoMessage() {} +func (*DVVTriplets) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{9} +} +func (m *DVVTriplets) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DVVTriplets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DVVTriplets.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 *DVVTriplets) XXX_Merge(src proto.Message) { + xxx_messageInfo_DVVTriplets.Merge(m, src) +} +func (m *DVVTriplets) XXX_Size() int { + return m.Size() +} +func (m *DVVTriplets) XXX_DiscardUnknown() { + xxx_messageInfo_DVVTriplets.DiscardUnknown(m) +} + +var xxx_messageInfo_DVVTriplets proto.InternalMessageInfo + +func (m *DVVTriplets) GetTriplets() []DVVTriplet { + if m != nil { + return m.Triplets + } + return nil +} + +// Delegation represents the bond with tokens held by an account. It is +// owned by one delegator, and is associated with the voting power of one +// validator. +type Delegation struct { + // delegator_address is the bech32-encoded address of the delegator. + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"` + // validator_address is the bech32-encoded address of the validator. + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + // shares define the delegation shares received. + Shares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"` +} + +func (m *Delegation) Reset() { *m = Delegation{} } +func (*Delegation) ProtoMessage() {} +func (m *Delegation) String() string { return proto.CompactTextString(m)} +func (*Delegation) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{10} +} +func (m *Delegation) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Delegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Delegation.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 *Delegation) XXX_Merge(src proto.Message) { + xxx_messageInfo_Delegation.Merge(m, src) +} +func (m *Delegation) XXX_Size() int { + return m.Size() +} +func (m *Delegation) XXX_DiscardUnknown() { + xxx_messageInfo_Delegation.DiscardUnknown(m) +} + +var xxx_messageInfo_Delegation proto.InternalMessageInfo + +// UnbondingDelegation stores all of a single delegator's unbonding bonds +// for a single validator in an time-ordered list. +type UnbondingDelegation struct { + // delegator_address is the bech32-encoded address of the delegator. + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"` + // validator_address is the bech32-encoded address of the validator. + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + // entries are the unbonding delegation entries. + Entries []UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries"` +} + +func (m *UnbondingDelegation) Reset() { *m = UnbondingDelegation{} } +func (*UnbondingDelegation) ProtoMessage() {} +func (m *UnbondingDelegation) String() string { return proto.CompactTextString(m)} +func (*UnbondingDelegation) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{11} +} +func (m *UnbondingDelegation) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UnbondingDelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UnbondingDelegation.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 *UnbondingDelegation) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnbondingDelegation.Merge(m, src) +} +func (m *UnbondingDelegation) XXX_Size() int { + return m.Size() +} +func (m *UnbondingDelegation) XXX_DiscardUnknown() { + xxx_messageInfo_UnbondingDelegation.DiscardUnknown(m) +} + +var xxx_messageInfo_UnbondingDelegation proto.InternalMessageInfo + +// UnbondingDelegationEntry defines an unbonding object with relevant metadata. +type UnbondingDelegationEntry struct { + // creation_height is the height which the unbonding took place. + CreationHeight int64 `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty,string"` + // completion_time is the unix time for unbonding completion. + CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"` + // initial_balance defines the tokens initially scheduled to receive at + // completion. + InitialBalance github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Coin" json:"initial_balance"` + // balance defines the tokens to receive at completion. + Balance github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Coin" json:"balance"` +} + +func (m *UnbondingDelegationEntry) Reset() { *m = UnbondingDelegationEntry{} } +func (*UnbondingDelegationEntry) ProtoMessage() {} +func (m *UnbondingDelegationEntry) String() string { return proto.CompactTextString(m)} +func (*UnbondingDelegationEntry) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{12} +} +func (m *UnbondingDelegationEntry) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UnbondingDelegationEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UnbondingDelegationEntry.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 *UnbondingDelegationEntry) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnbondingDelegationEntry.Merge(m, src) +} +func (m *UnbondingDelegationEntry) XXX_Size() int { + return m.Size() +} +func (m *UnbondingDelegationEntry) XXX_DiscardUnknown() { + xxx_messageInfo_UnbondingDelegationEntry.DiscardUnknown(m) +} + +var xxx_messageInfo_UnbondingDelegationEntry proto.InternalMessageInfo + +func (m *UnbondingDelegationEntry) GetCreationHeight() int64 { + if m != nil { + return m.CreationHeight + } + return 0 +} + +func (m *UnbondingDelegationEntry) GetCompletionTime() time.Time { + if m != nil { + return m.CompletionTime + } + return time.Time{} +} + +// RedelegationEntry defines a redelegation object with relevant metadata. +type RedelegationEntry struct { + // creation_height defines the height which the redelegation took place. + CreationHeight int64 `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty,string"` + // completion_time defines the unix time for redelegation completion. + CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"` + // initial_balance defines the initial balance when redelegation started. + InitialBalance github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Coin" json:"initial_balance"` + // shares_dst is the amount of destination-validator shares created by + // redelegation. + SharesDst github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"` +} + +func (m *RedelegationEntry) Reset() { *m = RedelegationEntry{} } +func (*RedelegationEntry) ProtoMessage() {} +func (m *RedelegationEntry) String() string { return proto.CompactTextString(m)} +func (*RedelegationEntry) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{13} +} +func (m *RedelegationEntry) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RedelegationEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RedelegationEntry.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 *RedelegationEntry) XXX_Merge(src proto.Message) { + xxx_messageInfo_RedelegationEntry.Merge(m, src) +} +func (m *RedelegationEntry) XXX_Size() int { + return m.Size() +} +func (m *RedelegationEntry) XXX_DiscardUnknown() { + xxx_messageInfo_RedelegationEntry.DiscardUnknown(m) +} + +var xxx_messageInfo_RedelegationEntry proto.InternalMessageInfo + +func (m *RedelegationEntry) GetCreationHeight() int64 { + if m != nil { + return m.CreationHeight + } + return 0 +} + +func (m *RedelegationEntry) GetCompletionTime() time.Time { + if m != nil { + return m.CompletionTime + } + return time.Time{} +} + +// Redelegation contains the list of a particular delegator's redelegating bonds +// from a particular source validator to a particular destination validator. +type Redelegation struct { + // delegator_address is the bech32-encoded address of the delegator. + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"` + // validator_src_address is the validator redelegation source operator + // address. + ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty"` + // validator_dst_address is the validator redelegation destination operator + // address. + ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty"` + // entries are the redelegation entries. + Entries []RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries"` +} + +func (m *Redelegation) Reset() { *m = Redelegation{} } +func (*Redelegation) ProtoMessage() {} +func (m *Redelegation) String() string { return proto.CompactTextString(m)} +func (*Redelegation) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{14} +} +func (m *Redelegation) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Redelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Redelegation.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 *Redelegation) XXX_Merge(src proto.Message) { + xxx_messageInfo_Redelegation.Merge(m, src) +} +func (m *Redelegation) XXX_Size() int { + return m.Size() +} +func (m *Redelegation) XXX_DiscardUnknown() { + xxx_messageInfo_Redelegation.DiscardUnknown(m) +} + +var xxx_messageInfo_Redelegation proto.InternalMessageInfo + +// Params defines the parameters for the staking module. +type Params struct { + // unbonding_time is the time duration of unbonding. + UnbondingTime string `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3" json:"unbonding_time,omitempty"` + // max_validators is the maximum number of validators. + MaxValidators uint32 `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty"` + // max_entries is the max entries for either unbonding delegation or + // redelegation (per pair/trio). + MaxEntries uint32 `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty"` + // historical_entries is the number of historical entries to persist. + HistoricalEntries uint32 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"` + // bond_denom defines the bondable coin denomination. + BondDenom string `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty"` + // min_commission_rate is the chain-wide minimum commission rate that a + // validator can charge their delegators + MinCommissionRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=min_commission_rate,json=minCommissionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_commission_rate" yaml:"min_commission_rate"` +} + +func (m *Params) Reset() { *m = Params{} } +func (*Params) ProtoMessage() {} +func (m *Params) String() string { return proto.CompactTextString(m)} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{15} +} +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) GetUnbondingTime() string { + if m != nil { + return m.UnbondingTime + } + return "" +} + +func (m *Params) GetMaxValidators() uint32 { + if m != nil { + return m.MaxValidators + } + return 0 +} + +func (m *Params) GetMaxEntries() uint32 { + if m != nil { + return m.MaxEntries + } + return 0 +} + +func (m *Params) GetHistoricalEntries() uint32 { + if m != nil { + return m.HistoricalEntries + } + return 0 +} + +func (m *Params) GetBondDenom() string { + if m != nil { + return m.BondDenom + } + return "" +} + +// DelegationResponse is equivalent to Delegation except that it contains a +// balance in addition to shares which is more suitable for client responses. +type DelegationResponse struct { + Delegation Delegation `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"` + Balance types2.Coin `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"` +} + +func (m *DelegationResponse) Reset() { *m = DelegationResponse{} } +func (*DelegationResponse) ProtoMessage() {} +func (m *DelegationResponse) String() string { return proto.CompactTextString(m)} +func (*DelegationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{16} +} +func (m *DelegationResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegationResponse.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 *DelegationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegationResponse.Merge(m, src) +} +func (m *DelegationResponse) XXX_Size() int { + return m.Size() +} +func (m *DelegationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DelegationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegationResponse proto.InternalMessageInfo + +func (m *DelegationResponse) GetDelegation() Delegation { + if m != nil { + return m.Delegation + } + return Delegation{} +} + +func (m *DelegationResponse) GetBalance() types2.Coin { + if m != nil { + return m.Balance + } + return types2.Coin{} +} + +// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it +// contains a balance in addition to shares which is more suitable for client +// responses. +type RedelegationEntryResponse struct { + RedelegationEntry RedelegationEntry `protobuf:"bytes,1,opt,name=redelegation_entry,json=redelegationEntry,proto3" json:"redelegation_entry"` + Balance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"` +} + +func (m *RedelegationEntryResponse) Reset() { *m = RedelegationEntryResponse{} } +func (m *RedelegationEntryResponse) String() string { return proto.CompactTextString(m) } +func (*RedelegationEntryResponse) ProtoMessage() {} +func (*RedelegationEntryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{17} +} +func (m *RedelegationEntryResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RedelegationEntryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RedelegationEntryResponse.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 *RedelegationEntryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RedelegationEntryResponse.Merge(m, src) +} +func (m *RedelegationEntryResponse) XXX_Size() int { + return m.Size() +} +func (m *RedelegationEntryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RedelegationEntryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RedelegationEntryResponse proto.InternalMessageInfo + +func (m *RedelegationEntryResponse) GetRedelegationEntry() RedelegationEntry { + if m != nil { + return m.RedelegationEntry + } + return RedelegationEntry{} +} + +// RedelegationResponse is equivalent to a Redelegation except that its entries +// contain a balance in addition to shares which is more suitable for client +// responses. +type RedelegationResponse struct { + Redelegation Redelegation `protobuf:"bytes,1,opt,name=redelegation,proto3" json:"redelegation"` + Entries []RedelegationEntryResponse `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries"` +} + +func (m *RedelegationResponse) Reset() { *m = RedelegationResponse{} } +func (m *RedelegationResponse) String() string { return proto.CompactTextString(m) } +func (*RedelegationResponse) ProtoMessage() {} +func (*RedelegationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{18} +} +func (m *RedelegationResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RedelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RedelegationResponse.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 *RedelegationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RedelegationResponse.Merge(m, src) +} +func (m *RedelegationResponse) XXX_Size() int { + return m.Size() +} +func (m *RedelegationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RedelegationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RedelegationResponse proto.InternalMessageInfo + +func (m *RedelegationResponse) GetRedelegation() Redelegation { + if m != nil { + return m.Redelegation + } + return Redelegation{} +} + +func (m *RedelegationResponse) GetEntries() []RedelegationEntryResponse { + if m != nil { + return m.Entries + } + return nil +} + +// Pool is used for tracking bonded and not-bonded token supply of the bond +// denomination. +type Pool struct { + NotBondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"` + BondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens"` +} + +func (m *Pool) Reset() { *m = Pool{} } +func (m *Pool) String() string { return proto.CompactTextString(m) } +func (*Pool) ProtoMessage() {} +func (*Pool) Descriptor() ([]byte, []int) { + return fileDescriptor_6f0df8198ed3eea5, []int{19} +} +func (m *Pool) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Pool.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 *Pool) XXX_Merge(src proto.Message) { + xxx_messageInfo_Pool.Merge(m, src) +} +func (m *Pool) XXX_Size() int { + return m.Size() +} +func (m *Pool) XXX_DiscardUnknown() { + xxx_messageInfo_Pool.DiscardUnknown(m) +} + +var xxx_messageInfo_Pool proto.InternalMessageInfo + +func init() { + proto.RegisterType((*HistoricalInfo)(nil), "multistaking.v0.HistoricalInfo") + proto.RegisterType((*CommissionRates)(nil), "multistaking.v0.CommissionRates") + proto.RegisterType((*Commission)(nil), "multistaking.v0.Commission") + proto.RegisterType((*Description)(nil), "multistaking.v0.Description") + proto.RegisterType((*Validator)(nil), "multistaking.v0.Validator") + proto.RegisterType((*ValAddresses)(nil), "multistaking.v0.ValAddresses") + proto.RegisterType((*DVPair)(nil), "multistaking.v0.DVPair") + proto.RegisterType((*DVPairs)(nil), "multistaking.v0.DVPairs") + proto.RegisterType((*DVVTriplet)(nil), "multistaking.v0.DVVTriplet") + proto.RegisterType((*DVVTriplets)(nil), "multistaking.v0.DVVTriplets") + proto.RegisterType((*Delegation)(nil), "multistaking.v0.Delegation") + proto.RegisterType((*UnbondingDelegation)(nil), "multistaking.v0.UnbondingDelegation") + proto.RegisterType((*UnbondingDelegationEntry)(nil), "multistaking.v0.UnbondingDelegationEntry") + proto.RegisterType((*RedelegationEntry)(nil), "multistaking.v0.RedelegationEntry") + proto.RegisterType((*Redelegation)(nil), "multistaking.v0.Redelegation") + proto.RegisterType((*Params)(nil), "multistaking.v0.Params") + proto.RegisterType((*DelegationResponse)(nil), "multistaking.v0.DelegationResponse") + proto.RegisterType((*RedelegationEntryResponse)(nil), "multistaking.v0.RedelegationEntryResponse") + proto.RegisterType((*RedelegationResponse)(nil), "multistaking.v0.RedelegationResponse") + proto.RegisterType((*Pool)(nil), "multistaking.v0.Pool") +} + +func init() { proto.RegisterFile("multistaking/v0/staking.proto", fileDescriptor_6f0df8198ed3eea5) } + +var fileDescriptor_6f0df8198ed3eea5 = []byte{ + // 1583 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0xcd, 0x6f, 0x1b, 0xc7, + 0x15, 0xe7, 0x52, 0x34, 0x45, 0x3d, 0x4a, 0xa2, 0x34, 0x56, 0x5b, 0x5a, 0xb6, 0x45, 0x81, 0x80, + 0x6b, 0xbb, 0x80, 0x48, 0x5b, 0x06, 0x8c, 0x56, 0x70, 0x0b, 0x98, 0xa2, 0x50, 0xab, 0xb6, 0x01, + 0x95, 0x92, 0x65, 0xb4, 0x3d, 0x10, 0xc3, 0xdd, 0x11, 0x39, 0xd5, 0xee, 0x2c, 0xb1, 0x33, 0x54, + 0x45, 0xa0, 0x05, 0x8a, 0xf6, 0xd2, 0xa3, 0x8f, 0x3d, 0xe4, 0xa0, 0x43, 0x8e, 0xbe, 0x04, 0x30, + 0xf2, 0x0f, 0xe4, 0x62, 0x04, 0x08, 0x60, 0xf8, 0x14, 0x04, 0x81, 0x12, 0xd8, 0x87, 0x04, 0x39, + 0x05, 0xb9, 0xe4, 0x92, 0x04, 0xc1, 0x7c, 0xec, 0x87, 0x48, 0x59, 0x96, 0x60, 0x1d, 0x0c, 0xf8, + 0x62, 0xef, 0x7c, 0xbc, 0xdf, 0xcc, 0xfb, 0xbd, 0xdf, 0x7b, 0x7a, 0x43, 0xb8, 0xe8, 0xf5, 0x5c, + 0x41, 0xb9, 0xc0, 0xdb, 0x94, 0xb5, 0xab, 0x3b, 0xd7, 0xaa, 0xe6, 0xb3, 0xd2, 0x0d, 0x7c, 0xe1, + 0xa3, 0x42, 0x72, 0xb9, 0xb2, 0x73, 0x6d, 0x76, 0xa6, 0xed, 0xb7, 0x7d, 0xb5, 0x56, 0x95, 0x5f, + 0x7a, 0xdb, 0xec, 0xb9, 0xb6, 0xef, 0xb7, 0x5d, 0x52, 0x55, 0xa3, 0x56, 0x6f, 0xab, 0x8a, 0x59, + 0xdf, 0x2c, 0xcd, 0x0d, 0x2e, 0x39, 0xbd, 0x00, 0x0b, 0xea, 0x33, 0xb3, 0x5e, 0x1a, 0x5c, 0x17, + 0xd4, 0x23, 0x5c, 0x60, 0xaf, 0x1b, 0x62, 0xdb, 0x3e, 0xf7, 0x7c, 0xde, 0xd4, 0x87, 0xea, 0x41, + 0x88, 0xad, 0x47, 0xd5, 0x16, 0xe6, 0xa4, 0xba, 0x73, 0xbd, 0x45, 0x04, 0xbe, 0x5e, 0xb5, 0x7d, + 0x1a, 0x62, 0x5f, 0x10, 0x84, 0x39, 0x24, 0xf0, 0x28, 0x13, 0x55, 0xd1, 0xef, 0x12, 0xae, 0xff, + 0xd5, 0xab, 0xe5, 0xff, 0x58, 0x30, 0x79, 0x87, 0x72, 0xe1, 0x07, 0xd4, 0xc6, 0xee, 0x2a, 0xdb, + 0xf2, 0xd1, 0x4d, 0xc8, 0x76, 0x08, 0x76, 0x48, 0x50, 0xb4, 0xe6, 0xad, 0x2b, 0xf9, 0xc5, 0x62, + 0x25, 0x46, 0xa8, 0x68, 0xdb, 0x3b, 0x6a, 0xbd, 0x96, 0x79, 0xba, 0x5f, 0x4a, 0x35, 0xcc, 0x6e, + 0xf4, 0x5b, 0xc8, 0xee, 0x60, 0x97, 0x13, 0x51, 0x4c, 0xcf, 0x8f, 0x5c, 0xc9, 0x2f, 0xce, 0x56, + 0x06, 0x78, 0xab, 0x6c, 0x62, 0x97, 0x3a, 0x58, 0xf8, 0x91, 0xa5, 0xde, 0x5f, 0x7e, 0x9c, 0x86, + 0xc2, 0xb2, 0xef, 0x79, 0x94, 0x73, 0xea, 0xb3, 0x06, 0x16, 0x84, 0xa3, 0x35, 0xc8, 0x04, 0x58, + 0x10, 0x75, 0x87, 0xb1, 0xda, 0x2d, 0xb9, 0xff, 0xb3, 0xfd, 0xd2, 0xaf, 0xdb, 0x54, 0x74, 0x7a, + 0xad, 0x8a, 0xed, 0x7b, 0x86, 0x05, 0xf3, 0xdf, 0x02, 0x77, 0xb6, 0x8d, 0x63, 0x75, 0x62, 0x3f, + 0x7f, 0xb2, 0x00, 0x86, 0xa4, 0x3a, 0xb1, 0x1b, 0x0a, 0x09, 0x3d, 0x84, 0x9c, 0x87, 0x77, 0x9b, + 0x0a, 0x35, 0x7d, 0x0a, 0xa8, 0xa3, 0x1e, 0xde, 0x95, 0x77, 0x45, 0x0e, 0x14, 0x24, 0xb0, 0xdd, + 0xc1, 0xac, 0x4d, 0x34, 0xfe, 0xc8, 0x29, 0xe0, 0x4f, 0x78, 0x78, 0x77, 0x59, 0x61, 0xca, 0x53, + 0x96, 0x72, 0xff, 0xdf, 0x2b, 0xa5, 0xbe, 0xde, 0x2b, 0x59, 0xe5, 0x27, 0x16, 0x40, 0x4c, 0x17, + 0x7a, 0x00, 0x53, 0x76, 0x34, 0x52, 0xc7, 0x73, 0x13, 0xb9, 0xf9, 0xa1, 0x08, 0x0c, 0xb0, 0x5c, + 0xcb, 0xc9, 0x1b, 0x3e, 0xdb, 0x2f, 0x59, 0x8d, 0x82, 0x3d, 0x10, 0x80, 0x15, 0xc8, 0xf7, 0xba, + 0x0e, 0x16, 0xa4, 0x29, 0xc5, 0xa8, 0x18, 0x93, 0x31, 0xd5, 0x4a, 0xad, 0x84, 0x4a, 0xad, 0x6c, + 0x84, 0x4a, 0xd5, 0x58, 0x8f, 0xbe, 0x28, 0x59, 0x0d, 0xd0, 0x86, 0x72, 0x29, 0x71, 0xed, 0xc7, + 0x16, 0xe4, 0xeb, 0x84, 0xdb, 0x01, 0xed, 0x4a, 0xe9, 0xa3, 0x22, 0x8c, 0x7a, 0x3e, 0xa3, 0xdb, + 0x46, 0x68, 0x63, 0x8d, 0x70, 0x88, 0x66, 0x21, 0x47, 0x1d, 0xc2, 0x04, 0x15, 0x7d, 0x1d, 0xa9, + 0x46, 0x34, 0x96, 0x56, 0xff, 0x20, 0x2d, 0x4e, 0x43, 0x92, 0x1b, 0xe1, 0x10, 0x5d, 0x85, 0x29, + 0x4e, 0xec, 0x5e, 0x40, 0x45, 0xbf, 0x69, 0xfb, 0x4c, 0x60, 0x5b, 0x14, 0x33, 0x6a, 0x4b, 0x21, + 0x9c, 0x5f, 0xd6, 0xd3, 0x12, 0xc4, 0x21, 0x02, 0x53, 0x97, 0x17, 0xcf, 0x68, 0x10, 0x33, 0x4c, + 0x5c, 0xf7, 0xc3, 0x2c, 0x8c, 0x45, 0x82, 0x45, 0xcb, 0x30, 0xe5, 0x77, 0x49, 0x20, 0xbf, 0x9b, + 0xd8, 0x71, 0x02, 0xc2, 0xb9, 0x91, 0x66, 0xf1, 0xf9, 0x93, 0x85, 0x19, 0x13, 0xb6, 0xdb, 0x7a, + 0x65, 0x5d, 0x04, 0x94, 0xb5, 0x1b, 0x85, 0xd0, 0xc2, 0x4c, 0xa3, 0xbf, 0xc8, 0x48, 0x31, 0x4e, + 0x18, 0xef, 0xf1, 0x66, 0xb7, 0xd7, 0xda, 0x26, 0x7d, 0xc3, 0xeb, 0xcc, 0x10, 0xaf, 0xb7, 0x59, + 0xbf, 0x56, 0xfc, 0x38, 0x86, 0xb6, 0x83, 0x7e, 0x57, 0xf8, 0x95, 0xb5, 0x5e, 0xeb, 0x2e, 0xe9, + 0xcb, 0x68, 0x19, 0x9c, 0x35, 0x05, 0x83, 0x7e, 0x09, 0xd9, 0xbf, 0x63, 0xea, 0x12, 0x47, 0xb1, + 0x92, 0x6b, 0x98, 0x91, 0x9c, 0xe7, 0x02, 0x8b, 0x1e, 0x37, 0x54, 0x98, 0x11, 0xda, 0x80, 0xac, + 0xf0, 0xb7, 0x09, 0x33, 0x04, 0x9c, 0x48, 0xaa, 0xab, 0x4c, 0x24, 0xa4, 0xba, 0xca, 0x44, 0xc3, + 0x60, 0xa1, 0x36, 0x4c, 0x39, 0xc4, 0x25, 0x6d, 0x45, 0x13, 0xef, 0xe0, 0x80, 0xf0, 0x62, 0xf6, + 0x14, 0x52, 0xa1, 0x10, 0xa1, 0xae, 0x2b, 0x50, 0x54, 0x87, 0xbc, 0x13, 0x4b, 0xa9, 0x38, 0xaa, + 0x48, 0xbc, 0x30, 0x24, 0xf7, 0x84, 0xdc, 0x4c, 0xc9, 0x49, 0x9a, 0x49, 0xc5, 0xf4, 0x58, 0xcb, + 0x67, 0x0e, 0x65, 0xed, 0x66, 0x87, 0xd0, 0x76, 0x47, 0x14, 0x73, 0xf3, 0xd6, 0x95, 0x91, 0x46, + 0x21, 0x9a, 0xbf, 0xa3, 0xa6, 0xd1, 0x5d, 0x98, 0x8c, 0xb7, 0xaa, 0x84, 0x18, 0x3b, 0x41, 0x42, + 0x4c, 0x44, 0xb6, 0x72, 0x15, 0xdd, 0x06, 0x88, 0xb3, 0xad, 0x08, 0x0a, 0xe8, 0xfc, 0x11, 0xb9, + 0x6a, 0xee, 0x9e, 0x30, 0x42, 0x2e, 0x9c, 0xf5, 0x28, 0x6b, 0x72, 0xe2, 0x6e, 0x35, 0x0d, 0x39, + 0x12, 0x2b, 0x7f, 0x0a, 0xc1, 0x9c, 0xf6, 0x28, 0x5b, 0x27, 0xee, 0x56, 0x3d, 0x82, 0x45, 0x17, + 0x01, 0xe4, 0xfd, 0x9b, 0x0e, 0x61, 0xbe, 0x57, 0x1c, 0x57, 0x4a, 0x1a, 0x93, 0x33, 0x75, 0x39, + 0xb1, 0x34, 0xfe, 0xbf, 0xbd, 0x52, 0xca, 0x24, 0x4e, 0xaa, 0xbc, 0x06, 0xe3, 0x9b, 0xd8, 0x35, + 0x9a, 0x27, 0x1c, 0xdd, 0x84, 0x31, 0x1c, 0x0e, 0x8a, 0xd6, 0xfc, 0xc8, 0x91, 0x39, 0x13, 0x6f, + 0xd5, 0xa9, 0xf8, 0xef, 0xcf, 0xe7, 0xad, 0xf2, 0xfb, 0x16, 0x64, 0xeb, 0x9b, 0x6b, 0x98, 0x06, + 0x68, 0x05, 0xa6, 0x63, 0x85, 0x1d, 0x37, 0x11, 0x63, 0x51, 0x86, 0x99, 0xb8, 0x02, 0xd3, 0x3b, + 0x61, 0x6e, 0x47, 0x30, 0xe9, 0xd7, 0xc1, 0x44, 0x26, 0x66, 0x7e, 0xc0, 0xf1, 0x3f, 0xc0, 0xa8, + 0xbe, 0x25, 0x47, 0x37, 0xe0, 0x4c, 0x57, 0x7e, 0x28, 0x7f, 0xf3, 0x8b, 0xbf, 0x1a, 0x56, 0xa6, + 0xda, 0x68, 0x02, 0xab, 0xf7, 0x96, 0x7f, 0xb4, 0x00, 0xea, 0x9b, 0x9b, 0x1b, 0x01, 0xed, 0xba, + 0x44, 0x9c, 0x96, 0xab, 0xf7, 0xe0, 0x17, 0xb1, 0xab, 0x3c, 0xb0, 0x8f, 0xed, 0xee, 0xd9, 0xc8, + 0x6c, 0x3d, 0xb0, 0x0f, 0x45, 0x73, 0xb8, 0x88, 0xd0, 0x46, 0x8e, 0x8d, 0x56, 0xe7, 0xe2, 0x70, + 0xfe, 0xee, 0x41, 0x3e, 0x76, 0x9f, 0xa3, 0xdf, 0x43, 0x4e, 0x98, 0x6f, 0x43, 0xe3, 0xf9, 0x43, + 0x68, 0x0c, 0xf7, 0x1b, 0x2a, 0x23, 0x93, 0xf2, 0x4f, 0x92, 0xcd, 0x58, 0xc2, 0x6f, 0x95, 0x70, + 0x64, 0xf9, 0x35, 0xe5, 0xf1, 0x34, 0x3a, 0x05, 0x83, 0x35, 0x40, 0xe7, 0x0f, 0x16, 0x9c, 0x7d, + 0x10, 0xd6, 0x9d, 0xb7, 0x96, 0x89, 0x55, 0x18, 0x25, 0x4c, 0x04, 0x54, 0x51, 0x21, 0x83, 0x7c, + 0x75, 0x28, 0xc8, 0x87, 0x38, 0xb1, 0xc2, 0x44, 0xd0, 0x37, 0x21, 0x0f, 0xed, 0x07, 0xdc, 0xff, + 0x3e, 0x0d, 0xc5, 0x57, 0x59, 0xa2, 0xcb, 0x50, 0xb0, 0x03, 0xa2, 0x26, 0xc2, 0xc2, 0x6f, 0xa9, + 0xc2, 0x3f, 0x19, 0x4e, 0x9b, 0xba, 0x7f, 0x1f, 0x64, 0x63, 0x24, 0x15, 0x25, 0xb7, 0x9e, 0xb8, + 0x13, 0x9a, 0x8c, 0x8d, 0x55, 0xe5, 0xe7, 0x50, 0xa0, 0x8c, 0x0a, 0x8a, 0xdd, 0x66, 0x0b, 0xbb, + 0x98, 0xd9, 0xba, 0x8b, 0xc9, 0x2f, 0x9e, 0xab, 0x18, 0xbe, 0x64, 0x1b, 0x5f, 0x31, 0x6d, 0x7c, + 0x65, 0xd9, 0xa7, 0xac, 0x56, 0x35, 0xda, 0xb8, 0x7c, 0x0c, 0x6d, 0x48, 0x83, 0xc6, 0xa4, 0x39, + 0xa2, 0xa6, 0x4f, 0x40, 0x0e, 0x8c, 0x86, 0x87, 0x65, 0x4e, 0xfd, 0xb0, 0x10, 0x3a, 0xd1, 0x39, + 0x7d, 0x95, 0x86, 0xe9, 0x06, 0x71, 0xde, 0x65, 0xca, 0xff, 0x06, 0xa0, 0x73, 0x52, 0xd6, 0x48, + 0xdd, 0x7a, 0xbd, 0x61, 0x8e, 0x8f, 0x69, 0xbc, 0x3a, 0x17, 0x09, 0xa6, 0x3f, 0x4a, 0xc3, 0x78, + 0x92, 0xe9, 0x77, 0xe0, 0x6f, 0x06, 0xaa, 0xc5, 0x05, 0x23, 0xa3, 0x0a, 0x46, 0x79, 0xa8, 0x60, + 0x0c, 0x89, 0xef, 0xe8, 0x4a, 0xf1, 0x49, 0x1a, 0xb2, 0x6b, 0x38, 0xc0, 0x1e, 0x47, 0x97, 0x86, + 0xda, 0x3c, 0xfd, 0x34, 0x19, 0x68, 0xe0, 0x2e, 0xc1, 0xa4, 0x7c, 0xf1, 0x45, 0xd7, 0xd3, 0xc4, + 0x4c, 0xa8, 0x27, 0x5b, 0xf4, 0x66, 0xe0, 0xa8, 0x04, 0x79, 0xb9, 0x2d, 0xae, 0x6f, 0x72, 0x0f, + 0x78, 0x78, 0x77, 0x45, 0xcf, 0xa0, 0x05, 0x40, 0x9d, 0xe8, 0xf1, 0xdd, 0x8c, 0xdd, 0x92, 0xfb, + 0xa6, 0xe3, 0x95, 0x70, 0xfb, 0xc1, 0x36, 0xec, 0xcc, 0x40, 0x1b, 0x86, 0xfe, 0xa9, 0x7b, 0xc2, + 0x81, 0xc7, 0xa0, 0x69, 0xc0, 0xef, 0x9d, 0x4c, 0x7d, 0xdf, 0xed, 0x97, 0x66, 0xfb, 0xd8, 0x73, + 0x97, 0xca, 0x87, 0x40, 0x96, 0x55, 0x8f, 0x78, 0xf0, 0x2d, 0x99, 0x50, 0xe5, 0x7b, 0x16, 0xa0, + 0xb8, 0xe0, 0x36, 0x08, 0xef, 0xca, 0xc7, 0x8a, 0xec, 0x7a, 0x13, 0x9d, 0xaa, 0xf5, 0x8a, 0xae, + 0x37, 0x36, 0x0c, 0xbb, 0xde, 0x84, 0xbc, 0x7f, 0x17, 0x57, 0xb2, 0xf4, 0xeb, 0x72, 0xd8, 0x84, + 0x7c, 0xb0, 0x3c, 0xa5, 0xca, 0xcf, 0x2d, 0x38, 0x37, 0xa4, 0x90, 0xe8, 0x96, 0x0f, 0x01, 0x05, + 0x89, 0x45, 0x15, 0x94, 0xbe, 0xb9, 0xed, 0xf1, 0x95, 0x36, 0x1d, 0x0c, 0xd5, 0xbf, 0xcd, 0x83, + 0x55, 0xf8, 0x4d, 0xbb, 0xf4, 0xc8, 0xb1, 0x8c, 0xe2, 0xfc, 0x03, 0x0b, 0x66, 0x92, 0x97, 0x89, + 0xfc, 0xf9, 0x23, 0x8c, 0x27, 0xef, 0x62, 0x3c, 0xb9, 0x78, 0xa4, 0x27, 0xc6, 0x89, 0x03, 0x86, + 0xe8, 0x4f, 0x71, 0xde, 0xe9, 0xdf, 0x77, 0x7e, 0xf3, 0x7a, 0x36, 0xc2, 0x5b, 0x0c, 0xe6, 0x5f, + 0x46, 0x05, 0xe2, 0xbf, 0x69, 0xc8, 0xac, 0xf9, 0xbe, 0x8b, 0xfe, 0x05, 0xd3, 0xcc, 0x17, 0x4d, + 0xa9, 0x64, 0xe2, 0x34, 0xcd, 0xbb, 0x54, 0x57, 0xad, 0x3f, 0x9f, 0x8c, 0xa4, 0x6f, 0xf6, 0x4b, + 0xc3, 0x50, 0x03, 0xcc, 0x15, 0x98, 0x2f, 0x6a, 0x6a, 0x7d, 0x43, 0xbf, 0x5a, 0x03, 0x98, 0x38, + 0x78, 0xb4, 0xae, 0x72, 0xf7, 0x4f, 0x7c, 0xf4, 0xc4, 0x51, 0xc7, 0x8e, 0xb7, 0x12, 0x67, 0x2e, + 0xe5, 0x64, 0xd4, 0xbe, 0xdd, 0x2b, 0x59, 0xb5, 0xcd, 0xa7, 0x2f, 0xe6, 0xac, 0x67, 0x2f, 0xe6, + 0xac, 0x2f, 0x5f, 0xcc, 0x59, 0x8f, 0x5e, 0xce, 0xa5, 0x9e, 0xbd, 0x9c, 0x4b, 0x7d, 0xfa, 0x72, + 0x2e, 0xf5, 0xd7, 0x5b, 0x89, 0x83, 0x03, 0x82, 0x5d, 0xea, 0x0b, 0x62, 0x77, 0xaa, 0x8a, 0xf5, + 0x85, 0xf0, 0xd7, 0xca, 0xdd, 0x81, 0xb1, 0xfe, 0x89, 0x6f, 0xe7, 0x5a, 0x2b, 0xab, 0xfe, 0x4a, + 0xde, 0xf8, 0x39, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x94, 0x02, 0x2a, 0xdd, 0x14, 0x00, 0x00, +} + +func (this *Pool) Description() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) { + return StakingDescription() +} +func StakingDescription() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) { + d := &github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet{} + var gzipped = []byte{ + // 8146 bytes of a gzipped FileDescriptorSet + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x7b, 0x70, 0x24, 0xc7, + 0x79, 0x1f, 0xf6, 0x81, 0x7d, 0x7c, 0xbb, 0xd8, 0x1d, 0x34, 0x70, 0xc7, 0x3d, 0x1c, 0x09, 0x80, + 0x4b, 0x91, 0x3c, 0xbe, 0x80, 0xe3, 0x91, 0x77, 0x24, 0xf7, 0x44, 0x29, 0x8b, 0xdd, 0x3d, 0x1c, + 0x8e, 0x78, 0x69, 0x16, 0x38, 0x3e, 0x5c, 0xa9, 0xc9, 0x60, 0xb6, 0xb1, 0x18, 0xde, 0xec, 0xcc, + 0x78, 0x66, 0x16, 0x77, 0x60, 0x25, 0x29, 0x3a, 0x8a, 0x13, 0x99, 0x71, 0x1c, 0x39, 0x4e, 0xc5, + 0xb2, 0xa4, 0x53, 0x28, 0xdb, 0x91, 0x14, 0x47, 0x4e, 0x2c, 0x8b, 0x91, 0xe3, 0xb8, 0x92, 0x72, + 0x92, 0x4a, 0xa2, 0xb8, 0x2a, 0x29, 0x45, 0x7f, 0x24, 0xae, 0x54, 0xcc, 0x58, 0x94, 0x2b, 0x52, + 0x6c, 0x39, 0x91, 0x15, 0x3a, 0x8f, 0x62, 0xec, 0x4a, 0xf5, 0x6b, 0x1e, 0xfb, 0xc0, 0x2e, 0xa8, + 0xa3, 0xac, 0x8a, 0xfe, 0x01, 0xb6, 0xbf, 0xfe, 0xbe, 0x5f, 0x7f, 0xfd, 0xf5, 0xd7, 0x5f, 0x7f, + 0xdd, 0xd3, 0x33, 0xf0, 0xb5, 0x2b, 0xb0, 0xd8, 0xb6, 0xac, 0xb6, 0x81, 0x97, 0x6d, 0xc7, 0xf2, + 0xac, 0xbd, 0xee, 0xfe, 0x72, 0x0b, 0xbb, 0x9a, 0xa3, 0xdb, 0x9e, 0xe5, 0x2c, 0x51, 0x1a, 0x2a, + 0x32, 0x8e, 0x25, 0xc1, 0x51, 0xde, 0x80, 0xe9, 0x2b, 0xba, 0x81, 0xeb, 0x3e, 0x63, 0x13, 0x7b, + 0xe8, 0x69, 0x48, 0xee, 0xeb, 0x06, 0x2e, 0xc5, 0x16, 0x13, 0xe7, 0x72, 0x17, 0xde, 0xb7, 0xd4, + 0x23, 0xb4, 0x14, 0x95, 0xd8, 0x26, 0x64, 0x99, 0x4a, 0x94, 0xff, 0x38, 0x09, 0x33, 0x03, 0x6a, + 0x11, 0x82, 0xa4, 0xa9, 0x76, 0x08, 0x62, 0xec, 0x5c, 0x56, 0xa6, 0xbf, 0x51, 0x09, 0xd2, 0xb6, + 0xaa, 0xdd, 0x50, 0xdb, 0xb8, 0x14, 0xa7, 0x64, 0x51, 0x44, 0xf3, 0x00, 0x2d, 0x6c, 0x63, 0xb3, + 0x85, 0x4d, 0xed, 0xa8, 0x94, 0x58, 0x4c, 0x9c, 0xcb, 0xca, 0x21, 0x0a, 0x7a, 0x04, 0xa6, 0xed, + 0xee, 0x9e, 0xa1, 0x6b, 0x4a, 0x88, 0x0d, 0x16, 0x13, 0xe7, 0x26, 0x65, 0x89, 0x55, 0xd4, 0x03, + 0xe6, 0x07, 0xa1, 0x78, 0x13, 0xab, 0x37, 0xc2, 0xac, 0x39, 0xca, 0x5a, 0x20, 0xe4, 0x10, 0x63, + 0x0d, 0xf2, 0x1d, 0xec, 0xba, 0x6a, 0x1b, 0x2b, 0xde, 0x91, 0x8d, 0x4b, 0x49, 0xda, 0xfb, 0xc5, + 0xbe, 0xde, 0xf7, 0xf6, 0x3c, 0xc7, 0xa5, 0x76, 0x8e, 0x6c, 0x8c, 0xaa, 0x90, 0xc5, 0x66, 0xb7, + 0xc3, 0x10, 0x26, 0x87, 0xd8, 0xaf, 0x61, 0x76, 0x3b, 0xbd, 0x28, 0x19, 0x22, 0xc6, 0x21, 0xd2, + 0x2e, 0x76, 0x0e, 0x75, 0x0d, 0x97, 0x52, 0x14, 0xe0, 0xc1, 0x3e, 0x80, 0x26, 0xab, 0xef, 0xc5, + 0x10, 0x72, 0xa8, 0x06, 0x59, 0x7c, 0xcb, 0xc3, 0xa6, 0xab, 0x5b, 0x66, 0x29, 0x4d, 0x41, 0xee, + 0x1f, 0x30, 0x8a, 0xd8, 0x68, 0xf5, 0x42, 0x04, 0x72, 0xe8, 0x12, 0xa4, 0x2d, 0xdb, 0xd3, 0x2d, + 0xd3, 0x2d, 0x65, 0x16, 0x63, 0xe7, 0x72, 0x17, 0xee, 0x1e, 0xe8, 0x08, 0x5b, 0x8c, 0x47, 0x16, + 0xcc, 0x68, 0x0d, 0x24, 0xd7, 0xea, 0x3a, 0x1a, 0x56, 0x34, 0xab, 0x85, 0x15, 0xdd, 0xdc, 0xb7, + 0x4a, 0x59, 0x0a, 0xb0, 0xd0, 0xdf, 0x11, 0xca, 0x58, 0xb3, 0x5a, 0x78, 0xcd, 0xdc, 0xb7, 0xe4, + 0x82, 0x1b, 0x29, 0xa3, 0xd3, 0x90, 0x72, 0x8f, 0x4c, 0x4f, 0xbd, 0x55, 0xca, 0x53, 0x0f, 0xe1, + 0x25, 0xe2, 0x3a, 0xb8, 0xa5, 0x93, 0xe6, 0x4a, 0x53, 0xcc, 0x75, 0x78, 0xb1, 0xfc, 0xab, 0x29, + 0x28, 0x8e, 0xe3, 0x7c, 0x97, 0x61, 0x72, 0x9f, 0xf4, 0xbf, 0x14, 0x3f, 0x89, 0x75, 0x98, 0x4c, + 0xd4, 0xbc, 0xa9, 0x77, 0x69, 0xde, 0x2a, 0xe4, 0x4c, 0xec, 0x7a, 0xb8, 0xc5, 0x7c, 0x25, 0x31, + 0xa6, 0xb7, 0x01, 0x13, 0xea, 0x77, 0xb6, 0xe4, 0xbb, 0x72, 0xb6, 0x17, 0xa0, 0xe8, 0xab, 0xa4, + 0x38, 0xaa, 0xd9, 0x16, 0x5e, 0xbb, 0x3c, 0x4a, 0x93, 0xa5, 0x86, 0x90, 0x93, 0x89, 0x98, 0x5c, + 0xc0, 0x91, 0x32, 0xaa, 0x03, 0x58, 0x26, 0xb6, 0xf6, 0x95, 0x16, 0xd6, 0x8c, 0x52, 0x66, 0x88, + 0x95, 0xb6, 0x08, 0x4b, 0x9f, 0x95, 0x2c, 0x46, 0xd5, 0x0c, 0xf4, 0x4c, 0xe0, 0x84, 0xe9, 0x21, + 0x3e, 0xb4, 0xc1, 0xa6, 0x5f, 0x9f, 0x1f, 0xee, 0x42, 0xc1, 0xc1, 0x64, 0x46, 0xe0, 0x16, 0xef, + 0x59, 0x96, 0x2a, 0xb1, 0x34, 0xb2, 0x67, 0x32, 0x17, 0x63, 0x1d, 0x9b, 0x72, 0xc2, 0x45, 0x74, + 0x1f, 0xf8, 0x04, 0x85, 0xba, 0x15, 0xd0, 0xf8, 0x94, 0x17, 0xc4, 0x4d, 0xb5, 0x83, 0xe7, 0x5e, + 0x81, 0x42, 0xd4, 0x3c, 0x68, 0x16, 0x26, 0x5d, 0x4f, 0x75, 0x3c, 0xea, 0x85, 0x93, 0x32, 0x2b, + 0x20, 0x09, 0x12, 0xd8, 0x6c, 0xd1, 0xf8, 0x37, 0x29, 0x93, 0x9f, 0xe8, 0x4f, 0x05, 0x1d, 0x4e, + 0xd0, 0x0e, 0x3f, 0xd0, 0x3f, 0xa2, 0x11, 0xe4, 0xde, 0x7e, 0xcf, 0x3d, 0x05, 0x53, 0x91, 0x0e, + 0x8c, 0xdb, 0x74, 0xf9, 0x17, 0x93, 0x70, 0x6a, 0x20, 0x36, 0x7a, 0x01, 0x66, 0xbb, 0xa6, 0x6e, + 0x7a, 0xd8, 0xb1, 0x1d, 0x4c, 0x5c, 0x96, 0xb5, 0x55, 0xfa, 0x46, 0x7a, 0x88, 0xd3, 0xed, 0x86, + 0xb9, 0x19, 0x8a, 0x3c, 0xd3, 0xed, 0x27, 0xa2, 0x17, 0x21, 0x47, 0xfc, 0x43, 0x75, 0x54, 0x0a, + 0xc8, 0x66, 0xe3, 0x85, 0xf1, 0xba, 0xbc, 0x54, 0x0f, 0x24, 0x57, 0x12, 0x1f, 0x89, 0xc5, 0xe5, + 0x30, 0x16, 0x3a, 0x80, 0xfc, 0x21, 0x76, 0xf4, 0x7d, 0x5d, 0x63, 0xd8, 0xc4, 0x9c, 0x85, 0x0b, + 0x4f, 0x8f, 0x89, 0x7d, 0x3d, 0x24, 0xda, 0xf4, 0x54, 0x0f, 0x57, 0x60, 0x77, 0xf3, 0x7a, 0x43, + 0x5e, 0xbb, 0xb2, 0xd6, 0xa8, 0xcb, 0x11, 0xe4, 0xb9, 0x2f, 0xc6, 0x20, 0x17, 0xd2, 0x85, 0x84, + 0x2d, 0xb3, 0xdb, 0xd9, 0xc3, 0x0e, 0xb7, 0x38, 0x2f, 0xa1, 0xb3, 0x90, 0xdd, 0xef, 0x1a, 0x06, + 0x73, 0x1b, 0xb6, 0xe6, 0x65, 0x08, 0x81, 0xb8, 0x0c, 0x89, 0x52, 0x3c, 0x10, 0xd0, 0x28, 0x45, + 0x7e, 0xa3, 0xfb, 0x20, 0xa7, 0xbb, 0x8a, 0x83, 0x6d, 0xac, 0x7a, 0xb8, 0x55, 0x4a, 0x2e, 0xc6, + 0xce, 0x65, 0x56, 0xe2, 0xa5, 0x98, 0x0c, 0xba, 0x2b, 0x73, 0x2a, 0x9a, 0x83, 0x8c, 0xf0, 0xbd, + 0xd2, 0x24, 0xe1, 0x90, 0xfd, 0x32, 0xab, 0xe3, 0xd2, 0x29, 0x51, 0xc7, 0xca, 0xe5, 0x27, 0x61, + 0xba, 0xaf, 0x93, 0xa8, 0x08, 0xb9, 0x7a, 0xa3, 0xb6, 0x5e, 0x95, 0xab, 0x3b, 0x6b, 0x5b, 0x9b, + 0xd2, 0x04, 0x2a, 0x40, 0xa8, 0xdf, 0x52, 0xec, 0xe1, 0x6c, 0xe6, 0x9b, 0x69, 0xe9, 0xd5, 0x57, + 0x5f, 0x7d, 0x35, 0x5e, 0xfe, 0xa7, 0x29, 0x98, 0x1d, 0x14, 0xe5, 0x06, 0x06, 0xdc, 0xc0, 0x26, + 0x89, 0x88, 0x4d, 0xaa, 0x30, 0x69, 0xa8, 0x7b, 0xd8, 0xa0, 0x9d, 0x2b, 0x5c, 0x78, 0x64, 0xac, + 0x38, 0xba, 0xb4, 0x4e, 0x44, 0x64, 0x26, 0x89, 0x3e, 0xc0, 0x2d, 0x37, 0x49, 0x11, 0x1e, 0x1e, + 0x0f, 0x81, 0x44, 0x3f, 0x6e, 0xe5, 0xb3, 0x90, 0x25, 0xff, 0xd9, 0xb0, 0xa4, 0xd8, 0xb0, 0x10, + 0x02, 0x1d, 0x96, 0x39, 0xc8, 0xd0, 0xc0, 0xd6, 0xc2, 0xfe, 0x90, 0x89, 0x32, 0x09, 0x05, 0x2d, + 0xbc, 0xaf, 0x76, 0x0d, 0x4f, 0x39, 0x54, 0x8d, 0x2e, 0xa6, 0x21, 0x2a, 0x2b, 0xe7, 0x39, 0xf1, + 0x3a, 0xa1, 0xa1, 0x05, 0xc8, 0xb1, 0x38, 0xa8, 0x9b, 0x2d, 0x7c, 0x8b, 0xae, 0x84, 0x93, 0x32, + 0x0b, 0x8d, 0x6b, 0x84, 0x42, 0x9a, 0x7f, 0xd9, 0xb5, 0x4c, 0x11, 0x4c, 0x68, 0x13, 0x84, 0x40, + 0x9b, 0x7f, 0xaa, 0x77, 0x11, 0xbe, 0x67, 0x70, 0xf7, 0xfa, 0xa2, 0xdf, 0x83, 0x50, 0xa4, 0x1c, + 0x4f, 0xf0, 0xb9, 0xaa, 0x1a, 0xa5, 0x69, 0xea, 0x00, 0x05, 0x46, 0xde, 0xe2, 0xd4, 0xf2, 0x97, + 0xe2, 0x90, 0xa4, 0x4b, 0x41, 0x11, 0x72, 0x3b, 0x2f, 0x6e, 0x37, 0x94, 0xfa, 0xd6, 0xee, 0xca, + 0x7a, 0x43, 0x8a, 0x91, 0xa1, 0xa7, 0x84, 0x2b, 0xeb, 0x5b, 0xd5, 0x1d, 0x29, 0xee, 0x97, 0xd7, + 0x36, 0x77, 0x2e, 0x3d, 0x29, 0x25, 0x7c, 0x81, 0x5d, 0x46, 0x48, 0x86, 0x19, 0x9e, 0xb8, 0x20, + 0x4d, 0x22, 0x09, 0xf2, 0x0c, 0x60, 0xed, 0x85, 0x46, 0xfd, 0xd2, 0x93, 0x52, 0x2a, 0x4a, 0x79, + 0xe2, 0x82, 0x94, 0x46, 0x53, 0x90, 0xa5, 0x94, 0x95, 0xad, 0xad, 0x75, 0x29, 0xe3, 0x63, 0x36, + 0x77, 0xe4, 0xb5, 0xcd, 0x55, 0x29, 0xeb, 0x63, 0xae, 0xca, 0x5b, 0xbb, 0xdb, 0x12, 0xf8, 0x08, + 0x1b, 0x8d, 0x66, 0xb3, 0xba, 0xda, 0x90, 0x72, 0x3e, 0xc7, 0xca, 0x8b, 0x3b, 0x8d, 0xa6, 0x94, + 0x8f, 0xa8, 0xf5, 0xc4, 0x05, 0x69, 0xca, 0x6f, 0xa2, 0xb1, 0xb9, 0xbb, 0x21, 0x15, 0xd0, 0x34, + 0x4c, 0xb1, 0x26, 0x84, 0x12, 0xc5, 0x1e, 0xd2, 0xa5, 0x27, 0x25, 0x29, 0x50, 0x84, 0xa1, 0x4c, + 0x47, 0x08, 0x97, 0x9e, 0x94, 0x50, 0xb9, 0x06, 0x93, 0xd4, 0x0d, 0x11, 0x82, 0xc2, 0x7a, 0x75, + 0xa5, 0xb1, 0xae, 0x6c, 0x6d, 0x93, 0x49, 0x53, 0x5d, 0x97, 0x62, 0x01, 0x4d, 0x6e, 0x7c, 0x68, + 0x77, 0x4d, 0x6e, 0xd4, 0xa5, 0x78, 0x98, 0xb6, 0xdd, 0xa8, 0xee, 0x34, 0xea, 0x52, 0xa2, 0xac, + 0xc1, 0xec, 0xa0, 0x25, 0x70, 0xe0, 0x14, 0x0a, 0xf9, 0x42, 0x7c, 0x88, 0x2f, 0x50, 0xac, 0x5e, + 0x5f, 0x28, 0x7f, 0x3d, 0x0e, 0x33, 0x03, 0xd2, 0x80, 0x81, 0x8d, 0x7c, 0x10, 0x26, 0x99, 0x2f, + 0xb3, 0x50, 0xfc, 0xd0, 0xc0, 0x7c, 0x82, 0x7a, 0x76, 0x5f, 0x72, 0x44, 0xe5, 0xc2, 0x69, 0x63, + 0x62, 0x48, 0xda, 0x48, 0x20, 0xfa, 0x1c, 0xf6, 0x4f, 0xf7, 0x2d, 0xd7, 0x2c, 0xa3, 0xb9, 0x34, + 0x4e, 0x46, 0x43, 0x69, 0x27, 0x5b, 0xb6, 0x27, 0x07, 0x2c, 0xdb, 0x97, 0x61, 0xba, 0x0f, 0x68, + 0xec, 0xe5, 0xf3, 0xc3, 0x31, 0x28, 0x0d, 0x33, 0xce, 0x88, 0x90, 0x18, 0x8f, 0x84, 0xc4, 0xcb, + 0xbd, 0x16, 0xbc, 0x77, 0xf8, 0x20, 0xf4, 0x8d, 0xf5, 0x67, 0x63, 0x70, 0x7a, 0xf0, 0xf6, 0x60, + 0xa0, 0x0e, 0x1f, 0x80, 0x54, 0x07, 0x7b, 0x07, 0x96, 0x48, 0x84, 0x1f, 0x18, 0x90, 0x5e, 0x91, + 0xea, 0xde, 0xc1, 0xe6, 0x52, 0xe1, 0xfc, 0x2c, 0x31, 0x2c, 0xc7, 0x67, 0xda, 0xf4, 0x69, 0xfa, + 0x63, 0x71, 0x38, 0x35, 0x10, 0x7c, 0xa0, 0xa2, 0xf7, 0x00, 0xe8, 0xa6, 0xdd, 0xf5, 0x58, 0xb2, + 0xcb, 0x22, 0x71, 0x96, 0x52, 0x68, 0xf0, 0x22, 0x51, 0xb6, 0xeb, 0xf9, 0xf5, 0x6c, 0x11, 0x05, + 0x46, 0xa2, 0x0c, 0x4f, 0x07, 0x8a, 0x26, 0xa9, 0xa2, 0xf3, 0x43, 0x7a, 0xda, 0xe7, 0x98, 0xe7, + 0x41, 0xd2, 0x0c, 0x1d, 0x9b, 0x9e, 0xe2, 0x7a, 0x0e, 0x56, 0x3b, 0xba, 0xd9, 0x66, 0xeb, 0x6c, + 0x65, 0x72, 0x5f, 0x35, 0x5c, 0x2c, 0x17, 0x59, 0x75, 0x53, 0xd4, 0x12, 0x09, 0xea, 0x40, 0x4e, + 0x48, 0x22, 0x15, 0x91, 0x60, 0xd5, 0xbe, 0x44, 0xf9, 0x27, 0xb3, 0x90, 0x0b, 0x6d, 0xa6, 0xd0, + 0xbd, 0x90, 0x7f, 0x59, 0x3d, 0x54, 0x15, 0xb1, 0x41, 0x66, 0x96, 0xc8, 0x11, 0xda, 0x36, 0xdf, + 0x24, 0x9f, 0x87, 0x59, 0xca, 0x62, 0x75, 0x3d, 0xec, 0x28, 0x9a, 0xa1, 0xba, 0x2e, 0x35, 0x5a, + 0x86, 0xb2, 0x22, 0x52, 0xb7, 0x45, 0xaa, 0x6a, 0xa2, 0x06, 0x5d, 0x84, 0x19, 0x2a, 0xd1, 0xe9, + 0x1a, 0x9e, 0x6e, 0x1b, 0x58, 0x21, 0x5b, 0x76, 0x97, 0x2e, 0x39, 0xbe, 0x66, 0xd3, 0x84, 0x63, + 0x83, 0x33, 0x10, 0x8d, 0x5c, 0x54, 0x87, 0x7b, 0xa8, 0x58, 0x1b, 0x9b, 0xd8, 0x51, 0x3d, 0xac, + 0xe0, 0x1f, 0xee, 0xaa, 0x86, 0xab, 0xa8, 0x66, 0x4b, 0x39, 0x50, 0xdd, 0x83, 0xd2, 0xac, 0x9f, + 0x96, 0x9c, 0x21, 0x8c, 0xab, 0x9c, 0xaf, 0x41, 0xd9, 0xaa, 0x66, 0xeb, 0xaa, 0xea, 0x1e, 0xa0, + 0x0a, 0x9c, 0xa6, 0x28, 0xae, 0xe7, 0xe8, 0x66, 0x5b, 0xd1, 0x0e, 0xb0, 0x76, 0x43, 0xe9, 0x7a, + 0xfb, 0x4f, 0x97, 0xce, 0x86, 0xdb, 0xa7, 0x1a, 0x36, 0x29, 0x4f, 0x8d, 0xb0, 0xec, 0x7a, 0xfb, + 0x4f, 0xa3, 0x26, 0xe4, 0xc9, 0x60, 0x74, 0xf4, 0x57, 0xb0, 0xb2, 0x6f, 0x39, 0x74, 0x0d, 0x2d, + 0x0c, 0x08, 0x4d, 0x21, 0x0b, 0x2e, 0x6d, 0x71, 0x81, 0x0d, 0xab, 0x85, 0x2b, 0x93, 0xcd, 0xed, + 0x46, 0xa3, 0x2e, 0xe7, 0x04, 0xca, 0x15, 0xcb, 0x21, 0x0e, 0xd5, 0xb6, 0x7c, 0x03, 0xe7, 0x98, + 0x43, 0xb5, 0x2d, 0x61, 0xde, 0x8b, 0x30, 0xa3, 0x69, 0xac, 0xcf, 0xba, 0xa6, 0xf0, 0x8d, 0xb5, + 0x5b, 0x92, 0x22, 0xc6, 0xd2, 0xb4, 0x55, 0xc6, 0xc0, 0x7d, 0xdc, 0x45, 0xcf, 0xc0, 0xa9, 0xc0, + 0x58, 0x61, 0xc1, 0xe9, 0xbe, 0x5e, 0xf6, 0x8a, 0x5e, 0x84, 0x19, 0xfb, 0xa8, 0x5f, 0x10, 0x45, + 0x5a, 0xb4, 0x8f, 0x7a, 0xc5, 0x9e, 0x82, 0x59, 0xfb, 0xc0, 0xee, 0x97, 0x7b, 0x38, 0x2c, 0x87, + 0xec, 0x03, 0xbb, 0x57, 0xf0, 0x7e, 0x7a, 0xca, 0xe2, 0x60, 0x8d, 0x66, 0x87, 0x77, 0x85, 0xd9, + 0x43, 0x15, 0x68, 0x09, 0x24, 0x4d, 0x53, 0xb0, 0xa9, 0xee, 0x19, 0x58, 0x51, 0x1d, 0x6c, 0xaa, + 0x6e, 0x69, 0x81, 0x32, 0x27, 0x3d, 0xa7, 0x8b, 0xe5, 0x82, 0xa6, 0x35, 0x68, 0x65, 0x95, 0xd6, + 0xa1, 0x87, 0x61, 0xda, 0xda, 0x7b, 0x59, 0x63, 0x1e, 0xa9, 0xd8, 0x0e, 0xde, 0xd7, 0x6f, 0x95, + 0xde, 0x47, 0xcd, 0x5b, 0x24, 0x15, 0xd4, 0x1f, 0xb7, 0x29, 0x19, 0x3d, 0x04, 0x92, 0xe6, 0x1e, + 0xa8, 0x8e, 0x4d, 0x43, 0xb2, 0x6b, 0xab, 0x1a, 0x2e, 0xdd, 0xcf, 0x58, 0x19, 0x7d, 0x53, 0x90, + 0xc9, 0x8c, 0x70, 0x6f, 0xea, 0xfb, 0x9e, 0x40, 0x7c, 0x90, 0xcd, 0x08, 0x4a, 0xe3, 0x68, 0xe7, + 0x40, 0x22, 0x96, 0x88, 0x34, 0x7c, 0x8e, 0xb2, 0x15, 0xec, 0x03, 0x3b, 0xdc, 0xee, 0x7d, 0x30, + 0x45, 0x38, 0x83, 0x46, 0x1f, 0x62, 0x89, 0x9b, 0x7d, 0x10, 0x6a, 0xf1, 0x49, 0x38, 0x4d, 0x98, + 0x3a, 0xd8, 0x53, 0x5b, 0xaa, 0xa7, 0x86, 0xb8, 0x1f, 0xa5, 0xdc, 0xc4, 0xec, 0x1b, 0xbc, 0x32, + 0xa2, 0xa7, 0xd3, 0xdd, 0x3b, 0xf2, 0x1d, 0xeb, 0x31, 0xa6, 0x27, 0xa1, 0x09, 0xd7, 0x7a, 0xcf, + 0x76, 0x53, 0xe5, 0x0a, 0xe4, 0xc3, 0x7e, 0x8f, 0xb2, 0xc0, 0x3c, 0x5f, 0x8a, 0x91, 0x24, 0xa8, + 0xb6, 0x55, 0x27, 0xe9, 0xcb, 0x4b, 0x0d, 0x29, 0x4e, 0xd2, 0xa8, 0xf5, 0xb5, 0x9d, 0x86, 0x22, + 0xef, 0x6e, 0xee, 0xac, 0x6d, 0x34, 0xa4, 0x44, 0x28, 0xb1, 0xbf, 0x96, 0xcc, 0x3c, 0x20, 0x3d, + 0x58, 0xfe, 0xb5, 0x04, 0x14, 0xa2, 0x7b, 0x6b, 0xf4, 0x7e, 0xb8, 0x4b, 0x1c, 0x91, 0xb9, 0xd8, + 0x53, 0x6e, 0xea, 0x0e, 0x9d, 0x90, 0x1d, 0x95, 0x2d, 0x8e, 0xbe, 0xff, 0xcc, 0x72, 0xae, 0x26, + 0xf6, 0x9e, 0xd7, 0x1d, 0x32, 0xdd, 0x3a, 0xaa, 0x87, 0xd6, 0x61, 0xc1, 0xb4, 0x14, 0xd7, 0x53, + 0xcd, 0x96, 0xea, 0xb4, 0x94, 0xe0, 0x70, 0x52, 0x51, 0x35, 0x0d, 0xbb, 0xae, 0xc5, 0x16, 0x42, + 0x1f, 0xe5, 0x6e, 0xd3, 0x6a, 0x72, 0xe6, 0x60, 0x85, 0xa8, 0x72, 0xd6, 0x1e, 0xf7, 0x4d, 0x0c, + 0x73, 0xdf, 0xb3, 0x90, 0xed, 0xa8, 0xb6, 0x82, 0x4d, 0xcf, 0x39, 0xa2, 0xf9, 0x79, 0x46, 0xce, + 0x74, 0x54, 0xbb, 0x41, 0xca, 0xe8, 0x3a, 0x3c, 0x10, 0xb0, 0x2a, 0x06, 0x6e, 0xab, 0xda, 0x91, + 0x42, 0x93, 0x71, 0x7a, 0xd0, 0xa3, 0x68, 0x96, 0xb9, 0x6f, 0xe8, 0x9a, 0xe7, 0xd2, 0xf8, 0xc0, + 0x62, 0x5c, 0x39, 0x90, 0x58, 0xa7, 0x02, 0xd7, 0x5c, 0xcb, 0xa4, 0x39, 0x78, 0x4d, 0x70, 0xbf, + 0x77, 0x23, 0x1c, 0x1d, 0xa5, 0xa4, 0x34, 0x79, 0x2d, 0x99, 0x99, 0x94, 0x52, 0xd7, 0x92, 0x99, + 0x94, 0x94, 0xbe, 0x96, 0xcc, 0x64, 0xa4, 0xec, 0xb5, 0x64, 0x26, 0x2b, 0x41, 0xf9, 0x47, 0xb3, + 0x90, 0x0f, 0xef, 0x0c, 0xc8, 0x46, 0x4b, 0xa3, 0x6b, 0x63, 0x8c, 0x46, 0xcf, 0xfb, 0x8e, 0xdd, + 0x47, 0x2c, 0xd5, 0xc8, 0xa2, 0x59, 0x49, 0xb1, 0x34, 0x5c, 0x66, 0x92, 0x24, 0x61, 0x21, 0x6e, + 0x8d, 0x59, 0xda, 0x93, 0x91, 0x79, 0x09, 0xad, 0x42, 0xea, 0x65, 0x97, 0x62, 0xa7, 0x28, 0xf6, + 0xfb, 0x8e, 0xc7, 0xbe, 0xd6, 0xa4, 0xe0, 0xd9, 0x6b, 0x4d, 0x65, 0x73, 0x4b, 0xde, 0xa8, 0xae, + 0xcb, 0x5c, 0x1c, 0x9d, 0x81, 0xa4, 0xa1, 0xbe, 0x72, 0x14, 0x5d, 0x5e, 0x29, 0x09, 0x2d, 0x41, + 0xb1, 0x6b, 0xb2, 0x5d, 0x37, 0x19, 0x2a, 0xc2, 0x55, 0x0c, 0x73, 0x15, 0x82, 0xda, 0x75, 0xc2, + 0x3f, 0xa6, 0x7b, 0x9c, 0x81, 0xe4, 0x4d, 0xac, 0xde, 0x88, 0x2e, 0x82, 0x94, 0x84, 0xce, 0x41, + 0xbe, 0x85, 0xf7, 0xba, 0x6d, 0xc5, 0xc1, 0x2d, 0x55, 0xf3, 0xa2, 0xa1, 0x3f, 0x47, 0xab, 0x64, + 0x5a, 0x83, 0x9e, 0x83, 0x2c, 0x19, 0x23, 0x93, 0x8e, 0xf1, 0x34, 0x35, 0xc1, 0x63, 0xc7, 0x9b, + 0x80, 0x0f, 0xb1, 0x10, 0x92, 0x03, 0x79, 0x74, 0x0d, 0x52, 0x9e, 0xea, 0xb4, 0xb1, 0x47, 0x23, + 0x7f, 0x61, 0xc0, 0x71, 0xd5, 0x00, 0xa4, 0x1d, 0x2a, 0x41, 0xcc, 0x4a, 0x7d, 0x94, 0x23, 0xa0, + 0xab, 0x90, 0x66, 0xbf, 0xdc, 0xd2, 0xcc, 0x62, 0xe2, 0xe4, 0x60, 0xb2, 0x10, 0x7f, 0x0f, 0x63, + 0xd6, 0x32, 0x4c, 0x52, 0x67, 0x43, 0x00, 0xdc, 0xdd, 0xa4, 0x09, 0x94, 0x81, 0x64, 0x6d, 0x4b, + 0x26, 0x71, 0x4b, 0x82, 0x3c, 0xa3, 0x2a, 0xdb, 0x6b, 0x8d, 0x5a, 0x43, 0x8a, 0x97, 0x2f, 0x42, + 0x8a, 0x79, 0x10, 0x89, 0x69, 0xbe, 0x0f, 0x49, 0x13, 0xbc, 0xc8, 0x31, 0x62, 0xa2, 0x76, 0x77, + 0x63, 0xa5, 0x21, 0x4b, 0xf1, 0xf2, 0x2e, 0x14, 0x7b, 0xac, 0x8e, 0x4e, 0xc1, 0xb4, 0xdc, 0xd8, + 0x69, 0x6c, 0x92, 0x5d, 0x9b, 0xb2, 0xbb, 0xf9, 0xdc, 0xe6, 0xd6, 0xf3, 0x9b, 0xd2, 0x44, 0x94, + 0x2c, 0x02, 0x64, 0x0c, 0xcd, 0x82, 0x14, 0x90, 0x9b, 0x5b, 0xbb, 0x32, 0xd5, 0xe6, 0xc7, 0xe3, + 0x20, 0xf5, 0x9a, 0x0d, 0xdd, 0x05, 0x33, 0x3b, 0x55, 0x79, 0xb5, 0xb1, 0xa3, 0xb0, 0x9d, 0xa8, + 0x0f, 0x3d, 0x0b, 0x52, 0xb8, 0xe2, 0xca, 0x1a, 0xdd, 0x68, 0x2f, 0xc0, 0xd9, 0x30, 0xb5, 0xf1, + 0xc2, 0x4e, 0x63, 0xb3, 0x49, 0x1b, 0xaf, 0x6e, 0xae, 0x92, 0x68, 0xdd, 0x83, 0x27, 0xf6, 0xbe, + 0x09, 0xa2, 0x6a, 0x14, 0xaf, 0xb1, 0x5e, 0x97, 0x92, 0xbd, 0xe4, 0xad, 0xcd, 0xc6, 0xd6, 0x15, + 0x69, 0xb2, 0xb7, 0x75, 0xba, 0x1f, 0x4e, 0xa1, 0x39, 0x38, 0xdd, 0x4b, 0x55, 0x1a, 0x9b, 0x3b, + 0xf2, 0x8b, 0x52, 0xba, 0xb7, 0xe1, 0x66, 0x43, 0xbe, 0xbe, 0x56, 0x6b, 0x48, 0x19, 0x74, 0x1a, + 0x50, 0x54, 0xa3, 0x9d, 0xab, 0x5b, 0x75, 0x29, 0xdb, 0x17, 0x9f, 0xca, 0x2e, 0xe4, 0xc3, 0x9b, + 0xd2, 0xef, 0x49, 0x68, 0x2c, 0x7f, 0x2c, 0x0e, 0xb9, 0xd0, 0x26, 0x93, 0xec, 0x0e, 0x54, 0xc3, + 0xb0, 0x6e, 0x2a, 0xaa, 0xa1, 0xab, 0x2e, 0x8f, 0x5e, 0x40, 0x49, 0x55, 0x42, 0x19, 0x37, 0x5a, + 0x8c, 0xbf, 0x5e, 0xa4, 0xbe, 0x1f, 0xd7, 0x8b, 0x49, 0x29, 0x55, 0xfe, 0x54, 0x0c, 0xa4, 0xde, + 0xdd, 0x63, 0x4f, 0xf7, 0x63, 0xc3, 0xba, 0xff, 0x3d, 0x19, 0xbb, 0x4f, 0xc6, 0xa0, 0x10, 0xdd, + 0x32, 0xf6, 0xa8, 0x77, 0xef, 0x9f, 0xa8, 0x7a, 0xbf, 0x1d, 0x87, 0xa9, 0xc8, 0x46, 0x71, 0x5c, + 0xed, 0x7e, 0x18, 0xa6, 0xf5, 0x16, 0xee, 0xd8, 0x96, 0x87, 0x4d, 0xed, 0x48, 0x31, 0xf0, 0x21, + 0x36, 0x4a, 0x65, 0x1a, 0xe2, 0x97, 0x8f, 0xdf, 0x8a, 0x2e, 0xad, 0x05, 0x72, 0xeb, 0x44, 0xac, + 0x32, 0xb3, 0x56, 0x6f, 0x6c, 0x6c, 0x6f, 0xed, 0x34, 0x36, 0x6b, 0x2f, 0x8a, 0xe8, 0x22, 0x4b, + 0x7a, 0x0f, 0xdb, 0x7b, 0x18, 0xb4, 0xb7, 0x41, 0xea, 0x55, 0x8a, 0xc4, 0x8a, 0x01, 0x6a, 0x49, + 0x13, 0x68, 0x06, 0x8a, 0x9b, 0x5b, 0x4a, 0x73, 0xad, 0xde, 0x50, 0x1a, 0x57, 0xae, 0x34, 0x6a, + 0x3b, 0x4d, 0x76, 0xb8, 0xe8, 0x73, 0xef, 0x48, 0xf1, 0xb0, 0x89, 0x3f, 0x9e, 0x80, 0x99, 0x01, + 0x9a, 0xa0, 0x2a, 0x3f, 0x16, 0x60, 0x27, 0x15, 0x8f, 0x8d, 0xa3, 0xfd, 0x12, 0x49, 0xcc, 0xb7, + 0x55, 0xc7, 0xe3, 0xa7, 0x08, 0x0f, 0x01, 0xb1, 0x92, 0xe9, 0x91, 0x3c, 0xc1, 0xe1, 0x87, 0xb6, + 0xec, 0xac, 0xa0, 0x18, 0xd0, 0xd9, 0xb9, 0xed, 0xa3, 0x80, 0x6c, 0xcb, 0xd5, 0x3d, 0xfd, 0x10, + 0x2b, 0xba, 0x29, 0x4e, 0x78, 0x93, 0x8b, 0xb1, 0x73, 0x49, 0x59, 0x12, 0x35, 0x6b, 0xa6, 0xe7, + 0x73, 0x9b, 0xb8, 0xad, 0xf6, 0x70, 0x93, 0x3c, 0x26, 0x21, 0x4b, 0xa2, 0xc6, 0xe7, 0xbe, 0x17, + 0xf2, 0x2d, 0xab, 0x4b, 0x36, 0x54, 0x8c, 0x8f, 0x44, 0x8b, 0x98, 0x9c, 0x63, 0x34, 0x9f, 0x85, + 0x6f, 0x95, 0x83, 0xa3, 0xe5, 0xbc, 0x9c, 0x63, 0x34, 0xc6, 0xf2, 0x20, 0x14, 0xd5, 0x76, 0xdb, + 0x21, 0xe0, 0x02, 0x88, 0x6d, 0xfe, 0x0b, 0x3e, 0x99, 0x32, 0xce, 0x5d, 0x83, 0x8c, 0xb0, 0x03, + 0xc9, 0x87, 0x89, 0x25, 0x14, 0x9b, 0x9d, 0x68, 0xc5, 0xcf, 0x65, 0xe5, 0x8c, 0x29, 0x2a, 0xef, + 0x85, 0xbc, 0xee, 0x2a, 0xc1, 0xb3, 0xcd, 0xf8, 0x62, 0xfc, 0x5c, 0x46, 0xce, 0xe9, 0xae, 0xff, + 0x8c, 0xa4, 0xfc, 0xd9, 0x38, 0x14, 0xa2, 0x4f, 0x6d, 0x51, 0x1d, 0x32, 0x86, 0xc5, 0x1f, 0xb2, + 0xb0, 0x2b, 0x03, 0xe7, 0x46, 0x3c, 0xe8, 0x5d, 0x5a, 0xe7, 0xfc, 0xb2, 0x2f, 0x39, 0xf7, 0x6f, + 0x63, 0x90, 0x11, 0x64, 0x74, 0x1a, 0x92, 0xb6, 0xea, 0x1d, 0x50, 0xb8, 0xc9, 0x95, 0xb8, 0x14, + 0x93, 0x69, 0x99, 0xd0, 0x5d, 0x5b, 0x65, 0xcf, 0x89, 0x38, 0x9d, 0x94, 0xc9, 0xb8, 0x1a, 0x58, + 0x6d, 0xd1, 0x93, 0x05, 0xab, 0xd3, 0xc1, 0xa6, 0xe7, 0x8a, 0x71, 0xe5, 0xf4, 0x1a, 0x27, 0xa3, + 0x47, 0x60, 0xda, 0x73, 0x54, 0xdd, 0x88, 0xf0, 0x26, 0x29, 0xaf, 0x24, 0x2a, 0x7c, 0xe6, 0x0a, + 0x9c, 0x11, 0xb8, 0x2d, 0xec, 0xa9, 0xda, 0x01, 0x6e, 0x05, 0x42, 0x29, 0x7a, 0x82, 0x78, 0x17, + 0x67, 0xa8, 0xf3, 0x7a, 0x21, 0x5b, 0xfe, 0x4a, 0x1c, 0xa6, 0xc5, 0x59, 0x48, 0xcb, 0x37, 0xd6, + 0x06, 0x80, 0x6a, 0x9a, 0x96, 0x17, 0x36, 0x57, 0xbf, 0x2b, 0xf7, 0xc9, 0x2d, 0x55, 0x7d, 0x21, + 0x39, 0x04, 0x30, 0xf7, 0x7b, 0x31, 0x80, 0xa0, 0x6a, 0xa8, 0xdd, 0x16, 0x20, 0xc7, 0x9f, 0xc9, + 0xd3, 0x8b, 0x1d, 0xec, 0xf8, 0x0c, 0x18, 0xe9, 0x8a, 0x6e, 0xd0, 0x43, 0xce, 0x3d, 0xdc, 0xd6, + 0x4d, 0xfe, 0x74, 0x86, 0x15, 0xc4, 0x21, 0x67, 0x32, 0x78, 0x3c, 0x29, 0x43, 0xc6, 0xc5, 0x1d, + 0xd5, 0xf4, 0x74, 0x8d, 0x3f, 0x6f, 0xb9, 0x74, 0x22, 0xe5, 0x97, 0x9a, 0x5c, 0x5a, 0xf6, 0x71, + 0xca, 0xe7, 0x20, 0x23, 0xa8, 0x24, 0xf1, 0xdb, 0xdc, 0xda, 0x6c, 0x48, 0x13, 0x28, 0x0d, 0x89, + 0x66, 0x63, 0x47, 0x8a, 0x91, 0x4d, 0x6c, 0x75, 0x7d, 0xad, 0xda, 0x94, 0xe2, 0x2b, 0x7f, 0x1e, + 0x66, 0x34, 0xab, 0xd3, 0xdb, 0xe0, 0x8a, 0xd4, 0x73, 0x80, 0xe8, 0x5e, 0x8d, 0xbd, 0xf4, 0x18, + 0x67, 0x6a, 0x5b, 0x86, 0x6a, 0xb6, 0x97, 0x2c, 0xa7, 0x1d, 0x5c, 0x8b, 0x21, 0x7b, 0x0d, 0x37, + 0x74, 0x39, 0xc6, 0xde, 0xfb, 0xdf, 0xb1, 0xd8, 0xcf, 0xc6, 0x13, 0xab, 0xdb, 0x2b, 0xbf, 0x10, + 0x9f, 0x5b, 0x65, 0x82, 0xdb, 0xa2, 0x3b, 0x32, 0xde, 0x37, 0xb0, 0x46, 0x94, 0x87, 0xdf, 0x7f, + 0x04, 0x66, 0xdb, 0x56, 0xdb, 0xa2, 0x48, 0xcb, 0xe4, 0x17, 0xbf, 0x57, 0x93, 0xf5, 0xa9, 0x73, + 0x23, 0x2f, 0xe1, 0x54, 0x36, 0x61, 0x86, 0x33, 0x2b, 0xf4, 0xf1, 0x3d, 0x3b, 0xaa, 0x40, 0xc7, + 0x9e, 0x93, 0x97, 0xbe, 0xf0, 0x3b, 0x34, 0x2b, 0x91, 0xa7, 0xb9, 0x28, 0xa9, 0x63, 0xa7, 0x19, + 0x15, 0x19, 0x4e, 0x45, 0xf0, 0x58, 0x8c, 0xc0, 0xce, 0x08, 0xc4, 0x7f, 0xc1, 0x11, 0x67, 0x42, + 0x88, 0x4d, 0x2e, 0x5a, 0xa9, 0xc1, 0xd4, 0x49, 0xb0, 0xfe, 0x25, 0xc7, 0xca, 0xe3, 0x30, 0xc8, + 0x2a, 0x14, 0x29, 0x88, 0xd6, 0x75, 0x3d, 0xab, 0x43, 0x03, 0xf0, 0xf1, 0x30, 0xff, 0xea, 0x77, + 0xd8, 0xa4, 0x2d, 0x10, 0xb1, 0x9a, 0x2f, 0x55, 0xa9, 0x00, 0xbd, 0xb1, 0xd0, 0xc2, 0x9a, 0x31, + 0x02, 0xe1, 0xcb, 0x5c, 0x11, 0x9f, 0xbf, 0x72, 0x1d, 0x66, 0xc9, 0x6f, 0x1a, 0x1f, 0xc3, 0x9a, + 0x8c, 0x3e, 0x54, 0x2f, 0xfd, 0xbb, 0x0f, 0xb3, 0xb8, 0x30, 0xe3, 0x03, 0x84, 0x74, 0x0a, 0x8d, + 0x62, 0x1b, 0x7b, 0x1e, 0x76, 0x5c, 0x45, 0x35, 0x06, 0xa9, 0x17, 0x3a, 0x95, 0x2c, 0xfd, 0xcc, + 0xb7, 0xa2, 0xa3, 0xb8, 0xca, 0x24, 0xab, 0x86, 0x51, 0xd9, 0x85, 0xbb, 0x06, 0x78, 0xc5, 0x18, + 0x98, 0x1f, 0xe7, 0x98, 0xb3, 0x7d, 0x9e, 0x41, 0x60, 0xb7, 0x41, 0xd0, 0xfd, 0xb1, 0x1c, 0x03, + 0xf3, 0x13, 0x1c, 0x13, 0x71, 0x59, 0x31, 0xa4, 0x04, 0xf1, 0x1a, 0x4c, 0x1f, 0x62, 0x67, 0xcf, + 0x72, 0xf9, 0x49, 0xf0, 0x18, 0x70, 0x9f, 0xe4, 0x70, 0x45, 0x2e, 0x48, 0x8f, 0x86, 0x09, 0xd6, + 0x33, 0x90, 0xd9, 0x57, 0x35, 0x3c, 0x06, 0xc4, 0x6d, 0x0e, 0x91, 0x26, 0xfc, 0x44, 0xb4, 0x0a, + 0xf9, 0xb6, 0xc5, 0x97, 0xc8, 0xd1, 0xe2, 0x9f, 0xe2, 0xe2, 0x39, 0x21, 0xc3, 0x21, 0x6c, 0xcb, + 0xee, 0x1a, 0x64, 0xfd, 0x1c, 0x0d, 0xf1, 0xb7, 0x04, 0x84, 0x90, 0xe1, 0x10, 0x27, 0x30, 0xeb, + 0xeb, 0x02, 0xc2, 0x0d, 0xd9, 0xf3, 0x83, 0x90, 0xb3, 0x4c, 0xe3, 0xc8, 0x32, 0xc7, 0x51, 0xe2, + 0xd3, 0x1c, 0x01, 0xb8, 0x08, 0x01, 0xb8, 0x0c, 0xd9, 0x71, 0x07, 0xe2, 0x6f, 0x7f, 0x4b, 0x4c, + 0x0f, 0x31, 0x02, 0xab, 0x50, 0x14, 0x01, 0x4a, 0xb7, 0xcc, 0x31, 0x20, 0x3e, 0xc3, 0x21, 0x0a, + 0x21, 0x31, 0xde, 0x0d, 0x0f, 0xbb, 0x5e, 0x1b, 0x8f, 0x03, 0xf2, 0x59, 0xd1, 0x0d, 0x2e, 0xc2, + 0x4d, 0xb9, 0x87, 0x4d, 0xed, 0x60, 0x3c, 0x84, 0xcf, 0x09, 0x53, 0x0a, 0x19, 0x02, 0x51, 0x83, + 0xa9, 0x8e, 0xea, 0xb8, 0x07, 0xaa, 0x31, 0xd6, 0x70, 0xfc, 0x1d, 0x8e, 0x91, 0xf7, 0x85, 0xb8, + 0x45, 0xba, 0xe6, 0x49, 0x60, 0x7e, 0x41, 0x58, 0x24, 0x24, 0xc6, 0xa7, 0x9e, 0xeb, 0xd1, 0x63, + 0xf3, 0x93, 0xa0, 0xfd, 0x5d, 0x31, 0xf5, 0x98, 0xec, 0x46, 0x18, 0xf1, 0x32, 0x64, 0x5d, 0xfd, + 0x95, 0xb1, 0x60, 0x3e, 0x2f, 0x46, 0x9a, 0x0a, 0x10, 0xe1, 0x17, 0xe1, 0xcc, 0xc0, 0x65, 0x62, + 0x0c, 0xb0, 0x5f, 0xe4, 0x60, 0xa7, 0x07, 0x2c, 0x15, 0x3c, 0x24, 0x9c, 0x14, 0xf2, 0xef, 0x89, + 0x90, 0x80, 0x7b, 0xb0, 0xb6, 0xc9, 0xa6, 0xc5, 0x55, 0xf7, 0x4f, 0x66, 0xb5, 0xbf, 0x2f, 0xac, + 0xc6, 0x64, 0x23, 0x56, 0xdb, 0x81, 0xd3, 0x1c, 0xf1, 0x64, 0xe3, 0xfa, 0x4b, 0x22, 0xb0, 0x32, + 0xe9, 0xdd, 0xe8, 0xe8, 0xfe, 0x10, 0xcc, 0xf9, 0xe6, 0x14, 0xd9, 0xb1, 0xab, 0x74, 0x54, 0x7b, + 0x0c, 0xe4, 0x2f, 0x70, 0x64, 0x11, 0xf1, 0xfd, 0xf4, 0xda, 0xdd, 0x50, 0x6d, 0x02, 0xfe, 0x02, + 0x94, 0x04, 0x78, 0xd7, 0x74, 0xb0, 0x66, 0xb5, 0x4d, 0xfd, 0x15, 0xdc, 0x1a, 0x03, 0xfa, 0x97, + 0x7b, 0x86, 0x6a, 0x37, 0x24, 0x4e, 0x90, 0xd7, 0x40, 0xf2, 0x73, 0x15, 0x45, 0xef, 0xd8, 0x96, + 0xe3, 0x8d, 0x40, 0xfc, 0xa2, 0x18, 0x29, 0x5f, 0x6e, 0x8d, 0x8a, 0x55, 0x1a, 0xc0, 0xee, 0x92, + 0x8c, 0xeb, 0x92, 0x6f, 0x70, 0xa0, 0xa9, 0x40, 0x8a, 0x07, 0x0e, 0xcd, 0xea, 0xd8, 0xaa, 0x33, + 0x4e, 0xfc, 0xfb, 0x07, 0x22, 0x70, 0x70, 0x11, 0x1e, 0x38, 0x48, 0x46, 0x47, 0x56, 0xfb, 0x31, + 0x10, 0xbe, 0x24, 0x02, 0x87, 0x90, 0xe1, 0x10, 0x22, 0x61, 0x18, 0x03, 0xe2, 0x57, 0x04, 0x84, + 0x90, 0x21, 0x10, 0x1f, 0x0a, 0x16, 0x5a, 0x07, 0xb7, 0x75, 0xd7, 0xe3, 0x97, 0xc1, 0x8e, 0x87, + 0xfa, 0x87, 0xdf, 0x8a, 0x26, 0x61, 0x72, 0x48, 0x94, 0x44, 0x22, 0xfe, 0x20, 0x85, 0x6e, 0xd9, + 0x46, 0x2b, 0xf6, 0xab, 0x22, 0x12, 0x85, 0xc4, 0x88, 0x6e, 0xa1, 0x0c, 0x91, 0x98, 0x5d, 0x23, + 0x1b, 0x95, 0x31, 0xe0, 0xfe, 0x51, 0x8f, 0x72, 0x4d, 0x21, 0x4b, 0x30, 0x43, 0xf9, 0x4f, 0xd7, + 0xbc, 0x81, 0x8f, 0xc6, 0xf2, 0xce, 0x5f, 0xeb, 0xc9, 0x7f, 0x76, 0x99, 0x24, 0x8b, 0x21, 0xc5, + 0x9e, 0x7c, 0x0a, 0x8d, 0xba, 0xeb, 0x59, 0xfa, 0x91, 0xb7, 0x79, 0x7f, 0xa3, 0xe9, 0x54, 0x65, + 0x9d, 0x38, 0x79, 0x34, 0xe9, 0x19, 0x0d, 0xf6, 0xe1, 0xb7, 0x7d, 0x3f, 0x8f, 0xe4, 0x3c, 0x95, + 0x2b, 0x30, 0x15, 0x49, 0x78, 0x46, 0x43, 0xfd, 0x45, 0x0e, 0x95, 0x0f, 0xe7, 0x3b, 0x95, 0x8b, + 0x90, 0x24, 0xc9, 0xcb, 0x68, 0xf1, 0x1f, 0xe5, 0xe2, 0x94, 0xbd, 0xf2, 0x2c, 0x64, 0x44, 0xd2, + 0x32, 0x5a, 0xf4, 0x2f, 0x71, 0x51, 0x5f, 0x84, 0x88, 0x8b, 0x84, 0x65, 0xb4, 0xf8, 0x5f, 0x16, + 0xe2, 0x42, 0x84, 0x88, 0x8f, 0x6f, 0xc2, 0x5f, 0xff, 0x2b, 0x49, 0xbe, 0xe8, 0x08, 0xdb, 0x5d, + 0x86, 0x34, 0xcf, 0x54, 0x46, 0x4b, 0xff, 0x18, 0x6f, 0x5c, 0x48, 0x54, 0x9e, 0x82, 0xc9, 0x31, + 0x0d, 0xfe, 0x57, 0xb9, 0x28, 0xe3, 0xaf, 0xd4, 0x20, 0x17, 0xca, 0x4e, 0x46, 0x8b, 0xff, 0x04, + 0x17, 0x0f, 0x4b, 0x11, 0xd5, 0x79, 0x76, 0x32, 0x1a, 0xe0, 0xaf, 0x09, 0xd5, 0xb9, 0x04, 0x31, + 0x9b, 0x48, 0x4c, 0x46, 0x4b, 0x7f, 0x54, 0x58, 0x5d, 0x88, 0x54, 0x3e, 0x08, 0x59, 0x7f, 0xb1, + 0x19, 0x2d, 0xff, 0x93, 0x5c, 0x3e, 0x90, 0x21, 0x16, 0x08, 0x2d, 0x76, 0xa3, 0x21, 0xfe, 0xba, + 0xb0, 0x40, 0x48, 0x8a, 0x4c, 0xa3, 0xde, 0x04, 0x66, 0x34, 0xd2, 0x4f, 0x89, 0x69, 0xd4, 0x93, + 0xbf, 0x90, 0xd1, 0xa4, 0x31, 0x7f, 0x34, 0xc4, 0xdf, 0x10, 0xa3, 0x49, 0xf9, 0x89, 0x1a, 0xbd, + 0x19, 0xc1, 0x68, 0x8c, 0x9f, 0x16, 0x6a, 0xf4, 0x24, 0x04, 0x95, 0x6d, 0x40, 0xfd, 0xd9, 0xc0, + 0x68, 0xbc, 0x8f, 0x71, 0xbc, 0xe9, 0xbe, 0x64, 0xa0, 0xf2, 0x3c, 0x9c, 0x1e, 0x9c, 0x09, 0x8c, + 0x46, 0xfd, 0x99, 0xb7, 0x7b, 0xf6, 0x6e, 0xe1, 0x44, 0xa0, 0xb2, 0x13, 0x2c, 0x29, 0xe1, 0x2c, + 0x60, 0x34, 0xec, 0xc7, 0xdf, 0x8e, 0x06, 0xee, 0x70, 0x12, 0x50, 0xa9, 0x02, 0x04, 0x0b, 0xf0, + 0x68, 0xac, 0x4f, 0x72, 0xac, 0x90, 0x10, 0x99, 0x1a, 0x7c, 0xfd, 0x1d, 0x2d, 0x7f, 0x5b, 0x4c, + 0x0d, 0x2e, 0x41, 0xa6, 0x86, 0x58, 0x7a, 0x47, 0x4b, 0x7f, 0x4a, 0x4c, 0x0d, 0x21, 0x42, 0x3c, + 0x3b, 0xb4, 0xba, 0x8d, 0x46, 0xf8, 0xb4, 0xf0, 0xec, 0x90, 0x54, 0x65, 0x13, 0xa6, 0xfb, 0x16, + 0xc4, 0xd1, 0x50, 0x3f, 0xcb, 0xa1, 0xa4, 0xde, 0xf5, 0x30, 0xbc, 0x78, 0xf1, 0xc5, 0x70, 0x34, + 0xda, 0xcf, 0xf5, 0x2c, 0x5e, 0x7c, 0x2d, 0xac, 0x5c, 0x86, 0x8c, 0xd9, 0x35, 0x0c, 0x32, 0x79, + 0xd0, 0xf1, 0xb7, 0x7d, 0x4b, 0xff, 0xf5, 0x1d, 0x6e, 0x1d, 0x21, 0x50, 0xb9, 0x08, 0x93, 0xb8, + 0xb3, 0x87, 0x5b, 0xa3, 0x24, 0x7f, 0xf7, 0x1d, 0x11, 0x30, 0x09, 0x77, 0xe5, 0x83, 0x00, 0xec, + 0x68, 0x84, 0x3e, 0x86, 0x1f, 0x21, 0xfb, 0x7b, 0xef, 0xf0, 0xeb, 0x75, 0x81, 0x48, 0x00, 0xc0, + 0x2e, 0xeb, 0x1d, 0x0f, 0xf0, 0xad, 0x28, 0x00, 0x1d, 0x91, 0x67, 0x20, 0xfd, 0xb2, 0x6b, 0x99, + 0x9e, 0xda, 0x1e, 0x25, 0xfd, 0xfb, 0x5c, 0x5a, 0xf0, 0x13, 0x83, 0x75, 0x2c, 0x07, 0x7b, 0x6a, + 0xdb, 0x1d, 0x25, 0xfb, 0xdf, 0xb8, 0xac, 0x2f, 0x40, 0x84, 0x35, 0xd5, 0xf5, 0xc6, 0xe9, 0xf7, + 0x7f, 0x17, 0xc2, 0x42, 0x80, 0x28, 0x4d, 0x7e, 0xdf, 0xc0, 0x47, 0xa3, 0x64, 0xbf, 0x2d, 0x94, + 0xe6, 0xfc, 0x95, 0x67, 0x21, 0x4b, 0x7e, 0xb2, 0x3b, 0xb3, 0x23, 0x84, 0xff, 0x80, 0x0b, 0x07, + 0x12, 0xa4, 0x65, 0xd7, 0x6b, 0x79, 0xfa, 0x68, 0x63, 0x7f, 0x87, 0x8f, 0xb4, 0xe0, 0xaf, 0x54, + 0x21, 0xe7, 0x7a, 0xad, 0x56, 0x97, 0xe7, 0xa7, 0x23, 0xc4, 0xff, 0xc7, 0x3b, 0xfe, 0x91, 0x85, + 0x2f, 0x43, 0x46, 0xfb, 0xe6, 0x0d, 0xcf, 0xb6, 0xe8, 0xf3, 0x96, 0x51, 0x08, 0x6f, 0x73, 0x84, + 0x90, 0x48, 0xa5, 0x06, 0x79, 0xd2, 0x17, 0xf1, 0x2e, 0xc2, 0x28, 0x88, 0x3f, 0xe4, 0x06, 0x88, + 0x08, 0xad, 0xfc, 0x99, 0x2f, 0xbf, 0x35, 0x1f, 0xfb, 0xca, 0x5b, 0xf3, 0xb1, 0xdf, 0x7e, 0x6b, + 0x3e, 0xf6, 0xd1, 0xaf, 0xcf, 0x4f, 0x7c, 0xe5, 0xeb, 0xf3, 0x13, 0xbf, 0xf9, 0xf5, 0xf9, 0x89, + 0xc1, 0xa7, 0xc4, 0xb0, 0x6a, 0xad, 0x5a, 0xec, 0x7c, 0xf8, 0xa5, 0xfb, 0xdb, 0xba, 0x77, 0xd0, + 0xdd, 0x5b, 0xd2, 0xac, 0xce, 0xb2, 0x66, 0xb9, 0x1d, 0xcb, 0x5d, 0x8e, 0x9e, 0xeb, 0xd2, 0x5f, + 0xf0, 0x47, 0x31, 0xb2, 0x67, 0x8e, 0x1e, 0xe7, 0xaa, 0xe6, 0xd1, 0xb0, 0x97, 0x29, 0x2f, 0x41, + 0xa2, 0x6a, 0x1e, 0xa1, 0x33, 0x2c, 0xc0, 0x29, 0x5d, 0xc7, 0xe0, 0x17, 0x37, 0xd3, 0xa4, 0xbc, + 0xeb, 0x18, 0x68, 0x36, 0xb8, 0x5d, 0x1d, 0x3b, 0x97, 0xe7, 0x57, 0xa6, 0x57, 0x7e, 0x22, 0x76, + 0xb2, 0x9e, 0x64, 0xaa, 0xe6, 0x11, 0xed, 0xc8, 0x76, 0xec, 0xa5, 0x47, 0x47, 0x9e, 0x73, 0xdf, + 0x30, 0xad, 0x9b, 0x26, 0x51, 0xdb, 0xde, 0x13, 0x67, 0xdc, 0xf3, 0xbd, 0x67, 0xdc, 0xcf, 0x63, + 0xc3, 0x78, 0x8e, 0xf0, 0xed, 0x10, 0x91, 0xbd, 0x14, 0x7b, 0x47, 0x00, 0x7e, 0x2a, 0x0e, 0xf3, + 0x7d, 0xc7, 0xd9, 0xdc, 0x09, 0x86, 0x19, 0xa1, 0x02, 0x99, 0xba, 0xf0, 0xad, 0x12, 0xa4, 0x5d, + 0xac, 0x59, 0x66, 0xcb, 0xa5, 0x86, 0x48, 0xc8, 0xa2, 0x48, 0x0c, 0x61, 0xaa, 0xa6, 0xe5, 0xf2, + 0xab, 0xcf, 0xac, 0xb0, 0xf2, 0x89, 0x13, 0x1a, 0x62, 0x4a, 0xb4, 0x24, 0xac, 0xf1, 0xf8, 0x98, + 0xd6, 0x10, 0x9d, 0x88, 0x9c, 0xfc, 0x8f, 0x6b, 0x95, 0x9f, 0x8e, 0xc3, 0x42, 0xaf, 0x55, 0xc8, + 0xcc, 0x72, 0x3d, 0xb5, 0x63, 0x0f, 0x33, 0xcb, 0x65, 0xc8, 0xee, 0x08, 0x9e, 0x13, 0xdb, 0xe5, + 0xf6, 0x09, 0xed, 0x52, 0xf0, 0x9b, 0x12, 0x86, 0xb9, 0x30, 0xa6, 0x61, 0xfc, 0x7e, 0xbc, 0x2b, + 0xcb, 0xfc, 0x9f, 0x14, 0x9c, 0x61, 0xd3, 0x49, 0x61, 0x53, 0x89, 0x15, 0xb8, 0x4d, 0xf2, 0xe1, + 0xaa, 0xd1, 0xcf, 0x49, 0xca, 0xcf, 0xc1, 0xcc, 0x1a, 0x89, 0x16, 0x64, 0x17, 0x14, 0x3c, 0xe1, + 0x19, 0x78, 0x3b, 0x7c, 0x31, 0x92, 0xf0, 0xf3, 0xe7, 0x5b, 0x61, 0x52, 0xf9, 0x47, 0x62, 0x20, + 0x35, 0x35, 0xd5, 0x50, 0x9d, 0xef, 0x16, 0x0a, 0x3d, 0x05, 0xc0, 0xae, 0x7b, 0xf8, 0x2f, 0x6e, + 0x16, 0x2e, 0x94, 0x96, 0xc2, 0x9d, 0x5b, 0x62, 0x2d, 0xd1, 0x2b, 0x54, 0x59, 0xca, 0x4b, 0x7e, + 0x3e, 0xfc, 0x02, 0x40, 0x50, 0x81, 0xce, 0xc2, 0x5d, 0xcd, 0x5a, 0x75, 0xbd, 0x2a, 0x8b, 0x4b, + 0x42, 0xcd, 0xed, 0x46, 0x8d, 0xbd, 0x66, 0x35, 0x81, 0x4e, 0x03, 0x0a, 0x57, 0xfa, 0x97, 0x9a, + 0x4e, 0xc1, 0x74, 0x98, 0xce, 0xde, 0x79, 0x89, 0x93, 0x4c, 0x51, 0xef, 0xd8, 0x06, 0xa6, 0x4f, + 0x1e, 0x15, 0x5d, 0x58, 0x6d, 0x74, 0x12, 0xf2, 0xaf, 0xff, 0x3d, 0x7b, 0x0f, 0x62, 0x26, 0x10, + 0xf7, 0x6d, 0x5e, 0x59, 0x87, 0x69, 0x55, 0xd3, 0xb0, 0x1d, 0x81, 0x1c, 0x11, 0xaa, 0x09, 0x20, + 0x7d, 0x96, 0xca, 0x25, 0x03, 0xb4, 0xa7, 0x20, 0xe5, 0xd2, 0xde, 0x8f, 0x82, 0xf8, 0x0d, 0x0e, + 0xc1, 0xd9, 0x2b, 0x26, 0x4c, 0xb3, 0xf7, 0xfa, 0x70, 0x48, 0x8d, 0xe3, 0xcf, 0x19, 0xfe, 0xf1, + 0x17, 0xcf, 0xd3, 0x27, 0xab, 0xf7, 0x46, 0x87, 0x65, 0x80, 0x3b, 0xc9, 0x12, 0xc7, 0x0e, 0x14, + 0xc5, 0x50, 0x10, 0xed, 0x71, 0x85, 0x8f, 0x6f, 0xec, 0x9f, 0xf0, 0xc6, 0xe6, 0x07, 0xf9, 0x40, + 0xa8, 0xa5, 0x29, 0x8e, 0xca, 0x2a, 0x56, 0x1a, 0xc3, 0xe6, 0xf4, 0x4b, 0x8f, 0xf4, 0xaf, 0x4e, + 0xec, 0xdf, 0x63, 0x14, 0xf9, 0x72, 0xb8, 0x19, 0x7f, 0xee, 0x7d, 0x22, 0x09, 0xd3, 0x6a, 0x47, + 0x37, 0xad, 0x65, 0xfa, 0x97, 0xcf, 0xb9, 0x49, 0x5a, 0x18, 0xe3, 0xa1, 0xe4, 0x25, 0x36, 0x15, + 0x46, 0x7b, 0xcc, 0x1f, 0xfc, 0xf8, 0x67, 0x26, 0x83, 0xe9, 0x52, 0xd9, 0x00, 0x49, 0x5c, 0x09, + 0xc6, 0xa6, 0x66, 0xb5, 0xc6, 0x3a, 0xa5, 0xf8, 0x8e, 0xc0, 0x10, 0xe7, 0x5b, 0x0d, 0x2e, 0x5a, + 0x79, 0x3f, 0x64, 0x7c, 0x98, 0x51, 0x99, 0x89, 0x00, 0xf1, 0x25, 0x48, 0x5e, 0xc2, 0x66, 0xe6, + 0x38, 0x59, 0xe8, 0xdb, 0x42, 0x9e, 0xcd, 0xd0, 0x4d, 0xd2, 0x9b, 0x55, 0x28, 0xb4, 0x2c, 0xd3, + 0x53, 0xac, 0x8e, 0xee, 0xe1, 0x8e, 0xed, 0x8d, 0xcc, 0xeb, 0xfe, 0x90, 0x81, 0x64, 0xe4, 0x29, + 0x22, 0xb7, 0x25, 0xc4, 0x88, 0x26, 0xec, 0xad, 0xbf, 0x71, 0x34, 0xf9, 0x9f, 0xbe, 0x26, 0x54, + 0x86, 0x68, 0xf2, 0xae, 0xbc, 0xc3, 0x6d, 0xdd, 0xe0, 0xc1, 0xdc, 0xbb, 0xc5, 0xbc, 0xc0, 0xf7, + 0x8e, 0xcf, 0x26, 0x60, 0x9e, 0x33, 0xef, 0xa9, 0x2e, 0x5e, 0x3e, 0x7c, 0x7c, 0x0f, 0x7b, 0xea, + 0xe3, 0xcb, 0x9a, 0xa5, 0x8b, 0x95, 0x7c, 0x86, 0x07, 0x6b, 0x52, 0xbf, 0xc4, 0xeb, 0xe7, 0x06, + 0x3e, 0xee, 0x9e, 0x1b, 0x1e, 0xe4, 0xe7, 0xfa, 0x7d, 0xb0, 0x6c, 0x40, 0xb2, 0x66, 0xe9, 0x26, + 0x59, 0xdb, 0x5a, 0xd8, 0xb4, 0x3a, 0x3c, 0xdc, 0xb2, 0x02, 0xba, 0x0a, 0x29, 0xb5, 0x63, 0x75, + 0x4d, 0x8f, 0x85, 0xda, 0x95, 0xf3, 0x5f, 0x7e, 0x73, 0x61, 0xe2, 0x3f, 0xbe, 0xb9, 0x70, 0x8a, + 0xc1, 0xba, 0xad, 0x1b, 0x4b, 0xba, 0xb5, 0xdc, 0x51, 0xbd, 0x03, 0x32, 0x7d, 0xbf, 0xfa, 0xc6, + 0x63, 0xc0, 0xdb, 0x5b, 0x33, 0xbd, 0xcf, 0x7d, 0xe3, 0x97, 0x1e, 0x8e, 0xc9, 0x5c, 0xbe, 0x92, + 0xfc, 0xe6, 0xeb, 0x0b, 0xb1, 0xb2, 0x0d, 0xe9, 0x3a, 0xd6, 0x8e, 0x69, 0x70, 0xad, 0xa7, 0xc1, + 0xc7, 0x79, 0x83, 0x67, 0xfb, 0x1b, 0x64, 0x17, 0xf6, 0xea, 0x58, 0x0b, 0x35, 0x5b, 0xc7, 0x5a, + 0xb4, 0xc5, 0x95, 0xfa, 0x6f, 0x7e, 0x6d, 0x7e, 0xe2, 0xd5, 0xb7, 0xe6, 0x27, 0x86, 0x0e, 0x59, + 0x79, 0xf4, 0x90, 0xf9, 0x23, 0xf5, 0x99, 0x24, 0xdc, 0x43, 0xdf, 0x2f, 0x75, 0x3a, 0xba, 0xe9, + 0x2d, 0x6b, 0xce, 0x91, 0xed, 0x59, 0x64, 0xe2, 0x5a, 0xfb, 0x7c, 0xa0, 0xa6, 0x83, 0xea, 0x25, + 0x56, 0x3d, 0x78, 0x98, 0xca, 0xfb, 0x30, 0xb9, 0x4d, 0xe4, 0x88, 0x21, 0x3c, 0xcb, 0x53, 0x0d, + 0x9e, 0x6d, 0xb0, 0x02, 0xa1, 0xb2, 0x77, 0x52, 0xe3, 0x8c, 0xaa, 0x8b, 0xd7, 0x51, 0x0d, 0xac, + 0xee, 0xb3, 0x57, 0x7b, 0x12, 0x34, 0x4d, 0xcd, 0x10, 0x02, 0x7d, 0x8b, 0x67, 0x16, 0x26, 0xd5, + 0x2e, 0xbb, 0x30, 0x93, 0x20, 0xf9, 0x2b, 0x2d, 0x94, 0x9f, 0x83, 0x34, 0x7f, 0x6e, 0x8e, 0x24, + 0x48, 0xdc, 0xc0, 0x47, 0xb4, 0x9d, 0xbc, 0x4c, 0x7e, 0xa2, 0x25, 0x98, 0xa4, 0xca, 0xf3, 0x77, + 0x16, 0x4b, 0x4b, 0x7d, 0xda, 0x2f, 0x51, 0x25, 0x65, 0xc6, 0x56, 0xbe, 0x06, 0x99, 0xba, 0x45, + 0xbc, 0x27, 0x8a, 0x96, 0x65, 0x68, 0x54, 0x67, 0xbb, 0xcb, 0xc7, 0x4e, 0x66, 0x05, 0x74, 0x1a, + 0x52, 0xec, 0x55, 0x2f, 0x7e, 0xe9, 0x87, 0x97, 0xca, 0x35, 0x48, 0x53, 0xec, 0x2d, 0xdb, 0x7f, + 0xbd, 0x3a, 0x16, 0x7a, 0xbd, 0x9a, 0xc3, 0xc7, 0x03, 0x65, 0x11, 0x24, 0x5b, 0xaa, 0xa7, 0xf2, + 0x7e, 0xd3, 0xdf, 0xe5, 0x0f, 0x40, 0x86, 0x83, 0xb8, 0xe8, 0x02, 0x24, 0x2c, 0xdb, 0xe5, 0xd7, + 0x76, 0xe6, 0x86, 0x75, 0x65, 0xcb, 0x5e, 0x49, 0x12, 0xa7, 0x92, 0x09, 0xf3, 0xca, 0xe6, 0x50, + 0xb7, 0x78, 0x32, 0xe2, 0x16, 0x1d, 0xec, 0xed, 0xed, 0x7b, 0xc1, 0x0f, 0x36, 0x9c, 0x7d, 0xae, + 0xe0, 0x3b, 0xca, 0xed, 0x38, 0xcc, 0x87, 0x6a, 0x0f, 0xb1, 0xe3, 0xea, 0x96, 0xc9, 0xbc, 0x89, + 0x7b, 0x0a, 0x0a, 0x29, 0xc8, 0xeb, 0x87, 0xb8, 0xca, 0xb3, 0x90, 0xa8, 0xda, 0x36, 0x9a, 0x83, + 0x0c, 0x2d, 0x6b, 0x16, 0xf3, 0x95, 0xa4, 0xec, 0x97, 0x49, 0x9d, 0x6b, 0xed, 0x7b, 0x37, 0x55, + 0xc7, 0x7f, 0x13, 0x5a, 0x94, 0xcb, 0xcf, 0x40, 0xb6, 0x66, 0x99, 0x2e, 0x36, 0xdd, 0x2e, 0xcd, + 0x61, 0xf7, 0x0c, 0x4b, 0xbb, 0xc1, 0x11, 0x58, 0x81, 0x18, 0x5b, 0xb5, 0x6d, 0x2a, 0x99, 0x94, + 0xc9, 0x4f, 0x3e, 0x7b, 0xb6, 0x86, 0x9a, 0xe7, 0xe2, 0xc9, 0xcc, 0xc3, 0x3b, 0x18, 0x24, 0xa3, + 0x31, 0xb8, 0xbb, 0x7f, 0x22, 0xdd, 0xc0, 0x47, 0xee, 0x49, 0xe7, 0xd1, 0x0b, 0x90, 0xdd, 0xa6, + 0x9f, 0x95, 0x79, 0x0e, 0x1f, 0xa1, 0x39, 0x48, 0xe3, 0xd6, 0x85, 0x8b, 0x17, 0x1f, 0x7f, 0x86, + 0x79, 0xf9, 0xd5, 0x09, 0x59, 0x10, 0xd0, 0x3c, 0x64, 0x5d, 0xac, 0xd9, 0x17, 0x2e, 0x5e, 0xba, + 0xf1, 0x38, 0x73, 0xab, 0xab, 0x13, 0x72, 0x40, 0xaa, 0x64, 0x48, 0x8f, 0xbf, 0xf9, 0xe9, 0x85, + 0xd8, 0xca, 0x24, 0x24, 0xdc, 0x6e, 0xe7, 0x3d, 0xf3, 0x8d, 0x6f, 0xa7, 0x60, 0x31, 0x54, 0xcb, + 0x16, 0x85, 0x43, 0xd5, 0xd0, 0x5b, 0x6a, 0xf0, 0x31, 0x20, 0x29, 0xd4, 0x7f, 0xca, 0x31, 0x24, + 0xda, 0x1f, 0x6b, 0xc5, 0xf2, 0x2f, 0xc7, 0x20, 0x7f, 0x5d, 0x20, 0x37, 0xb1, 0x87, 0x2e, 0x03, + 0xf8, 0x2d, 0x89, 0xa9, 0x72, 0x76, 0xa9, 0xb7, 0xad, 0x25, 0x5f, 0x46, 0x0e, 0xb1, 0xa3, 0xa7, + 0xa8, 0x03, 0xda, 0x96, 0xcb, 0xdf, 0x8a, 0x1d, 0x21, 0xea, 0x33, 0xa3, 0x47, 0x01, 0xd1, 0xa8, + 0xa6, 0x1c, 0x5a, 0x9e, 0x6e, 0xb6, 0x15, 0xdb, 0xba, 0xc9, 0xbf, 0x35, 0x90, 0x90, 0x25, 0x5a, + 0x73, 0x9d, 0x56, 0x6c, 0x13, 0x3a, 0x51, 0x3a, 0xeb, 0xa3, 0x90, 0xed, 0x98, 0xda, 0x6a, 0x39, + 0xd8, 0x75, 0x79, 0xe0, 0x12, 0x45, 0x74, 0x19, 0xd2, 0x76, 0x77, 0x4f, 0x11, 0x51, 0x22, 0x77, + 0xe1, 0xee, 0x41, 0x73, 0x5e, 0xf8, 0x06, 0x9f, 0xf5, 0x29, 0xbb, 0xbb, 0x47, 0x3c, 0xe5, 0x5e, + 0xc8, 0x0f, 0x50, 0x26, 0x77, 0x18, 0xe8, 0x41, 0xbf, 0x64, 0xc4, 0x7b, 0xa0, 0xd8, 0x8e, 0x6e, + 0x39, 0xba, 0x77, 0x44, 0xaf, 0xdb, 0x25, 0x64, 0x49, 0x54, 0x6c, 0x73, 0x7a, 0xf9, 0x06, 0x14, + 0x9b, 0x34, 0x4d, 0x0f, 0x34, 0xbf, 0x18, 0xe8, 0x17, 0x1b, 0xad, 0xdf, 0x50, 0xcd, 0xe2, 0x7d, + 0x9a, 0x3d, 0xfc, 0x1f, 0x62, 0x90, 0x5b, 0x21, 0x13, 0x77, 0xad, 0x7e, 0xc5, 0x50, 0xdb, 0xe8, + 0x71, 0x38, 0xb5, 0xb2, 0xbe, 0x55, 0x7b, 0x4e, 0x59, 0xab, 0x2b, 0x57, 0xd6, 0xab, 0xab, 0xc1, + 0xfd, 0xde, 0xb9, 0xd3, 0xaf, 0xdd, 0x5e, 0x44, 0x21, 0xde, 0x5d, 0x93, 0xee, 0x25, 0xd1, 0x32, + 0xcc, 0x46, 0x45, 0xaa, 0x2b, 0xcd, 0xc6, 0xe6, 0x8e, 0x14, 0x9b, 0x3b, 0xf5, 0xda, 0xed, 0xc5, + 0xe9, 0x90, 0x44, 0x75, 0xcf, 0xc5, 0xa6, 0xd7, 0x2f, 0x50, 0xdb, 0xda, 0xd8, 0x58, 0xdb, 0x91, + 0xe2, 0x7d, 0x02, 0x35, 0xab, 0xd3, 0xd1, 0x3d, 0xf4, 0x10, 0x4c, 0x47, 0x05, 0x36, 0xd7, 0xd6, + 0xa5, 0xc4, 0x1c, 0x7a, 0xed, 0xf6, 0x62, 0x21, 0xc4, 0xbd, 0xa9, 0x1b, 0x73, 0x99, 0x8f, 0xfc, + 0xdc, 0xfc, 0xc4, 0xe7, 0x7e, 0x7e, 0x3e, 0xb6, 0xb2, 0x31, 0x74, 0xce, 0x3d, 0x71, 0xb2, 0x39, + 0x17, 0x5d, 0xb7, 0xdf, 0xb9, 0x3b, 0x12, 0x6e, 0x78, 0x1e, 0x16, 0x0a, 0xc6, 0xe3, 0x4e, 0xb7, + 0x51, 0x67, 0x0b, 0x73, 0xc7, 0xa7, 0x07, 0x73, 0x23, 0x16, 0x85, 0xb9, 0x91, 0x81, 0xa1, 0xfc, + 0x0c, 0x4c, 0x6d, 0xab, 0x8e, 0xd7, 0xc4, 0xde, 0x55, 0xac, 0xb6, 0xb0, 0x13, 0xcd, 0x1f, 0xa6, + 0x44, 0xfe, 0x80, 0x20, 0x49, 0x93, 0x04, 0xb6, 0x7e, 0xd2, 0xdf, 0xe5, 0x03, 0x48, 0xd2, 0x9b, + 0xc4, 0x7e, 0x6e, 0xc1, 0x25, 0x58, 0x6e, 0x41, 0x56, 0x86, 0x23, 0x0f, 0xbb, 0xe2, 0xf8, 0x8b, + 0x16, 0xd0, 0x93, 0x22, 0x43, 0x48, 0x1c, 0x9f, 0x21, 0xf0, 0xe9, 0xc5, 0xf3, 0x04, 0x03, 0xd2, + 0x7c, 0x88, 0x7d, 0x45, 0x62, 0x81, 0x22, 0x68, 0x03, 0x8a, 0xb6, 0xea, 0x78, 0xf4, 0x3d, 0xc5, + 0x03, 0xda, 0x0b, 0x3e, 0x83, 0x17, 0xfa, 0xe3, 0x49, 0xa4, 0xb3, 0xbc, 0x95, 0x29, 0x3b, 0x4c, + 0x2c, 0xff, 0x97, 0x24, 0xa4, 0xb8, 0x31, 0x9e, 0x85, 0x34, 0x37, 0x2b, 0x9f, 0x73, 0xf7, 0x2c, + 0xf5, 0x2f, 0xb3, 0x4b, 0xfe, 0x72, 0xc8, 0xf1, 0x84, 0x0c, 0x7a, 0x00, 0x32, 0xda, 0x81, 0xaa, + 0x9b, 0x8a, 0xde, 0xe2, 0x09, 0x68, 0xee, 0xad, 0x37, 0x17, 0xd2, 0x35, 0x42, 0x5b, 0xab, 0xcb, + 0x69, 0x5a, 0xb9, 0xd6, 0x22, 0x39, 0xcd, 0x01, 0xd6, 0xdb, 0x07, 0x1e, 0x8f, 0x1b, 0xbc, 0x84, + 0x9e, 0x86, 0x24, 0x71, 0x08, 0xfe, 0x16, 0xfb, 0x5c, 0xdf, 0xce, 0xc2, 0x3f, 0xfa, 0x59, 0xc9, + 0x90, 0x86, 0x3f, 0xfa, 0x9f, 0x17, 0x62, 0x32, 0x95, 0x40, 0x35, 0x98, 0x32, 0x54, 0xd7, 0x53, + 0xe8, 0x7a, 0x4c, 0x9a, 0x9f, 0xa4, 0x10, 0x67, 0xfa, 0x0d, 0xc2, 0x0d, 0xcb, 0x55, 0xcf, 0x11, + 0x29, 0x46, 0x6a, 0xa1, 0x73, 0x20, 0x51, 0x10, 0x8d, 0xce, 0x40, 0x96, 0x25, 0xa6, 0xa8, 0xdd, + 0x0b, 0x84, 0xce, 0x26, 0x26, 0xcd, 0x15, 0xcf, 0x42, 0x96, 0xbe, 0x37, 0x4b, 0x59, 0xd8, 0xf5, + 0xf5, 0x0c, 0x21, 0xd0, 0xca, 0x07, 0xa1, 0x18, 0x44, 0x7d, 0xc6, 0x92, 0x61, 0x28, 0x01, 0x99, + 0x32, 0x9e, 0x87, 0x59, 0x13, 0xdf, 0xa2, 0x17, 0xea, 0x23, 0xdc, 0x59, 0xca, 0x8d, 0x48, 0xdd, + 0xf5, 0xa8, 0xc4, 0xfd, 0x50, 0xd0, 0x84, 0xf1, 0x19, 0x2f, 0x50, 0xde, 0x29, 0x9f, 0x4a, 0xd9, + 0xce, 0x40, 0x46, 0xb5, 0x6d, 0xc6, 0x90, 0xe3, 0x51, 0xdf, 0xb6, 0x69, 0xd5, 0xc3, 0x30, 0x4d, + 0xfb, 0xe8, 0x60, 0xb7, 0x6b, 0x78, 0x1c, 0x24, 0x4f, 0x79, 0x8a, 0xa4, 0x42, 0x66, 0x74, 0xca, + 0x7b, 0x1f, 0x4c, 0xe1, 0x43, 0xbd, 0x85, 0x4d, 0x0d, 0x33, 0xbe, 0x29, 0xca, 0x97, 0x17, 0x44, + 0xca, 0xf4, 0x10, 0xf8, 0xd1, 0x5c, 0x11, 0x2b, 0x4d, 0x81, 0xe1, 0x09, 0x7a, 0x95, 0x91, 0xcb, + 0x25, 0x48, 0xd6, 0x55, 0x4f, 0x25, 0xe9, 0x92, 0x77, 0x8b, 0x2d, 0x9f, 0x79, 0x99, 0xfc, 0x2c, + 0xff, 0x4a, 0x02, 0x92, 0xd7, 0x2d, 0x0f, 0xa3, 0x27, 0x42, 0xa9, 0x6c, 0x61, 0x90, 0x3f, 0x37, + 0xf5, 0xb6, 0x89, 0x5b, 0x1b, 0x6e, 0x3b, 0xf4, 0x91, 0x9b, 0xc0, 0x9d, 0xe2, 0x11, 0x77, 0x9a, + 0x85, 0x49, 0xc7, 0xea, 0x9a, 0x2d, 0x71, 0xf1, 0x9b, 0x16, 0x50, 0x03, 0x32, 0xbe, 0x97, 0x24, + 0x47, 0x79, 0x49, 0x91, 0x78, 0x09, 0xf1, 0x61, 0x4e, 0x90, 0xd3, 0x7b, 0xdc, 0x59, 0x56, 0x20, + 0xeb, 0x07, 0x2f, 0xee, 0x6d, 0xe3, 0x39, 0x6c, 0x20, 0x46, 0x96, 0x48, 0x7f, 0xec, 0x7d, 0xe3, + 0x31, 0x8f, 0x93, 0xfc, 0x0a, 0x6e, 0xbd, 0x88, 0x5b, 0xf1, 0x0f, 0xee, 0xa4, 0x69, 0xbf, 0x02, + 0xb7, 0x62, 0x1f, 0xdd, 0xb9, 0x1b, 0xb2, 0xae, 0xde, 0x36, 0x55, 0xaf, 0xeb, 0x60, 0xee, 0x79, + 0x01, 0x81, 0xd4, 0x06, 0x2f, 0x41, 0x30, 0x4f, 0x0b, 0x7d, 0xb9, 0x6d, 0x19, 0x66, 0x82, 0x6f, + 0xa6, 0x05, 0x28, 0xcc, 0xcb, 0x90, 0x5f, 0xd5, 0x14, 0x35, 0xe5, 0x5f, 0x8f, 0x41, 0x8a, 0xaf, + 0x58, 0xc1, 0x30, 0xc4, 0x06, 0x0f, 0x43, 0x7c, 0xd8, 0x30, 0x24, 0xde, 0xfd, 0x30, 0x54, 0x01, + 0x7c, 0x35, 0x5d, 0xfe, 0x59, 0x95, 0x01, 0x69, 0x15, 0x53, 0xb1, 0xa9, 0xb7, 0xf9, 0xbc, 0x0f, + 0x09, 0x95, 0x7f, 0x2b, 0x46, 0x32, 0x7c, 0x5e, 0x8f, 0xaa, 0x30, 0x25, 0xf4, 0x52, 0xf6, 0x0d, + 0xb5, 0xcd, 0x5d, 0xf1, 0x9e, 0xa1, 0xca, 0x91, 0x55, 0x58, 0xce, 0x71, 0x7d, 0x68, 0x3e, 0x31, + 0x70, 0x58, 0xe3, 0x43, 0x86, 0x35, 0xe2, 0x47, 0x89, 0x77, 0xe7, 0x47, 0x91, 0x11, 0x4f, 0xf6, + 0x8c, 0x78, 0xf9, 0x6b, 0x31, 0xfe, 0xc5, 0xb6, 0x16, 0x7b, 0x83, 0xe3, 0x4f, 0x6a, 0xa8, 0x5e, + 0xe2, 0xbe, 0xd5, 0xc2, 0x2d, 0xa5, 0x6f, 0xcc, 0xee, 0xeb, 0x47, 0x8c, 0xea, 0x1c, 0x8c, 0x1d, + 0x12, 0x28, 0xcd, 0x60, 0x0c, 0xdf, 0x88, 0xc3, 0x74, 0x1f, 0xff, 0xff, 0x7f, 0x63, 0x19, 0x9d, + 0xbd, 0x93, 0x63, 0xce, 0xde, 0xd4, 0xd0, 0xd9, 0xfb, 0xc5, 0x38, 0x3d, 0x00, 0xb0, 0x2d, 0x57, + 0x35, 0xbe, 0x17, 0xb1, 0xf7, 0x2c, 0x64, 0x6d, 0xcb, 0x50, 0x58, 0x0d, 0x7b, 0xf5, 0x26, 0x63, + 0x5b, 0x86, 0xdc, 0xe7, 0x66, 0x93, 0x77, 0x28, 0x30, 0xa7, 0xee, 0xc0, 0x20, 0xa4, 0x7b, 0x27, + 0x94, 0x03, 0x79, 0x66, 0x0a, 0x9e, 0x35, 0x9d, 0x27, 0x36, 0xa0, 0x69, 0x58, 0xac, 0x3f, 0xcb, + 0x63, 0x6a, 0x33, 0x4e, 0x99, 0xf3, 0x11, 0x09, 0x96, 0x64, 0x0c, 0x3a, 0x39, 0x0a, 0x47, 0x2c, + 0x99, 0xf3, 0x95, 0xff, 0x66, 0x0c, 0x60, 0x9d, 0x58, 0x96, 0xf6, 0x97, 0xe4, 0x3b, 0x2e, 0x55, + 0x41, 0x89, 0xb4, 0x3c, 0x3f, 0x6c, 0xd0, 0x78, 0xfb, 0x79, 0x37, 0xac, 0x77, 0x0d, 0xa6, 0x02, + 0xdf, 0x76, 0xb1, 0x50, 0x66, 0xfe, 0x98, 0x5d, 0x69, 0x13, 0x7b, 0x72, 0xfe, 0x30, 0x54, 0x2a, + 0xff, 0xb3, 0x18, 0x64, 0xa9, 0x4e, 0x1b, 0xd8, 0x53, 0x23, 0x63, 0x18, 0x7b, 0xf7, 0x63, 0x78, + 0x0f, 0x00, 0x83, 0x71, 0xf5, 0x57, 0x30, 0xf7, 0xac, 0x2c, 0xa5, 0x34, 0xf5, 0x57, 0x30, 0xba, + 0xe4, 0x1b, 0x3c, 0x71, 0xbc, 0xc1, 0xc5, 0xae, 0x95, 0x9b, 0xfd, 0x2e, 0x48, 0xd3, 0x6f, 0x8a, + 0xde, 0x72, 0xf9, 0x46, 0x34, 0x65, 0x76, 0x3b, 0x3b, 0xb7, 0xdc, 0xf2, 0xcb, 0x90, 0xde, 0xb9, + 0xc5, 0xce, 0x13, 0xcf, 0x42, 0xd6, 0xb1, 0x2c, 0x9e, 0xfd, 0xb1, 0xac, 0x3b, 0x43, 0x08, 0x34, + 0xd9, 0x11, 0x67, 0x68, 0xf1, 0xe0, 0x0c, 0x2d, 0x38, 0x04, 0x4c, 0x8c, 0x75, 0x08, 0x48, 0x76, + 0x9f, 0x53, 0x91, 0x99, 0x84, 0x1e, 0x85, 0xbb, 0x9a, 0x6b, 0xab, 0x9b, 0x8d, 0xba, 0xb2, 0xd1, + 0x5c, 0xed, 0x79, 0xad, 0x7e, 0xae, 0xf8, 0xda, 0xed, 0xc5, 0x1c, 0xdf, 0x76, 0x0e, 0xe3, 0xde, + 0x96, 0x1b, 0xd7, 0xb7, 0x76, 0x1a, 0x52, 0x8c, 0x71, 0x6f, 0x3b, 0xf8, 0xd0, 0xf2, 0xd8, 0x47, + 0x7b, 0xcf, 0xc3, 0x99, 0x01, 0xdc, 0xfe, 0xe6, 0x73, 0xfa, 0xb5, 0xdb, 0x8b, 0x53, 0xdb, 0x0e, + 0x66, 0x5e, 0x46, 0x25, 0x96, 0xa0, 0xd4, 0x2f, 0xb1, 0xb5, 0xbd, 0xd5, 0xac, 0xae, 0x4b, 0x8b, + 0x73, 0xd2, 0x6b, 0xb7, 0x17, 0xf3, 0x22, 0x64, 0x10, 0xfe, 0xf7, 0x7e, 0xf7, 0xf9, 0x5b, 0x0f, + 0xc1, 0x3d, 0xf4, 0xbb, 0x4e, 0xae, 0xa7, 0xde, 0xd0, 0xcd, 0xf6, 0xf2, 0xe1, 0xf9, 0x65, 0xfe, + 0x53, 0x3c, 0x91, 0x0e, 0x57, 0x2f, 0x1d, 0x9e, 0x1f, 0x76, 0xb4, 0x3f, 0xf4, 0xbe, 0xc3, 0xdc, + 0x88, 0xab, 0x00, 0xa3, 0x37, 0xae, 0xc7, 0x3c, 0x36, 0x18, 0xf1, 0x70, 0x62, 0xee, 0xd8, 0xad, + 0x75, 0xf9, 0x2f, 0xc4, 0xa0, 0x70, 0x55, 0x77, 0x3d, 0xcb, 0xd1, 0x35, 0xd5, 0xa0, 0xef, 0x59, + 0x5e, 0x1a, 0x37, 0xde, 0xf4, 0xb8, 0xff, 0xd3, 0x90, 0x3a, 0x54, 0x0d, 0x36, 0xd1, 0xd9, 0x21, + 0x6f, 0x8f, 0xdd, 0x82, 0x79, 0x2e, 0x24, 0x19, 0x7f, 0xf9, 0xf3, 0x71, 0x28, 0xd2, 0x80, 0xe4, + 0xb2, 0x8f, 0x89, 0x92, 0xad, 0xed, 0x36, 0x24, 0x1d, 0xd5, 0xe3, 0xa7, 0xce, 0x2b, 0xef, 0xe7, + 0x4f, 0x1a, 0x1e, 0x18, 0xfd, 0x38, 0x60, 0xa9, 0xff, 0xa1, 0x03, 0x45, 0x42, 0xcf, 0x43, 0xa6, + 0xa3, 0xde, 0x52, 0x28, 0x6a, 0xfc, 0x0e, 0xa0, 0xa6, 0x3b, 0xea, 0x2d, 0xa2, 0x2b, 0x6a, 0x41, + 0x91, 0x00, 0x6b, 0x07, 0xaa, 0xd9, 0xc6, 0x0c, 0x3f, 0x71, 0x07, 0xf0, 0xa7, 0x3a, 0xea, 0xad, + 0x1a, 0xc5, 0x24, 0xad, 0x54, 0x32, 0x1f, 0x7b, 0x7d, 0x61, 0x82, 0x3e, 0xa7, 0x79, 0x23, 0x06, + 0x10, 0x98, 0x0b, 0xed, 0x82, 0xa4, 0xf9, 0x25, 0xda, 0xbc, 0xcb, 0x47, 0x6e, 0xb1, 0x6f, 0x04, + 0x7a, 0xac, 0xcc, 0x96, 0xa7, 0xaf, 0xbc, 0xb9, 0x10, 0x93, 0x8b, 0x5a, 0xcf, 0x00, 0x34, 0x20, + 0xd7, 0xb5, 0x5b, 0xaa, 0x87, 0x15, 0xba, 0x69, 0x8e, 0x9f, 0x60, 0xa9, 0x03, 0x26, 0x48, 0xaa, + 0x42, 0x6a, 0x7f, 0x9e, 0x7e, 0xeb, 0x35, 0xb8, 0x0c, 0x50, 0x82, 0x74, 0xc7, 0x32, 0xf5, 0x1b, + 0xdc, 0xd1, 0xb2, 0xb2, 0x28, 0xa2, 0x39, 0xc8, 0xb0, 0x77, 0xca, 0xbd, 0x23, 0x71, 0x5e, 0x2e, + 0xca, 0x44, 0xea, 0x26, 0xde, 0x73, 0x75, 0x61, 0x64, 0x59, 0x14, 0xc9, 0x56, 0xd1, 0xc5, 0x5a, + 0xd7, 0xd1, 0xbd, 0x23, 0x45, 0xb3, 0x4c, 0x4f, 0xd5, 0x3c, 0xfe, 0x76, 0x72, 0x51, 0xd0, 0x6b, + 0x8c, 0x4c, 0x40, 0x5a, 0xd8, 0x53, 0x75, 0xc3, 0x2d, 0xb1, 0xc7, 0x87, 0xa2, 0x18, 0x52, 0xf7, + 0x4b, 0xa9, 0xf0, 0x41, 0x67, 0x0d, 0x24, 0xcb, 0xc6, 0x4e, 0x24, 0x4f, 0x63, 0xae, 0x59, 0xfa, + 0xea, 0x1b, 0x8f, 0xcd, 0xf2, 0x61, 0xe3, 0x99, 0x1a, 0xbb, 0xff, 0x2e, 0x17, 0x85, 0x84, 0x48, + 0xe0, 0x5e, 0x24, 0x23, 0x25, 0xf6, 0xd7, 0x76, 0x77, 0x2f, 0x38, 0x1c, 0x9d, 0xed, 0xb3, 0x6b, + 0xd5, 0x3c, 0x5a, 0x29, 0xfd, 0x46, 0x00, 0x1d, 0x9c, 0x48, 0x3e, 0x87, 0x8f, 0xc8, 0x68, 0x71, + 0x9c, 0x6d, 0x0a, 0x43, 0x12, 0xa5, 0x97, 0x55, 0xdd, 0x10, 0x9f, 0xe0, 0x90, 0x79, 0x89, 0x7e, + 0x07, 0xdc, 0x53, 0xbd, 0xae, 0x78, 0x51, 0x9b, 0x97, 0xd0, 0x0e, 0xa4, 0x3c, 0xeb, 0x06, 0x36, + 0xb9, 0x01, 0x4e, 0xe4, 0xaa, 0x7d, 0x0f, 0x13, 0x65, 0x8e, 0x85, 0xda, 0x20, 0xb5, 0xb0, 0x81, + 0xdb, 0x6c, 0xc9, 0x3f, 0x50, 0x49, 0x02, 0x9e, 0xba, 0x03, 0x53, 0xa1, 0xe8, 0xa3, 0x36, 0x29, + 0x28, 0xaa, 0x47, 0xaf, 0x9a, 0xa4, 0xf9, 0x09, 0x6e, 0xaf, 0xbb, 0x87, 0xdc, 0x4d, 0x9c, 0xc8, + 0x84, 0xaf, 0xa3, 0x3c, 0x04, 0x52, 0xd7, 0xdc, 0xb3, 0x4c, 0xfa, 0x96, 0x3a, 0xcf, 0x33, 0x33, + 0x74, 0xe5, 0x2e, 0xfa, 0xf4, 0xab, 0x2c, 0xe1, 0x7c, 0x0e, 0x0a, 0x01, 0x2b, 0x9d, 0x10, 0xd9, + 0x13, 0x4c, 0x88, 0x29, 0x5f, 0x96, 0xd4, 0x92, 0x5d, 0x65, 0x30, 0xdb, 0xe8, 0xee, 0x97, 0xec, + 0x2a, 0x87, 0xcf, 0x55, 0xb1, 0xab, 0x0c, 0x84, 0x90, 0x01, 0x33, 0x1d, 0xdd, 0x54, 0x5c, 0x6c, + 0xec, 0x2b, 0xdc, 0x38, 0x04, 0x2b, 0x77, 0x07, 0x06, 0x73, 0xba, 0xa3, 0x9b, 0x4d, 0x6c, 0xec, + 0xd7, 0x7d, 0x58, 0x9a, 0x30, 0x59, 0x66, 0x4b, 0x61, 0xcf, 0x84, 0xd9, 0x17, 0xe5, 0xb3, 0x84, + 0x52, 0x27, 0x84, 0x4a, 0xfe, 0x23, 0xaf, 0x2f, 0x4c, 0xf0, 0x89, 0x33, 0x51, 0xde, 0xa6, 0x4f, + 0x35, 0xb8, 0xcf, 0x63, 0x17, 0x5d, 0x82, 0xac, 0x2a, 0x0a, 0xf4, 0x54, 0xe6, 0xb8, 0x39, 0x13, + 0xb0, 0xb2, 0xa9, 0xf8, 0xea, 0x7f, 0x5a, 0x8c, 0x95, 0x7f, 0x3e, 0x06, 0xa9, 0xfa, 0xf5, 0x6d, + 0x55, 0x77, 0x50, 0x03, 0xa6, 0x03, 0x0f, 0x1b, 0x77, 0x22, 0x06, 0x4e, 0x29, 0x66, 0x62, 0x63, + 0xd8, 0xbe, 0xeb, 0x58, 0x98, 0xde, 0x1d, 0x59, 0x4f, 0xc7, 0x3f, 0x00, 0x69, 0xa6, 0xa5, 0x8b, + 0x9e, 0x80, 0x49, 0x9b, 0xfc, 0xe0, 0x0f, 0x71, 0xee, 0xea, 0xf7, 0x4c, 0xca, 0xe8, 0x9f, 0xcb, + 0x12, 0xde, 0xf2, 0x1f, 0xc5, 0x00, 0xea, 0xd7, 0xaf, 0xef, 0x38, 0xba, 0x6d, 0x60, 0xef, 0x4e, + 0x75, 0x75, 0x1d, 0x4e, 0x85, 0xd2, 0x70, 0x47, 0x1b, 0xbb, 0xbb, 0x33, 0x41, 0x22, 0xee, 0x68, + 0x03, 0xd1, 0x5a, 0xae, 0xe7, 0xa3, 0x25, 0xc6, 0x46, 0xab, 0xbb, 0xde, 0x60, 0xfb, 0xad, 0x43, + 0x2e, 0xe8, 0xbe, 0x8b, 0x9e, 0x85, 0x8c, 0xc7, 0x7f, 0xfb, 0xcf, 0xc2, 0xfa, 0xcd, 0x28, 0xf8, + 0xb9, 0x29, 0x7d, 0x91, 0xf2, 0x1f, 0x13, 0x6b, 0x06, 0x2e, 0xfc, 0x7d, 0xe5, 0x38, 0x24, 0xfc, + 0xf2, 0xf0, 0x78, 0x27, 0x32, 0x05, 0x8e, 0xd5, 0x63, 0xce, 0xff, 0x1b, 0x83, 0x99, 0x5d, 0x11, + 0x77, 0xbe, 0x6f, 0x2d, 0xb1, 0x06, 0x69, 0x6c, 0x7a, 0x8e, 0x4e, 0x4d, 0xc1, 0xbe, 0x9b, 0xdc, + 0x3b, 0xc8, 0x03, 0x3a, 0x41, 0x3f, 0x42, 0x28, 0x9e, 0x0f, 0x70, 0xf9, 0x9e, 0xee, 0xff, 0xaf, + 0x38, 0x94, 0x86, 0x49, 0xa2, 0x07, 0xa1, 0xa8, 0x39, 0x98, 0x12, 0x94, 0xc8, 0x51, 0x55, 0x41, + 0x90, 0x79, 0xdc, 0xdf, 0x00, 0x92, 0x18, 0x11, 0x8f, 0x22, 0xac, 0x27, 0xce, 0x84, 0x0a, 0x81, + 0x30, 0x8d, 0xfc, 0x2e, 0x14, 0x75, 0x53, 0xf7, 0x74, 0xd5, 0x50, 0xf6, 0x54, 0x43, 0x35, 0x35, + 0xec, 0x1f, 0x79, 0x0d, 0xb8, 0x43, 0xb4, 0x54, 0xb3, 0x74, 0x73, 0x65, 0x99, 0xfb, 0xc6, 0x83, + 0x63, 0xf8, 0x06, 0x11, 0x90, 0x0b, 0xbc, 0x89, 0x15, 0xd6, 0x02, 0x6a, 0x41, 0x5a, 0x34, 0x96, + 0xbc, 0xe3, 0x8d, 0x09, 0xe8, 0x50, 0xe6, 0xf4, 0x8d, 0x38, 0x4c, 0xcb, 0xb8, 0xf5, 0x83, 0x6c, + 0xf2, 0x1f, 0x02, 0x60, 0x73, 0x92, 0xc4, 0x48, 0x96, 0x7a, 0x7d, 0x97, 0x73, 0x3c, 0xcb, 0xf0, + 0xea, 0xae, 0x17, 0xb2, 0xf4, 0x3f, 0x8f, 0x43, 0x3e, 0x6c, 0xe9, 0x1f, 0x80, 0x35, 0x03, 0xad, + 0x04, 0x01, 0x83, 0x9d, 0xed, 0x96, 0xfb, 0x02, 0x46, 0x9f, 0xf3, 0x1d, 0x1f, 0x29, 0xfe, 0x4d, + 0x1c, 0x52, 0xdb, 0xaa, 0xa3, 0x76, 0x5c, 0x74, 0x7f, 0x5f, 0x9a, 0xc7, 0xb6, 0x26, 0x3d, 0x09, + 0xdc, 0xfd, 0x50, 0x20, 0x3b, 0xbe, 0xd0, 0x65, 0x8d, 0x38, 0x7d, 0x58, 0x4b, 0xb6, 0x6c, 0xc1, + 0x33, 0x35, 0xb4, 0x00, 0x39, 0xc2, 0x16, 0xc4, 0x37, 0xc2, 0x03, 0x1d, 0xf5, 0x56, 0x83, 0x51, + 0xd0, 0x63, 0x80, 0x0e, 0xfc, 0xcd, 0xb7, 0x12, 0x74, 0x8b, 0xf0, 0x4d, 0x07, 0x35, 0x82, 0x3d, + 0x9a, 0x86, 0x4d, 0xf6, 0xa4, 0x61, 0xe8, 0xcf, 0xb2, 0x9c, 0xb0, 0x67, 0x33, 0xc8, 0x13, 0xf0, + 0xf5, 0x93, 0x79, 0xdf, 0x77, 0xde, 0x5c, 0x98, 0x3b, 0x52, 0x3b, 0x46, 0xa5, 0x3c, 0x00, 0xb2, + 0x4c, 0x73, 0xc4, 0xe8, 0x5e, 0x32, 0xe4, 0x95, 0x9f, 0x8c, 0x01, 0x0a, 0x02, 0xae, 0x8c, 0x5d, + 0x9b, 0x6c, 0x56, 0x48, 0xd6, 0x1b, 0xca, 0x54, 0x63, 0x43, 0xb2, 0xde, 0x40, 0x50, 0x64, 0xbd, + 0x21, 0xf7, 0x7e, 0x26, 0x88, 0x64, 0xf1, 0x51, 0x73, 0x98, 0x0f, 0x79, 0x6f, 0x78, 0x9a, 0x28, + 0x7f, 0x35, 0x06, 0x67, 0xfa, 0x3c, 0xc4, 0xd7, 0xf2, 0x79, 0x40, 0x4e, 0xa8, 0x92, 0x7f, 0xfe, + 0x96, 0x69, 0x3b, 0xbe, 0xa7, 0x4d, 0x3b, 0x7d, 0xf1, 0xef, 0x7a, 0x34, 0x0a, 0x7f, 0xb7, 0x59, + 0xba, 0xdf, 0x31, 0x76, 0x77, 0xf3, 0x0b, 0x31, 0x98, 0x0d, 0x2b, 0xe3, 0xf7, 0x67, 0x15, 0xf2, + 0x61, 0x5d, 0xfc, 0x07, 0xef, 0xc7, 0xf5, 0x84, 0x77, 0x22, 0x22, 0x88, 0xae, 0x05, 0xf3, 0x8e, + 0x9d, 0xef, 0x3c, 0x3c, 0xda, 0x1a, 0x42, 0x8b, 0xde, 0xf9, 0x97, 0xa4, 0x03, 0xf1, 0xe1, 0x38, + 0x24, 0xb7, 0x2d, 0xcb, 0x40, 0x7f, 0x0e, 0xa6, 0x4d, 0xcb, 0x53, 0x88, 0x27, 0xe3, 0x96, 0xc2, + 0xf7, 0xa5, 0x2c, 0x6a, 0x7d, 0xe8, 0x64, 0x46, 0xfa, 0xdd, 0x37, 0x17, 0xfa, 0xa1, 0x7a, 0x2c, + 0x57, 0x34, 0x2d, 0x6f, 0x85, 0xd6, 0xef, 0xb0, 0x5d, 0xab, 0x03, 0x53, 0xd1, 0xa6, 0x59, 0x94, + 0xdb, 0x38, 0x71, 0xd3, 0x53, 0xc7, 0x35, 0x9b, 0xdf, 0x0b, 0xb5, 0xc9, 0xee, 0xb3, 0x7d, 0xfb, + 0xf5, 0x85, 0xd8, 0xca, 0xf5, 0xa1, 0xc7, 0x9a, 0xef, 0x0f, 0x35, 0xec, 0x60, 0xd5, 0xd0, 0x2d, + 0x0f, 0x6b, 0x07, 0xcb, 0xd4, 0xea, 0x8f, 0x89, 0xd3, 0xca, 0x5b, 0x3d, 0x65, 0x7e, 0x2f, 0xe5, + 0xbc, 0x38, 0xdf, 0xfc, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1b, 0xfd, 0x21, 0x55, 0xde, 0x6e, + 0x00, 0x00, + } + r := bytes.NewReader(gzipped) + gzipr, err := compress_gzip.NewReader(r) + if err != nil { + panic(err) + } + ungzipped, err := io_ioutil.ReadAll(gzipr) + if err != nil { + panic(err) + } + if err := github_com_cosmos_gogoproto_proto.Unmarshal(ungzipped, d); err != nil { + panic(err) + } + return d +} +func (this *CommissionRates) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*CommissionRates) + if !ok { + that2, ok := that.(CommissionRates) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Rate.Equal(that1.Rate) { + return false + } + if !this.MaxRate.Equal(that1.MaxRate) { + return false + } + if !this.MaxChangeRate.Equal(that1.MaxChangeRate) { + return false + } + return true +} +func (this *Commission) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Commission) + if !ok { + that2, ok := that.(Commission) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.CommissionRates.Equal(&that1.CommissionRates) { + return false + } + if !this.UpdateTime.Equal(that1.UpdateTime) { + return false + } + return true +} +func (this *Description) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Description) + if !ok { + that2, ok := that.(Description) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Moniker != that1.Moniker { + return false + } + if this.Identity != that1.Identity { + return false + } + if this.Website != that1.Website { + return false + } + if this.SecurityContact != that1.SecurityContact { + return false + } + if this.Details != that1.Details { + return false + } + return true +} +func (this *UnbondingDelegationEntry) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*UnbondingDelegationEntry) + if !ok { + that2, ok := that.(UnbondingDelegationEntry) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.CreationHeight != that1.CreationHeight { + return false + } + if !this.CompletionTime.Equal(that1.CompletionTime) { + return false + } + if !this.InitialBalance.Equal(that1.InitialBalance) { + return false + } + if !this.Balance.Equal(that1.Balance) { + return false + } + return true +} +func (this *RedelegationEntry) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RedelegationEntry) + if !ok { + that2, ok := that.(RedelegationEntry) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.CreationHeight != that1.CreationHeight { + return false + } + if !this.CompletionTime.Equal(that1.CompletionTime) { + return false + } + if !this.InitialBalance.Equal(that1.InitialBalance) { + return false + } + if !this.SharesDst.Equal(that1.SharesDst) { + return false + } + return true +} +func (this *Params) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Params) + if !ok { + that2, ok := that.(Params) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.UnbondingTime != that1.UnbondingTime { + return false + } + if this.MaxValidators != that1.MaxValidators { + return false + } + if this.MaxEntries != that1.MaxEntries { + return false + } + if this.HistoricalEntries != that1.HistoricalEntries { + return false + } + if this.BondDenom != that1.BondDenom { + return false + } + if !this.MinCommissionRate.Equal(that1.MinCommissionRate) { + return false + } + return true +} +func (this *RedelegationEntryResponse) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RedelegationEntryResponse) + if !ok { + that2, ok := that.(RedelegationEntryResponse) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.RedelegationEntry.Equal(&that1.RedelegationEntry) { + return false + } + if !this.Balance.Equal(that1.Balance) { + return false + } + return true +} +func (this *Pool) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Pool) + if !ok { + that2, ok := that.(Pool) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.NotBondedTokens.Equal(that1.NotBondedTokens) { + return false + } + if !this.BondedTokens.Equal(that1.BondedTokens) { + return false + } + return true +} +func (m *HistoricalInfo) 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 *HistoricalInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HistoricalInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Valset) > 0 { + for iNdEx := len(m.Valset) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Valset[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CommissionRates) 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 *CommissionRates) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommissionRates) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.MaxChangeRate.Size() + i -= size + if _, err := m.MaxChangeRate.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size := m.MaxRate.Size() + i -= size + if _, err := m.MaxRate.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.Rate.Size() + i -= size + if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Commission) 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 *Commission) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UpdateTime):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintStaking(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0x12 + { + size, err := m.CommissionRates.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Description) 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 *Description) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Description) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Details) > 0 { + i -= len(m.Details) + copy(dAtA[i:], m.Details) + i = encodeVarintStaking(dAtA, i, uint64(len(m.Details))) + i-- + dAtA[i] = 0x2a + } + if len(m.SecurityContact) > 0 { + i -= len(m.SecurityContact) + copy(dAtA[i:], m.SecurityContact) + i = encodeVarintStaking(dAtA, i, uint64(len(m.SecurityContact))) + i-- + dAtA[i] = 0x22 + } + if len(m.Website) > 0 { + i -= len(m.Website) + copy(dAtA[i:], m.Website) + i = encodeVarintStaking(dAtA, i, uint64(len(m.Website))) + i-- + dAtA[i] = 0x1a + } + if len(m.Identity) > 0 { + i -= len(m.Identity) + copy(dAtA[i:], m.Identity) + i = encodeVarintStaking(dAtA, i, uint64(len(m.Identity))) + i-- + dAtA[i] = 0x12 + } + if len(m.Moniker) > 0 { + i -= len(m.Moniker) + copy(dAtA[i:], m.Moniker) + i = encodeVarintStaking(dAtA, i, uint64(len(m.Moniker))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Validator) 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 *Validator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.BondDenom) > 0 { + i -= len(m.BondDenom) + copy(dAtA[i:], m.BondDenom) + i = encodeVarintStaking(dAtA, i, uint64(len(m.BondDenom))) + i-- + dAtA[i] = 0x62 + } + { + size := m.MinSelfDelegation.Size() + i -= size + if _, err := m.MinSelfDelegation.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + { + size, err := m.Commission.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + n5, err5 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UnbondingTime):]) + if err5 != nil { + return 0, err5 + } + i -= n5 + i = encodeVarintStaking(dAtA, i, uint64(n5)) + i-- + dAtA[i] = 0x4a + if m.UnbondingHeight != 0 { + i = encodeVarintStaking(dAtA, i, uint64(m.UnbondingHeight)) + i-- + dAtA[i] = 0x40 + } + { + size, err := m.Description.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + { + size := m.DelegatorShares.Size() + i -= size + if _, err := m.DelegatorShares.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + { + size := m.Tokens.Size() + i -= size + if _, err := m.Tokens.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintStaking(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x22 + } + if m.Jailed { + i-- + if m.Jailed { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.ConsensusPubkey != nil { + { + size, err := m.ConsensusPubkey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.OperatorAddress) > 0 { + i -= len(m.OperatorAddress) + copy(dAtA[i:], m.OperatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.OperatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValAddresses) 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 *ValAddresses) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Addresses) > 0 { + for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Addresses[iNdEx]) + copy(dAtA[i:], m.Addresses[iNdEx]) + i = encodeVarintStaking(dAtA, i, uint64(len(m.Addresses[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *DVPair) 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 *DVPair) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DVPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddress) > 0 { + i -= len(m.ValidatorAddress) + copy(dAtA[i:], m.ValidatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DVPairs) 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 *DVPairs) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DVPairs) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Pairs) > 0 { + for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *DVVTriplet) 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 *DVVTriplet) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DVVTriplet) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorDstAddress) > 0 { + i -= len(m.ValidatorDstAddress) + copy(dAtA[i:], m.ValidatorDstAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.ValidatorSrcAddress) > 0 { + i -= len(m.ValidatorSrcAddress) + copy(dAtA[i:], m.ValidatorSrcAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DVVTriplets) 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 *DVVTriplets) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DVVTriplets) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Triplets) > 0 { + for iNdEx := len(m.Triplets) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Triplets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Delegation) 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 *Delegation) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Delegation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Shares.Size() + i -= size + if _, err := m.Shares.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.ValidatorAddress) > 0 { + i -= len(m.ValidatorAddress) + copy(dAtA[i:], m.ValidatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UnbondingDelegation) 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 *UnbondingDelegation) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UnbondingDelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Entries) > 0 { + for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.ValidatorAddress) > 0 { + i -= len(m.ValidatorAddress) + copy(dAtA[i:], m.ValidatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UnbondingDelegationEntry) 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 *UnbondingDelegationEntry) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Balance.Size() + i -= size + if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size := m.InitialBalance.Size() + i -= size + if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + n10, err10 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + if err10 != nil { + return 0, err10 + } + i -= n10 + i = encodeVarintStaking(dAtA, i, uint64(n10)) + i-- + dAtA[i] = 0x12 + if m.CreationHeight != 0 { + i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RedelegationEntry) 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 *RedelegationEntry) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.SharesDst.Size() + i -= size + if _, err := m.SharesDst.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size := m.InitialBalance.Size() + i -= size + if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + n12, err12 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + if err12 != nil { + return 0, err12 + } + i -= n12 + i = encodeVarintStaking(dAtA, i, uint64(n12)) + i-- + dAtA[i] = 0x12 + if m.CreationHeight != 0 { + i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Redelegation) 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 *Redelegation) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Redelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Entries) > 0 { + for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.ValidatorDstAddress) > 0 { + i -= len(m.ValidatorDstAddress) + copy(dAtA[i:], m.ValidatorDstAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.ValidatorSrcAddress) > 0 { + i -= len(m.ValidatorSrcAddress) + copy(dAtA[i:], m.ValidatorSrcAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +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 + { + size := m.MinCommissionRate.Size() + i -= size + if _, err := m.MinCommissionRate.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + if len(m.BondDenom) > 0 { + i -= len(m.BondDenom) + copy(dAtA[i:], m.BondDenom) + i = encodeVarintStaking(dAtA, i, uint64(len(m.BondDenom))) + i-- + dAtA[i] = 0x2a + } + if m.HistoricalEntries != 0 { + i = encodeVarintStaking(dAtA, i, uint64(m.HistoricalEntries)) + i-- + dAtA[i] = 0x20 + } + if m.MaxEntries != 0 { + i = encodeVarintStaking(dAtA, i, uint64(m.MaxEntries)) + i-- + dAtA[i] = 0x18 + } + if m.MaxValidators != 0 { + i = encodeVarintStaking(dAtA, i, uint64(m.MaxValidators)) + i-- + dAtA[i] = 0x10 + } + if len(m.UnbondingTime) > 0 { + i -= len(m.UnbondingTime) + copy(dAtA[i:], m.UnbondingTime) + i = encodeVarintStaking(dAtA, i, uint64(len(m.UnbondingTime))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DelegationResponse) 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 *DelegationResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Delegation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RedelegationEntryResponse) 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 *RedelegationEntryResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RedelegationEntryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Balance.Size() + i -= size + if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.RedelegationEntry.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RedelegationResponse) 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 *RedelegationResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RedelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Entries) > 0 { + for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.Redelegation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Pool) 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 *Pool) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.BondedTokens.Size() + i -= size + if _, err := m.BondedTokens.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.NotBondedTokens.Size() + i -= size + if _, err := m.NotBondedTokens.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintStaking(dAtA []byte, offset int, v uint64) int { + offset -= sovStaking(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *HistoricalInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Header.Size() + n += 1 + l + sovStaking(uint64(l)) + if len(m.Valset) > 0 { + for _, e := range m.Valset { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *CommissionRates) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Rate.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.MaxRate.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.MaxChangeRate.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *Commission) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.CommissionRates.Size() + n += 1 + l + sovStaking(uint64(l)) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UpdateTime) + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *Description) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Moniker) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.Identity) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.Website) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.SecurityContact) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.Details) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + return n +} + +func (m *Validator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OperatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + if m.ConsensusPubkey != nil { + l = m.ConsensusPubkey.Size() + n += 1 + l + sovStaking(uint64(l)) + } + if m.Jailed { + n += 2 + } + l = len(m.Status) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = m.Tokens.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.DelegatorShares.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Description.Size() + n += 1 + l + sovStaking(uint64(l)) + if m.UnbondingHeight != 0 { + n += 1 + sovStaking(uint64(m.UnbondingHeight)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UnbondingTime) + n += 1 + l + sovStaking(uint64(l)) + l = m.Commission.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.MinSelfDelegation.Size() + n += 1 + l + sovStaking(uint64(l)) + l = len(m.BondDenom) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + return n +} + +func (m *ValAddresses) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Addresses) > 0 { + for _, s := range m.Addresses { + l = len(s) + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *DVPair) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + return n +} + +func (m *DVPairs) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Pairs) > 0 { + for _, e := range m.Pairs { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *DVVTriplet) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorSrcAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorDstAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + return n +} + +func (m *DVVTriplets) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Triplets) > 0 { + for _, e := range m.Triplets { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *Delegation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = m.Shares.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *UnbondingDelegation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + if len(m.Entries) > 0 { + for _, e := range m.Entries { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *UnbondingDelegationEntry) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CreationHeight != 0 { + n += 1 + sovStaking(uint64(m.CreationHeight)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + n += 1 + l + sovStaking(uint64(l)) + l = m.InitialBalance.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Balance.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *RedelegationEntry) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CreationHeight != 0 { + n += 1 + sovStaking(uint64(m.CreationHeight)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + n += 1 + l + sovStaking(uint64(l)) + l = m.InitialBalance.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.SharesDst.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *Redelegation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorSrcAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorDstAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + if len(m.Entries) > 0 { + for _, e := range m.Entries { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.UnbondingTime) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + if m.MaxValidators != 0 { + n += 1 + sovStaking(uint64(m.MaxValidators)) + } + if m.MaxEntries != 0 { + n += 1 + sovStaking(uint64(m.MaxEntries)) + } + if m.HistoricalEntries != 0 { + n += 1 + sovStaking(uint64(m.HistoricalEntries)) + } + l = len(m.BondDenom) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = m.MinCommissionRate.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *DelegationResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Delegation.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Balance.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *RedelegationEntryResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.RedelegationEntry.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Balance.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *RedelegationResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Redelegation.Size() + n += 1 + l + sovStaking(uint64(l)) + if len(m.Entries) > 0 { + for _, e := range m.Entries { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *Pool) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.NotBondedTokens.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.BondedTokens.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func sovStaking(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozStaking(x uint64) (n int) { + return sovStaking(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *ValAddresses) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ValAddresses{`, + `Addresses:` + fmt.Sprintf("%v", this.Addresses) + `,`, + `}`, + }, "") + return s +} +func valueToStringStaking(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *HistoricalInfo) 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 ErrIntOverflowStaking + } + 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: HistoricalInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HistoricalInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Valset", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Valset = append(m.Valset, Validator{}) + if err := m.Valset[len(m.Valset)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommissionRates) 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 ErrIntOverflowStaking + } + 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: CommissionRates: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommissionRates: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxRate", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MaxRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxChangeRate", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MaxChangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Commission) 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 ErrIntOverflowStaking + } + 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: Commission: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Commission: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommissionRates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CommissionRates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Description) 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 ErrIntOverflowStaking + } + 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: Description: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + 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 ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Moniker = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Identity = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + 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 ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Website = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SecurityContact", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SecurityContact = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Details = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Validator) 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 ErrIntOverflowStaking + } + 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: Validator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OperatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConsensusPubkey == nil { + m.ConsensusPubkey = &types1.Any{} + } + if err := m.ConsensusPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Jailed = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Tokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorShares", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DelegatorShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingHeight", wireType) + } + m.UnbondingHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UnbondingHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Commission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MinSelfDelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BondDenom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValAddresses) 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 ErrIntOverflowStaking + } + 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: ValAddresses: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValAddresses: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DVPair) 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 ErrIntOverflowStaking + } + 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: DVPair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DVPair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DVPairs) 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 ErrIntOverflowStaking + } + 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: DVPairs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DVPairs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Pairs = append(m.Pairs, DVPair{}) + if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DVVTriplet) 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 ErrIntOverflowStaking + } + 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: DVVTriplet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DVVTriplet: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DVVTriplets) 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 ErrIntOverflowStaking + } + 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: DVVTriplets: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DVVTriplets: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Triplets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Triplets = append(m.Triplets, DVVTriplet{}) + if err := m.Triplets[len(m.Triplets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Delegation) 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 ErrIntOverflowStaking + } + 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: Delegation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Delegation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Shares", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Shares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnbondingDelegation) 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 ErrIntOverflowStaking + } + 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: UnbondingDelegation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Entries = append(m.Entries, UnbondingDelegationEntry{}) + if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnbondingDelegationEntry) 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 ErrIntOverflowStaking + } + 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: UnbondingDelegationEntry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnbondingDelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType) + } + m.CreationHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CreationHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RedelegationEntry) 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 ErrIntOverflowStaking + } + 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: RedelegationEntry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RedelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType) + } + m.CreationHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CreationHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SharesDst", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.SharesDst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Redelegation) 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 ErrIntOverflowStaking + } + 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: Redelegation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Redelegation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Entries = append(m.Entries, RedelegationEntry{}) + if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +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 ErrIntOverflowStaking + } + 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 != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnbondingTime = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType) + } + m.MaxValidators = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxValidators |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxEntries", wireType) + } + m.MaxEntries = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxEntries |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType) + } + m.HistoricalEntries = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HistoricalEntries |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BondDenom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MinCommissionRate", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MinCommissionRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegationResponse) 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 ErrIntOverflowStaking + } + 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: DelegationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delegation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Delegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RedelegationEntryResponse) 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 ErrIntOverflowStaking + } + 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: RedelegationEntryResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RedelegationEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RedelegationEntry", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RedelegationEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RedelegationResponse) 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 ErrIntOverflowStaking + } + 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: RedelegationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RedelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Redelegation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Redelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Entries = append(m.Entries, RedelegationEntryResponse{}) + if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Pool) 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 ErrIntOverflowStaking + } + 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: Pool: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.NotBondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipStaking(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, ErrIntOverflowStaking + } + 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, ErrIntOverflowStaking + } + 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, ErrIntOverflowStaking + } + 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, ErrInvalidLengthStaking + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupStaking + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthStaking + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthStaking = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowStaking = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupStaking = fmt.Errorf("proto: unexpected end of group") +) diff --git a/app/upgrades/multi-staking/types.go b/app/upgrades/multi-staking/types.go new file mode 100644 index 00000000..69c4f6f1 --- /dev/null +++ b/app/upgrades/multi-staking/types.go @@ -0,0 +1,80 @@ +package multistaking + +import ( + "time" + + types1 "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + multistakingtypes "github.com/realio-tech/multi-staking-module/x/multi-staking/types" +) + +type Params struct { + // unbonding_time is the time duration of unbonding. + UnbondingTime string `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time"` + // max_validators is the maximum number of validators. + MaxValidators uint32 `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty"` + // max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio). + MaxEntries uint32 `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty"` + // historical_entries is the number of historical entries to persist. + HistoricalEntries uint32 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"` + // bond_denom defines the bondable coin denomination. + BondDenom string `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty"` + // min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators + MinCommissionRate sdk.Dec `protobuf:"bytes,6,opt,name=min_commission_rate,json=minCommissionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_commission_rate" yaml:"min_commission_rate"` +} + +type Validator struct { + // operator_address defines the address of the validator's operator; bech encoded in JSON. + OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"` + // consensus_pubkey is the consensus public key of the validator, as a Protobuf Any. + ConsensusPubkey *types1.Any `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty"` + // jailed defined whether the validator has been jailed from bonded status or not. + Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"` + // status is the validator status (bonded/unbonding/unbonded). + Status string `protobuf:"varint,4,opt,name=status,proto3,enum=cosmos.staking.v1beta1.BondStatus" json:"status,omitempty"` + // tokens define the delegated tokens (incl. self-delegation). + Tokens sdk.Int `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"` + // delegator_shares defines total shares issued to a validator's delegators. + DelegatorShares sdk.Dec `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"delegator_shares"` + // description defines the description terms for the validator. + Description stakingtypes.Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description"` + // unbonding_height defines, if unbonding, the height at which this validator has begun unbonding. + UnbondingHeight int64 `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty"` + // unbonding_time defines, if unbonding, the min time for the validator to complete unbonding. + UnbondingTime time.Time `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time"` + // commission defines the commission parameters. + Commission stakingtypes.Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"` + // min_self_delegation is the validator's self declared minimum self delegation. + // + // Since: cosmos-sdk 0.46 + MinSelfDelegation sdk.Int `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_self_delegation"` +} + +type GenesisState struct { + // params defines all the paramaters of related to deposit. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + // last_total_power tracks the total amounts of bonded tokens recorded during + // the previous end block. + LastTotalPower sdk.Int `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"last_total_power"` + // last_validator_powers is a special index that provides a historical list + // of the last-block's bonded validators. + LastValidatorPowers []stakingtypes.LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers"` + // delegations defines the validator set at genesis. + Validators []Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"` + // delegations defines the delegations active at genesis. + Delegations []stakingtypes.Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations"` + // unbonding_delegations defines the unbonding delegations active at genesis. + UnbondingDelegations []stakingtypes.UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations"` + // redelegations defines the redelegations active at genesis. + Redelegations []stakingtypes.Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations"` + Exported bool `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,omitempty"` +} + +type MultiStakingGenesisState struct { + MultiStakingLocks []multistakingtypes.MultiStakingLock `protobuf:"bytes,1,rep,name=multi_staking_locks,json=multiStakingLocks,proto3" json:"multi_staking_locks"` + MultiStakingUnlocks []multistakingtypes.MultiStakingUnlock `protobuf:"bytes,2,rep,name=multi_staking_unlocks,json=multiStakingUnlocks,proto3" json:"multi_staking_unlocks"` + MultiStakingCoinInfo []multistakingtypes.MultiStakingCoinInfo `protobuf:"bytes,3,rep,name=multi_staking_coin_info,json=multiStakingCoinInfo,proto3" json:"multi_staking_coin_info"` + ValidatorMultiStakingCoins []multistakingtypes.ValidatorMultiStakingCoin `protobuf:"bytes,4,rep,name=validator_multi_staking_coins,json=validatorMultiStakingCoins,proto3" json:"validator_multi_staking_coins"` + StakingGenesisState GenesisState `protobuf:"bytes,6,opt,name=staking_genesis_state,json=stakingGenesisState,proto3" json:"staking_genesis_state"` +} diff --git a/app/upgrades/multi-staking/upgrade.go b/app/upgrades/multi-staking/upgrade.go new file mode 100644 index 00000000..47660571 --- /dev/null +++ b/app/upgrades/multi-staking/upgrade.go @@ -0,0 +1,332 @@ +package multistaking + +import ( + "encoding/json" + "fmt" + "time" + + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/codec" + servertypes "github.com/cosmos/cosmos-sdk/server/types" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" + multistaking "github.com/realio-tech/multi-staking-module/x/multi-staking" + minttypes "github.com/realiotech/realio-network/x/mint/types" + + authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" + bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + multistakingkeeper "github.com/realio-tech/multi-staking-module/x/multi-staking/keeper" + + "cosmossdk.io/math" + multistakingtypes "github.com/realio-tech/multi-staking-module/x/multi-staking/types" + "github.com/realiotech/realio-network/app/upgrades/multi-staking/legacy" + "github.com/spf13/cast" +) + +var ( + bondedPoolAddress = authtypes.NewModuleAddress(stakingtypes.BondedPoolName) + unbondedPoolAddress = authtypes.NewModuleAddress(stakingtypes.NotBondedPoolName) + multiStakingAddress = authtypes.NewModuleAddress(multistakingtypes.ModuleName) + mintModuleAddress = authtypes.NewModuleAddress(minttypes.ModuleName) + newBondedCoinDenom = "stake" + msCoinDenomLists = []string{"ario", "arst"} +) + +func CreateUpgradeHandler( + mm *module.Manager, + configurator module.Configurator, + appOpts servertypes.AppOptions, + cdc codec.Codec, + bk bankkeeper.Keeper, + msk multistakingkeeper.Keeper, + ak authkeeper.AccountKeeper, + keys map[string]*storetypes.KVStoreKey, +) upgradetypes.UpgradeHandler { + return func(ctx sdk.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) { + ctx.Logger().Info("Starting upgrade for multi staking...") + + nodeHome := cast.ToString(appOpts.Get(flags.FlagHome)) + upgradeGenFile := nodeHome + "/config/state.json" + appState, _, err := genutiltypes.GenesisStateFromGenFile(upgradeGenFile) + if err != nil { + panic(err) + } + + // migrate multistaking + appState, err = migrateMultiStaking(appState) + if err != nil { + panic(err) + } + + // validate genesis + var genesisState multistakingtypes.GenesisState + cdc.MustUnmarshalJSON(appState[multistakingtypes.ModuleName], &genesisState) + err = genesisState.Validate() + if err != nil { + panic(err) + } + + ak.GetModuleAccount(ctx, multistakingtypes.ModuleName) + + // migrate bank + migrateBank(ctx, bk) + + vm[multistakingtypes.ModuleName] = multistaking.AppModule{}.ConsensusVersion() + mm.Modules[multistakingtypes.ModuleName].InitGenesis(ctx, cdc, appState[multistakingtypes.ModuleName]) + + return mm.RunMigrations(ctx, configurator, vm) + } +} + +func migrateBank(ctx sdk.Context, bk bankkeeper.Keeper) { + // convert bonded pool balances and send MsCoins to multi-staking module account + convertStakingModulePoolBalances(ctx, bk, bondedPoolAddress) + + // convert unbonded pool balances and send MsCoins to multi-staking module account + convertStakingModulePoolBalances(ctx, bk, unbondedPoolAddress) +} + +func convertStakingModulePoolBalances(ctx sdk.Context, bk bankkeeper.Keeper, accAddr sdk.AccAddress) { + // Send coins from accAddr add same amout to multistaking account + accountBalances := bk.GetAllBalances(ctx, accAddr) + bk.SendCoins(ctx, accAddr, multiStakingAddress, accountBalances) + // mint stake to bonded pool + convertedCoinsAmount := math.ZeroInt() + for _, coinAmount := range accountBalances { + convertedCoinsAmount = convertedCoinsAmount.Add(coinAmount.Amount) + } + amount := sdk.NewCoins(sdk.NewCoin(newBondedCoinDenom, convertedCoinsAmount)) + bk.MintCoins(ctx, minttypes.ModuleName, amount) + bk.SendCoins(ctx, mintModuleAddress, accAddr, amount) +} + +func migrateMultiStaking(appState map[string]json.RawMessage) (map[string]json.RawMessage, error) { + var oldState legacy.GenesisState + err := json.Unmarshal(appState[stakingtypes.ModuleName], &oldState) + if err != nil { + return nil, err + } + + newState := MultiStakingGenesisState{} + // Migrate state.StakingGenesisState + stakingGenesisState := GenesisState{} + + stakingGenesisState.Params = Params{ + UnbondingTime: oldState.Params.UnbondingTime, + MaxValidators: oldState.Params.MaxValidators, + MaxEntries: oldState.Params.MaxEntries, + HistoricalEntries: oldState.Params.HistoricalEntries, + BondDenom: newBondedCoinDenom, + MinCommissionRate: oldState.Params.MinCommissionRate, + } + stakingGenesisState.LastTotalPower = oldState.LastTotalPower + stakingGenesisState.Validators = convertValidators(oldState.Validators) + stakingGenesisState.Delegations = convertDelegations(oldState.Delegations) + stakingGenesisState.UnbondingDelegations = convertUnbondings(oldState.UnbondingDelegations) + stakingGenesisState.Redelegations = convertRedelegations(oldState.Redelegations) + stakingGenesisState.Exported = oldState.Exported + + newState.StakingGenesisState = stakingGenesisState + + // Migrate state.ValidatorAllowedToken field + newState.ValidatorMultiStakingCoins = make([]multistakingtypes.ValidatorMultiStakingCoin, 0) + + for _, val := range oldState.Validators { + allowedToken := multistakingtypes.ValidatorMultiStakingCoin{ + ValAddr: val.OperatorAddress, + CoinDenom: val.BondDenom, + } + newState.ValidatorMultiStakingCoins = append(newState.ValidatorMultiStakingCoins, allowedToken) + } + + // Migrate state.MultiStakingLock field + newState.MultiStakingLocks = make([]multistakingtypes.MultiStakingLock, 0) + + for _, val := range oldState.Validators { + for _, del := range oldState.Delegations { + if del.ValidatorAddress == val.OperatorAddress { + val, amount := tokenAmountFromShares(val, del.Shares) + lock := multistakingtypes.MultiStakingLock{ + LockID: multistakingtypes.LockID{ + MultiStakerAddr: del.DelegatorAddress, + ValAddr: del.ValidatorAddress, + }, + LockedCoin: multistakingtypes.MultiStakingCoin{ + Denom: val.BondDenom, + Amount: amount, + BondWeight: sdk.OneDec(), + }, + } + newState.MultiStakingLocks = append(newState.MultiStakingLocks, lock) + } + + } + } + + newState.MultiStakingCoinInfo = make([]multistakingtypes.MultiStakingCoinInfo, 0) + for _, msCoinDenom := range msCoinDenomLists { + msCoinInfo := multistakingtypes.MultiStakingCoinInfo{ + Denom: msCoinDenom, + BondWeight: sdk.OneDec(), + } + newState.MultiStakingCoinInfo = append(newState.MultiStakingCoinInfo, msCoinInfo) + } + + // Migrate state.MultiStakingUnlock field + newState.MultiStakingUnlocks = make([]multistakingtypes.MultiStakingUnlock, 0) + for _, ubd := range oldState.UnbondingDelegations { + unlockID := multistakingtypes.UnlockID{ + MultiStakerAddr: ubd.DelegatorAddress, + ValAddr: ubd.ValidatorAddress, + } + + unlockEntries := make([]multistakingtypes.UnlockEntry, 0) + for _, entry := range ubd.Entries { + unlockEntry := multistakingtypes.UnlockEntry{ + CreationHeight: entry.CreationHeight, + UnlockingCoin: multistakingtypes.MultiStakingCoin{ + Denom: entry.InitialBalance.Denom, + Amount: entry.InitialBalance.Amount, + BondWeight: sdk.OneDec(), + }, + } + unlockEntries = append(unlockEntries, unlockEntry) + } + + msUnLock := multistakingtypes.MultiStakingUnlock{ + UnlockID: unlockID, + Entries: unlockEntries, + } + + newState.MultiStakingUnlocks = append(newState.MultiStakingUnlocks, msUnLock) + } + + newData, err := json.Marshal(&newState) + if err != nil { + return nil, err + } + + appState[multistakingtypes.ModuleName] = newData + + return appState, nil +} + +func tokenAmountFromShares(v legacy.Validator, delShares sdk.Dec) (legacy.Validator, math.Int) { + remainingShares := v.DelegatorShares.Sub(delShares) + + var amount math.Int + if remainingShares.IsZero() { + // last delegation share gets any trimmings + amount = v.Tokens + v.Tokens = math.ZeroInt() + } else { + // leave excess tokens in the validator + // however fully use all the delegator shares + amount = tokensFromShares(v, delShares).TruncateInt() + v.Tokens = v.Tokens.Sub(amount) + + if v.Tokens.IsNegative() { + panic("attempting to remove more tokens than available in validator") + } + } + + v.DelegatorShares = remainingShares + + return v, amount +} + +func tokensFromShares(v legacy.Validator, shares sdk.Dec) sdk.Dec { + return (shares.MulInt(v.Tokens)).Quo(v.DelegatorShares) +} + +func convertValidators(validators []legacy.Validator) []Validator { + newValidators := make([]Validator, 0) + for _, val := range validators { + date, err := time.Parse("2006-01-02T15:04:05.999999999Z07:00", "2023-06-20T11:54:21.351285642Z") + fmt.Println("time", val.Commission.UpdateTime.String(), err, date) + newVal := Validator{ + OperatorAddress: val.OperatorAddress, + ConsensusPubkey: val.ConsensusPubkey, + Jailed: val.Jailed, + Status: val.Status, + Tokens: val.Tokens, + DelegatorShares: val.DelegatorShares, + Description: stakingtypes.Description(val.Description), + UnbondingHeight: val.UnbondingHeight, + UnbondingTime: val.UnbondingTime, + Commission: stakingtypes.Commission{ + CommissionRates: stakingtypes.CommissionRates(val.Commission.CommissionRates), + UpdateTime: val.Commission.UpdateTime, + }, + MinSelfDelegation: val.MinSelfDelegation, + } + newValidators = append(newValidators, newVal) + } + return newValidators +} + +func convertDelegations(delegations []legacy.Delegation) []stakingtypes.Delegation { + newDelegations := make([]stakingtypes.Delegation, 0) + for _, del := range delegations { + newDel := stakingtypes.Delegation{ + DelegatorAddress: del.DelegatorAddress, + ValidatorAddress: del.ValidatorAddress, + Shares: del.Shares, + } + + newDelegations = append(newDelegations, newDel) + } + return newDelegations +} + +func convertUnbondings(ubds []legacy.UnbondingDelegation) []stakingtypes.UnbondingDelegation { + newUbds := make([]stakingtypes.UnbondingDelegation, 0) + for _, ubd := range ubds { + newEntries := make([]stakingtypes.UnbondingDelegationEntry, 0) + for _, entry := range ubd.Entries { + newEntry := stakingtypes.UnbondingDelegationEntry{ + CreationHeight: entry.CreationHeight, + CompletionTime: entry.CompletionTime, + InitialBalance: entry.InitialBalance.Amount, + Balance: entry.Balance.Amount, + } + newEntries = append(newEntries, newEntry) + } + newUbd := stakingtypes.UnbondingDelegation{ + DelegatorAddress: ubd.DelegatorAddress, + ValidatorAddress: ubd.ValidatorAddress, + Entries: newEntries, + } + newUbds = append(newUbds, newUbd) + } + return newUbds +} + +func convertRedelegations(reDels []legacy.Redelegation) []stakingtypes.Redelegation { + newRedels := make([]stakingtypes.Redelegation, 0) + for _, reDel := range reDels { + newEntries := make([]stakingtypes.RedelegationEntry, 0) + for _, entry := range reDel.Entries { + newEntry := stakingtypes.RedelegationEntry{ + CreationHeight: entry.CreationHeight, + CompletionTime: entry.CompletionTime, + InitialBalance: entry.InitialBalance.Amount, + SharesDst: entry.SharesDst, + } + newEntries = append(newEntries, newEntry) + } + newRedel := stakingtypes.Redelegation{ + DelegatorAddress: reDel.DelegatorAddress, + ValidatorSrcAddress: reDel.ValidatorSrcAddress, + ValidatorDstAddress: reDel.ValidatorDstAddress, + Entries: newEntries, + } + newRedels = append(newRedels, newRedel) + } + return newRedels +} diff --git a/go.mod b/go.mod index a22b0f01..77123f96 100644 --- a/go.mod +++ b/go.mod @@ -5,8 +5,9 @@ go 1.20 require ( cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/math v1.0.1 - github.com/cosmos/cosmos-sdk v0.46.11 - github.com/cosmos/gogoproto v1.4.6 + github.com/cosmos/cosmos-proto v1.0.0-beta.1 + github.com/cosmos/cosmos-sdk v0.46.12 + github.com/cosmos/gogoproto v1.4.11 github.com/cosmos/ibc-go/v6 v6.1.1 github.com/ethereum/go-ethereum v1.10.26 github.com/evmos/ethermint v0.21.0 @@ -15,24 +16,26 @@ require ( github.com/gorilla/mux v1.8.0 github.com/grpc-ecosystem/grpc-gateway v1.16.0 github.com/rakyll/statik v0.1.7 + github.com/realio-tech/multi-staking-module v0.0.0 github.com/spf13/cast v1.5.1 github.com/spf13/cobra v1.7.0 github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.8.4 github.com/tendermint/tendermint v0.34.27 github.com/tendermint/tm-db v0.6.7 - google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 - google.golang.org/grpc v1.56.0 + google.golang.org/genproto/googleapis/api v0.0.0-20230726155614-23370e0ffb3e + google.golang.org/grpc v1.57.0 + google.golang.org/protobuf v1.31.0 gopkg.in/yaml.v2 v2.4.0 sigs.k8s.io/yaml v1.3.0 ) require ( - cloud.google.com/go v0.110.0 // indirect - cloud.google.com/go/compute v1.19.1 // indirect + cloud.google.com/go v0.110.6 // indirect + cloud.google.com/go/compute v1.23.0 // indirect cloud.google.com/go/compute/metadata v0.2.3 // indirect - cloud.google.com/go/iam v0.13.0 // indirect - cloud.google.com/go/storage v1.28.1 // indirect + cloud.google.com/go/iam v1.1.1 // indirect + cloud.google.com/go/storage v1.30.1 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect github.com/99designs/keyring v1.2.1 // indirect @@ -58,7 +61,6 @@ require ( github.com/cometbft/cometbft-db v0.7.0 // indirect github.com/confio/ics23/go v0.9.0 // indirect github.com/cosmos/btcutil v1.0.5 // indirect - github.com/cosmos/cosmos-proto v1.0.0-beta.1 // indirect github.com/cosmos/go-bip39 v1.0.0 // indirect github.com/cosmos/gorocksdb v1.2.0 // indirect github.com/cosmos/iavl v0.19.5 // indirect @@ -94,9 +96,10 @@ require ( github.com/google/btree v1.1.2 // indirect github.com/google/go-cmp v0.5.9 // indirect github.com/google/orderedcode v0.0.1 // indirect + github.com/google/s2a-go v0.1.4 // indirect github.com/google/uuid v1.3.0 // indirect github.com/googleapis/enterprise-certificate-proxy v0.2.3 // indirect - github.com/googleapis/gax-go/v2 v2.7.1 // indirect + github.com/googleapis/gax-go/v2 v2.11.0 // indirect github.com/gorilla/handlers v1.5.1 // indirect github.com/gorilla/websocket v1.5.0 // indirect github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect @@ -170,18 +173,19 @@ require ( github.com/zondax/ledger-go v0.14.1 // indirect go.etcd.io/bbolt v1.3.6 // indirect go.opencensus.io v0.24.0 // indirect - golang.org/x/crypto v0.5.0 // indirect - golang.org/x/exp v0.0.0-20230131160201-f062dba9d201 // indirect - golang.org/x/net v0.9.0 // indirect - golang.org/x/oauth2 v0.7.0 // indirect - golang.org/x/sync v0.1.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/crypto v0.12.0 // indirect + golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb // indirect + golang.org/x/net v0.14.0 // indirect + golang.org/x/oauth2 v0.8.0 // indirect + golang.org/x/sync v0.2.0 // indirect + golang.org/x/sys v0.11.0 // indirect + golang.org/x/term v0.11.0 // indirect + golang.org/x/text v0.12.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect - google.golang.org/api v0.114.0 // indirect + google.golang.org/api v0.126.0 // indirect google.golang.org/appengine v1.6.7 // indirect - google.golang.org/protobuf v1.30.0 // indirect + google.golang.org/genproto v0.0.0-20230803162519-f966b187b2e5 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20230815205213-6bfd019c3878 // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect gopkg.in/yaml.v3 v3.0.1 // indirect @@ -191,12 +195,19 @@ require ( replace ( // use Realio sdk v0.46.11-realio-4 - github.com/cosmos/cosmos-sdk => github.com/realiotech/cosmos-sdk v0.46.11-realio-4 + // github.com/cosmos/cosmos-sdk => github.com/realiotech/cosmos-sdk v0.46.11-realio-4 + + github.com/cosmos/cosmos-sdk => github.com/decentrio/cosmos-sdk v0.46.12-0.20240103120710-e7af80d04f39 + // github.com/cosmos/cosmos-sdk => ./cosmos-sdk + // temporary fork of ethermint while evmos upgrades github.com/evmos/ethermint => github.com/realiotech/ethermint v0.21.0-realio-1 // use cosmos flavored protobufs github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1 + + github.com/realio-tech/multi-staking-module => github.com/realiotech/multi-staking v1.0.0-rc2 + + // github.com/realio-tech/multi-staking-module => github.com/GNaD13/multi-staking v0.0.0-20240103093120-70811831ca3b // Informal Tendermint fork github.com/tendermint/tendermint => github.com/cometbft/cometbft v0.34.27 - ) diff --git a/go.sum b/go.sum index 508abf8c..fd4c72dd 100644 --- a/go.sum +++ b/go.sum @@ -34,8 +34,8 @@ cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w9 cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= -cloud.google.com/go v0.110.0 h1:Zc8gqp3+a9/Eyph2KDmcGaPtbKRIoqq4YTlL4NMD0Ys= -cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY= +cloud.google.com/go v0.110.6 h1:8uYAkj3YHTP/1iwReuHPxLSbdcyc+dSBbzFMrVwDR6Q= +cloud.google.com/go v0.110.6/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI= cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= @@ -73,8 +73,8 @@ cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= -cloud.google.com/go/compute v1.19.1 h1:am86mquDUgjGNWxiGn+5PGLbmgiWXlE/yNWpIpNvuXY= -cloud.google.com/go/compute v1.19.1/go.mod h1:6ylj3a05WF8leseCdIf77NK0g1ey+nj5IKd5/kvShxE= +cloud.google.com/go/compute v1.23.0 h1:tP41Zoavr8ptEqaW6j+LQOnyBBhO7OkOMAGrgLopTwY= +cloud.google.com/go/compute v1.23.0/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM= cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY= cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= @@ -114,13 +114,12 @@ cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y97 cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= -cloud.google.com/go/iam v0.13.0 h1:+CmB+K0J/33d0zSQ9SlFWUeCCEn5XJA0ZMZ3pHE9u8k= -cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0= +cloud.google.com/go/iam v1.1.1 h1:lW7fzj15aVIXYHREOqjRBV9PsH0Z6u8Y46a1YGvQP4Y= +cloud.google.com/go/iam v1.1.1/go.mod h1:A5avdyVL2tCppe4unb0951eI9jreack+RJ0/d+KUZOU= cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= -cloud.google.com/go/longrunning v0.4.1 h1:v+yFJOfKC3yZdY6ZUI933pIYdhyhV8S3NpWrXWmg7jM= cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= @@ -178,8 +177,8 @@ cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3f cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= -cloud.google.com/go/storage v1.28.1 h1:F5QDG5ChchaAVQhINh24U99OWHURqrW8OmQcGKXcbgI= -cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y= +cloud.google.com/go/storage v1.30.1 h1:uOdMxAs8HExqBlnLtnQyP0YkvbiDpdGShGKtx6U/oNM= +cloud.google.com/go/storage v1.30.1/go.mod h1:NfxhC0UJE1aXSx7CIIbCf7y9HKT7BiccwkR7+P7gN8E= cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= @@ -373,8 +372,8 @@ github.com/cosmos/cosmos-proto v1.0.0-beta.1/go.mod h1:8k2GNZghi5sDRFw/scPL8gMSo github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= -github.com/cosmos/gogoproto v1.4.6 h1:Ee7z15dWJaGlgM2rWrK8N2IX7PQcuccu8oG68jp5RL4= -github.com/cosmos/gogoproto v1.4.6/go.mod h1:VS/ASYmPgv6zkPKLjR9EB91lwbLHOzaGCirmKKhncfI= +github.com/cosmos/gogoproto v1.4.11 h1:LZcMHrx4FjUgrqQSWeaGC1v/TeuVFqSLa43CC6aWR2g= +github.com/cosmos/gogoproto v1.4.11/go.mod h1:/g39Mh8m17X8Q/GDEs5zYTSNaNnInBSohtaxzQnYq1Y= github.com/cosmos/gorocksdb v1.2.0 h1:d0l3jJG8M4hBouIZq0mDUHZ+zjOx044J3nGRskwTb4Y= github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw= github.com/cosmos/iavl v0.19.5 h1:rGA3hOrgNxgRM5wYcSCxgQBap7fW82WZgY78V9po/iY= @@ -400,6 +399,8 @@ github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/decentrio/cosmos-sdk v0.46.12-0.20240103120710-e7af80d04f39 h1:o5K+CQjwEK3y6rNdHKwD10kwx/ISwHNqGFnId+wpQjI= +github.com/decentrio/cosmos-sdk v0.46.12-0.20240103120710-e7af80d04f39/go.mod h1:bG4AkW9bqc8ycrryyKGQEl3YV9BY2wr6HggGq8kvcgM= github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4= github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo= github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= @@ -636,6 +637,8 @@ github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/s2a-go v0.1.4 h1:1kZ/sQM3srePvKs3tXAvQzo66XfcReoqFpIpIccE7Oc= +github.com/google/s2a-go v0.1.4/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= @@ -656,8 +659,8 @@ github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99 github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= -github.com/googleapis/gax-go/v2 v2.7.1 h1:gF4c0zjUP2H/s/hEGyLA3I0fA2ZWjzYiONAD6cvPr8A= -github.com/googleapis/gax-go/v2 v2.7.1/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI= +github.com/googleapis/gax-go/v2 v2.11.0 h1:9V9PWXEsWnPpQhu/PeQIkS4eGzMlTLGgt80cUUI8Ki4= +github.com/googleapis/gax-go/v2 v2.11.0/go.mod h1:DxmR61SGKkGLa2xigwuZIQpkCI2S5iydzRfb3peWZJI= github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= @@ -1027,10 +1030,10 @@ github.com/rakyll/statik v0.1.7/go.mod h1:AlZONWzMtEnMs7W4e/1LURLiI49pIMmp6V9Ung github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= -github.com/realiotech/cosmos-sdk v0.46.11-realio-4 h1:Iv/5DFeHpk22hPOF7DyOmBey5/1JraUVt4iec+s/TLc= -github.com/realiotech/cosmos-sdk v0.46.11-realio-4/go.mod h1:INxTBJpv7zqrROoAlBtucfTPvQPoVgTTrfkNv1EN+vY= github.com/realiotech/ethermint v0.21.0-realio-1 h1:x+RYL/yjTI+QTN0mppmwGR3N8h/DZAVnz8d1wTFtORM= github.com/realiotech/ethermint v0.21.0-realio-1/go.mod h1:0c+GK/UxT/wykI8InX9U1Pmnj1M4wPRMgJtibd/RnqI= +github.com/realiotech/multi-staking v1.0.0-rc2 h1:ExpH5+oR7DikN/ZZ7M+/VTrNwUAumWPUo5K2Q2Vu/uc= +github.com/realiotech/multi-staking v1.0.0-rc2/go.mod h1:GRUwhBGWtVwHX0yByxXdfpCLHm3PgWMG8dnXvhoIfog= github.com/regen-network/cosmos-proto v0.3.1 h1:rV7iM4SSFAagvy8RiyhiACbWEGotmqzywPxOvwMdxcg= github.com/regen-network/cosmos-proto v0.3.1/go.mod h1:jO0sVX6a1B36nmE8C9xBFXpNwWejXC7QqCOnH3O0+YM= github.com/regen-network/protobuf v1.3.3-alpha.regen.1 h1:OHEc+q5iIAXpqiqFKeLpu5NwTIkVXUs48vFMwzqpqY4= @@ -1236,8 +1239,9 @@ golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.5.0 h1:U/0M97KRkSFvyD/3FSmdP5W5swImpNgle/EHFhOsQPE= -golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU= +golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk= +golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -1252,8 +1256,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= -golang.org/x/exp v0.0.0-20230131160201-f062dba9d201 h1:BEABXpNXLEz0WxtA+6CQIz2xkg80e+1zrhWyMcq8VzE= -golang.org/x/exp v0.0.0-20230131160201-f062dba9d201/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb h1:mIKbk8weKhSeLH2GmUTrvx8CjkyJmnU1wFmg59CUjFA= +golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= @@ -1281,7 +1285,7 @@ golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8= +golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= 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= @@ -1336,6 +1340,7 @@ golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= @@ -1348,8 +1353,8 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= -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/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14= +golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= 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= @@ -1375,8 +1380,8 @@ golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= golang.org/x/oauth2 v0.1.0/go.mod h1:G9FE4dLTsbXUu90h/Pf85g4w1D+SSAgR+q46nJZ8M4A= -golang.org/x/oauth2 v0.7.0 h1:qe6s0zUXlPX80/dITx3440hWZ7GwMwgDDyrSGTPJG/g= -golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4= +golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8= +golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -1391,8 +1396,8 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI= +golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1501,14 +1506,14 @@ golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.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/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM= +golang.org/x/sys v0.11.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= golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ= -golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0= +golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU= 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= @@ -1518,9 +1523,10 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -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/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc= +golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= 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= @@ -1657,8 +1663,8 @@ google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= -google.golang.org/api v0.114.0 h1:1xQPji6cO2E2vLiI+C/XiFAnsn1WV3mjaEwGLhi3grE= -google.golang.org/api v0.114.0/go.mod h1:ifYI2ZsFK6/uGddGfAD5BMxlnkBqCmqHSDUVi45N5Yg= +google.golang.org/api v0.126.0 h1:q4GJq+cAdMAC7XP7njvQ4tvohGLiSlytuL4BQxbIZ+o= +google.golang.org/api v0.126.0/go.mod h1:mBwVAtz+87bEN6CbA1GtZPDOqY2R5ONPqJeIlvyo4Aw= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1778,8 +1784,12 @@ google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqw google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= -google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A= -google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU= +google.golang.org/genproto v0.0.0-20230803162519-f966b187b2e5 h1:L6iMMGrtzgHsWofoFcihmDEMYeDR9KN/ThbPWGrh++g= +google.golang.org/genproto v0.0.0-20230803162519-f966b187b2e5/go.mod h1:oH/ZOT02u4kWEp7oYBGYFFkCdKS/uYR9Z7+0/xuuFp8= +google.golang.org/genproto/googleapis/api v0.0.0-20230726155614-23370e0ffb3e h1:z3vDksarJxsAKM5dmEGv0GHwE2hKJ096wZra71Vs4sw= +google.golang.org/genproto/googleapis/api v0.0.0-20230726155614-23370e0ffb3e/go.mod h1:rsr7RhLuwsDKL7RmgDDCUc6yaGr1iqceVb5Wv6f6YvQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230815205213-6bfd019c3878 h1:lv6/DhyiFFGsmzxbsUUTOkN29II+zeWHxvT8Lpdxsv0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230815205213-6bfd019c3878/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= @@ -1822,8 +1832,8 @@ google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACu google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= -google.golang.org/grpc v1.56.0 h1:+y7Bs8rtMd07LeXmL3NxcTLn7mUkbKZqEpPhMNkwJEE= -google.golang.org/grpc v1.56.0/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s= +google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw= +google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= @@ -1840,8 +1850,8 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng= -google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= +google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/local_node.sh b/local_node.sh index 0bdbf57d..e3fc1121 100755 --- a/local_node.sh +++ b/local_node.sh @@ -54,7 +54,7 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then # If keys exist they should be deleted for KEY in "${KEYS[@]}"; do - realio-networkd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --home "$HOMEDIR" + realio-networkd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --home "$HOME/.realio-network-tmp" done RST_ISSUER=$(realio-networkd keys show ${KEYS[2]} --keyring-backend $KEYRING --home "$HOMEDIR" -a) @@ -67,6 +67,7 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then jq '.app_state["mint"]["params"]["mint_denom"]="ario"' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" jq '.app_state["crisis"]["constant_fee"]["denom"]="ario"' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="ario"' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" + jq '.app_state["gov"]["voting_params"]["voting_period"]="45s"' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" jq '.app_state["evm"]["params"]["evm_denom"]="ario"' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" jq '.app_state["asset"]["tokens"]=[{ "authorizationRequired": true, "authorized": [{ "address": "'"$RST_ISSUER"'", "authorized": true }], "manager": "'"$RST_ISSUER"'", "name": "Realio Security Token", "symbol": "rst", "total": "50000000" }]' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" jq '.app_state["bank"]["denom_metadata"]=[ { "description": "The native utility, gas, evm, governance and staking token of the Realio Network", "denom_units": [ { "denom": "ario", "exponent": 0, "aliases": [ "attorio" ] }, { "denom": "rio", "exponent": 18, "aliases": [] } ], "base": "ario", "display": "rio", "name": "Realio Network Rio", "symbol": "RIO", "uri": "", "uri_hash": "" }, { "description": "Realio Security Token", "denom_units": [ { "denom": "arst", "exponent": 0, "aliases": [ "attorst" ] }, { "denom": "rst", "exponent": 18, "aliases": [] } ], "base": "arst", "display": "rst", "name": "Realio Security Token", "symbol": "RST", "uri": "", "uri_hash": "" } ]' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" @@ -122,4 +123,6 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then fi # Start the node (remove the --pruning=nothing flag if historical queries are not needed) -realio-networkd start --pruning=nothing "$TRACE" --log_level $LOGLEVEL --minimum-gas-prices=0.0001ario --json-rpc.api eth,txpool,personal,net,debug,web3 --api.enable --home "$HOMEDIR" \ No newline at end of file +realio-networkd start --pruning=nothing "$TRACE" --log_level $LOGLEVEL --minimum-gas-prices=0.00001ario --json-rpc.api eth,txpool,personal,net,debug,web3 --api.enable --home "$HOMEDIR" + +#realio-networkd start --pruning=nothing "$TRACE" --log_level $LOGLEVEL --minimum-gas-prices=0ario --json-rpc.api eth,txpool,personal,net,debug,web3 --api.enable --home "$HOMEDIR" \ No newline at end of file diff --git a/scripts/node.sh b/scripts/node.sh new file mode 100644 index 00000000..a7a758e4 --- /dev/null +++ b/scripts/node.sh @@ -0,0 +1,22 @@ +# start main chain (decentrio) +git checkout test/upgrade +./local_node.sh + +# proposal upgrade +realio-networkd tx gov submit-legacy-proposal software-upgrade multistaking --upgrade-height 30 --description "testing, testing, 1, 2, 3" --upgrade-info "testing" --title "Test Proposal" --from dev0 --keyring-backend test --no-validate --chain-id realionetworklocal_7777-1 --deposit 10000000ario --yes --home "$HOME/.realio-network-tmp" --fees 1000000000000000000000000ario --gas 1000000 + +# vote +realio-networkd tx gov vote 1 yes --from dev0 --keyring-backend test --chain-id realionetworklocal_7777-1 --yes --home "$HOME/.realio-network-tmp" --fees 1000000000000000000000000ario + +# wait until upgrade height and cancel node process + +# copy state to config +# export new state +realio-networkd export --home "$HOME/.realio-network-tmp" >> ~/.realio-network-tmp/config/state.json + +# checkout intergrate-multistaking +git checkout intergrate-multistaking +# build new binary +make install +# run node +realio-networkd start --log_level "info" --minimum-gas-prices=0.00001ario --json-rpc.api eth,txpool,personal,net,debug,web3 --api.enable --home "$HOME/.realio-network-tmp"