@leapwallet/buffer-boba
Version:
Buffer Boba is a library for decoding protocol buffers in the cosmos ecosystem.
1,358 lines • 73.7 kB
TypeScript
import { Validator, ValidatorAmino, ValidatorSDKType } from './validator';
import { Coin, CoinAmino, CoinSDKType } from '../../cosmos/base/v1beta1/coin';
import { BinaryReader, BinaryWriter } from '../../../../binary';
export declare enum AuthzPermissionChange {
/** GRANT - Grant the address trade permissions */
GRANT = 0,
/** REVOKE - Revoke trade permissions from the address */
REVOKE = 1,
UNRECOGNIZED = -1
}
export declare const AuthzPermissionChangeSDKType: typeof AuthzPermissionChange;
export declare const AuthzPermissionChangeAmino: typeof AuthzPermissionChange;
export declare function authzPermissionChangeFromJSON(object: any): AuthzPermissionChange;
export declare function authzPermissionChangeToJSON(object: AuthzPermissionChange): string;
export interface MsgUpdateInnerRedemptionRateBounds {
creator: string;
chainId: string;
minInnerRedemptionRate: string;
maxInnerRedemptionRate: string;
}
export interface MsgUpdateInnerRedemptionRateBoundsProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateInnerRedemptionRateBounds';
value: Uint8Array;
}
export interface MsgUpdateInnerRedemptionRateBoundsAmino {
creator?: string;
chain_id?: string;
min_inner_redemption_rate?: string;
max_inner_redemption_rate?: string;
}
export interface MsgUpdateInnerRedemptionRateBoundsAminoMsg {
type: '/stride.stakeibc.MsgUpdateInnerRedemptionRateBounds';
value: MsgUpdateInnerRedemptionRateBoundsAmino;
}
export interface MsgUpdateInnerRedemptionRateBoundsSDKType {
creator: string;
chain_id: string;
min_inner_redemption_rate: string;
max_inner_redemption_rate: string;
}
export interface MsgUpdateInnerRedemptionRateBoundsResponse {
}
export interface MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateInnerRedemptionRateBoundsResponse';
value: Uint8Array;
}
export interface MsgUpdateInnerRedemptionRateBoundsResponseAmino {
}
export interface MsgUpdateInnerRedemptionRateBoundsResponseAminoMsg {
type: '/stride.stakeibc.MsgUpdateInnerRedemptionRateBoundsResponse';
value: MsgUpdateInnerRedemptionRateBoundsResponseAmino;
}
export interface MsgUpdateInnerRedemptionRateBoundsResponseSDKType {
}
export interface MsgLiquidStake {
creator: string;
amount: string;
hostDenom: string;
}
export interface MsgLiquidStakeProtoMsg {
typeUrl: '/stride.stakeibc.MsgLiquidStake';
value: Uint8Array;
}
export interface MsgLiquidStakeAmino {
creator?: string;
amount?: string;
host_denom?: string;
}
export interface MsgLiquidStakeAminoMsg {
type: 'stakeibc/LiquidStake';
value: MsgLiquidStakeAmino;
}
export interface MsgLiquidStakeSDKType {
creator: string;
amount: string;
host_denom: string;
}
export interface MsgLiquidStakeResponse {
stToken: Coin;
}
export interface MsgLiquidStakeResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgLiquidStakeResponse';
value: Uint8Array;
}
export interface MsgLiquidStakeResponseAmino {
st_token?: CoinAmino;
}
export interface MsgLiquidStakeResponseAminoMsg {
type: '/stride.stakeibc.MsgLiquidStakeResponse';
value: MsgLiquidStakeResponseAmino;
}
export interface MsgLiquidStakeResponseSDKType {
st_token: CoinSDKType;
}
export interface MsgLSMLiquidStake {
creator: string;
amount: string;
lsmTokenIbcDenom: string;
}
export interface MsgLSMLiquidStakeProtoMsg {
typeUrl: '/stride.stakeibc.MsgLSMLiquidStake';
value: Uint8Array;
}
export interface MsgLSMLiquidStakeAmino {
creator?: string;
amount?: string;
lsm_token_ibc_denom?: string;
}
export interface MsgLSMLiquidStakeAminoMsg {
type: 'stakeibc/LSMLiquidStake';
value: MsgLSMLiquidStakeAmino;
}
export interface MsgLSMLiquidStakeSDKType {
creator: string;
amount: string;
lsm_token_ibc_denom: string;
}
export interface MsgLSMLiquidStakeResponse {
transactionComplete: boolean;
}
export interface MsgLSMLiquidStakeResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgLSMLiquidStakeResponse';
value: Uint8Array;
}
export interface MsgLSMLiquidStakeResponseAmino {
transaction_complete?: boolean;
}
export interface MsgLSMLiquidStakeResponseAminoMsg {
type: '/stride.stakeibc.MsgLSMLiquidStakeResponse';
value: MsgLSMLiquidStakeResponseAmino;
}
export interface MsgLSMLiquidStakeResponseSDKType {
transaction_complete: boolean;
}
export interface MsgClearBalance {
creator: string;
chainId: string;
amount: string;
channel: string;
}
export interface MsgClearBalanceProtoMsg {
typeUrl: '/stride.stakeibc.MsgClearBalance';
value: Uint8Array;
}
export interface MsgClearBalanceAmino {
creator?: string;
chain_id?: string;
amount?: string;
channel?: string;
}
export interface MsgClearBalanceAminoMsg {
type: 'still-no-defined';
value: MsgClearBalanceAmino;
}
export interface MsgClearBalanceSDKType {
creator: string;
chain_id: string;
amount: string;
channel: string;
}
export interface MsgClearBalanceResponse {
}
export interface MsgClearBalanceResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgClearBalanceResponse';
value: Uint8Array;
}
export interface MsgClearBalanceResponseAmino {
}
export interface MsgClearBalanceResponseAminoMsg {
type: '/stride.stakeibc.MsgClearBalanceResponse';
value: MsgClearBalanceResponseAmino;
}
export interface MsgClearBalanceResponseSDKType {
}
export interface MsgRedeemStake {
creator: string;
amount: string;
hostZone: string;
receiver: string;
}
export interface MsgRedeemStakeProtoMsg {
typeUrl: '/stride.stakeibc.MsgRedeemStake';
value: Uint8Array;
}
export interface MsgRedeemStakeAmino {
creator?: string;
amount?: string;
host_zone?: string;
receiver?: string;
}
export interface MsgRedeemStakeAminoMsg {
type: 'stakeibc/RedeemStake';
value: MsgRedeemStakeAmino;
}
export interface MsgRedeemStakeSDKType {
creator: string;
amount: string;
host_zone: string;
receiver: string;
}
export interface MsgRedeemStakeResponse {
}
export interface MsgRedeemStakeResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgRedeemStakeResponse';
value: Uint8Array;
}
export interface MsgRedeemStakeResponseAmino {
}
export interface MsgRedeemStakeResponseAminoMsg {
type: '/stride.stakeibc.MsgRedeemStakeResponse';
value: MsgRedeemStakeResponseAmino;
}
export interface MsgRedeemStakeResponseSDKType {
}
/** next: 15 */
export interface MsgRegisterHostZone {
connectionId: string;
bech32prefix: string;
hostDenom: string;
ibcDenom: string;
creator: string;
transferChannelId: string;
unbondingPeriod: bigint;
minRedemptionRate: string;
maxRedemptionRate: string;
lsmLiquidStakeEnabled: boolean;
communityPoolTreasuryAddress: string;
maxMessagesPerIcaTx: bigint;
}
export interface MsgRegisterHostZoneProtoMsg {
typeUrl: '/stride.stakeibc.MsgRegisterHostZone';
value: Uint8Array;
}
/** next: 15 */
export interface MsgRegisterHostZoneAmino {
connection_id?: string;
bech32prefix?: string;
host_denom?: string;
ibc_denom?: string;
creator?: string;
transfer_channel_id?: string;
unbonding_period?: string;
min_redemption_rate?: string;
max_redemption_rate?: string;
lsm_liquid_stake_enabled?: boolean;
community_pool_treasury_address?: string;
max_messages_per_ica_tx?: string;
}
export interface MsgRegisterHostZoneAminoMsg {
type: 'stakeibc/RegisterHostZone';
value: MsgRegisterHostZoneAmino;
}
/** next: 15 */
export interface MsgRegisterHostZoneSDKType {
connection_id: string;
bech32prefix: string;
host_denom: string;
ibc_denom: string;
creator: string;
transfer_channel_id: string;
unbonding_period: bigint;
min_redemption_rate: string;
max_redemption_rate: string;
lsm_liquid_stake_enabled: boolean;
community_pool_treasury_address: string;
max_messages_per_ica_tx: bigint;
}
export interface MsgRegisterHostZoneResponse {
}
export interface MsgRegisterHostZoneResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgRegisterHostZoneResponse';
value: Uint8Array;
}
export interface MsgRegisterHostZoneResponseAmino {
}
export interface MsgRegisterHostZoneResponseAminoMsg {
type: '/stride.stakeibc.MsgRegisterHostZoneResponse';
value: MsgRegisterHostZoneResponseAmino;
}
export interface MsgRegisterHostZoneResponseSDKType {
}
export interface MsgClaimUndelegatedTokens {
creator: string;
/** UserUnbondingRecords are keyed on {chain_id}.{epoch}.{receiver} */
hostZoneId: string;
epoch: bigint;
receiver: string;
}
export interface MsgClaimUndelegatedTokensProtoMsg {
typeUrl: '/stride.stakeibc.MsgClaimUndelegatedTokens';
value: Uint8Array;
}
export interface MsgClaimUndelegatedTokensAmino {
creator?: string;
/** UserUnbondingRecords are keyed on {chain_id}.{epoch}.{receiver} */
host_zone_id?: string;
epoch?: string;
receiver?: string;
}
export interface MsgClaimUndelegatedTokensAminoMsg {
type: 'stakeibc/ClaimUndelegatedTokens';
value: MsgClaimUndelegatedTokensAmino;
}
export interface MsgClaimUndelegatedTokensSDKType {
creator: string;
host_zone_id: string;
epoch: bigint;
receiver: string;
}
export interface MsgClaimUndelegatedTokensResponse {
}
export interface MsgClaimUndelegatedTokensResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgClaimUndelegatedTokensResponse';
value: Uint8Array;
}
export interface MsgClaimUndelegatedTokensResponseAmino {
}
export interface MsgClaimUndelegatedTokensResponseAminoMsg {
type: '/stride.stakeibc.MsgClaimUndelegatedTokensResponse';
value: MsgClaimUndelegatedTokensResponseAmino;
}
export interface MsgClaimUndelegatedTokensResponseSDKType {
}
export interface MsgRebalanceValidators {
creator: string;
hostZone: string;
numRebalance: bigint;
}
export interface MsgRebalanceValidatorsProtoMsg {
typeUrl: '/stride.stakeibc.MsgRebalanceValidators';
value: Uint8Array;
}
export interface MsgRebalanceValidatorsAmino {
creator?: string;
host_zone?: string;
num_rebalance?: string;
}
export interface MsgRebalanceValidatorsAminoMsg {
type: 'stakeibc/RebalanceValidators';
value: MsgRebalanceValidatorsAmino;
}
export interface MsgRebalanceValidatorsSDKType {
creator: string;
host_zone: string;
num_rebalance: bigint;
}
export interface MsgRebalanceValidatorsResponse {
}
export interface MsgRebalanceValidatorsResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgRebalanceValidatorsResponse';
value: Uint8Array;
}
export interface MsgRebalanceValidatorsResponseAmino {
}
export interface MsgRebalanceValidatorsResponseAminoMsg {
type: '/stride.stakeibc.MsgRebalanceValidatorsResponse';
value: MsgRebalanceValidatorsResponseAmino;
}
export interface MsgRebalanceValidatorsResponseSDKType {
}
export interface MsgAddValidators {
creator: string;
hostZone: string;
validators: Validator[];
}
export interface MsgAddValidatorsProtoMsg {
typeUrl: '/stride.stakeibc.MsgAddValidators';
value: Uint8Array;
}
export interface MsgAddValidatorsAmino {
creator?: string;
host_zone?: string;
validators?: ValidatorAmino[];
}
export interface MsgAddValidatorsAminoMsg {
type: '/stride.stakeibc.MsgAddValidators';
value: MsgAddValidatorsAmino;
}
export interface MsgAddValidatorsSDKType {
creator: string;
host_zone: string;
validators: ValidatorSDKType[];
}
export interface MsgAddValidatorsResponse {
}
export interface MsgAddValidatorsResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgAddValidatorsResponse';
value: Uint8Array;
}
export interface MsgAddValidatorsResponseAmino {
}
export interface MsgAddValidatorsResponseAminoMsg {
type: '/stride.stakeibc.MsgAddValidatorsResponse';
value: MsgAddValidatorsResponseAmino;
}
export interface MsgAddValidatorsResponseSDKType {
}
export interface ValidatorWeight {
address: string;
weight: bigint;
}
export interface ValidatorWeightProtoMsg {
typeUrl: '/stride.stakeibc.ValidatorWeight';
value: Uint8Array;
}
export interface ValidatorWeightAmino {
address?: string;
weight?: string;
}
export interface ValidatorWeightAminoMsg {
type: '/stride.stakeibc.ValidatorWeight';
value: ValidatorWeightAmino;
}
export interface ValidatorWeightSDKType {
address: string;
weight: bigint;
}
export interface MsgChangeValidatorWeights {
creator: string;
hostZone: string;
validatorWeights: ValidatorWeight[];
}
export interface MsgChangeValidatorWeightsProtoMsg {
typeUrl: '/stride.stakeibc.MsgChangeValidatorWeights';
value: Uint8Array;
}
export interface MsgChangeValidatorWeightsAmino {
creator?: string;
host_zone?: string;
validator_weights?: ValidatorWeightAmino[];
}
export interface MsgChangeValidatorWeightsAminoMsg {
type: '/stride.stakeibc.MsgChangeValidatorWeights';
value: MsgChangeValidatorWeightsAmino;
}
export interface MsgChangeValidatorWeightsSDKType {
creator: string;
host_zone: string;
validator_weights: ValidatorWeightSDKType[];
}
export interface MsgChangeValidatorWeightsResponse {
}
export interface MsgChangeValidatorWeightsResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgChangeValidatorWeightsResponse';
value: Uint8Array;
}
export interface MsgChangeValidatorWeightsResponseAmino {
}
export interface MsgChangeValidatorWeightsResponseAminoMsg {
type: '/stride.stakeibc.MsgChangeValidatorWeightsResponse';
value: MsgChangeValidatorWeightsResponseAmino;
}
export interface MsgChangeValidatorWeightsResponseSDKType {
}
export interface MsgDeleteValidator {
creator: string;
hostZone: string;
valAddr: string;
}
export interface MsgDeleteValidatorProtoMsg {
typeUrl: '/stride.stakeibc.MsgDeleteValidator';
value: Uint8Array;
}
export interface MsgDeleteValidatorAmino {
creator?: string;
host_zone?: string;
val_addr?: string;
}
export interface MsgDeleteValidatorAminoMsg {
type: 'stakeibc/DeleteValidator';
value: MsgDeleteValidatorAmino;
}
export interface MsgDeleteValidatorSDKType {
creator: string;
host_zone: string;
val_addr: string;
}
export interface MsgDeleteValidatorResponse {
}
export interface MsgDeleteValidatorResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgDeleteValidatorResponse';
value: Uint8Array;
}
export interface MsgDeleteValidatorResponseAmino {
}
export interface MsgDeleteValidatorResponseAminoMsg {
type: '/stride.stakeibc.MsgDeleteValidatorResponse';
value: MsgDeleteValidatorResponseAmino;
}
export interface MsgDeleteValidatorResponseSDKType {
}
export interface MsgRestoreInterchainAccount {
creator: string;
chainId: string;
connectionId: string;
accountOwner: string;
}
export interface MsgRestoreInterchainAccountProtoMsg {
typeUrl: '/stride.stakeibc.MsgRestoreInterchainAccount';
value: Uint8Array;
}
export interface MsgRestoreInterchainAccountAmino {
creator?: string;
chain_id?: string;
connection_id?: string;
account_owner?: string;
}
export interface MsgRestoreInterchainAccountAminoMsg {
type: 'stakeibc/RestoreInterchainAccount';
value: MsgRestoreInterchainAccountAmino;
}
export interface MsgRestoreInterchainAccountSDKType {
creator: string;
chain_id: string;
connection_id: string;
account_owner: string;
}
export interface MsgRestoreInterchainAccountResponse {
}
export interface MsgRestoreInterchainAccountResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgRestoreInterchainAccountResponse';
value: Uint8Array;
}
export interface MsgRestoreInterchainAccountResponseAmino {
}
export interface MsgRestoreInterchainAccountResponseAminoMsg {
type: '/stride.stakeibc.MsgRestoreInterchainAccountResponse';
value: MsgRestoreInterchainAccountResponseAmino;
}
export interface MsgRestoreInterchainAccountResponseSDKType {
}
export interface MsgUpdateValidatorSharesExchRate {
creator: string;
chainId: string;
valoper: string;
}
export interface MsgUpdateValidatorSharesExchRateProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateValidatorSharesExchRate';
value: Uint8Array;
}
export interface MsgUpdateValidatorSharesExchRateAmino {
creator?: string;
chain_id?: string;
valoper?: string;
}
export interface MsgUpdateValidatorSharesExchRateAminoMsg {
type: 'stakeibc/UpdateValidatorSharesExchRate';
value: MsgUpdateValidatorSharesExchRateAmino;
}
export interface MsgUpdateValidatorSharesExchRateSDKType {
creator: string;
chain_id: string;
valoper: string;
}
export interface MsgUpdateValidatorSharesExchRateResponse {
}
export interface MsgUpdateValidatorSharesExchRateResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateValidatorSharesExchRateResponse';
value: Uint8Array;
}
export interface MsgUpdateValidatorSharesExchRateResponseAmino {
}
export interface MsgUpdateValidatorSharesExchRateResponseAminoMsg {
type: '/stride.stakeibc.MsgUpdateValidatorSharesExchRateResponse';
value: MsgUpdateValidatorSharesExchRateResponseAmino;
}
export interface MsgUpdateValidatorSharesExchRateResponseSDKType {
}
export interface MsgCalibrateDelegation {
creator: string;
chainId: string;
valoper: string;
}
export interface MsgCalibrateDelegationProtoMsg {
typeUrl: '/stride.stakeibc.MsgCalibrateDelegation';
value: Uint8Array;
}
export interface MsgCalibrateDelegationAmino {
creator?: string;
chain_id?: string;
valoper?: string;
}
export interface MsgCalibrateDelegationAminoMsg {
type: '/stride.stakeibc.MsgCalibrateDelegation';
value: MsgCalibrateDelegationAmino;
}
export interface MsgCalibrateDelegationSDKType {
creator: string;
chain_id: string;
valoper: string;
}
export interface MsgCalibrateDelegationResponse {
}
export interface MsgCalibrateDelegationResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgCalibrateDelegationResponse';
value: Uint8Array;
}
export interface MsgCalibrateDelegationResponseAmino {
}
export interface MsgCalibrateDelegationResponseAminoMsg {
type: '/stride.stakeibc.MsgCalibrateDelegationResponse';
value: MsgCalibrateDelegationResponseAmino;
}
export interface MsgCalibrateDelegationResponseSDKType {
}
export interface MsgResumeHostZone {
creator: string;
chainId: string;
}
export interface MsgResumeHostZoneProtoMsg {
typeUrl: '/stride.stakeibc.MsgResumeHostZone';
value: Uint8Array;
}
export interface MsgResumeHostZoneAmino {
creator?: string;
chain_id?: string;
}
export interface MsgResumeHostZoneAminoMsg {
type: '/stride.stakeibc.MsgResumeHostZone';
value: MsgResumeHostZoneAmino;
}
export interface MsgResumeHostZoneSDKType {
creator: string;
chain_id: string;
}
export interface MsgResumeHostZoneResponse {
}
export interface MsgResumeHostZoneResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgResumeHostZoneResponse';
value: Uint8Array;
}
export interface MsgResumeHostZoneResponseAmino {
}
export interface MsgResumeHostZoneResponseAminoMsg {
type: '/stride.stakeibc.MsgResumeHostZoneResponse';
value: MsgResumeHostZoneResponseAmino;
}
export interface MsgResumeHostZoneResponseSDKType {
}
/** Creates a new trade route */
export interface MsgCreateTradeRoute {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority: string;
/** The chain ID of the host zone */
hostChainId: string;
/** Connection IDs between stride and the other zones */
strideToRewardConnectionId: string;
strideToTradeConnectionId: string;
/** Transfer channels between the host, reward, and trade zones */
hostToRewardTransferChannelId: string;
rewardToTradeTransferChannelId: string;
tradeToHostTransferChannelId: string;
/** ibc denom for the reward token on the host zone (e.g. ibc/usdc on dYdX) */
rewardDenomOnHost: string;
/** native denom of reward token on the reward zone (e.g. usdc on Noble) */
rewardDenomOnReward: string;
/** ibc denom of the reward token on the trade zone (e.g. ibc/usdc on Osmosis) */
rewardDenomOnTrade: string;
/** ibc denom of the host's token on the trade zone (e.g. ibc/dydx on Osmosis) */
hostDenomOnTrade: string;
/** the host zone's native denom (e.g. dydx on dYdX) */
hostDenomOnHost: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* The osmosis pool ID
*/
/** @deprecated */
poolId: bigint;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* Threshold defining the percentage of tokens that could be lost in the trade
* This captures both the loss from slippage and from a stale price on stride
* "0.05" means the output from the trade can be no less than a 5% deviation
* from the current value
*/
/** @deprecated */
maxAllowedSwapLossRate: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* minimum amount of reward tokens to initate a swap
* if not provided, defaults to 0
*/
minSwapAmount: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* maximum amount of reward tokens in a single swap
* if not provided, defaults to 10e24
*/
maxSwapAmount: string;
/**
* Minimum amount of reward token that must be accumulated before
* the tokens are transferred to the trade ICA
*/
minTransferAmount: string;
}
export interface MsgCreateTradeRouteProtoMsg {
typeUrl: '/stride.stakeibc.MsgCreateTradeRoute';
value: Uint8Array;
}
/** Creates a new trade route */
export interface MsgCreateTradeRouteAmino {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority?: string;
/** The chain ID of the host zone */
host_chain_id?: string;
/** Connection IDs between stride and the other zones */
stride_to_reward_connection_id?: string;
stride_to_trade_connection_id?: string;
/** Transfer channels between the host, reward, and trade zones */
host_to_reward_transfer_channel_id?: string;
reward_to_trade_transfer_channel_id?: string;
trade_to_host_transfer_channel_id?: string;
/** ibc denom for the reward token on the host zone (e.g. ibc/usdc on dYdX) */
reward_denom_on_host?: string;
/** native denom of reward token on the reward zone (e.g. usdc on Noble) */
reward_denom_on_reward?: string;
/** ibc denom of the reward token on the trade zone (e.g. ibc/usdc on Osmosis) */
reward_denom_on_trade?: string;
/** ibc denom of the host's token on the trade zone (e.g. ibc/dydx on Osmosis) */
host_denom_on_trade?: string;
/** the host zone's native denom (e.g. dydx on dYdX) */
host_denom_on_host?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* The osmosis pool ID
*/
/** @deprecated */
pool_id?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* Threshold defining the percentage of tokens that could be lost in the trade
* This captures both the loss from slippage and from a stale price on stride
* "0.05" means the output from the trade can be no less than a 5% deviation
* from the current value
*/
/** @deprecated */
max_allowed_swap_loss_rate?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* minimum amount of reward tokens to initate a swap
* if not provided, defaults to 0
*/
min_swap_amount?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* maximum amount of reward tokens in a single swap
* if not provided, defaults to 10e24
*/
max_swap_amount?: string;
/**
* Minimum amount of reward token that must be accumulated before
* the tokens are transferred to the trade ICA
*/
min_transfer_amount?: string;
}
export interface MsgCreateTradeRouteAminoMsg {
type: 'stride/x/stakeibc/MsgCreateTradeRoute';
value: MsgCreateTradeRouteAmino;
}
/** Creates a new trade route */
export interface MsgCreateTradeRouteSDKType {
authority: string;
host_chain_id: string;
stride_to_reward_connection_id: string;
stride_to_trade_connection_id: string;
host_to_reward_transfer_channel_id: string;
reward_to_trade_transfer_channel_id: string;
trade_to_host_transfer_channel_id: string;
reward_denom_on_host: string;
reward_denom_on_reward: string;
reward_denom_on_trade: string;
host_denom_on_trade: string;
host_denom_on_host: string;
/** @deprecated */
pool_id: bigint;
/** @deprecated */
max_allowed_swap_loss_rate: string;
min_swap_amount: string;
max_swap_amount: string;
min_transfer_amount: string;
}
export interface MsgCreateTradeRouteResponse {
}
export interface MsgCreateTradeRouteResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgCreateTradeRouteResponse';
value: Uint8Array;
}
export interface MsgCreateTradeRouteResponseAmino {
}
export interface MsgCreateTradeRouteResponseAminoMsg {
type: '/stride.stakeibc.MsgCreateTradeRouteResponse';
value: MsgCreateTradeRouteResponseAmino;
}
export interface MsgCreateTradeRouteResponseSDKType {
}
/** Deletes a trade route */
export interface MsgDeleteTradeRoute {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority: string;
/** The reward denom of the route in it's native form (e.g. usdc) */
rewardDenom: string;
/** The host zone's denom in it's native form (e.g. dydx) */
hostDenom: string;
}
export interface MsgDeleteTradeRouteProtoMsg {
typeUrl: '/stride.stakeibc.MsgDeleteTradeRoute';
value: Uint8Array;
}
/** Deletes a trade route */
export interface MsgDeleteTradeRouteAmino {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority?: string;
/** The reward denom of the route in it's native form (e.g. usdc) */
reward_denom?: string;
/** The host zone's denom in it's native form (e.g. dydx) */
host_denom?: string;
}
export interface MsgDeleteTradeRouteAminoMsg {
type: 'stride/x/stakeibc/MsgDeleteTradeRoute';
value: MsgDeleteTradeRouteAmino;
}
/** Deletes a trade route */
export interface MsgDeleteTradeRouteSDKType {
authority: string;
reward_denom: string;
host_denom: string;
}
export interface MsgDeleteTradeRouteResponse {
}
export interface MsgDeleteTradeRouteResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgDeleteTradeRouteResponse';
value: Uint8Array;
}
export interface MsgDeleteTradeRouteResponseAmino {
}
export interface MsgDeleteTradeRouteResponseAminoMsg {
type: '/stride.stakeibc.MsgDeleteTradeRouteResponse';
value: MsgDeleteTradeRouteResponseAmino;
}
export interface MsgDeleteTradeRouteResponseSDKType {
}
/** Updates the config of a trade route */
export interface MsgUpdateTradeRoute {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority: string;
/** The reward denom of the route in it's native form (e.g. usdc) */
rewardDenom: string;
/** The host zone's denom in it's native form (e.g. dydx) */
hostDenom: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* The osmosis pool ID
*/
/** @deprecated */
poolId: bigint;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* Threshold defining the percentage of tokens that could be lost in the trade
* This captures both the loss from slippage and from a stale price on stride
* "0.05" means the output from the trade can be no less than a 5% deviation
* from the current value
*/
/** @deprecated */
maxAllowedSwapLossRate: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* minimum amount of reward tokens to initate a swap
* if not provided, defaults to 0
*/
/** @deprecated */
minSwapAmount: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* maximum amount of reward tokens in a single swap
* if not provided, defaults to 10e24
*/
/** @deprecated */
maxSwapAmount: string;
/**
* Minimum amount of reward token that must be accumulated before
* the tokens are transferred to the trade ICA
*/
minTransferAmount: string;
}
export interface MsgUpdateTradeRouteProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateTradeRoute';
value: Uint8Array;
}
/** Updates the config of a trade route */
export interface MsgUpdateTradeRouteAmino {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority?: string;
/** The reward denom of the route in it's native form (e.g. usdc) */
reward_denom?: string;
/** The host zone's denom in it's native form (e.g. dydx) */
host_denom?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* The osmosis pool ID
*/
/** @deprecated */
pool_id?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* Threshold defining the percentage of tokens that could be lost in the trade
* This captures both the loss from slippage and from a stale price on stride
* "0.05" means the output from the trade can be no less than a 5% deviation
* from the current value
*/
/** @deprecated */
max_allowed_swap_loss_rate?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* minimum amount of reward tokens to initate a swap
* if not provided, defaults to 0
*/
/** @deprecated */
min_swap_amount?: string;
/**
* Deprecated, the trades are now executed off-chain via authz
*
* maximum amount of reward tokens in a single swap
* if not provided, defaults to 10e24
*/
/** @deprecated */
max_swap_amount?: string;
/**
* Minimum amount of reward token that must be accumulated before
* the tokens are transferred to the trade ICA
*/
min_transfer_amount?: string;
}
export interface MsgUpdateTradeRouteAminoMsg {
type: 'stride/x/stakeibc/MsgUpdateTradeRoute';
value: MsgUpdateTradeRouteAmino;
}
/** Updates the config of a trade route */
export interface MsgUpdateTradeRouteSDKType {
authority: string;
reward_denom: string;
host_denom: string;
/** @deprecated */
pool_id: bigint;
/** @deprecated */
max_allowed_swap_loss_rate: string;
/** @deprecated */
min_swap_amount: string;
/** @deprecated */
max_swap_amount: string;
min_transfer_amount: string;
}
export interface MsgUpdateTradeRouteResponse {
}
export interface MsgUpdateTradeRouteResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateTradeRouteResponse';
value: Uint8Array;
}
export interface MsgUpdateTradeRouteResponseAmino {
}
export interface MsgUpdateTradeRouteResponseAminoMsg {
type: '/stride.stakeibc.MsgUpdateTradeRouteResponse';
value: MsgUpdateTradeRouteResponseAmino;
}
export interface MsgUpdateTradeRouteResponseSDKType {
}
/**
* Registers or updates a community pool rebate by specifying the amount liquid
* staked
*/
export interface MsgSetCommunityPoolRebate {
/** Message signer (admin only) */
creator: string;
/**
* Chain id of the chain whose community pool has a liquid staking rebate
* arrangement with stride
*/
chainId: string;
/** Rebate percentage represented as a decimal (e.g. 0.2 for 20%) */
rebateRate: string;
/** Number of stTokens recieved by the community pool after liquid staking */
liquidStakedStTokenAmount: string;
}
export interface MsgSetCommunityPoolRebateProtoMsg {
typeUrl: '/stride.stakeibc.MsgSetCommunityPoolRebate';
value: Uint8Array;
}
/**
* Registers or updates a community pool rebate by specifying the amount liquid
* staked
*/
export interface MsgSetCommunityPoolRebateAmino {
/** Message signer (admin only) */
creator?: string;
/**
* Chain id of the chain whose community pool has a liquid staking rebate
* arrangement with stride
*/
chain_id?: string;
/** Rebate percentage represented as a decimal (e.g. 0.2 for 20%) */
rebate_rate?: string;
/** Number of stTokens recieved by the community pool after liquid staking */
liquid_staked_st_token_amount?: string;
}
export interface MsgSetCommunityPoolRebateAminoMsg {
type: 'stride/x/stakeibc/MsgSetCommunityPoolRebate';
value: MsgSetCommunityPoolRebateAmino;
}
/**
* Registers or updates a community pool rebate by specifying the amount liquid
* staked
*/
export interface MsgSetCommunityPoolRebateSDKType {
creator: string;
chain_id: string;
rebate_rate: string;
liquid_staked_st_token_amount: string;
}
export interface MsgSetCommunityPoolRebateResponse {
}
export interface MsgSetCommunityPoolRebateResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgSetCommunityPoolRebateResponse';
value: Uint8Array;
}
export interface MsgSetCommunityPoolRebateResponseAmino {
}
export interface MsgSetCommunityPoolRebateResponseAminoMsg {
type: '/stride.stakeibc.MsgSetCommunityPoolRebateResponse';
value: MsgSetCommunityPoolRebateResponseAmino;
}
export interface MsgSetCommunityPoolRebateResponseSDKType {
}
/** Grants or revokes trade permissions to a given address via authz */
export interface MsgToggleTradeController {
/** Message signer (admin only) */
creator: string;
/** Chain ID of the trade account */
chainId: string;
/** Permission change (either grant or revoke) */
permissionChange: AuthzPermissionChange;
/** Address of trade operator */
address: string;
}
export interface MsgToggleTradeControllerProtoMsg {
typeUrl: '/stride.stakeibc.MsgToggleTradeController';
value: Uint8Array;
}
/** Grants or revokes trade permissions to a given address via authz */
export interface MsgToggleTradeControllerAmino {
/** Message signer (admin only) */
creator?: string;
/** Chain ID of the trade account */
chain_id?: string;
/** Permission change (either grant or revoke) */
permission_change?: AuthzPermissionChange;
/** Address of trade operator */
address?: string;
}
export interface MsgToggleTradeControllerAminoMsg {
type: 'stride/x/stakeibc/MsgToggleTradeController';
value: MsgToggleTradeControllerAmino;
}
/** Grants or revokes trade permissions to a given address via authz */
export interface MsgToggleTradeControllerSDKType {
creator: string;
chain_id: string;
permission_change: AuthzPermissionChange;
address: string;
}
export interface MsgToggleTradeControllerResponse {
}
export interface MsgToggleTradeControllerResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgToggleTradeControllerResponse';
value: Uint8Array;
}
export interface MsgToggleTradeControllerResponseAmino {
}
export interface MsgToggleTradeControllerResponseAminoMsg {
type: '/stride.stakeibc.MsgToggleTradeControllerResponse';
value: MsgToggleTradeControllerResponseAmino;
}
export interface MsgToggleTradeControllerResponseSDKType {
}
/** Updates host zone params */
export interface MsgUpdateHostZoneParams {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority: string;
/** Chain ID of the host zone */
chainId: string;
/** Max messages that can be sent in a single ICA message */
maxMessagesPerIcaTx: bigint;
}
export interface MsgUpdateHostZoneParamsProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateHostZoneParams';
value: Uint8Array;
}
/** Updates host zone params */
export interface MsgUpdateHostZoneParamsAmino {
/**
* authority is the address that controls the module (defaults to x/gov unless
* overwritten).
*/
authority?: string;
/** Chain ID of the host zone */
chain_id?: string;
/** Max messages that can be sent in a single ICA message */
max_messages_per_ica_tx?: string;
}
export interface MsgUpdateHostZoneParamsAminoMsg {
type: 'stride/x/stakeibc/MsgUpdateHostZoneParams';
value: MsgUpdateHostZoneParamsAmino;
}
/** Updates host zone params */
export interface MsgUpdateHostZoneParamsSDKType {
authority: string;
chain_id: string;
max_messages_per_ica_tx: bigint;
}
export interface MsgUpdateHostZoneParamsResponse {
}
export interface MsgUpdateHostZoneParamsResponseProtoMsg {
typeUrl: '/stride.stakeibc.MsgUpdateHostZoneParamsResponse';
value: Uint8Array;
}
export interface MsgUpdateHostZoneParamsResponseAmino {
}
export interface MsgUpdateHostZoneParamsResponseAminoMsg {
type: '/stride.stakeibc.MsgUpdateHostZoneParamsResponse';
value: MsgUpdateHostZoneParamsResponseAmino;
}
export interface MsgUpdateHostZoneParamsResponseSDKType {
}
export declare const MsgUpdateInnerRedemptionRateBounds: {
typeUrl: string;
encode(message: MsgUpdateInnerRedemptionRateBounds, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateInnerRedemptionRateBounds;
fromPartial(object: Partial<MsgUpdateInnerRedemptionRateBounds>): MsgUpdateInnerRedemptionRateBounds;
fromAmino(object: MsgUpdateInnerRedemptionRateBoundsAmino): MsgUpdateInnerRedemptionRateBounds;
toAmino(message: MsgUpdateInnerRedemptionRateBounds): MsgUpdateInnerRedemptionRateBoundsAmino;
fromAminoMsg(object: MsgUpdateInnerRedemptionRateBoundsAminoMsg): MsgUpdateInnerRedemptionRateBounds;
fromProtoMsg(message: MsgUpdateInnerRedemptionRateBoundsProtoMsg): MsgUpdateInnerRedemptionRateBounds;
toProto(message: MsgUpdateInnerRedemptionRateBounds): Uint8Array;
toProtoMsg(message: MsgUpdateInnerRedemptionRateBounds): MsgUpdateInnerRedemptionRateBoundsProtoMsg;
};
export declare const MsgUpdateInnerRedemptionRateBoundsResponse: {
typeUrl: string;
encode(_: MsgUpdateInnerRedemptionRateBoundsResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateInnerRedemptionRateBoundsResponse;
fromPartial(_: Partial<MsgUpdateInnerRedemptionRateBoundsResponse>): MsgUpdateInnerRedemptionRateBoundsResponse;
fromAmino(_: MsgUpdateInnerRedemptionRateBoundsResponseAmino): MsgUpdateInnerRedemptionRateBoundsResponse;
toAmino(_: MsgUpdateInnerRedemptionRateBoundsResponse): MsgUpdateInnerRedemptionRateBoundsResponseAmino;
fromAminoMsg(object: MsgUpdateInnerRedemptionRateBoundsResponseAminoMsg): MsgUpdateInnerRedemptionRateBoundsResponse;
fromProtoMsg(message: MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): MsgUpdateInnerRedemptionRateBoundsResponse;
toProto(message: MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
toProtoMsg(message: MsgUpdateInnerRedemptionRateBoundsResponse): MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
};
export declare const MsgLiquidStake: {
typeUrl: string;
encode(message: MsgLiquidStake, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgLiquidStake;
fromPartial(object: Partial<MsgLiquidStake>): MsgLiquidStake;
fromAmino(object: MsgLiquidStakeAmino): MsgLiquidStake;
toAmino(message: MsgLiquidStake): MsgLiquidStakeAmino;
fromAminoMsg(object: MsgLiquidStakeAminoMsg): MsgLiquidStake;
toAminoMsg(message: MsgLiquidStake): MsgLiquidStakeAminoMsg;
fromProtoMsg(message: MsgLiquidStakeProtoMsg): MsgLiquidStake;
toProto(message: MsgLiquidStake): Uint8Array;
toProtoMsg(message: MsgLiquidStake): MsgLiquidStakeProtoMsg;
};
export declare const MsgLiquidStakeResponse: {
typeUrl: string;
encode(message: MsgLiquidStakeResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgLiquidStakeResponse;
fromPartial(object: Partial<MsgLiquidStakeResponse>): MsgLiquidStakeResponse;
fromAmino(object: MsgLiquidStakeResponseAmino): MsgLiquidStakeResponse;
toAmino(message: MsgLiquidStakeResponse): MsgLiquidStakeResponseAmino;
fromAminoMsg(object: MsgLiquidStakeResponseAminoMsg): MsgLiquidStakeResponse;
fromProtoMsg(message: MsgLiquidStakeResponseProtoMsg): MsgLiquidStakeResponse;
toProto(message: MsgLiquidStakeResponse): Uint8Array;
toProtoMsg(message: MsgLiquidStakeResponse): MsgLiquidStakeResponseProtoMsg;
};
export declare const MsgLSMLiquidStake: {
typeUrl: string;
encode(message: MsgLSMLiquidStake, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgLSMLiquidStake;
fromPartial(object: Partial<MsgLSMLiquidStake>): MsgLSMLiquidStake;
fromAmino(object: MsgLSMLiquidStakeAmino): MsgLSMLiquidStake;
toAmino(message: MsgLSMLiquidStake): MsgLSMLiquidStakeAmino;
fromAminoMsg(object: MsgLSMLiquidStakeAminoMsg): MsgLSMLiquidStake;
toAminoMsg(message: MsgLSMLiquidStake): MsgLSMLiquidStakeAminoMsg;
fromProtoMsg(message: MsgLSMLiquidStakeProtoMsg): MsgLSMLiquidStake;
toProto(message: MsgLSMLiquidStake): Uint8Array;
toProtoMsg(message: MsgLSMLiquidStake): MsgLSMLiquidStakeProtoMsg;
};
export declare const MsgLSMLiquidStakeResponse: {
typeUrl: string;
encode(message: MsgLSMLiquidStakeResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgLSMLiquidStakeResponse;
fromPartial(object: Partial<MsgLSMLiquidStakeResponse>): MsgLSMLiquidStakeResponse;
fromAmino(object: MsgLSMLiquidStakeResponseAmino): MsgLSMLiquidStakeResponse;
toAmino(message: MsgLSMLiquidStakeResponse): MsgLSMLiquidStakeResponseAmino;
fromAminoMsg(object: MsgLSMLiquidStakeResponseAminoMsg): MsgLSMLiquidStakeResponse;
fromProtoMsg(message: MsgLSMLiquidStakeResponseProtoMsg): MsgLSMLiquidStakeResponse;
toProto(message: MsgLSMLiquidStakeResponse): Uint8Array;
toProtoMsg(message: MsgLSMLiquidStakeResponse): MsgLSMLiquidStakeResponseProtoMsg;
};
export declare const MsgClearBalance: {
typeUrl: string;
encode(message: MsgClearBalance, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgClearBalance;
fromPartial(object: Partial<MsgClearBalance>): MsgClearBalance;
fromAmino(object: MsgClearBalanceAmino): MsgClearBalance;
toAmino(message: MsgClearBalance): MsgClearBalanceAmino;
fromAminoMsg(object: MsgClearBalanceAminoMsg): MsgClearBalance;
toAminoMsg(message: MsgClearBalance): MsgClearBalanceAminoMsg;
fromProtoMsg(message: MsgClearBalanceProtoMsg): MsgClearBalance;
toProto(message: MsgClearBalance): Uint8Array;
toProtoMsg(message: MsgClearBalance): MsgClearBalanceProtoMsg;
};
export declare const MsgClearBalanceResponse: {
typeUrl: string;
encode(_: MsgClearBalanceResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgClearBalanceResponse;
fromPartial(_: Partial<MsgClearBalanceResponse>): MsgClearBalanceResponse;
fromAmino(_: MsgClearBalanceResponseAmino): MsgClearBalanceResponse;
toAmino(_: MsgClearBalanceResponse): MsgClearBalanceResponseAmino;
fromAminoMsg(object: MsgClearBalanceResponseAminoMsg): MsgClearBalanceResponse;
fromProtoMsg(message: MsgClearBalanceResponseProtoMsg): MsgClearBalanceResponse;
toProto(message: MsgClearBalanceResponse): Uint8Array;
toProtoMsg(message: MsgClearBalanceResponse): MsgClearBalanceResponseProtoMsg;
};
export declare const MsgRedeemStake: {
typeUrl: string;
encode(message: MsgRedeemStake, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgRedeemStake;
fromPartial(object: Partial<MsgRedeemStake>): MsgRedeemStake;
fromAmino(object: MsgRedeemStakeAmino): MsgRedeemStake;
toAmino(message: MsgRedeemStake): MsgRedeemStakeAmino;
fromAminoMsg(object: MsgRedeemStakeAminoMsg): MsgRedeemStake;
toAminoMsg(message: MsgRedeemStake): MsgRedeemStakeAminoMsg;
fromProtoMsg(message: MsgRedeemStakeProtoMsg): MsgRedeemStake;
toProto(message: MsgRedeemStake): Uint8Array;
toProtoMsg(message: MsgRedeemStake): MsgRedeemStakeProtoMsg;
};
export declare const MsgRedeemStakeResponse: {
typeUrl: string;
encode(_: MsgRedeemStakeResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgRedeemStakeResponse;
fromPartial(_: Partial<MsgRedeemStakeResponse>): MsgRedeemStakeResponse;
fromAmino(_: MsgRedeemStakeResponseAmino): MsgRedeemStakeResponse;
toAmino(_: MsgRedeemStakeResponse): MsgRedeemStakeResponseAmino;
fromAminoMsg(object: MsgRedeemStakeResponseAminoMsg): MsgRedeemStakeResponse;
fromProtoMsg(message: MsgRedeemStakeResponseProtoMsg): MsgRedeemStakeResponse;
toProto(message: MsgRedeemStakeResponse): Uint8Array;
toProtoMsg(message: MsgRedeemStakeResponse): MsgRedeemStakeResponseProtoMsg;
};
export declare const MsgRegisterHostZone: {
typeUrl: string;
encode(message: MsgRegisterHostZone, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgRegisterHostZone;
fromPartial(object: Partial<MsgRegisterHostZone>): MsgRegisterHostZone;
fromAmino(object: MsgRegisterHostZoneAmino): MsgRegisterHostZone;
toAmino(message: MsgRegisterHostZone): MsgRegisterHostZoneAmino;
fromAminoMsg(object: MsgRegisterHostZoneAminoMsg): MsgRegisterHostZone;
toAminoMsg(message: MsgRegisterHostZone): MsgRegisterHostZoneAminoMsg;
fromProtoMsg(message: MsgRegisterHostZoneProtoMsg): MsgRegisterHostZone;
toProto(message: MsgRegisterHostZone): Uint8Array;
toProtoMsg(message: MsgRegisterHostZone): MsgRegisterHostZoneProtoMsg;
};
export declare const MsgRegisterHostZoneResponse: {
typeUrl: string;
encode(_: MsgRegisterHostZoneResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgRegisterHostZoneResponse;
fromPartial(_: Partial<MsgRegisterHostZoneResponse>): MsgRegisterHostZoneResponse;
fromAmino(_: MsgRegisterHostZoneResponseAmino): MsgRegisterHostZoneResponse;
toAmino(_: MsgRegisterHostZoneResponse): MsgRegisterHostZoneResponseAmino;
fromAminoMsg(object: MsgRegisterHostZoneResponseAminoMsg): MsgRegisterHostZoneResponse;
fromProtoMsg(message: MsgRegisterHostZoneResponseProtoMsg): MsgRegisterHostZoneResponse;
toProto(message: MsgRegisterHostZoneResponse): Uint8Array;
toProtoMsg(message: MsgRegisterHostZoneResponse): MsgRegisterHostZoneResponseProtoMsg;
};
export declare const MsgClaimUndelegatedTokens: {
typeUrl: string;
encode(message: MsgClaimUndelegatedTokens, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgClaimUndelegatedTokens;
fromPartial(object: Partial<MsgClaimUndelegatedTokens>): MsgClaimUndelegatedTokens;
fromAmino(object: MsgClaimUndelegatedTokensAmino): MsgClaimUndelegatedTokens;
toAmino(message: MsgClaimUndelegatedTokens): MsgClaimUndelegatedTokensAmino;
fromAminoMsg(object: MsgClaimUndelegatedTokensAminoMsg): MsgClaimUndelegatedTokens;
toAminoMsg(message: MsgClaimUndelegatedTokens): MsgClaimUndelegatedTokensAminoMsg;
fromProtoMsg(message: MsgClaimUndelegatedTokensProtoMsg): MsgClaimUndelegatedTokens;
toProto(message: MsgClaimUndelegatedTokens): Uint8Array;
toProtoMsg(message: MsgClaimUndelegatedTokens): MsgClaimUndelegatedTokensProtoMsg;
};
export declare const MsgClaimUndelegatedTokensResponse: {
typeUrl: string;
encode(_: MsgClaimUndelegatedTokensResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgClaimUndelegatedTokensResponse;
fromPartial(_: Partial<MsgClaimUndelegatedTokensResponse>): MsgClaimUndelegatedTokensResponse;
fromAmino(_: MsgClaimUndelegatedTokensResponseAmino): MsgClaimUndelegatedTokensResponse;
toAmino(_: MsgClaimUndelegatedTokensResponse): MsgClaimUndelegatedTokensResponseAmino;
fromAminoMsg(object: MsgClaimUndelegatedTokensResponseAminoMsg): MsgClaimUndelegatedTokensResponse;
fromProtoMsg(message: MsgClaimUndelegatedTokensResponseProtoMsg): MsgClaimUndelegatedTokensResponse;
toProto(message: MsgClaimUndelegatedTokensResponse): Uint8Array;
toProtoMsg(message: MsgClaimUndelegatedTokensResponse): MsgClaimUndelegatedTokensResponseProtoMsg;
};
export declare const MsgRebalanceValidators: {
typeUrl: string;
encode(message: MsgRebalanceValidators, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MsgRebalanceValidators;
fromPartial(object: Partial<MsgRebalanceValidators>): MsgRebalanceValidators;
fromAmino(object: MsgRebalanceValidatorsAmino): MsgRebalanceValidators;
toAmino(message: MsgRebalanceValidators): MsgRebalanceValidatorsAmino;
fromAminoMsg(object: MsgRebalanceValidatorsAminoMsg): MsgRebalanceValidators;
toAminoMsg(message: MsgRebalanceValidators): MsgRebalanceValidatorsAminoMsg;
fromProtoMsg(message: MsgRebalanceValidatorsProtoMsg): MsgRebalanceValidators;
toProto(message: MsgRebalanceValidators): Uint8Array;
toProtoMsg(message: MsgRebalanceValidators): MsgRebalanceValidatorsProtoMsg;
};
export declare const MsgRebalanceValidatorsResponse: {
typeUrl: string;
encode(_: MsgRebalanceValidatorsResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Ui