From 1a582a738c574cbcaef9bd435bd31796daedcffe Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 20 Oct 2020 15:47:46 +0200 Subject: [PATCH] stargate: Update codec --- .../src/codec/generated/codecimpl.d.ts | 2877 +++++++++++++++++ .../stargate/src/codec/generated/codecimpl.js | 2397 ++++++++++++++ .../types/codec/generated/codecimpl.d.ts | 2877 +++++++++++++++++ 3 files changed, 8151 insertions(+) diff --git a/packages/stargate/src/codec/generated/codecimpl.d.ts b/packages/stargate/src/codec/generated/codecimpl.d.ts index e348516f..346edf38 100644 --- a/packages/stargate/src/codec/generated/codecimpl.d.ts +++ b/packages/stargate/src/codec/generated/codecimpl.d.ts @@ -1695,6 +1695,1564 @@ export namespace cosmos { } } + /** Namespace staking. */ + namespace staking { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a HistoricalInfo. */ + interface IHistoricalInfo { + /** HistoricalInfo header */ + header?: tendermint.types.IHeader | null; + + /** HistoricalInfo valset */ + valset?: cosmos.staking.v1beta1.IValidator[] | null; + } + + /** Represents a HistoricalInfo. */ + class HistoricalInfo implements IHistoricalInfo { + /** + * Constructs a new HistoricalInfo. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IHistoricalInfo); + + /** HistoricalInfo header. */ + public header?: tendermint.types.IHeader | null; + + /** HistoricalInfo valset. */ + public valset: cosmos.staking.v1beta1.IValidator[]; + + /** + * Creates a new HistoricalInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns HistoricalInfo instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IHistoricalInfo, + ): cosmos.staking.v1beta1.HistoricalInfo; + + /** + * Encodes the specified HistoricalInfo message. Does not implicitly {@link cosmos.staking.v1beta1.HistoricalInfo.verify|verify} messages. + * @param m HistoricalInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IHistoricalInfo, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a HistoricalInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns HistoricalInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.HistoricalInfo; + } + + /** Properties of a CommissionRates. */ + interface ICommissionRates { + /** CommissionRates rate */ + rate?: string | null; + + /** CommissionRates maxRate */ + maxRate?: string | null; + + /** CommissionRates maxChangeRate */ + maxChangeRate?: string | null; + } + + /** Represents a CommissionRates. */ + class CommissionRates implements ICommissionRates { + /** + * Constructs a new CommissionRates. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.ICommissionRates); + + /** CommissionRates rate. */ + public rate: string; + + /** CommissionRates maxRate. */ + public maxRate: string; + + /** CommissionRates maxChangeRate. */ + public maxChangeRate: string; + + /** + * Creates a new CommissionRates instance using the specified properties. + * @param [properties] Properties to set + * @returns CommissionRates instance + */ + public static create( + properties?: cosmos.staking.v1beta1.ICommissionRates, + ): cosmos.staking.v1beta1.CommissionRates; + + /** + * Encodes the specified CommissionRates message. Does not implicitly {@link cosmos.staking.v1beta1.CommissionRates.verify|verify} messages. + * @param m CommissionRates message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.ICommissionRates, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a CommissionRates message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CommissionRates + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.CommissionRates; + } + + /** Properties of a Commission. */ + interface ICommission { + /** Commission commissionRates */ + commissionRates?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** Commission updateTime */ + updateTime?: google.protobuf.ITimestamp | null; + } + + /** Represents a Commission. */ + class Commission implements ICommission { + /** + * Constructs a new Commission. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.ICommission); + + /** Commission commissionRates. */ + public commissionRates?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** Commission updateTime. */ + public updateTime?: google.protobuf.ITimestamp | null; + + /** + * Creates a new Commission instance using the specified properties. + * @param [properties] Properties to set + * @returns Commission instance + */ + public static create( + properties?: cosmos.staking.v1beta1.ICommission, + ): cosmos.staking.v1beta1.Commission; + + /** + * Encodes the specified Commission message. Does not implicitly {@link cosmos.staking.v1beta1.Commission.verify|verify} messages. + * @param m Commission message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.ICommission, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Commission message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Commission + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Commission; + } + + /** Properties of a Description. */ + interface IDescription { + /** Description moniker */ + moniker?: string | null; + + /** Description identity */ + identity?: string | null; + + /** Description website */ + website?: string | null; + + /** Description securityContact */ + securityContact?: string | null; + + /** Description details */ + details?: string | null; + } + + /** Represents a Description. */ + class Description implements IDescription { + /** + * Constructs a new Description. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDescription); + + /** Description moniker. */ + public moniker: string; + + /** Description identity. */ + public identity: string; + + /** Description website. */ + public website: string; + + /** Description securityContact. */ + public securityContact: string; + + /** Description details. */ + public details: string; + + /** + * Creates a new Description instance using the specified properties. + * @param [properties] Properties to set + * @returns Description instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDescription, + ): cosmos.staking.v1beta1.Description; + + /** + * Encodes the specified Description message. Does not implicitly {@link cosmos.staking.v1beta1.Description.verify|verify} messages. + * @param m Description message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDescription, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Description message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Description + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.Description; + } + + /** Properties of a Validator. */ + interface IValidator { + /** Validator operatorAddress */ + operatorAddress?: string | null; + + /** Validator consensusPubkey */ + consensusPubkey?: string | null; + + /** Validator jailed */ + jailed?: boolean | null; + + /** Validator status */ + status?: number | null; + + /** Validator tokens */ + tokens?: string | null; + + /** Validator delegatorShares */ + delegatorShares?: string | null; + + /** Validator description */ + description?: cosmos.staking.v1beta1.IDescription | null; + + /** Validator unbondingHeight */ + unbondingHeight?: Long | null; + + /** Validator unbondingTime */ + unbondingTime?: google.protobuf.ITimestamp | null; + + /** Validator commission */ + commission?: cosmos.staking.v1beta1.ICommission | null; + + /** Validator minSelfDelegation */ + minSelfDelegation?: string | null; + } + + /** Represents a Validator. */ + class Validator implements IValidator { + /** + * Constructs a new Validator. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IValidator); + + /** Validator operatorAddress. */ + public operatorAddress: string; + + /** Validator consensusPubkey. */ + public consensusPubkey: string; + + /** Validator jailed. */ + public jailed: boolean; + + /** Validator status. */ + public status: number; + + /** Validator tokens. */ + public tokens: string; + + /** Validator delegatorShares. */ + public delegatorShares: string; + + /** Validator description. */ + public description?: cosmos.staking.v1beta1.IDescription | null; + + /** Validator unbondingHeight. */ + public unbondingHeight: Long; + + /** Validator unbondingTime. */ + public unbondingTime?: google.protobuf.ITimestamp | null; + + /** Validator commission. */ + public commission?: cosmos.staking.v1beta1.ICommission | null; + + /** Validator minSelfDelegation. */ + public minSelfDelegation: string; + + /** + * Creates a new Validator instance using the specified properties. + * @param [properties] Properties to set + * @returns Validator instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IValidator, + ): cosmos.staking.v1beta1.Validator; + + /** + * Encodes the specified Validator message. Does not implicitly {@link cosmos.staking.v1beta1.Validator.verify|verify} messages. + * @param m Validator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IValidator, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Validator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Validator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Validator; + } + + /** Properties of a ValAddresses. */ + interface IValAddresses { + /** ValAddresses addresses */ + addresses?: string[] | null; + } + + /** Represents a ValAddresses. */ + class ValAddresses implements IValAddresses { + /** + * Constructs a new ValAddresses. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IValAddresses); + + /** ValAddresses addresses. */ + public addresses: string[]; + + /** + * Creates a new ValAddresses instance using the specified properties. + * @param [properties] Properties to set + * @returns ValAddresses instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IValAddresses, + ): cosmos.staking.v1beta1.ValAddresses; + + /** + * Encodes the specified ValAddresses message. Does not implicitly {@link cosmos.staking.v1beta1.ValAddresses.verify|verify} messages. + * @param m ValAddresses message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IValAddresses, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ValAddresses message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ValAddresses + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.ValAddresses; + } + + /** Properties of a DVPair. */ + interface IDVPair { + /** DVPair delegatorAddress */ + delegatorAddress?: string | null; + + /** DVPair validatorAddress */ + validatorAddress?: string | null; + } + + /** Represents a DVPair. */ + class DVPair implements IDVPair { + /** + * Constructs a new DVPair. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVPair); + + /** DVPair delegatorAddress. */ + public delegatorAddress: string; + + /** DVPair validatorAddress. */ + public validatorAddress: string; + + /** + * Creates a new DVPair instance using the specified properties. + * @param [properties] Properties to set + * @returns DVPair instance + */ + public static create(properties?: cosmos.staking.v1beta1.IDVPair): cosmos.staking.v1beta1.DVPair; + + /** + * Encodes the specified DVPair message. Does not implicitly {@link cosmos.staking.v1beta1.DVPair.verify|verify} messages. + * @param m DVPair message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVPair, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVPair message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVPair + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.DVPair; + } + + /** Properties of a DVPairs. */ + interface IDVPairs { + /** DVPairs pairs */ + pairs?: cosmos.staking.v1beta1.IDVPair[] | null; + } + + /** Represents a DVPairs. */ + class DVPairs implements IDVPairs { + /** + * Constructs a new DVPairs. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVPairs); + + /** DVPairs pairs. */ + public pairs: cosmos.staking.v1beta1.IDVPair[]; + + /** + * Creates a new DVPairs instance using the specified properties. + * @param [properties] Properties to set + * @returns DVPairs instance + */ + public static create(properties?: cosmos.staking.v1beta1.IDVPairs): cosmos.staking.v1beta1.DVPairs; + + /** + * Encodes the specified DVPairs message. Does not implicitly {@link cosmos.staking.v1beta1.DVPairs.verify|verify} messages. + * @param m DVPairs message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVPairs, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVPairs message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVPairs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.DVPairs; + } + + /** Properties of a DVVTriplet. */ + interface IDVVTriplet { + /** DVVTriplet delegatorAddress */ + delegatorAddress?: string | null; + + /** DVVTriplet validatorSrcAddress */ + validatorSrcAddress?: string | null; + + /** DVVTriplet validatorDstAddress */ + validatorDstAddress?: string | null; + } + + /** Represents a DVVTriplet. */ + class DVVTriplet implements IDVVTriplet { + /** + * Constructs a new DVVTriplet. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVVTriplet); + + /** DVVTriplet delegatorAddress. */ + public delegatorAddress: string; + + /** DVVTriplet validatorSrcAddress. */ + public validatorSrcAddress: string; + + /** DVVTriplet validatorDstAddress. */ + public validatorDstAddress: string; + + /** + * Creates a new DVVTriplet instance using the specified properties. + * @param [properties] Properties to set + * @returns DVVTriplet instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDVVTriplet, + ): cosmos.staking.v1beta1.DVVTriplet; + + /** + * Encodes the specified DVVTriplet message. Does not implicitly {@link cosmos.staking.v1beta1.DVVTriplet.verify|verify} messages. + * @param m DVVTriplet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVVTriplet, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVVTriplet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVVTriplet + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.DVVTriplet; + } + + /** Properties of a DVVTriplets. */ + interface IDVVTriplets { + /** DVVTriplets triplets */ + triplets?: cosmos.staking.v1beta1.IDVVTriplet[] | null; + } + + /** Represents a DVVTriplets. */ + class DVVTriplets implements IDVVTriplets { + /** + * Constructs a new DVVTriplets. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVVTriplets); + + /** DVVTriplets triplets. */ + public triplets: cosmos.staking.v1beta1.IDVVTriplet[]; + + /** + * Creates a new DVVTriplets instance using the specified properties. + * @param [properties] Properties to set + * @returns DVVTriplets instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDVVTriplets, + ): cosmos.staking.v1beta1.DVVTriplets; + + /** + * Encodes the specified DVVTriplets message. Does not implicitly {@link cosmos.staking.v1beta1.DVVTriplets.verify|verify} messages. + * @param m DVVTriplets message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVVTriplets, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVVTriplets message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVVTriplets + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.DVVTriplets; + } + + /** Properties of a Delegation. */ + interface IDelegation { + /** Delegation delegatorAddress */ + delegatorAddress?: string | null; + + /** Delegation validatorAddress */ + validatorAddress?: string | null; + + /** Delegation shares */ + shares?: string | null; + } + + /** Represents a Delegation. */ + class Delegation implements IDelegation { + /** + * Constructs a new Delegation. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDelegation); + + /** Delegation delegatorAddress. */ + public delegatorAddress: string; + + /** Delegation validatorAddress. */ + public validatorAddress: string; + + /** Delegation shares. */ + public shares: string; + + /** + * Creates a new Delegation instance using the specified properties. + * @param [properties] Properties to set + * @returns Delegation instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDelegation, + ): cosmos.staking.v1beta1.Delegation; + + /** + * Encodes the specified Delegation message. Does not implicitly {@link cosmos.staking.v1beta1.Delegation.verify|verify} messages. + * @param m Delegation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDelegation, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Delegation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Delegation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Delegation; + } + + /** Properties of an UnbondingDelegation. */ + interface IUnbondingDelegation { + /** UnbondingDelegation delegatorAddress */ + delegatorAddress?: string | null; + + /** UnbondingDelegation validatorAddress */ + validatorAddress?: string | null; + + /** UnbondingDelegation entries */ + entries?: cosmos.staking.v1beta1.IUnbondingDelegationEntry[] | null; + } + + /** Represents an UnbondingDelegation. */ + class UnbondingDelegation implements IUnbondingDelegation { + /** + * Constructs a new UnbondingDelegation. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IUnbondingDelegation); + + /** UnbondingDelegation delegatorAddress. */ + public delegatorAddress: string; + + /** UnbondingDelegation validatorAddress. */ + public validatorAddress: string; + + /** UnbondingDelegation entries. */ + public entries: cosmos.staking.v1beta1.IUnbondingDelegationEntry[]; + + /** + * Creates a new UnbondingDelegation instance using the specified properties. + * @param [properties] Properties to set + * @returns UnbondingDelegation instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IUnbondingDelegation, + ): cosmos.staking.v1beta1.UnbondingDelegation; + + /** + * Encodes the specified UnbondingDelegation message. Does not implicitly {@link cosmos.staking.v1beta1.UnbondingDelegation.verify|verify} messages. + * @param m UnbondingDelegation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IUnbondingDelegation, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an UnbondingDelegation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns UnbondingDelegation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.UnbondingDelegation; + } + + /** Properties of an UnbondingDelegationEntry. */ + interface IUnbondingDelegationEntry { + /** UnbondingDelegationEntry creationHeight */ + creationHeight?: Long | null; + + /** UnbondingDelegationEntry completionTime */ + completionTime?: google.protobuf.ITimestamp | null; + + /** UnbondingDelegationEntry initialBalance */ + initialBalance?: string | null; + + /** UnbondingDelegationEntry balance */ + balance?: string | null; + } + + /** Represents an UnbondingDelegationEntry. */ + class UnbondingDelegationEntry implements IUnbondingDelegationEntry { + /** + * Constructs a new UnbondingDelegationEntry. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IUnbondingDelegationEntry); + + /** UnbondingDelegationEntry creationHeight. */ + public creationHeight: Long; + + /** UnbondingDelegationEntry completionTime. */ + public completionTime?: google.protobuf.ITimestamp | null; + + /** UnbondingDelegationEntry initialBalance. */ + public initialBalance: string; + + /** UnbondingDelegationEntry balance. */ + public balance: string; + + /** + * Creates a new UnbondingDelegationEntry instance using the specified properties. + * @param [properties] Properties to set + * @returns UnbondingDelegationEntry instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IUnbondingDelegationEntry, + ): cosmos.staking.v1beta1.UnbondingDelegationEntry; + + /** + * Encodes the specified UnbondingDelegationEntry message. Does not implicitly {@link cosmos.staking.v1beta1.UnbondingDelegationEntry.verify|verify} messages. + * @param m UnbondingDelegationEntry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IUnbondingDelegationEntry, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an UnbondingDelegationEntry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns UnbondingDelegationEntry + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.UnbondingDelegationEntry; + } + + /** Properties of a RedelegationEntry. */ + interface IRedelegationEntry { + /** RedelegationEntry creationHeight */ + creationHeight?: Long | null; + + /** RedelegationEntry completionTime */ + completionTime?: google.protobuf.ITimestamp | null; + + /** RedelegationEntry initialBalance */ + initialBalance?: string | null; + + /** RedelegationEntry sharesDst */ + sharesDst?: string | null; + } + + /** Represents a RedelegationEntry. */ + class RedelegationEntry implements IRedelegationEntry { + /** + * Constructs a new RedelegationEntry. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegationEntry); + + /** RedelegationEntry creationHeight. */ + public creationHeight: Long; + + /** RedelegationEntry completionTime. */ + public completionTime?: google.protobuf.ITimestamp | null; + + /** RedelegationEntry initialBalance. */ + public initialBalance: string; + + /** RedelegationEntry sharesDst. */ + public sharesDst: string; + + /** + * Creates a new RedelegationEntry instance using the specified properties. + * @param [properties] Properties to set + * @returns RedelegationEntry instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegationEntry, + ): cosmos.staking.v1beta1.RedelegationEntry; + + /** + * Encodes the specified RedelegationEntry message. Does not implicitly {@link cosmos.staking.v1beta1.RedelegationEntry.verify|verify} messages. + * @param m RedelegationEntry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IRedelegationEntry, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a RedelegationEntry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns RedelegationEntry + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.RedelegationEntry; + } + + /** Properties of a Redelegation. */ + interface IRedelegation { + /** Redelegation delegatorAddress */ + delegatorAddress?: string | null; + + /** Redelegation validatorSrcAddress */ + validatorSrcAddress?: string | null; + + /** Redelegation validatorDstAddress */ + validatorDstAddress?: string | null; + + /** Redelegation entries */ + entries?: cosmos.staking.v1beta1.IRedelegationEntry[] | null; + } + + /** Represents a Redelegation. */ + class Redelegation implements IRedelegation { + /** + * Constructs a new Redelegation. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegation); + + /** Redelegation delegatorAddress. */ + public delegatorAddress: string; + + /** Redelegation validatorSrcAddress. */ + public validatorSrcAddress: string; + + /** Redelegation validatorDstAddress. */ + public validatorDstAddress: string; + + /** Redelegation entries. */ + public entries: cosmos.staking.v1beta1.IRedelegationEntry[]; + + /** + * Creates a new Redelegation instance using the specified properties. + * @param [properties] Properties to set + * @returns Redelegation instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegation, + ): cosmos.staking.v1beta1.Redelegation; + + /** + * Encodes the specified Redelegation message. Does not implicitly {@link cosmos.staking.v1beta1.Redelegation.verify|verify} messages. + * @param m Redelegation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IRedelegation, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Redelegation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Redelegation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.Redelegation; + } + + /** Properties of a Params. */ + interface IParams { + /** Params unbondingTime */ + unbondingTime?: google.protobuf.IDuration | null; + + /** Params maxValidators */ + maxValidators?: number | null; + + /** Params maxEntries */ + maxEntries?: number | null; + + /** Params historicalEntries */ + historicalEntries?: number | null; + + /** Params bondDenom */ + bondDenom?: string | null; + } + + /** Represents a Params. */ + class Params implements IParams { + /** + * Constructs a new Params. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IParams); + + /** Params unbondingTime. */ + public unbondingTime?: google.protobuf.IDuration | null; + + /** Params maxValidators. */ + public maxValidators: number; + + /** Params maxEntries. */ + public maxEntries: number; + + /** Params historicalEntries. */ + public historicalEntries: number; + + /** Params bondDenom. */ + public bondDenom: string; + + /** + * Creates a new Params instance using the specified properties. + * @param [properties] Properties to set + * @returns Params instance + */ + public static create(properties?: cosmos.staking.v1beta1.IParams): cosmos.staking.v1beta1.Params; + + /** + * Encodes the specified Params message. Does not implicitly {@link cosmos.staking.v1beta1.Params.verify|verify} messages. + * @param m Params message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IParams, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Params message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Params + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Params; + } + + /** Properties of a DelegationResponse. */ + interface IDelegationResponse { + /** DelegationResponse delegation */ + delegation?: cosmos.staking.v1beta1.IDelegation | null; + + /** DelegationResponse balance */ + balance?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a DelegationResponse. */ + class DelegationResponse implements IDelegationResponse { + /** + * Constructs a new DelegationResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDelegationResponse); + + /** DelegationResponse delegation. */ + public delegation?: cosmos.staking.v1beta1.IDelegation | null; + + /** DelegationResponse balance. */ + public balance?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new DelegationResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns DelegationResponse instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDelegationResponse, + ): cosmos.staking.v1beta1.DelegationResponse; + + /** + * Encodes the specified DelegationResponse message. Does not implicitly {@link cosmos.staking.v1beta1.DelegationResponse.verify|verify} messages. + * @param m DelegationResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IDelegationResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a DelegationResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DelegationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.DelegationResponse; + } + + /** Properties of a RedelegationEntryResponse. */ + interface IRedelegationEntryResponse { + /** RedelegationEntryResponse redelegationEntry */ + redelegationEntry?: cosmos.staking.v1beta1.IRedelegationEntry | null; + + /** RedelegationEntryResponse balance */ + balance?: string | null; + } + + /** Represents a RedelegationEntryResponse. */ + class RedelegationEntryResponse implements IRedelegationEntryResponse { + /** + * Constructs a new RedelegationEntryResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegationEntryResponse); + + /** RedelegationEntryResponse redelegationEntry. */ + public redelegationEntry?: cosmos.staking.v1beta1.IRedelegationEntry | null; + + /** RedelegationEntryResponse balance. */ + public balance: string; + + /** + * Creates a new RedelegationEntryResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns RedelegationEntryResponse instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegationEntryResponse, + ): cosmos.staking.v1beta1.RedelegationEntryResponse; + + /** + * Encodes the specified RedelegationEntryResponse message. Does not implicitly {@link cosmos.staking.v1beta1.RedelegationEntryResponse.verify|verify} messages. + * @param m RedelegationEntryResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IRedelegationEntryResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a RedelegationEntryResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns RedelegationEntryResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.RedelegationEntryResponse; + } + + /** Properties of a RedelegationResponse. */ + interface IRedelegationResponse { + /** RedelegationResponse redelegation */ + redelegation?: cosmos.staking.v1beta1.IRedelegation | null; + + /** RedelegationResponse entries */ + entries?: cosmos.staking.v1beta1.IRedelegationEntryResponse[] | null; + } + + /** Represents a RedelegationResponse. */ + class RedelegationResponse implements IRedelegationResponse { + /** + * Constructs a new RedelegationResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegationResponse); + + /** RedelegationResponse redelegation. */ + public redelegation?: cosmos.staking.v1beta1.IRedelegation | null; + + /** RedelegationResponse entries. */ + public entries: cosmos.staking.v1beta1.IRedelegationEntryResponse[]; + + /** + * Creates a new RedelegationResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns RedelegationResponse instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegationResponse, + ): cosmos.staking.v1beta1.RedelegationResponse; + + /** + * Encodes the specified RedelegationResponse message. Does not implicitly {@link cosmos.staking.v1beta1.RedelegationResponse.verify|verify} messages. + * @param m RedelegationResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IRedelegationResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a RedelegationResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns RedelegationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.RedelegationResponse; + } + + /** Properties of a Pool. */ + interface IPool { + /** Pool notBondedTokens */ + notBondedTokens?: string | null; + + /** Pool bondedTokens */ + bondedTokens?: string | null; + } + + /** Represents a Pool. */ + class Pool implements IPool { + /** + * Constructs a new Pool. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IPool); + + /** Pool notBondedTokens. */ + public notBondedTokens: string; + + /** Pool bondedTokens. */ + public bondedTokens: string; + + /** + * Creates a new Pool instance using the specified properties. + * @param [properties] Properties to set + * @returns Pool instance + */ + public static create(properties?: cosmos.staking.v1beta1.IPool): cosmos.staking.v1beta1.Pool; + + /** + * Encodes the specified Pool message. Does not implicitly {@link cosmos.staking.v1beta1.Pool.verify|verify} messages. + * @param m Pool message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IPool, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Pool message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Pool + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Pool; + } + + /** Properties of a MsgCreateValidator. */ + interface IMsgCreateValidator { + /** MsgCreateValidator description */ + description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgCreateValidator commission */ + commission?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** MsgCreateValidator minSelfDelegation */ + minSelfDelegation?: string | null; + + /** MsgCreateValidator delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgCreateValidator validatorAddress */ + validatorAddress?: string | null; + + /** MsgCreateValidator pubkey */ + pubkey?: string | null; + + /** MsgCreateValidator value */ + value?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgCreateValidator. */ + class MsgCreateValidator implements IMsgCreateValidator { + /** + * Constructs a new MsgCreateValidator. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgCreateValidator); + + /** MsgCreateValidator description. */ + public description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgCreateValidator commission. */ + public commission?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** MsgCreateValidator minSelfDelegation. */ + public minSelfDelegation: string; + + /** MsgCreateValidator delegatorAddress. */ + public delegatorAddress: string; + + /** MsgCreateValidator validatorAddress. */ + public validatorAddress: string; + + /** MsgCreateValidator pubkey. */ + public pubkey: string; + + /** MsgCreateValidator value. */ + public value?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgCreateValidator instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgCreateValidator instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgCreateValidator, + ): cosmos.staking.v1beta1.MsgCreateValidator; + + /** + * Encodes the specified MsgCreateValidator message. Does not implicitly {@link cosmos.staking.v1beta1.MsgCreateValidator.verify|verify} messages. + * @param m MsgCreateValidator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgCreateValidator, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgCreateValidator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgCreateValidator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgCreateValidator; + } + + /** Properties of a MsgEditValidator. */ + interface IMsgEditValidator { + /** MsgEditValidator description */ + description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgEditValidator validatorAddress */ + validatorAddress?: string | null; + + /** MsgEditValidator commissionRate */ + commissionRate?: string | null; + + /** MsgEditValidator minSelfDelegation */ + minSelfDelegation?: string | null; + } + + /** Represents a MsgEditValidator. */ + class MsgEditValidator implements IMsgEditValidator { + /** + * Constructs a new MsgEditValidator. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgEditValidator); + + /** MsgEditValidator description. */ + public description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgEditValidator validatorAddress. */ + public validatorAddress: string; + + /** MsgEditValidator commissionRate. */ + public commissionRate: string; + + /** MsgEditValidator minSelfDelegation. */ + public minSelfDelegation: string; + + /** + * Creates a new MsgEditValidator instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgEditValidator instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgEditValidator, + ): cosmos.staking.v1beta1.MsgEditValidator; + + /** + * Encodes the specified MsgEditValidator message. Does not implicitly {@link cosmos.staking.v1beta1.MsgEditValidator.verify|verify} messages. + * @param m MsgEditValidator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgEditValidator, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgEditValidator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgEditValidator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgEditValidator; + } + + /** Properties of a MsgDelegate. */ + interface IMsgDelegate { + /** MsgDelegate delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgDelegate validatorAddress */ + validatorAddress?: string | null; + + /** MsgDelegate amount */ + amount?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgDelegate. */ + class MsgDelegate implements IMsgDelegate { + /** + * Constructs a new MsgDelegate. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgDelegate); + + /** MsgDelegate delegatorAddress. */ + public delegatorAddress: string; + + /** MsgDelegate validatorAddress. */ + public validatorAddress: string; + + /** MsgDelegate amount. */ + public amount?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgDelegate instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgDelegate instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgDelegate, + ): cosmos.staking.v1beta1.MsgDelegate; + + /** + * Encodes the specified MsgDelegate message. Does not implicitly {@link cosmos.staking.v1beta1.MsgDelegate.verify|verify} messages. + * @param m MsgDelegate message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IMsgDelegate, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgDelegate message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgDelegate + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgDelegate; + } + + /** Properties of a MsgBeginRedelegate. */ + interface IMsgBeginRedelegate { + /** MsgBeginRedelegate delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgBeginRedelegate validatorSrcAddress */ + validatorSrcAddress?: string | null; + + /** MsgBeginRedelegate validatorDstAddress */ + validatorDstAddress?: string | null; + + /** MsgBeginRedelegate amount */ + amount?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgBeginRedelegate. */ + class MsgBeginRedelegate implements IMsgBeginRedelegate { + /** + * Constructs a new MsgBeginRedelegate. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgBeginRedelegate); + + /** MsgBeginRedelegate delegatorAddress. */ + public delegatorAddress: string; + + /** MsgBeginRedelegate validatorSrcAddress. */ + public validatorSrcAddress: string; + + /** MsgBeginRedelegate validatorDstAddress. */ + public validatorDstAddress: string; + + /** MsgBeginRedelegate amount. */ + public amount?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgBeginRedelegate instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgBeginRedelegate instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgBeginRedelegate, + ): cosmos.staking.v1beta1.MsgBeginRedelegate; + + /** + * Encodes the specified MsgBeginRedelegate message. Does not implicitly {@link cosmos.staking.v1beta1.MsgBeginRedelegate.verify|verify} messages. + * @param m MsgBeginRedelegate message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgBeginRedelegate, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgBeginRedelegate message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgBeginRedelegate + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgBeginRedelegate; + } + + /** Properties of a MsgUndelegate. */ + interface IMsgUndelegate { + /** MsgUndelegate delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgUndelegate validatorAddress */ + validatorAddress?: string | null; + + /** MsgUndelegate amount */ + amount?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgUndelegate. */ + class MsgUndelegate implements IMsgUndelegate { + /** + * Constructs a new MsgUndelegate. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgUndelegate); + + /** MsgUndelegate delegatorAddress. */ + public delegatorAddress: string; + + /** MsgUndelegate validatorAddress. */ + public validatorAddress: string; + + /** MsgUndelegate amount. */ + public amount?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgUndelegate instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgUndelegate instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgUndelegate, + ): cosmos.staking.v1beta1.MsgUndelegate; + + /** + * Encodes the specified MsgUndelegate message. Does not implicitly {@link cosmos.staking.v1beta1.MsgUndelegate.verify|verify} messages. + * @param m MsgUndelegate message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgUndelegate, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgUndelegate message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgUndelegate + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgUndelegate; + } + } + } + /** Namespace tx. */ namespace tx { /** Namespace signing. */ @@ -4358,6 +5916,104 @@ export namespace google { ): google.protobuf.GeneratedCodeInfo.Annotation; } } + + /** Properties of a Timestamp. */ + interface ITimestamp { + /** Timestamp seconds */ + seconds?: Long | null; + + /** Timestamp nanos */ + nanos?: number | null; + } + + /** Represents a Timestamp. */ + class Timestamp implements ITimestamp { + /** + * Constructs a new Timestamp. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.ITimestamp); + + /** Timestamp seconds. */ + public seconds: Long; + + /** Timestamp nanos. */ + public nanos: number; + + /** + * Creates a new Timestamp instance using the specified properties. + * @param [properties] Properties to set + * @returns Timestamp instance + */ + public static create(properties?: google.protobuf.ITimestamp): google.protobuf.Timestamp; + + /** + * Encodes the specified Timestamp message. Does not implicitly {@link google.protobuf.Timestamp.verify|verify} messages. + * @param m Timestamp message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.ITimestamp, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Timestamp message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Timestamp + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.Timestamp; + } + + /** Properties of a Duration. */ + interface IDuration { + /** Duration seconds */ + seconds?: Long | null; + + /** Duration nanos */ + nanos?: number | null; + } + + /** Represents a Duration. */ + class Duration implements IDuration { + /** + * Constructs a new Duration. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IDuration); + + /** Duration seconds. */ + public seconds: Long; + + /** Duration nanos. */ + public nanos: number; + + /** + * Creates a new Duration instance using the specified properties. + * @param [properties] Properties to set + * @returns Duration instance + */ + public static create(properties?: google.protobuf.IDuration): google.protobuf.Duration; + + /** + * Encodes the specified Duration message. Does not implicitly {@link google.protobuf.Duration.verify|verify} messages. + * @param m Duration message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IDuration, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Duration message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Duration + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.Duration; + } } /** Namespace api. */ @@ -9880,6 +11536,52 @@ export namespace ibc { export namespace tendermint { /** Namespace crypto. */ namespace crypto { + /** Properties of a PublicKey. */ + interface IPublicKey { + /** PublicKey ed25519 */ + ed25519?: Uint8Array | null; + } + + /** Represents a PublicKey. */ + class PublicKey implements IPublicKey { + /** + * Constructs a new PublicKey. + * @param [p] Properties to set + */ + constructor(p?: tendermint.crypto.IPublicKey); + + /** PublicKey ed25519. */ + public ed25519: Uint8Array; + + /** PublicKey sum. */ + public sum?: "ed25519"; + + /** + * Creates a new PublicKey instance using the specified properties. + * @param [properties] Properties to set + * @returns PublicKey instance + */ + public static create(properties?: tendermint.crypto.IPublicKey): tendermint.crypto.PublicKey; + + /** + * Encodes the specified PublicKey message. Does not implicitly {@link tendermint.crypto.PublicKey.verify|verify} messages. + * @param m PublicKey message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.crypto.IPublicKey, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PublicKey message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PublicKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.crypto.PublicKey; + } + /** Properties of a Proof. */ interface IProof { /** Proof total */ @@ -10143,4 +11845,1179 @@ export namespace tendermint { public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.crypto.ProofOps; } } + + /** Namespace libs. */ + namespace libs { + /** Namespace bits. */ + namespace bits { + /** Properties of a BitArray. */ + interface IBitArray { + /** BitArray bits */ + bits?: Long | null; + + /** BitArray elems */ + elems?: Long[] | null; + } + + /** Represents a BitArray. */ + class BitArray implements IBitArray { + /** + * Constructs a new BitArray. + * @param [p] Properties to set + */ + constructor(p?: tendermint.libs.bits.IBitArray); + + /** BitArray bits. */ + public bits: Long; + + /** BitArray elems. */ + public elems: Long[]; + + /** + * Creates a new BitArray instance using the specified properties. + * @param [properties] Properties to set + * @returns BitArray instance + */ + public static create(properties?: tendermint.libs.bits.IBitArray): tendermint.libs.bits.BitArray; + + /** + * Encodes the specified BitArray message. Does not implicitly {@link tendermint.libs.bits.BitArray.verify|verify} messages. + * @param m BitArray message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.libs.bits.IBitArray, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a BitArray message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns BitArray + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.libs.bits.BitArray; + } + } + } + + /** Namespace types. */ + namespace types { + /** BlockIDFlag enum. */ + enum BlockIDFlag { + BLOCK_ID_FLAG_UNKNOWN = 0, + BLOCK_ID_FLAG_ABSENT = 1, + BLOCK_ID_FLAG_COMMIT = 2, + BLOCK_ID_FLAG_NIL = 3, + } + + /** SignedMsgType enum. */ + enum SignedMsgType { + SIGNED_MSG_TYPE_UNKNOWN = 0, + SIGNED_MSG_TYPE_PREVOTE = 1, + SIGNED_MSG_TYPE_PRECOMMIT = 2, + SIGNED_MSG_TYPE_PROPOSAL = 32, + } + + /** Properties of a PartSetHeader. */ + interface IPartSetHeader { + /** PartSetHeader total */ + total?: number | null; + + /** PartSetHeader hash */ + hash?: Uint8Array | null; + } + + /** Represents a PartSetHeader. */ + class PartSetHeader implements IPartSetHeader { + /** + * Constructs a new PartSetHeader. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IPartSetHeader); + + /** PartSetHeader total. */ + public total: number; + + /** PartSetHeader hash. */ + public hash: Uint8Array; + + /** + * Creates a new PartSetHeader instance using the specified properties. + * @param [properties] Properties to set + * @returns PartSetHeader instance + */ + public static create(properties?: tendermint.types.IPartSetHeader): tendermint.types.PartSetHeader; + + /** + * Encodes the specified PartSetHeader message. Does not implicitly {@link tendermint.types.PartSetHeader.verify|verify} messages. + * @param m PartSetHeader message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IPartSetHeader, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PartSetHeader message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PartSetHeader + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.PartSetHeader; + } + + /** Properties of a Part. */ + interface IPart { + /** Part index */ + index?: number | null; + + /** Part bytes */ + bytes?: Uint8Array | null; + + /** Part proof */ + proof?: tendermint.crypto.IProof | null; + } + + /** Represents a Part. */ + class Part implements IPart { + /** + * Constructs a new Part. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IPart); + + /** Part index. */ + public index: number; + + /** Part bytes. */ + public bytes: Uint8Array; + + /** Part proof. */ + public proof?: tendermint.crypto.IProof | null; + + /** + * Creates a new Part instance using the specified properties. + * @param [properties] Properties to set + * @returns Part instance + */ + public static create(properties?: tendermint.types.IPart): tendermint.types.Part; + + /** + * Encodes the specified Part message. Does not implicitly {@link tendermint.types.Part.verify|verify} messages. + * @param m Part message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IPart, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Part message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Part + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Part; + } + + /** Properties of a BlockID. */ + interface IBlockID { + /** BlockID hash */ + hash?: Uint8Array | null; + + /** BlockID partSetHeader */ + partSetHeader?: tendermint.types.IPartSetHeader | null; + } + + /** Represents a BlockID. */ + class BlockID implements IBlockID { + /** + * Constructs a new BlockID. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IBlockID); + + /** BlockID hash. */ + public hash: Uint8Array; + + /** BlockID partSetHeader. */ + public partSetHeader?: tendermint.types.IPartSetHeader | null; + + /** + * Creates a new BlockID instance using the specified properties. + * @param [properties] Properties to set + * @returns BlockID instance + */ + public static create(properties?: tendermint.types.IBlockID): tendermint.types.BlockID; + + /** + * Encodes the specified BlockID message. Does not implicitly {@link tendermint.types.BlockID.verify|verify} messages. + * @param m BlockID message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IBlockID, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a BlockID message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns BlockID + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.BlockID; + } + + /** Properties of a Header. */ + interface IHeader { + /** Header version */ + version?: tendermint.version.IConsensus | null; + + /** Header chainId */ + chainId?: string | null; + + /** Header height */ + height?: Long | null; + + /** Header time */ + time?: google.protobuf.ITimestamp | null; + + /** Header lastBlockId */ + lastBlockId?: tendermint.types.IBlockID | null; + + /** Header lastCommitHash */ + lastCommitHash?: Uint8Array | null; + + /** Header dataHash */ + dataHash?: Uint8Array | null; + + /** Header validatorsHash */ + validatorsHash?: Uint8Array | null; + + /** Header nextValidatorsHash */ + nextValidatorsHash?: Uint8Array | null; + + /** Header consensusHash */ + consensusHash?: Uint8Array | null; + + /** Header appHash */ + appHash?: Uint8Array | null; + + /** Header lastResultsHash */ + lastResultsHash?: Uint8Array | null; + + /** Header evidenceHash */ + evidenceHash?: Uint8Array | null; + + /** Header proposerAddress */ + proposerAddress?: Uint8Array | null; + } + + /** Represents a Header. */ + class Header implements IHeader { + /** + * Constructs a new Header. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IHeader); + + /** Header version. */ + public version?: tendermint.version.IConsensus | null; + + /** Header chainId. */ + public chainId: string; + + /** Header height. */ + public height: Long; + + /** Header time. */ + public time?: google.protobuf.ITimestamp | null; + + /** Header lastBlockId. */ + public lastBlockId?: tendermint.types.IBlockID | null; + + /** Header lastCommitHash. */ + public lastCommitHash: Uint8Array; + + /** Header dataHash. */ + public dataHash: Uint8Array; + + /** Header validatorsHash. */ + public validatorsHash: Uint8Array; + + /** Header nextValidatorsHash. */ + public nextValidatorsHash: Uint8Array; + + /** Header consensusHash. */ + public consensusHash: Uint8Array; + + /** Header appHash. */ + public appHash: Uint8Array; + + /** Header lastResultsHash. */ + public lastResultsHash: Uint8Array; + + /** Header evidenceHash. */ + public evidenceHash: Uint8Array; + + /** Header proposerAddress. */ + public proposerAddress: Uint8Array; + + /** + * Creates a new Header instance using the specified properties. + * @param [properties] Properties to set + * @returns Header instance + */ + public static create(properties?: tendermint.types.IHeader): tendermint.types.Header; + + /** + * Encodes the specified Header message. Does not implicitly {@link tendermint.types.Header.verify|verify} messages. + * @param m Header message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IHeader, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Header message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Header + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Header; + } + + /** Properties of a Data. */ + interface IData { + /** Data txs */ + txs?: Uint8Array[] | null; + + /** Data hash */ + hash?: Uint8Array | null; + } + + /** Represents a Data. */ + class Data implements IData { + /** + * Constructs a new Data. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IData); + + /** Data txs. */ + public txs: Uint8Array[]; + + /** Data hash. */ + public hash: Uint8Array; + + /** + * Creates a new Data instance using the specified properties. + * @param [properties] Properties to set + * @returns Data instance + */ + public static create(properties?: tendermint.types.IData): tendermint.types.Data; + + /** + * Encodes the specified Data message. Does not implicitly {@link tendermint.types.Data.verify|verify} messages. + * @param m Data message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IData, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Data message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Data + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Data; + } + + /** Properties of a Vote. */ + interface IVote { + /** Vote type */ + type?: tendermint.types.SignedMsgType | null; + + /** Vote height */ + height?: Long | null; + + /** Vote round */ + round?: number | null; + + /** Vote blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** Vote timestamp */ + timestamp?: google.protobuf.ITimestamp | null; + + /** Vote validatorAddress */ + validatorAddress?: Uint8Array | null; + + /** Vote validatorIndex */ + validatorIndex?: number | null; + + /** Vote signature */ + signature?: Uint8Array | null; + } + + /** Represents a Vote. */ + class Vote implements IVote { + /** + * Constructs a new Vote. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IVote); + + /** Vote type. */ + public type: tendermint.types.SignedMsgType; + + /** Vote height. */ + public height: Long; + + /** Vote round. */ + public round: number; + + /** Vote blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** Vote timestamp. */ + public timestamp?: google.protobuf.ITimestamp | null; + + /** Vote validatorAddress. */ + public validatorAddress: Uint8Array; + + /** Vote validatorIndex. */ + public validatorIndex: number; + + /** Vote signature. */ + public signature: Uint8Array; + + /** + * Creates a new Vote instance using the specified properties. + * @param [properties] Properties to set + * @returns Vote instance + */ + public static create(properties?: tendermint.types.IVote): tendermint.types.Vote; + + /** + * Encodes the specified Vote message. Does not implicitly {@link tendermint.types.Vote.verify|verify} messages. + * @param m Vote message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IVote, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Vote message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Vote + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Vote; + } + + /** Properties of a Commit. */ + interface ICommit { + /** Commit height */ + height?: Long | null; + + /** Commit round */ + round?: number | null; + + /** Commit blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** Commit signatures */ + signatures?: tendermint.types.ICommitSig[] | null; + + /** Commit hash */ + hash?: Uint8Array | null; + + /** Commit bitArray */ + bitArray?: tendermint.libs.bits.IBitArray | null; + } + + /** Represents a Commit. */ + class Commit implements ICommit { + /** + * Constructs a new Commit. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ICommit); + + /** Commit height. */ + public height: Long; + + /** Commit round. */ + public round: number; + + /** Commit blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** Commit signatures. */ + public signatures: tendermint.types.ICommitSig[]; + + /** Commit hash. */ + public hash: Uint8Array; + + /** Commit bitArray. */ + public bitArray?: tendermint.libs.bits.IBitArray | null; + + /** + * Creates a new Commit instance using the specified properties. + * @param [properties] Properties to set + * @returns Commit instance + */ + public static create(properties?: tendermint.types.ICommit): tendermint.types.Commit; + + /** + * Encodes the specified Commit message. Does not implicitly {@link tendermint.types.Commit.verify|verify} messages. + * @param m Commit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ICommit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Commit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Commit + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Commit; + } + + /** Properties of a CommitSig. */ + interface ICommitSig { + /** CommitSig blockIdFlag */ + blockIdFlag?: tendermint.types.BlockIDFlag | null; + + /** CommitSig validatorAddress */ + validatorAddress?: Uint8Array | null; + + /** CommitSig timestamp */ + timestamp?: google.protobuf.ITimestamp | null; + + /** CommitSig signature */ + signature?: Uint8Array | null; + } + + /** Represents a CommitSig. */ + class CommitSig implements ICommitSig { + /** + * Constructs a new CommitSig. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ICommitSig); + + /** CommitSig blockIdFlag. */ + public blockIdFlag: tendermint.types.BlockIDFlag; + + /** CommitSig validatorAddress. */ + public validatorAddress: Uint8Array; + + /** CommitSig timestamp. */ + public timestamp?: google.protobuf.ITimestamp | null; + + /** CommitSig signature. */ + public signature: Uint8Array; + + /** + * Creates a new CommitSig instance using the specified properties. + * @param [properties] Properties to set + * @returns CommitSig instance + */ + public static create(properties?: tendermint.types.ICommitSig): tendermint.types.CommitSig; + + /** + * Encodes the specified CommitSig message. Does not implicitly {@link tendermint.types.CommitSig.verify|verify} messages. + * @param m CommitSig message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ICommitSig, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a CommitSig message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CommitSig + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.CommitSig; + } + + /** Properties of a Proposal. */ + interface IProposal { + /** Proposal type */ + type?: tendermint.types.SignedMsgType | null; + + /** Proposal height */ + height?: Long | null; + + /** Proposal round */ + round?: number | null; + + /** Proposal polRound */ + polRound?: number | null; + + /** Proposal blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** Proposal timestamp */ + timestamp?: google.protobuf.ITimestamp | null; + + /** Proposal signature */ + signature?: Uint8Array | null; + } + + /** Represents a Proposal. */ + class Proposal implements IProposal { + /** + * Constructs a new Proposal. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IProposal); + + /** Proposal type. */ + public type: tendermint.types.SignedMsgType; + + /** Proposal height. */ + public height: Long; + + /** Proposal round. */ + public round: number; + + /** Proposal polRound. */ + public polRound: number; + + /** Proposal blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** Proposal timestamp. */ + public timestamp?: google.protobuf.ITimestamp | null; + + /** Proposal signature. */ + public signature: Uint8Array; + + /** + * Creates a new Proposal instance using the specified properties. + * @param [properties] Properties to set + * @returns Proposal instance + */ + public static create(properties?: tendermint.types.IProposal): tendermint.types.Proposal; + + /** + * Encodes the specified Proposal message. Does not implicitly {@link tendermint.types.Proposal.verify|verify} messages. + * @param m Proposal message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IProposal, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Proposal message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Proposal + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Proposal; + } + + /** Properties of a SignedHeader. */ + interface ISignedHeader { + /** SignedHeader header */ + header?: tendermint.types.IHeader | null; + + /** SignedHeader commit */ + commit?: tendermint.types.ICommit | null; + } + + /** Represents a SignedHeader. */ + class SignedHeader implements ISignedHeader { + /** + * Constructs a new SignedHeader. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ISignedHeader); + + /** SignedHeader header. */ + public header?: tendermint.types.IHeader | null; + + /** SignedHeader commit. */ + public commit?: tendermint.types.ICommit | null; + + /** + * Creates a new SignedHeader instance using the specified properties. + * @param [properties] Properties to set + * @returns SignedHeader instance + */ + public static create(properties?: tendermint.types.ISignedHeader): tendermint.types.SignedHeader; + + /** + * Encodes the specified SignedHeader message. Does not implicitly {@link tendermint.types.SignedHeader.verify|verify} messages. + * @param m SignedHeader message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ISignedHeader, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a SignedHeader message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SignedHeader + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.SignedHeader; + } + + /** Properties of a LightBlock. */ + interface ILightBlock { + /** LightBlock signedHeader */ + signedHeader?: tendermint.types.ISignedHeader | null; + + /** LightBlock validatorSet */ + validatorSet?: tendermint.types.IValidatorSet | null; + } + + /** Represents a LightBlock. */ + class LightBlock implements ILightBlock { + /** + * Constructs a new LightBlock. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ILightBlock); + + /** LightBlock signedHeader. */ + public signedHeader?: tendermint.types.ISignedHeader | null; + + /** LightBlock validatorSet. */ + public validatorSet?: tendermint.types.IValidatorSet | null; + + /** + * Creates a new LightBlock instance using the specified properties. + * @param [properties] Properties to set + * @returns LightBlock instance + */ + public static create(properties?: tendermint.types.ILightBlock): tendermint.types.LightBlock; + + /** + * Encodes the specified LightBlock message. Does not implicitly {@link tendermint.types.LightBlock.verify|verify} messages. + * @param m LightBlock message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ILightBlock, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a LightBlock message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns LightBlock + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.LightBlock; + } + + /** Properties of a BlockMeta. */ + interface IBlockMeta { + /** BlockMeta blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** BlockMeta blockSize */ + blockSize?: Long | null; + + /** BlockMeta header */ + header?: tendermint.types.IHeader | null; + + /** BlockMeta numTxs */ + numTxs?: Long | null; + } + + /** Represents a BlockMeta. */ + class BlockMeta implements IBlockMeta { + /** + * Constructs a new BlockMeta. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IBlockMeta); + + /** BlockMeta blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** BlockMeta blockSize. */ + public blockSize: Long; + + /** BlockMeta header. */ + public header?: tendermint.types.IHeader | null; + + /** BlockMeta numTxs. */ + public numTxs: Long; + + /** + * Creates a new BlockMeta instance using the specified properties. + * @param [properties] Properties to set + * @returns BlockMeta instance + */ + public static create(properties?: tendermint.types.IBlockMeta): tendermint.types.BlockMeta; + + /** + * Encodes the specified BlockMeta message. Does not implicitly {@link tendermint.types.BlockMeta.verify|verify} messages. + * @param m BlockMeta message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IBlockMeta, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a BlockMeta message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns BlockMeta + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.BlockMeta; + } + + /** Properties of a TxProof. */ + interface ITxProof { + /** TxProof rootHash */ + rootHash?: Uint8Array | null; + + /** TxProof data */ + data?: Uint8Array | null; + + /** TxProof proof */ + proof?: tendermint.crypto.IProof | null; + } + + /** Represents a TxProof. */ + class TxProof implements ITxProof { + /** + * Constructs a new TxProof. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ITxProof); + + /** TxProof rootHash. */ + public rootHash: Uint8Array; + + /** TxProof data. */ + public data: Uint8Array; + + /** TxProof proof. */ + public proof?: tendermint.crypto.IProof | null; + + /** + * Creates a new TxProof instance using the specified properties. + * @param [properties] Properties to set + * @returns TxProof instance + */ + public static create(properties?: tendermint.types.ITxProof): tendermint.types.TxProof; + + /** + * Encodes the specified TxProof message. Does not implicitly {@link tendermint.types.TxProof.verify|verify} messages. + * @param m TxProof message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ITxProof, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a TxProof message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns TxProof + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.TxProof; + } + + /** Properties of a ValidatorSet. */ + interface IValidatorSet { + /** ValidatorSet validators */ + validators?: tendermint.types.IValidator[] | null; + + /** ValidatorSet proposer */ + proposer?: tendermint.types.IValidator | null; + + /** ValidatorSet totalVotingPower */ + totalVotingPower?: Long | null; + } + + /** Represents a ValidatorSet. */ + class ValidatorSet implements IValidatorSet { + /** + * Constructs a new ValidatorSet. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IValidatorSet); + + /** ValidatorSet validators. */ + public validators: tendermint.types.IValidator[]; + + /** ValidatorSet proposer. */ + public proposer?: tendermint.types.IValidator | null; + + /** ValidatorSet totalVotingPower. */ + public totalVotingPower: Long; + + /** + * Creates a new ValidatorSet instance using the specified properties. + * @param [properties] Properties to set + * @returns ValidatorSet instance + */ + public static create(properties?: tendermint.types.IValidatorSet): tendermint.types.ValidatorSet; + + /** + * Encodes the specified ValidatorSet message. Does not implicitly {@link tendermint.types.ValidatorSet.verify|verify} messages. + * @param m ValidatorSet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IValidatorSet, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ValidatorSet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ValidatorSet + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.ValidatorSet; + } + + /** Properties of a Validator. */ + interface IValidator { + /** Validator address */ + address?: Uint8Array | null; + + /** Validator pubKey */ + pubKey?: tendermint.crypto.IPublicKey | null; + + /** Validator votingPower */ + votingPower?: Long | null; + + /** Validator proposerPriority */ + proposerPriority?: Long | null; + } + + /** Represents a Validator. */ + class Validator implements IValidator { + /** + * Constructs a new Validator. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IValidator); + + /** Validator address. */ + public address: Uint8Array; + + /** Validator pubKey. */ + public pubKey?: tendermint.crypto.IPublicKey | null; + + /** Validator votingPower. */ + public votingPower: Long; + + /** Validator proposerPriority. */ + public proposerPriority: Long; + + /** + * Creates a new Validator instance using the specified properties. + * @param [properties] Properties to set + * @returns Validator instance + */ + public static create(properties?: tendermint.types.IValidator): tendermint.types.Validator; + + /** + * Encodes the specified Validator message. Does not implicitly {@link tendermint.types.Validator.verify|verify} messages. + * @param m Validator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IValidator, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Validator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Validator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Validator; + } + + /** Properties of a SimpleValidator. */ + interface ISimpleValidator { + /** SimpleValidator pubKey */ + pubKey?: tendermint.crypto.IPublicKey | null; + + /** SimpleValidator votingPower */ + votingPower?: Long | null; + } + + /** Represents a SimpleValidator. */ + class SimpleValidator implements ISimpleValidator { + /** + * Constructs a new SimpleValidator. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ISimpleValidator); + + /** SimpleValidator pubKey. */ + public pubKey?: tendermint.crypto.IPublicKey | null; + + /** SimpleValidator votingPower. */ + public votingPower: Long; + + /** + * Creates a new SimpleValidator instance using the specified properties. + * @param [properties] Properties to set + * @returns SimpleValidator instance + */ + public static create(properties?: tendermint.types.ISimpleValidator): tendermint.types.SimpleValidator; + + /** + * Encodes the specified SimpleValidator message. Does not implicitly {@link tendermint.types.SimpleValidator.verify|verify} messages. + * @param m SimpleValidator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ISimpleValidator, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a SimpleValidator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SimpleValidator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.SimpleValidator; + } + } + + /** Namespace version. */ + namespace version { + /** Properties of an App. */ + interface IApp { + /** App protocol */ + protocol?: Long | null; + + /** App software */ + software?: string | null; + } + + /** Represents an App. */ + class App implements IApp { + /** + * Constructs a new App. + * @param [p] Properties to set + */ + constructor(p?: tendermint.version.IApp); + + /** App protocol. */ + public protocol: Long; + + /** App software. */ + public software: string; + + /** + * Creates a new App instance using the specified properties. + * @param [properties] Properties to set + * @returns App instance + */ + public static create(properties?: tendermint.version.IApp): tendermint.version.App; + + /** + * Encodes the specified App message. Does not implicitly {@link tendermint.version.App.verify|verify} messages. + * @param m App message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.version.IApp, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an App message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns App + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.version.App; + } + + /** Properties of a Consensus. */ + interface IConsensus { + /** Consensus block */ + block?: Long | null; + + /** Consensus app */ + app?: Long | null; + } + + /** Represents a Consensus. */ + class Consensus implements IConsensus { + /** + * Constructs a new Consensus. + * @param [p] Properties to set + */ + constructor(p?: tendermint.version.IConsensus); + + /** Consensus block. */ + public block: Long; + + /** Consensus app. */ + public app: Long; + + /** + * Creates a new Consensus instance using the specified properties. + * @param [properties] Properties to set + * @returns Consensus instance + */ + public static create(properties?: tendermint.version.IConsensus): tendermint.version.Consensus; + + /** + * Encodes the specified Consensus message. Does not implicitly {@link tendermint.version.Consensus.verify|verify} messages. + * @param m Consensus message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.version.IConsensus, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Consensus message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Consensus + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.version.Consensus; + } + } } diff --git a/packages/stargate/src/codec/generated/codecimpl.js b/packages/stargate/src/codec/generated/codecimpl.js index 8316d31d..8674615a 100644 --- a/packages/stargate/src/codec/generated/codecimpl.js +++ b/packages/stargate/src/codec/generated/codecimpl.js @@ -1201,6 +1201,1267 @@ exports.cosmos = $root.cosmos = (() => { })(); return crypto; })(); + cosmos.staking = (function () { + const staking = {}; + staking.v1beta1 = (function () { + const v1beta1 = {}; + v1beta1.HistoricalInfo = (function () { + function HistoricalInfo(p) { + this.valset = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + HistoricalInfo.prototype.header = null; + HistoricalInfo.prototype.valset = $util.emptyArray; + HistoricalInfo.create = function create(properties) { + return new HistoricalInfo(properties); + }; + HistoricalInfo.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.header != null && Object.hasOwnProperty.call(m, "header")) + $root.tendermint.types.Header.encode(m.header, w.uint32(10).fork()).ldelim(); + if (m.valset != null && m.valset.length) { + for (var i = 0; i < m.valset.length; ++i) + $root.cosmos.staking.v1beta1.Validator.encode(m.valset[i], w.uint32(18).fork()).ldelim(); + } + return w; + }; + HistoricalInfo.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.HistoricalInfo(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.header = $root.tendermint.types.Header.decode(r, r.uint32()); + break; + case 2: + if (!(m.valset && m.valset.length)) m.valset = []; + m.valset.push($root.cosmos.staking.v1beta1.Validator.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return HistoricalInfo; + })(); + v1beta1.CommissionRates = (function () { + function CommissionRates(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + CommissionRates.prototype.rate = ""; + CommissionRates.prototype.maxRate = ""; + CommissionRates.prototype.maxChangeRate = ""; + CommissionRates.create = function create(properties) { + return new CommissionRates(properties); + }; + CommissionRates.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.rate != null && Object.hasOwnProperty.call(m, "rate")) w.uint32(10).string(m.rate); + if (m.maxRate != null && Object.hasOwnProperty.call(m, "maxRate")) w.uint32(18).string(m.maxRate); + if (m.maxChangeRate != null && Object.hasOwnProperty.call(m, "maxChangeRate")) + w.uint32(26).string(m.maxChangeRate); + return w; + }; + CommissionRates.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.CommissionRates(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.rate = r.string(); + break; + case 2: + m.maxRate = r.string(); + break; + case 3: + m.maxChangeRate = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return CommissionRates; + })(); + v1beta1.Commission = (function () { + function Commission(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Commission.prototype.commissionRates = null; + Commission.prototype.updateTime = null; + Commission.create = function create(properties) { + return new Commission(properties); + }; + Commission.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.commissionRates != null && Object.hasOwnProperty.call(m, "commissionRates")) + $root.cosmos.staking.v1beta1.CommissionRates.encode( + m.commissionRates, + w.uint32(10).fork(), + ).ldelim(); + if (m.updateTime != null && Object.hasOwnProperty.call(m, "updateTime")) + $root.google.protobuf.Timestamp.encode(m.updateTime, w.uint32(18).fork()).ldelim(); + return w; + }; + Commission.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Commission(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.commissionRates = $root.cosmos.staking.v1beta1.CommissionRates.decode(r, r.uint32()); + break; + case 2: + m.updateTime = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Commission; + })(); + v1beta1.Description = (function () { + function Description(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Description.prototype.moniker = ""; + Description.prototype.identity = ""; + Description.prototype.website = ""; + Description.prototype.securityContact = ""; + Description.prototype.details = ""; + Description.create = function create(properties) { + return new Description(properties); + }; + Description.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.moniker != null && Object.hasOwnProperty.call(m, "moniker")) w.uint32(10).string(m.moniker); + if (m.identity != null && Object.hasOwnProperty.call(m, "identity")) + w.uint32(18).string(m.identity); + if (m.website != null && Object.hasOwnProperty.call(m, "website")) w.uint32(26).string(m.website); + if (m.securityContact != null && Object.hasOwnProperty.call(m, "securityContact")) + w.uint32(34).string(m.securityContact); + if (m.details != null && Object.hasOwnProperty.call(m, "details")) w.uint32(42).string(m.details); + return w; + }; + Description.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Description(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.moniker = r.string(); + break; + case 2: + m.identity = r.string(); + break; + case 3: + m.website = r.string(); + break; + case 4: + m.securityContact = r.string(); + break; + case 5: + m.details = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Description; + })(); + v1beta1.Validator = (function () { + function Validator(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Validator.prototype.operatorAddress = ""; + Validator.prototype.consensusPubkey = ""; + Validator.prototype.jailed = false; + Validator.prototype.status = 0; + Validator.prototype.tokens = ""; + Validator.prototype.delegatorShares = ""; + Validator.prototype.description = null; + Validator.prototype.unbondingHeight = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Validator.prototype.unbondingTime = null; + Validator.prototype.commission = null; + Validator.prototype.minSelfDelegation = ""; + Validator.create = function create(properties) { + return new Validator(properties); + }; + Validator.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.operatorAddress != null && Object.hasOwnProperty.call(m, "operatorAddress")) + w.uint32(10).string(m.operatorAddress); + if (m.consensusPubkey != null && Object.hasOwnProperty.call(m, "consensusPubkey")) + w.uint32(18).string(m.consensusPubkey); + if (m.jailed != null && Object.hasOwnProperty.call(m, "jailed")) w.uint32(24).bool(m.jailed); + if (m.status != null && Object.hasOwnProperty.call(m, "status")) w.uint32(32).int32(m.status); + if (m.tokens != null && Object.hasOwnProperty.call(m, "tokens")) w.uint32(42).string(m.tokens); + if (m.delegatorShares != null && Object.hasOwnProperty.call(m, "delegatorShares")) + w.uint32(50).string(m.delegatorShares); + if (m.description != null && Object.hasOwnProperty.call(m, "description")) + $root.cosmos.staking.v1beta1.Description.encode(m.description, w.uint32(58).fork()).ldelim(); + if (m.unbondingHeight != null && Object.hasOwnProperty.call(m, "unbondingHeight")) + w.uint32(64).int64(m.unbondingHeight); + if (m.unbondingTime != null && Object.hasOwnProperty.call(m, "unbondingTime")) + $root.google.protobuf.Timestamp.encode(m.unbondingTime, w.uint32(74).fork()).ldelim(); + if (m.commission != null && Object.hasOwnProperty.call(m, "commission")) + $root.cosmos.staking.v1beta1.Commission.encode(m.commission, w.uint32(82).fork()).ldelim(); + if (m.minSelfDelegation != null && Object.hasOwnProperty.call(m, "minSelfDelegation")) + w.uint32(90).string(m.minSelfDelegation); + return w; + }; + Validator.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Validator(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.operatorAddress = r.string(); + break; + case 2: + m.consensusPubkey = r.string(); + break; + case 3: + m.jailed = r.bool(); + break; + case 4: + m.status = r.int32(); + break; + case 5: + m.tokens = r.string(); + break; + case 6: + m.delegatorShares = r.string(); + break; + case 7: + m.description = $root.cosmos.staking.v1beta1.Description.decode(r, r.uint32()); + break; + case 8: + m.unbondingHeight = r.int64(); + break; + case 9: + m.unbondingTime = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 10: + m.commission = $root.cosmos.staking.v1beta1.Commission.decode(r, r.uint32()); + break; + case 11: + m.minSelfDelegation = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Validator; + })(); + v1beta1.ValAddresses = (function () { + function ValAddresses(p) { + this.addresses = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ValAddresses.prototype.addresses = $util.emptyArray; + ValAddresses.create = function create(properties) { + return new ValAddresses(properties); + }; + ValAddresses.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.addresses != null && m.addresses.length) { + for (var i = 0; i < m.addresses.length; ++i) w.uint32(10).string(m.addresses[i]); + } + return w; + }; + ValAddresses.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.ValAddresses(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.addresses && m.addresses.length)) m.addresses = []; + m.addresses.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ValAddresses; + })(); + v1beta1.DVPair = (function () { + function DVPair(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DVPair.prototype.delegatorAddress = ""; + DVPair.prototype.validatorAddress = ""; + DVPair.create = function create(properties) { + return new DVPair(properties); + }; + DVPair.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).string(m.validatorAddress); + return w; + }; + DVPair.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.DVPair(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorAddress = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DVPair; + })(); + v1beta1.DVPairs = (function () { + function DVPairs(p) { + this.pairs = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DVPairs.prototype.pairs = $util.emptyArray; + DVPairs.create = function create(properties) { + return new DVPairs(properties); + }; + DVPairs.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.pairs != null && m.pairs.length) { + for (var i = 0; i < m.pairs.length; ++i) + $root.cosmos.staking.v1beta1.DVPair.encode(m.pairs[i], w.uint32(10).fork()).ldelim(); + } + return w; + }; + DVPairs.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.DVPairs(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.pairs && m.pairs.length)) m.pairs = []; + m.pairs.push($root.cosmos.staking.v1beta1.DVPair.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DVPairs; + })(); + v1beta1.DVVTriplet = (function () { + function DVVTriplet(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DVVTriplet.prototype.delegatorAddress = ""; + DVVTriplet.prototype.validatorSrcAddress = ""; + DVVTriplet.prototype.validatorDstAddress = ""; + DVVTriplet.create = function create(properties) { + return new DVVTriplet(properties); + }; + DVVTriplet.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorSrcAddress != null && Object.hasOwnProperty.call(m, "validatorSrcAddress")) + w.uint32(18).string(m.validatorSrcAddress); + if (m.validatorDstAddress != null && Object.hasOwnProperty.call(m, "validatorDstAddress")) + w.uint32(26).string(m.validatorDstAddress); + return w; + }; + DVVTriplet.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.DVVTriplet(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorSrcAddress = r.string(); + break; + case 3: + m.validatorDstAddress = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DVVTriplet; + })(); + v1beta1.DVVTriplets = (function () { + function DVVTriplets(p) { + this.triplets = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DVVTriplets.prototype.triplets = $util.emptyArray; + DVVTriplets.create = function create(properties) { + return new DVVTriplets(properties); + }; + DVVTriplets.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.triplets != null && m.triplets.length) { + for (var i = 0; i < m.triplets.length; ++i) + $root.cosmos.staking.v1beta1.DVVTriplet.encode(m.triplets[i], w.uint32(10).fork()).ldelim(); + } + return w; + }; + DVVTriplets.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.DVVTriplets(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.triplets && m.triplets.length)) m.triplets = []; + m.triplets.push($root.cosmos.staking.v1beta1.DVVTriplet.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DVVTriplets; + })(); + v1beta1.Delegation = (function () { + function Delegation(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Delegation.prototype.delegatorAddress = ""; + Delegation.prototype.validatorAddress = ""; + Delegation.prototype.shares = ""; + Delegation.create = function create(properties) { + return new Delegation(properties); + }; + Delegation.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).string(m.validatorAddress); + if (m.shares != null && Object.hasOwnProperty.call(m, "shares")) w.uint32(26).string(m.shares); + return w; + }; + Delegation.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Delegation(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorAddress = r.string(); + break; + case 3: + m.shares = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Delegation; + })(); + v1beta1.UnbondingDelegation = (function () { + function UnbondingDelegation(p) { + this.entries = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + UnbondingDelegation.prototype.delegatorAddress = ""; + UnbondingDelegation.prototype.validatorAddress = ""; + UnbondingDelegation.prototype.entries = $util.emptyArray; + UnbondingDelegation.create = function create(properties) { + return new UnbondingDelegation(properties); + }; + UnbondingDelegation.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).string(m.validatorAddress); + if (m.entries != null && m.entries.length) { + for (var i = 0; i < m.entries.length; ++i) + $root.cosmos.staking.v1beta1.UnbondingDelegationEntry.encode( + m.entries[i], + w.uint32(26).fork(), + ).ldelim(); + } + return w; + }; + UnbondingDelegation.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.UnbondingDelegation(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorAddress = r.string(); + break; + case 3: + if (!(m.entries && m.entries.length)) m.entries = []; + m.entries.push($root.cosmos.staking.v1beta1.UnbondingDelegationEntry.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return UnbondingDelegation; + })(); + v1beta1.UnbondingDelegationEntry = (function () { + function UnbondingDelegationEntry(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + UnbondingDelegationEntry.prototype.creationHeight = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + UnbondingDelegationEntry.prototype.completionTime = null; + UnbondingDelegationEntry.prototype.initialBalance = ""; + UnbondingDelegationEntry.prototype.balance = ""; + UnbondingDelegationEntry.create = function create(properties) { + return new UnbondingDelegationEntry(properties); + }; + UnbondingDelegationEntry.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.creationHeight != null && Object.hasOwnProperty.call(m, "creationHeight")) + w.uint32(8).int64(m.creationHeight); + if (m.completionTime != null && Object.hasOwnProperty.call(m, "completionTime")) + $root.google.protobuf.Timestamp.encode(m.completionTime, w.uint32(18).fork()).ldelim(); + if (m.initialBalance != null && Object.hasOwnProperty.call(m, "initialBalance")) + w.uint32(26).string(m.initialBalance); + if (m.balance != null && Object.hasOwnProperty.call(m, "balance")) w.uint32(34).string(m.balance); + return w; + }; + UnbondingDelegationEntry.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.UnbondingDelegationEntry(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.creationHeight = r.int64(); + break; + case 2: + m.completionTime = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 3: + m.initialBalance = r.string(); + break; + case 4: + m.balance = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return UnbondingDelegationEntry; + })(); + v1beta1.RedelegationEntry = (function () { + function RedelegationEntry(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + RedelegationEntry.prototype.creationHeight = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + RedelegationEntry.prototype.completionTime = null; + RedelegationEntry.prototype.initialBalance = ""; + RedelegationEntry.prototype.sharesDst = ""; + RedelegationEntry.create = function create(properties) { + return new RedelegationEntry(properties); + }; + RedelegationEntry.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.creationHeight != null && Object.hasOwnProperty.call(m, "creationHeight")) + w.uint32(8).int64(m.creationHeight); + if (m.completionTime != null && Object.hasOwnProperty.call(m, "completionTime")) + $root.google.protobuf.Timestamp.encode(m.completionTime, w.uint32(18).fork()).ldelim(); + if (m.initialBalance != null && Object.hasOwnProperty.call(m, "initialBalance")) + w.uint32(26).string(m.initialBalance); + if (m.sharesDst != null && Object.hasOwnProperty.call(m, "sharesDst")) + w.uint32(34).string(m.sharesDst); + return w; + }; + RedelegationEntry.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.RedelegationEntry(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.creationHeight = r.int64(); + break; + case 2: + m.completionTime = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 3: + m.initialBalance = r.string(); + break; + case 4: + m.sharesDst = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return RedelegationEntry; + })(); + v1beta1.Redelegation = (function () { + function Redelegation(p) { + this.entries = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Redelegation.prototype.delegatorAddress = ""; + Redelegation.prototype.validatorSrcAddress = ""; + Redelegation.prototype.validatorDstAddress = ""; + Redelegation.prototype.entries = $util.emptyArray; + Redelegation.create = function create(properties) { + return new Redelegation(properties); + }; + Redelegation.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorSrcAddress != null && Object.hasOwnProperty.call(m, "validatorSrcAddress")) + w.uint32(18).string(m.validatorSrcAddress); + if (m.validatorDstAddress != null && Object.hasOwnProperty.call(m, "validatorDstAddress")) + w.uint32(26).string(m.validatorDstAddress); + if (m.entries != null && m.entries.length) { + for (var i = 0; i < m.entries.length; ++i) + $root.cosmos.staking.v1beta1.RedelegationEntry.encode( + m.entries[i], + w.uint32(34).fork(), + ).ldelim(); + } + return w; + }; + Redelegation.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Redelegation(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorSrcAddress = r.string(); + break; + case 3: + m.validatorDstAddress = r.string(); + break; + case 4: + if (!(m.entries && m.entries.length)) m.entries = []; + m.entries.push($root.cosmos.staking.v1beta1.RedelegationEntry.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Redelegation; + })(); + v1beta1.Params = (function () { + function Params(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Params.prototype.unbondingTime = null; + Params.prototype.maxValidators = 0; + Params.prototype.maxEntries = 0; + Params.prototype.historicalEntries = 0; + Params.prototype.bondDenom = ""; + Params.create = function create(properties) { + return new Params(properties); + }; + Params.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.unbondingTime != null && Object.hasOwnProperty.call(m, "unbondingTime")) + $root.google.protobuf.Duration.encode(m.unbondingTime, w.uint32(10).fork()).ldelim(); + if (m.maxValidators != null && Object.hasOwnProperty.call(m, "maxValidators")) + w.uint32(16).uint32(m.maxValidators); + if (m.maxEntries != null && Object.hasOwnProperty.call(m, "maxEntries")) + w.uint32(24).uint32(m.maxEntries); + if (m.historicalEntries != null && Object.hasOwnProperty.call(m, "historicalEntries")) + w.uint32(32).uint32(m.historicalEntries); + if (m.bondDenom != null && Object.hasOwnProperty.call(m, "bondDenom")) + w.uint32(42).string(m.bondDenom); + return w; + }; + Params.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Params(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.unbondingTime = $root.google.protobuf.Duration.decode(r, r.uint32()); + break; + case 2: + m.maxValidators = r.uint32(); + break; + case 3: + m.maxEntries = r.uint32(); + break; + case 4: + m.historicalEntries = r.uint32(); + break; + case 5: + m.bondDenom = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Params; + })(); + v1beta1.DelegationResponse = (function () { + function DelegationResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DelegationResponse.prototype.delegation = null; + DelegationResponse.prototype.balance = null; + DelegationResponse.create = function create(properties) { + return new DelegationResponse(properties); + }; + DelegationResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegation != null && Object.hasOwnProperty.call(m, "delegation")) + $root.cosmos.staking.v1beta1.Delegation.encode(m.delegation, w.uint32(10).fork()).ldelim(); + if (m.balance != null && Object.hasOwnProperty.call(m, "balance")) + $root.cosmos.base.v1beta1.Coin.encode(m.balance, w.uint32(18).fork()).ldelim(); + return w; + }; + DelegationResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.DelegationResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegation = $root.cosmos.staking.v1beta1.Delegation.decode(r, r.uint32()); + break; + case 2: + m.balance = $root.cosmos.base.v1beta1.Coin.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DelegationResponse; + })(); + v1beta1.RedelegationEntryResponse = (function () { + function RedelegationEntryResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + RedelegationEntryResponse.prototype.redelegationEntry = null; + RedelegationEntryResponse.prototype.balance = ""; + RedelegationEntryResponse.create = function create(properties) { + return new RedelegationEntryResponse(properties); + }; + RedelegationEntryResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.redelegationEntry != null && Object.hasOwnProperty.call(m, "redelegationEntry")) + $root.cosmos.staking.v1beta1.RedelegationEntry.encode( + m.redelegationEntry, + w.uint32(10).fork(), + ).ldelim(); + if (m.balance != null && Object.hasOwnProperty.call(m, "balance")) w.uint32(34).string(m.balance); + return w; + }; + RedelegationEntryResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.RedelegationEntryResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.redelegationEntry = $root.cosmos.staking.v1beta1.RedelegationEntry.decode(r, r.uint32()); + break; + case 4: + m.balance = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return RedelegationEntryResponse; + })(); + v1beta1.RedelegationResponse = (function () { + function RedelegationResponse(p) { + this.entries = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + RedelegationResponse.prototype.redelegation = null; + RedelegationResponse.prototype.entries = $util.emptyArray; + RedelegationResponse.create = function create(properties) { + return new RedelegationResponse(properties); + }; + RedelegationResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.redelegation != null && Object.hasOwnProperty.call(m, "redelegation")) + $root.cosmos.staking.v1beta1.Redelegation.encode(m.redelegation, w.uint32(10).fork()).ldelim(); + if (m.entries != null && m.entries.length) { + for (var i = 0; i < m.entries.length; ++i) + $root.cosmos.staking.v1beta1.RedelegationEntryResponse.encode( + m.entries[i], + w.uint32(18).fork(), + ).ldelim(); + } + return w; + }; + RedelegationResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.RedelegationResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.redelegation = $root.cosmos.staking.v1beta1.Redelegation.decode(r, r.uint32()); + break; + case 2: + if (!(m.entries && m.entries.length)) m.entries = []; + m.entries.push($root.cosmos.staking.v1beta1.RedelegationEntryResponse.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return RedelegationResponse; + })(); + v1beta1.Pool = (function () { + function Pool(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Pool.prototype.notBondedTokens = ""; + Pool.prototype.bondedTokens = ""; + Pool.create = function create(properties) { + return new Pool(properties); + }; + Pool.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.notBondedTokens != null && Object.hasOwnProperty.call(m, "notBondedTokens")) + w.uint32(10).string(m.notBondedTokens); + if (m.bondedTokens != null && Object.hasOwnProperty.call(m, "bondedTokens")) + w.uint32(18).string(m.bondedTokens); + return w; + }; + Pool.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.Pool(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.notBondedTokens = r.string(); + break; + case 2: + m.bondedTokens = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Pool; + })(); + v1beta1.MsgCreateValidator = (function () { + function MsgCreateValidator(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgCreateValidator.prototype.description = null; + MsgCreateValidator.prototype.commission = null; + MsgCreateValidator.prototype.minSelfDelegation = ""; + MsgCreateValidator.prototype.delegatorAddress = ""; + MsgCreateValidator.prototype.validatorAddress = ""; + MsgCreateValidator.prototype.pubkey = ""; + MsgCreateValidator.prototype.value = null; + MsgCreateValidator.create = function create(properties) { + return new MsgCreateValidator(properties); + }; + MsgCreateValidator.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.description != null && Object.hasOwnProperty.call(m, "description")) + $root.cosmos.staking.v1beta1.Description.encode(m.description, w.uint32(10).fork()).ldelim(); + if (m.commission != null && Object.hasOwnProperty.call(m, "commission")) + $root.cosmos.staking.v1beta1.CommissionRates.encode(m.commission, w.uint32(18).fork()).ldelim(); + if (m.minSelfDelegation != null && Object.hasOwnProperty.call(m, "minSelfDelegation")) + w.uint32(26).string(m.minSelfDelegation); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(34).string(m.delegatorAddress); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(42).string(m.validatorAddress); + if (m.pubkey != null && Object.hasOwnProperty.call(m, "pubkey")) w.uint32(50).string(m.pubkey); + if (m.value != null && Object.hasOwnProperty.call(m, "value")) + $root.cosmos.base.v1beta1.Coin.encode(m.value, w.uint32(58).fork()).ldelim(); + return w; + }; + MsgCreateValidator.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.MsgCreateValidator(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.description = $root.cosmos.staking.v1beta1.Description.decode(r, r.uint32()); + break; + case 2: + m.commission = $root.cosmos.staking.v1beta1.CommissionRates.decode(r, r.uint32()); + break; + case 3: + m.minSelfDelegation = r.string(); + break; + case 4: + m.delegatorAddress = r.string(); + break; + case 5: + m.validatorAddress = r.string(); + break; + case 6: + m.pubkey = r.string(); + break; + case 7: + m.value = $root.cosmos.base.v1beta1.Coin.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgCreateValidator; + })(); + v1beta1.MsgEditValidator = (function () { + function MsgEditValidator(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgEditValidator.prototype.description = null; + MsgEditValidator.prototype.validatorAddress = ""; + MsgEditValidator.prototype.commissionRate = ""; + MsgEditValidator.prototype.minSelfDelegation = ""; + MsgEditValidator.create = function create(properties) { + return new MsgEditValidator(properties); + }; + MsgEditValidator.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.description != null && Object.hasOwnProperty.call(m, "description")) + $root.cosmos.staking.v1beta1.Description.encode(m.description, w.uint32(10).fork()).ldelim(); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).string(m.validatorAddress); + if (m.commissionRate != null && Object.hasOwnProperty.call(m, "commissionRate")) + w.uint32(26).string(m.commissionRate); + if (m.minSelfDelegation != null && Object.hasOwnProperty.call(m, "minSelfDelegation")) + w.uint32(34).string(m.minSelfDelegation); + return w; + }; + MsgEditValidator.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.MsgEditValidator(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.description = $root.cosmos.staking.v1beta1.Description.decode(r, r.uint32()); + break; + case 2: + m.validatorAddress = r.string(); + break; + case 3: + m.commissionRate = r.string(); + break; + case 4: + m.minSelfDelegation = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgEditValidator; + })(); + v1beta1.MsgDelegate = (function () { + function MsgDelegate(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgDelegate.prototype.delegatorAddress = ""; + MsgDelegate.prototype.validatorAddress = ""; + MsgDelegate.prototype.amount = null; + MsgDelegate.create = function create(properties) { + return new MsgDelegate(properties); + }; + MsgDelegate.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).string(m.validatorAddress); + if (m.amount != null && Object.hasOwnProperty.call(m, "amount")) + $root.cosmos.base.v1beta1.Coin.encode(m.amount, w.uint32(26).fork()).ldelim(); + return w; + }; + MsgDelegate.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.MsgDelegate(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorAddress = r.string(); + break; + case 3: + m.amount = $root.cosmos.base.v1beta1.Coin.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgDelegate; + })(); + v1beta1.MsgBeginRedelegate = (function () { + function MsgBeginRedelegate(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgBeginRedelegate.prototype.delegatorAddress = ""; + MsgBeginRedelegate.prototype.validatorSrcAddress = ""; + MsgBeginRedelegate.prototype.validatorDstAddress = ""; + MsgBeginRedelegate.prototype.amount = null; + MsgBeginRedelegate.create = function create(properties) { + return new MsgBeginRedelegate(properties); + }; + MsgBeginRedelegate.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorSrcAddress != null && Object.hasOwnProperty.call(m, "validatorSrcAddress")) + w.uint32(18).string(m.validatorSrcAddress); + if (m.validatorDstAddress != null && Object.hasOwnProperty.call(m, "validatorDstAddress")) + w.uint32(26).string(m.validatorDstAddress); + if (m.amount != null && Object.hasOwnProperty.call(m, "amount")) + $root.cosmos.base.v1beta1.Coin.encode(m.amount, w.uint32(34).fork()).ldelim(); + return w; + }; + MsgBeginRedelegate.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.MsgBeginRedelegate(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorSrcAddress = r.string(); + break; + case 3: + m.validatorDstAddress = r.string(); + break; + case 4: + m.amount = $root.cosmos.base.v1beta1.Coin.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgBeginRedelegate; + })(); + v1beta1.MsgUndelegate = (function () { + function MsgUndelegate(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgUndelegate.prototype.delegatorAddress = ""; + MsgUndelegate.prototype.validatorAddress = ""; + MsgUndelegate.prototype.amount = null; + MsgUndelegate.create = function create(properties) { + return new MsgUndelegate(properties); + }; + MsgUndelegate.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.delegatorAddress != null && Object.hasOwnProperty.call(m, "delegatorAddress")) + w.uint32(10).string(m.delegatorAddress); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).string(m.validatorAddress); + if (m.amount != null && Object.hasOwnProperty.call(m, "amount")) + $root.cosmos.base.v1beta1.Coin.encode(m.amount, w.uint32(26).fork()).ldelim(); + return w; + }; + MsgUndelegate.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.staking.v1beta1.MsgUndelegate(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.delegatorAddress = r.string(); + break; + case 2: + m.validatorAddress = r.string(); + break; + case 3: + m.amount = $root.cosmos.base.v1beta1.Coin.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgUndelegate; + })(); + return v1beta1; + })(); + return staking; + })(); cosmos.tx = (function () { const tx = {}; tx.signing = (function () { @@ -3631,6 +4892,84 @@ exports.google = $root.google = (() => { })(); return GeneratedCodeInfo; })(); + protobuf.Timestamp = (function () { + function Timestamp(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Timestamp.prototype.seconds = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Timestamp.prototype.nanos = 0; + Timestamp.create = function create(properties) { + return new Timestamp(properties); + }; + Timestamp.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.seconds != null && Object.hasOwnProperty.call(m, "seconds")) w.uint32(8).int64(m.seconds); + if (m.nanos != null && Object.hasOwnProperty.call(m, "nanos")) w.uint32(16).int32(m.nanos); + return w; + }; + Timestamp.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.Timestamp(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.seconds = r.int64(); + break; + case 2: + m.nanos = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Timestamp; + })(); + protobuf.Duration = (function () { + function Duration(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Duration.prototype.seconds = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Duration.prototype.nanos = 0; + Duration.create = function create(properties) { + return new Duration(properties); + }; + Duration.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.seconds != null && Object.hasOwnProperty.call(m, "seconds")) w.uint32(8).int64(m.seconds); + if (m.nanos != null && Object.hasOwnProperty.call(m, "nanos")) w.uint32(16).int32(m.nanos); + return w; + }; + Duration.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.Duration(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.seconds = r.int64(); + break; + case 2: + m.nanos = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Duration; + })(); return protobuf; })(); google.api = (function () { @@ -7831,6 +9170,45 @@ exports.tendermint = $root.tendermint = (() => { const tendermint = {}; tendermint.crypto = (function () { const crypto = {}; + crypto.PublicKey = (function () { + function PublicKey(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + PublicKey.prototype.ed25519 = $util.newBuffer([]); + let $oneOfFields; + Object.defineProperty(PublicKey.prototype, "sum", { + get: $util.oneOfGetter(($oneOfFields = ["ed25519"])), + set: $util.oneOfSetter($oneOfFields), + }); + PublicKey.create = function create(properties) { + return new PublicKey(properties); + }; + PublicKey.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.ed25519 != null && Object.hasOwnProperty.call(m, "ed25519")) w.uint32(10).bytes(m.ed25519); + return w; + }; + PublicKey.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.crypto.PublicKey(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.ed25519 = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return PublicKey; + })(); crypto.Proof = (function () { function Proof(p) { this.aunts = []; @@ -8053,6 +9431,1025 @@ exports.tendermint = $root.tendermint = (() => { })(); return crypto; })(); + tendermint.libs = (function () { + const libs = {}; + libs.bits = (function () { + const bits = {}; + bits.BitArray = (function () { + function BitArray(p) { + this.elems = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + BitArray.prototype.bits = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + BitArray.prototype.elems = $util.emptyArray; + BitArray.create = function create(properties) { + return new BitArray(properties); + }; + BitArray.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.bits != null && Object.hasOwnProperty.call(m, "bits")) w.uint32(8).int64(m.bits); + if (m.elems != null && m.elems.length) { + w.uint32(18).fork(); + for (var i = 0; i < m.elems.length; ++i) w.uint64(m.elems[i]); + w.ldelim(); + } + return w; + }; + BitArray.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.libs.bits.BitArray(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.bits = r.int64(); + break; + case 2: + if (!(m.elems && m.elems.length)) m.elems = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.elems.push(r.uint64()); + } else m.elems.push(r.uint64()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return BitArray; + })(); + return bits; + })(); + return libs; + })(); + tendermint.types = (function () { + const types = {}; + types.BlockIDFlag = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "BLOCK_ID_FLAG_UNKNOWN")] = 0; + values[(valuesById[1] = "BLOCK_ID_FLAG_ABSENT")] = 1; + values[(valuesById[2] = "BLOCK_ID_FLAG_COMMIT")] = 2; + values[(valuesById[3] = "BLOCK_ID_FLAG_NIL")] = 3; + return values; + })(); + types.SignedMsgType = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "SIGNED_MSG_TYPE_UNKNOWN")] = 0; + values[(valuesById[1] = "SIGNED_MSG_TYPE_PREVOTE")] = 1; + values[(valuesById[2] = "SIGNED_MSG_TYPE_PRECOMMIT")] = 2; + values[(valuesById[32] = "SIGNED_MSG_TYPE_PROPOSAL")] = 32; + return values; + })(); + types.PartSetHeader = (function () { + function PartSetHeader(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + PartSetHeader.prototype.total = 0; + PartSetHeader.prototype.hash = $util.newBuffer([]); + PartSetHeader.create = function create(properties) { + return new PartSetHeader(properties); + }; + PartSetHeader.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.total != null && Object.hasOwnProperty.call(m, "total")) w.uint32(8).uint32(m.total); + if (m.hash != null && Object.hasOwnProperty.call(m, "hash")) w.uint32(18).bytes(m.hash); + return w; + }; + PartSetHeader.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.PartSetHeader(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.total = r.uint32(); + break; + case 2: + m.hash = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return PartSetHeader; + })(); + types.Part = (function () { + function Part(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Part.prototype.index = 0; + Part.prototype.bytes = $util.newBuffer([]); + Part.prototype.proof = null; + Part.create = function create(properties) { + return new Part(properties); + }; + Part.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.index != null && Object.hasOwnProperty.call(m, "index")) w.uint32(8).uint32(m.index); + if (m.bytes != null && Object.hasOwnProperty.call(m, "bytes")) w.uint32(18).bytes(m.bytes); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) + $root.tendermint.crypto.Proof.encode(m.proof, w.uint32(26).fork()).ldelim(); + return w; + }; + Part.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Part(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.index = r.uint32(); + break; + case 2: + m.bytes = r.bytes(); + break; + case 3: + m.proof = $root.tendermint.crypto.Proof.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Part; + })(); + types.BlockID = (function () { + function BlockID(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + BlockID.prototype.hash = $util.newBuffer([]); + BlockID.prototype.partSetHeader = null; + BlockID.create = function create(properties) { + return new BlockID(properties); + }; + BlockID.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.hash != null && Object.hasOwnProperty.call(m, "hash")) w.uint32(10).bytes(m.hash); + if (m.partSetHeader != null && Object.hasOwnProperty.call(m, "partSetHeader")) + $root.tendermint.types.PartSetHeader.encode(m.partSetHeader, w.uint32(18).fork()).ldelim(); + return w; + }; + BlockID.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.BlockID(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.hash = r.bytes(); + break; + case 2: + m.partSetHeader = $root.tendermint.types.PartSetHeader.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return BlockID; + })(); + types.Header = (function () { + function Header(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Header.prototype.version = null; + Header.prototype.chainId = ""; + Header.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Header.prototype.time = null; + Header.prototype.lastBlockId = null; + Header.prototype.lastCommitHash = $util.newBuffer([]); + Header.prototype.dataHash = $util.newBuffer([]); + Header.prototype.validatorsHash = $util.newBuffer([]); + Header.prototype.nextValidatorsHash = $util.newBuffer([]); + Header.prototype.consensusHash = $util.newBuffer([]); + Header.prototype.appHash = $util.newBuffer([]); + Header.prototype.lastResultsHash = $util.newBuffer([]); + Header.prototype.evidenceHash = $util.newBuffer([]); + Header.prototype.proposerAddress = $util.newBuffer([]); + Header.create = function create(properties) { + return new Header(properties); + }; + Header.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.version != null && Object.hasOwnProperty.call(m, "version")) + $root.tendermint.version.Consensus.encode(m.version, w.uint32(10).fork()).ldelim(); + if (m.chainId != null && Object.hasOwnProperty.call(m, "chainId")) w.uint32(18).string(m.chainId); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(24).int64(m.height); + if (m.time != null && Object.hasOwnProperty.call(m, "time")) + $root.google.protobuf.Timestamp.encode(m.time, w.uint32(34).fork()).ldelim(); + if (m.lastBlockId != null && Object.hasOwnProperty.call(m, "lastBlockId")) + $root.tendermint.types.BlockID.encode(m.lastBlockId, w.uint32(42).fork()).ldelim(); + if (m.lastCommitHash != null && Object.hasOwnProperty.call(m, "lastCommitHash")) + w.uint32(50).bytes(m.lastCommitHash); + if (m.dataHash != null && Object.hasOwnProperty.call(m, "dataHash")) w.uint32(58).bytes(m.dataHash); + if (m.validatorsHash != null && Object.hasOwnProperty.call(m, "validatorsHash")) + w.uint32(66).bytes(m.validatorsHash); + if (m.nextValidatorsHash != null && Object.hasOwnProperty.call(m, "nextValidatorsHash")) + w.uint32(74).bytes(m.nextValidatorsHash); + if (m.consensusHash != null && Object.hasOwnProperty.call(m, "consensusHash")) + w.uint32(82).bytes(m.consensusHash); + if (m.appHash != null && Object.hasOwnProperty.call(m, "appHash")) w.uint32(90).bytes(m.appHash); + if (m.lastResultsHash != null && Object.hasOwnProperty.call(m, "lastResultsHash")) + w.uint32(98).bytes(m.lastResultsHash); + if (m.evidenceHash != null && Object.hasOwnProperty.call(m, "evidenceHash")) + w.uint32(106).bytes(m.evidenceHash); + if (m.proposerAddress != null && Object.hasOwnProperty.call(m, "proposerAddress")) + w.uint32(114).bytes(m.proposerAddress); + return w; + }; + Header.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Header(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.version = $root.tendermint.version.Consensus.decode(r, r.uint32()); + break; + case 2: + m.chainId = r.string(); + break; + case 3: + m.height = r.int64(); + break; + case 4: + m.time = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 5: + m.lastBlockId = $root.tendermint.types.BlockID.decode(r, r.uint32()); + break; + case 6: + m.lastCommitHash = r.bytes(); + break; + case 7: + m.dataHash = r.bytes(); + break; + case 8: + m.validatorsHash = r.bytes(); + break; + case 9: + m.nextValidatorsHash = r.bytes(); + break; + case 10: + m.consensusHash = r.bytes(); + break; + case 11: + m.appHash = r.bytes(); + break; + case 12: + m.lastResultsHash = r.bytes(); + break; + case 13: + m.evidenceHash = r.bytes(); + break; + case 14: + m.proposerAddress = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Header; + })(); + types.Data = (function () { + function Data(p) { + this.txs = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Data.prototype.txs = $util.emptyArray; + Data.prototype.hash = $util.newBuffer([]); + Data.create = function create(properties) { + return new Data(properties); + }; + Data.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.txs != null && m.txs.length) { + for (var i = 0; i < m.txs.length; ++i) w.uint32(10).bytes(m.txs[i]); + } + if (m.hash != null && Object.hasOwnProperty.call(m, "hash")) w.uint32(18).bytes(m.hash); + return w; + }; + Data.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Data(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.txs && m.txs.length)) m.txs = []; + m.txs.push(r.bytes()); + break; + case 2: + m.hash = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Data; + })(); + types.Vote = (function () { + function Vote(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Vote.prototype.type = 0; + Vote.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Vote.prototype.round = 0; + Vote.prototype.blockId = null; + Vote.prototype.timestamp = null; + Vote.prototype.validatorAddress = $util.newBuffer([]); + Vote.prototype.validatorIndex = 0; + Vote.prototype.signature = $util.newBuffer([]); + Vote.create = function create(properties) { + return new Vote(properties); + }; + Vote.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.type != null && Object.hasOwnProperty.call(m, "type")) w.uint32(8).int32(m.type); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(16).int64(m.height); + if (m.round != null && Object.hasOwnProperty.call(m, "round")) w.uint32(24).int32(m.round); + if (m.blockId != null && Object.hasOwnProperty.call(m, "blockId")) + $root.tendermint.types.BlockID.encode(m.blockId, w.uint32(34).fork()).ldelim(); + if (m.timestamp != null && Object.hasOwnProperty.call(m, "timestamp")) + $root.google.protobuf.Timestamp.encode(m.timestamp, w.uint32(42).fork()).ldelim(); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(50).bytes(m.validatorAddress); + if (m.validatorIndex != null && Object.hasOwnProperty.call(m, "validatorIndex")) + w.uint32(56).int32(m.validatorIndex); + if (m.signature != null && Object.hasOwnProperty.call(m, "signature")) + w.uint32(66).bytes(m.signature); + return w; + }; + Vote.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Vote(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.type = r.int32(); + break; + case 2: + m.height = r.int64(); + break; + case 3: + m.round = r.int32(); + break; + case 4: + m.blockId = $root.tendermint.types.BlockID.decode(r, r.uint32()); + break; + case 5: + m.timestamp = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 6: + m.validatorAddress = r.bytes(); + break; + case 7: + m.validatorIndex = r.int32(); + break; + case 8: + m.signature = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Vote; + })(); + types.Commit = (function () { + function Commit(p) { + this.signatures = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Commit.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Commit.prototype.round = 0; + Commit.prototype.blockId = null; + Commit.prototype.signatures = $util.emptyArray; + Commit.prototype.hash = $util.newBuffer([]); + Commit.prototype.bitArray = null; + Commit.create = function create(properties) { + return new Commit(properties); + }; + Commit.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(8).int64(m.height); + if (m.round != null && Object.hasOwnProperty.call(m, "round")) w.uint32(16).int32(m.round); + if (m.blockId != null && Object.hasOwnProperty.call(m, "blockId")) + $root.tendermint.types.BlockID.encode(m.blockId, w.uint32(26).fork()).ldelim(); + if (m.signatures != null && m.signatures.length) { + for (var i = 0; i < m.signatures.length; ++i) + $root.tendermint.types.CommitSig.encode(m.signatures[i], w.uint32(34).fork()).ldelim(); + } + if (m.hash != null && Object.hasOwnProperty.call(m, "hash")) w.uint32(42).bytes(m.hash); + if (m.bitArray != null && Object.hasOwnProperty.call(m, "bitArray")) + $root.tendermint.libs.bits.BitArray.encode(m.bitArray, w.uint32(50).fork()).ldelim(); + return w; + }; + Commit.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Commit(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.height = r.int64(); + break; + case 2: + m.round = r.int32(); + break; + case 3: + m.blockId = $root.tendermint.types.BlockID.decode(r, r.uint32()); + break; + case 4: + if (!(m.signatures && m.signatures.length)) m.signatures = []; + m.signatures.push($root.tendermint.types.CommitSig.decode(r, r.uint32())); + break; + case 5: + m.hash = r.bytes(); + break; + case 6: + m.bitArray = $root.tendermint.libs.bits.BitArray.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Commit; + })(); + types.CommitSig = (function () { + function CommitSig(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + CommitSig.prototype.blockIdFlag = 0; + CommitSig.prototype.validatorAddress = $util.newBuffer([]); + CommitSig.prototype.timestamp = null; + CommitSig.prototype.signature = $util.newBuffer([]); + CommitSig.create = function create(properties) { + return new CommitSig(properties); + }; + CommitSig.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.blockIdFlag != null && Object.hasOwnProperty.call(m, "blockIdFlag")) + w.uint32(8).int32(m.blockIdFlag); + if (m.validatorAddress != null && Object.hasOwnProperty.call(m, "validatorAddress")) + w.uint32(18).bytes(m.validatorAddress); + if (m.timestamp != null && Object.hasOwnProperty.call(m, "timestamp")) + $root.google.protobuf.Timestamp.encode(m.timestamp, w.uint32(26).fork()).ldelim(); + if (m.signature != null && Object.hasOwnProperty.call(m, "signature")) + w.uint32(34).bytes(m.signature); + return w; + }; + CommitSig.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.CommitSig(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.blockIdFlag = r.int32(); + break; + case 2: + m.validatorAddress = r.bytes(); + break; + case 3: + m.timestamp = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 4: + m.signature = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return CommitSig; + })(); + types.Proposal = (function () { + function Proposal(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Proposal.prototype.type = 0; + Proposal.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Proposal.prototype.round = 0; + Proposal.prototype.polRound = 0; + Proposal.prototype.blockId = null; + Proposal.prototype.timestamp = null; + Proposal.prototype.signature = $util.newBuffer([]); + Proposal.create = function create(properties) { + return new Proposal(properties); + }; + Proposal.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.type != null && Object.hasOwnProperty.call(m, "type")) w.uint32(8).int32(m.type); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(16).int64(m.height); + if (m.round != null && Object.hasOwnProperty.call(m, "round")) w.uint32(24).int32(m.round); + if (m.polRound != null && Object.hasOwnProperty.call(m, "polRound")) w.uint32(32).int32(m.polRound); + if (m.blockId != null && Object.hasOwnProperty.call(m, "blockId")) + $root.tendermint.types.BlockID.encode(m.blockId, w.uint32(42).fork()).ldelim(); + if (m.timestamp != null && Object.hasOwnProperty.call(m, "timestamp")) + $root.google.protobuf.Timestamp.encode(m.timestamp, w.uint32(50).fork()).ldelim(); + if (m.signature != null && Object.hasOwnProperty.call(m, "signature")) + w.uint32(58).bytes(m.signature); + return w; + }; + Proposal.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Proposal(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.type = r.int32(); + break; + case 2: + m.height = r.int64(); + break; + case 3: + m.round = r.int32(); + break; + case 4: + m.polRound = r.int32(); + break; + case 5: + m.blockId = $root.tendermint.types.BlockID.decode(r, r.uint32()); + break; + case 6: + m.timestamp = $root.google.protobuf.Timestamp.decode(r, r.uint32()); + break; + case 7: + m.signature = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Proposal; + })(); + types.SignedHeader = (function () { + function SignedHeader(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + SignedHeader.prototype.header = null; + SignedHeader.prototype.commit = null; + SignedHeader.create = function create(properties) { + return new SignedHeader(properties); + }; + SignedHeader.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.header != null && Object.hasOwnProperty.call(m, "header")) + $root.tendermint.types.Header.encode(m.header, w.uint32(10).fork()).ldelim(); + if (m.commit != null && Object.hasOwnProperty.call(m, "commit")) + $root.tendermint.types.Commit.encode(m.commit, w.uint32(18).fork()).ldelim(); + return w; + }; + SignedHeader.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.SignedHeader(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.header = $root.tendermint.types.Header.decode(r, r.uint32()); + break; + case 2: + m.commit = $root.tendermint.types.Commit.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return SignedHeader; + })(); + types.LightBlock = (function () { + function LightBlock(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + LightBlock.prototype.signedHeader = null; + LightBlock.prototype.validatorSet = null; + LightBlock.create = function create(properties) { + return new LightBlock(properties); + }; + LightBlock.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.signedHeader != null && Object.hasOwnProperty.call(m, "signedHeader")) + $root.tendermint.types.SignedHeader.encode(m.signedHeader, w.uint32(10).fork()).ldelim(); + if (m.validatorSet != null && Object.hasOwnProperty.call(m, "validatorSet")) + $root.tendermint.types.ValidatorSet.encode(m.validatorSet, w.uint32(18).fork()).ldelim(); + return w; + }; + LightBlock.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.LightBlock(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.signedHeader = $root.tendermint.types.SignedHeader.decode(r, r.uint32()); + break; + case 2: + m.validatorSet = $root.tendermint.types.ValidatorSet.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return LightBlock; + })(); + types.BlockMeta = (function () { + function BlockMeta(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + BlockMeta.prototype.blockId = null; + BlockMeta.prototype.blockSize = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + BlockMeta.prototype.header = null; + BlockMeta.prototype.numTxs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + BlockMeta.create = function create(properties) { + return new BlockMeta(properties); + }; + BlockMeta.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.blockId != null && Object.hasOwnProperty.call(m, "blockId")) + $root.tendermint.types.BlockID.encode(m.blockId, w.uint32(10).fork()).ldelim(); + if (m.blockSize != null && Object.hasOwnProperty.call(m, "blockSize")) + w.uint32(16).int64(m.blockSize); + if (m.header != null && Object.hasOwnProperty.call(m, "header")) + $root.tendermint.types.Header.encode(m.header, w.uint32(26).fork()).ldelim(); + if (m.numTxs != null && Object.hasOwnProperty.call(m, "numTxs")) w.uint32(32).int64(m.numTxs); + return w; + }; + BlockMeta.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.BlockMeta(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.blockId = $root.tendermint.types.BlockID.decode(r, r.uint32()); + break; + case 2: + m.blockSize = r.int64(); + break; + case 3: + m.header = $root.tendermint.types.Header.decode(r, r.uint32()); + break; + case 4: + m.numTxs = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return BlockMeta; + })(); + types.TxProof = (function () { + function TxProof(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + TxProof.prototype.rootHash = $util.newBuffer([]); + TxProof.prototype.data = $util.newBuffer([]); + TxProof.prototype.proof = null; + TxProof.create = function create(properties) { + return new TxProof(properties); + }; + TxProof.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.rootHash != null && Object.hasOwnProperty.call(m, "rootHash")) w.uint32(10).bytes(m.rootHash); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) w.uint32(18).bytes(m.data); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) + $root.tendermint.crypto.Proof.encode(m.proof, w.uint32(26).fork()).ldelim(); + return w; + }; + TxProof.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.TxProof(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.rootHash = r.bytes(); + break; + case 2: + m.data = r.bytes(); + break; + case 3: + m.proof = $root.tendermint.crypto.Proof.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return TxProof; + })(); + types.ValidatorSet = (function () { + function ValidatorSet(p) { + this.validators = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ValidatorSet.prototype.validators = $util.emptyArray; + ValidatorSet.prototype.proposer = null; + ValidatorSet.prototype.totalVotingPower = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + ValidatorSet.create = function create(properties) { + return new ValidatorSet(properties); + }; + ValidatorSet.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.validators != null && m.validators.length) { + for (var i = 0; i < m.validators.length; ++i) + $root.tendermint.types.Validator.encode(m.validators[i], w.uint32(10).fork()).ldelim(); + } + if (m.proposer != null && Object.hasOwnProperty.call(m, "proposer")) + $root.tendermint.types.Validator.encode(m.proposer, w.uint32(18).fork()).ldelim(); + if (m.totalVotingPower != null && Object.hasOwnProperty.call(m, "totalVotingPower")) + w.uint32(24).int64(m.totalVotingPower); + return w; + }; + ValidatorSet.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.ValidatorSet(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.validators && m.validators.length)) m.validators = []; + m.validators.push($root.tendermint.types.Validator.decode(r, r.uint32())); + break; + case 2: + m.proposer = $root.tendermint.types.Validator.decode(r, r.uint32()); + break; + case 3: + m.totalVotingPower = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ValidatorSet; + })(); + types.Validator = (function () { + function Validator(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Validator.prototype.address = $util.newBuffer([]); + Validator.prototype.pubKey = null; + Validator.prototype.votingPower = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Validator.prototype.proposerPriority = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + Validator.create = function create(properties) { + return new Validator(properties); + }; + Validator.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).bytes(m.address); + if (m.pubKey != null && Object.hasOwnProperty.call(m, "pubKey")) + $root.tendermint.crypto.PublicKey.encode(m.pubKey, w.uint32(18).fork()).ldelim(); + if (m.votingPower != null && Object.hasOwnProperty.call(m, "votingPower")) + w.uint32(24).int64(m.votingPower); + if (m.proposerPriority != null && Object.hasOwnProperty.call(m, "proposerPriority")) + w.uint32(32).int64(m.proposerPriority); + return w; + }; + Validator.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.Validator(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.bytes(); + break; + case 2: + m.pubKey = $root.tendermint.crypto.PublicKey.decode(r, r.uint32()); + break; + case 3: + m.votingPower = r.int64(); + break; + case 4: + m.proposerPriority = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Validator; + })(); + types.SimpleValidator = (function () { + function SimpleValidator(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + SimpleValidator.prototype.pubKey = null; + SimpleValidator.prototype.votingPower = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + SimpleValidator.create = function create(properties) { + return new SimpleValidator(properties); + }; + SimpleValidator.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.pubKey != null && Object.hasOwnProperty.call(m, "pubKey")) + $root.tendermint.crypto.PublicKey.encode(m.pubKey, w.uint32(10).fork()).ldelim(); + if (m.votingPower != null && Object.hasOwnProperty.call(m, "votingPower")) + w.uint32(16).int64(m.votingPower); + return w; + }; + SimpleValidator.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.types.SimpleValidator(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.pubKey = $root.tendermint.crypto.PublicKey.decode(r, r.uint32()); + break; + case 2: + m.votingPower = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return SimpleValidator; + })(); + return types; + })(); + tendermint.version = (function () { + const version = {}; + version.App = (function () { + function App(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + App.prototype.protocol = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + App.prototype.software = ""; + App.create = function create(properties) { + return new App(properties); + }; + App.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.protocol != null && Object.hasOwnProperty.call(m, "protocol")) w.uint32(8).uint64(m.protocol); + if (m.software != null && Object.hasOwnProperty.call(m, "software")) w.uint32(18).string(m.software); + return w; + }; + App.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.version.App(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.protocol = r.uint64(); + break; + case 2: + m.software = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return App; + })(); + version.Consensus = (function () { + function Consensus(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Consensus.prototype.block = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Consensus.prototype.app = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Consensus.create = function create(properties) { + return new Consensus(properties); + }; + Consensus.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.block != null && Object.hasOwnProperty.call(m, "block")) w.uint32(8).uint64(m.block); + if (m.app != null && Object.hasOwnProperty.call(m, "app")) w.uint32(16).uint64(m.app); + return w; + }; + Consensus.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.tendermint.version.Consensus(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.block = r.uint64(); + break; + case 2: + m.app = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Consensus; + })(); + return version; + })(); return tendermint; })(); module.exports = $root; diff --git a/packages/stargate/types/codec/generated/codecimpl.d.ts b/packages/stargate/types/codec/generated/codecimpl.d.ts index e348516f..346edf38 100644 --- a/packages/stargate/types/codec/generated/codecimpl.d.ts +++ b/packages/stargate/types/codec/generated/codecimpl.d.ts @@ -1695,6 +1695,1564 @@ export namespace cosmos { } } + /** Namespace staking. */ + namespace staking { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a HistoricalInfo. */ + interface IHistoricalInfo { + /** HistoricalInfo header */ + header?: tendermint.types.IHeader | null; + + /** HistoricalInfo valset */ + valset?: cosmos.staking.v1beta1.IValidator[] | null; + } + + /** Represents a HistoricalInfo. */ + class HistoricalInfo implements IHistoricalInfo { + /** + * Constructs a new HistoricalInfo. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IHistoricalInfo); + + /** HistoricalInfo header. */ + public header?: tendermint.types.IHeader | null; + + /** HistoricalInfo valset. */ + public valset: cosmos.staking.v1beta1.IValidator[]; + + /** + * Creates a new HistoricalInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns HistoricalInfo instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IHistoricalInfo, + ): cosmos.staking.v1beta1.HistoricalInfo; + + /** + * Encodes the specified HistoricalInfo message. Does not implicitly {@link cosmos.staking.v1beta1.HistoricalInfo.verify|verify} messages. + * @param m HistoricalInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IHistoricalInfo, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a HistoricalInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns HistoricalInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.HistoricalInfo; + } + + /** Properties of a CommissionRates. */ + interface ICommissionRates { + /** CommissionRates rate */ + rate?: string | null; + + /** CommissionRates maxRate */ + maxRate?: string | null; + + /** CommissionRates maxChangeRate */ + maxChangeRate?: string | null; + } + + /** Represents a CommissionRates. */ + class CommissionRates implements ICommissionRates { + /** + * Constructs a new CommissionRates. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.ICommissionRates); + + /** CommissionRates rate. */ + public rate: string; + + /** CommissionRates maxRate. */ + public maxRate: string; + + /** CommissionRates maxChangeRate. */ + public maxChangeRate: string; + + /** + * Creates a new CommissionRates instance using the specified properties. + * @param [properties] Properties to set + * @returns CommissionRates instance + */ + public static create( + properties?: cosmos.staking.v1beta1.ICommissionRates, + ): cosmos.staking.v1beta1.CommissionRates; + + /** + * Encodes the specified CommissionRates message. Does not implicitly {@link cosmos.staking.v1beta1.CommissionRates.verify|verify} messages. + * @param m CommissionRates message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.ICommissionRates, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a CommissionRates message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CommissionRates + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.CommissionRates; + } + + /** Properties of a Commission. */ + interface ICommission { + /** Commission commissionRates */ + commissionRates?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** Commission updateTime */ + updateTime?: google.protobuf.ITimestamp | null; + } + + /** Represents a Commission. */ + class Commission implements ICommission { + /** + * Constructs a new Commission. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.ICommission); + + /** Commission commissionRates. */ + public commissionRates?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** Commission updateTime. */ + public updateTime?: google.protobuf.ITimestamp | null; + + /** + * Creates a new Commission instance using the specified properties. + * @param [properties] Properties to set + * @returns Commission instance + */ + public static create( + properties?: cosmos.staking.v1beta1.ICommission, + ): cosmos.staking.v1beta1.Commission; + + /** + * Encodes the specified Commission message. Does not implicitly {@link cosmos.staking.v1beta1.Commission.verify|verify} messages. + * @param m Commission message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.ICommission, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Commission message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Commission + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Commission; + } + + /** Properties of a Description. */ + interface IDescription { + /** Description moniker */ + moniker?: string | null; + + /** Description identity */ + identity?: string | null; + + /** Description website */ + website?: string | null; + + /** Description securityContact */ + securityContact?: string | null; + + /** Description details */ + details?: string | null; + } + + /** Represents a Description. */ + class Description implements IDescription { + /** + * Constructs a new Description. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDescription); + + /** Description moniker. */ + public moniker: string; + + /** Description identity. */ + public identity: string; + + /** Description website. */ + public website: string; + + /** Description securityContact. */ + public securityContact: string; + + /** Description details. */ + public details: string; + + /** + * Creates a new Description instance using the specified properties. + * @param [properties] Properties to set + * @returns Description instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDescription, + ): cosmos.staking.v1beta1.Description; + + /** + * Encodes the specified Description message. Does not implicitly {@link cosmos.staking.v1beta1.Description.verify|verify} messages. + * @param m Description message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDescription, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Description message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Description + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.Description; + } + + /** Properties of a Validator. */ + interface IValidator { + /** Validator operatorAddress */ + operatorAddress?: string | null; + + /** Validator consensusPubkey */ + consensusPubkey?: string | null; + + /** Validator jailed */ + jailed?: boolean | null; + + /** Validator status */ + status?: number | null; + + /** Validator tokens */ + tokens?: string | null; + + /** Validator delegatorShares */ + delegatorShares?: string | null; + + /** Validator description */ + description?: cosmos.staking.v1beta1.IDescription | null; + + /** Validator unbondingHeight */ + unbondingHeight?: Long | null; + + /** Validator unbondingTime */ + unbondingTime?: google.protobuf.ITimestamp | null; + + /** Validator commission */ + commission?: cosmos.staking.v1beta1.ICommission | null; + + /** Validator minSelfDelegation */ + minSelfDelegation?: string | null; + } + + /** Represents a Validator. */ + class Validator implements IValidator { + /** + * Constructs a new Validator. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IValidator); + + /** Validator operatorAddress. */ + public operatorAddress: string; + + /** Validator consensusPubkey. */ + public consensusPubkey: string; + + /** Validator jailed. */ + public jailed: boolean; + + /** Validator status. */ + public status: number; + + /** Validator tokens. */ + public tokens: string; + + /** Validator delegatorShares. */ + public delegatorShares: string; + + /** Validator description. */ + public description?: cosmos.staking.v1beta1.IDescription | null; + + /** Validator unbondingHeight. */ + public unbondingHeight: Long; + + /** Validator unbondingTime. */ + public unbondingTime?: google.protobuf.ITimestamp | null; + + /** Validator commission. */ + public commission?: cosmos.staking.v1beta1.ICommission | null; + + /** Validator minSelfDelegation. */ + public minSelfDelegation: string; + + /** + * Creates a new Validator instance using the specified properties. + * @param [properties] Properties to set + * @returns Validator instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IValidator, + ): cosmos.staking.v1beta1.Validator; + + /** + * Encodes the specified Validator message. Does not implicitly {@link cosmos.staking.v1beta1.Validator.verify|verify} messages. + * @param m Validator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IValidator, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Validator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Validator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Validator; + } + + /** Properties of a ValAddresses. */ + interface IValAddresses { + /** ValAddresses addresses */ + addresses?: string[] | null; + } + + /** Represents a ValAddresses. */ + class ValAddresses implements IValAddresses { + /** + * Constructs a new ValAddresses. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IValAddresses); + + /** ValAddresses addresses. */ + public addresses: string[]; + + /** + * Creates a new ValAddresses instance using the specified properties. + * @param [properties] Properties to set + * @returns ValAddresses instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IValAddresses, + ): cosmos.staking.v1beta1.ValAddresses; + + /** + * Encodes the specified ValAddresses message. Does not implicitly {@link cosmos.staking.v1beta1.ValAddresses.verify|verify} messages. + * @param m ValAddresses message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IValAddresses, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ValAddresses message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ValAddresses + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.ValAddresses; + } + + /** Properties of a DVPair. */ + interface IDVPair { + /** DVPair delegatorAddress */ + delegatorAddress?: string | null; + + /** DVPair validatorAddress */ + validatorAddress?: string | null; + } + + /** Represents a DVPair. */ + class DVPair implements IDVPair { + /** + * Constructs a new DVPair. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVPair); + + /** DVPair delegatorAddress. */ + public delegatorAddress: string; + + /** DVPair validatorAddress. */ + public validatorAddress: string; + + /** + * Creates a new DVPair instance using the specified properties. + * @param [properties] Properties to set + * @returns DVPair instance + */ + public static create(properties?: cosmos.staking.v1beta1.IDVPair): cosmos.staking.v1beta1.DVPair; + + /** + * Encodes the specified DVPair message. Does not implicitly {@link cosmos.staking.v1beta1.DVPair.verify|verify} messages. + * @param m DVPair message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVPair, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVPair message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVPair + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.DVPair; + } + + /** Properties of a DVPairs. */ + interface IDVPairs { + /** DVPairs pairs */ + pairs?: cosmos.staking.v1beta1.IDVPair[] | null; + } + + /** Represents a DVPairs. */ + class DVPairs implements IDVPairs { + /** + * Constructs a new DVPairs. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVPairs); + + /** DVPairs pairs. */ + public pairs: cosmos.staking.v1beta1.IDVPair[]; + + /** + * Creates a new DVPairs instance using the specified properties. + * @param [properties] Properties to set + * @returns DVPairs instance + */ + public static create(properties?: cosmos.staking.v1beta1.IDVPairs): cosmos.staking.v1beta1.DVPairs; + + /** + * Encodes the specified DVPairs message. Does not implicitly {@link cosmos.staking.v1beta1.DVPairs.verify|verify} messages. + * @param m DVPairs message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVPairs, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVPairs message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVPairs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.DVPairs; + } + + /** Properties of a DVVTriplet. */ + interface IDVVTriplet { + /** DVVTriplet delegatorAddress */ + delegatorAddress?: string | null; + + /** DVVTriplet validatorSrcAddress */ + validatorSrcAddress?: string | null; + + /** DVVTriplet validatorDstAddress */ + validatorDstAddress?: string | null; + } + + /** Represents a DVVTriplet. */ + class DVVTriplet implements IDVVTriplet { + /** + * Constructs a new DVVTriplet. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVVTriplet); + + /** DVVTriplet delegatorAddress. */ + public delegatorAddress: string; + + /** DVVTriplet validatorSrcAddress. */ + public validatorSrcAddress: string; + + /** DVVTriplet validatorDstAddress. */ + public validatorDstAddress: string; + + /** + * Creates a new DVVTriplet instance using the specified properties. + * @param [properties] Properties to set + * @returns DVVTriplet instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDVVTriplet, + ): cosmos.staking.v1beta1.DVVTriplet; + + /** + * Encodes the specified DVVTriplet message. Does not implicitly {@link cosmos.staking.v1beta1.DVVTriplet.verify|verify} messages. + * @param m DVVTriplet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVVTriplet, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVVTriplet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVVTriplet + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.DVVTriplet; + } + + /** Properties of a DVVTriplets. */ + interface IDVVTriplets { + /** DVVTriplets triplets */ + triplets?: cosmos.staking.v1beta1.IDVVTriplet[] | null; + } + + /** Represents a DVVTriplets. */ + class DVVTriplets implements IDVVTriplets { + /** + * Constructs a new DVVTriplets. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDVVTriplets); + + /** DVVTriplets triplets. */ + public triplets: cosmos.staking.v1beta1.IDVVTriplet[]; + + /** + * Creates a new DVVTriplets instance using the specified properties. + * @param [properties] Properties to set + * @returns DVVTriplets instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDVVTriplets, + ): cosmos.staking.v1beta1.DVVTriplets; + + /** + * Encodes the specified DVVTriplets message. Does not implicitly {@link cosmos.staking.v1beta1.DVVTriplets.verify|verify} messages. + * @param m DVVTriplets message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDVVTriplets, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DVVTriplets message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DVVTriplets + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.DVVTriplets; + } + + /** Properties of a Delegation. */ + interface IDelegation { + /** Delegation delegatorAddress */ + delegatorAddress?: string | null; + + /** Delegation validatorAddress */ + validatorAddress?: string | null; + + /** Delegation shares */ + shares?: string | null; + } + + /** Represents a Delegation. */ + class Delegation implements IDelegation { + /** + * Constructs a new Delegation. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDelegation); + + /** Delegation delegatorAddress. */ + public delegatorAddress: string; + + /** Delegation validatorAddress. */ + public validatorAddress: string; + + /** Delegation shares. */ + public shares: string; + + /** + * Creates a new Delegation instance using the specified properties. + * @param [properties] Properties to set + * @returns Delegation instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDelegation, + ): cosmos.staking.v1beta1.Delegation; + + /** + * Encodes the specified Delegation message. Does not implicitly {@link cosmos.staking.v1beta1.Delegation.verify|verify} messages. + * @param m Delegation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IDelegation, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Delegation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Delegation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Delegation; + } + + /** Properties of an UnbondingDelegation. */ + interface IUnbondingDelegation { + /** UnbondingDelegation delegatorAddress */ + delegatorAddress?: string | null; + + /** UnbondingDelegation validatorAddress */ + validatorAddress?: string | null; + + /** UnbondingDelegation entries */ + entries?: cosmos.staking.v1beta1.IUnbondingDelegationEntry[] | null; + } + + /** Represents an UnbondingDelegation. */ + class UnbondingDelegation implements IUnbondingDelegation { + /** + * Constructs a new UnbondingDelegation. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IUnbondingDelegation); + + /** UnbondingDelegation delegatorAddress. */ + public delegatorAddress: string; + + /** UnbondingDelegation validatorAddress. */ + public validatorAddress: string; + + /** UnbondingDelegation entries. */ + public entries: cosmos.staking.v1beta1.IUnbondingDelegationEntry[]; + + /** + * Creates a new UnbondingDelegation instance using the specified properties. + * @param [properties] Properties to set + * @returns UnbondingDelegation instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IUnbondingDelegation, + ): cosmos.staking.v1beta1.UnbondingDelegation; + + /** + * Encodes the specified UnbondingDelegation message. Does not implicitly {@link cosmos.staking.v1beta1.UnbondingDelegation.verify|verify} messages. + * @param m UnbondingDelegation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IUnbondingDelegation, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an UnbondingDelegation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns UnbondingDelegation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.UnbondingDelegation; + } + + /** Properties of an UnbondingDelegationEntry. */ + interface IUnbondingDelegationEntry { + /** UnbondingDelegationEntry creationHeight */ + creationHeight?: Long | null; + + /** UnbondingDelegationEntry completionTime */ + completionTime?: google.protobuf.ITimestamp | null; + + /** UnbondingDelegationEntry initialBalance */ + initialBalance?: string | null; + + /** UnbondingDelegationEntry balance */ + balance?: string | null; + } + + /** Represents an UnbondingDelegationEntry. */ + class UnbondingDelegationEntry implements IUnbondingDelegationEntry { + /** + * Constructs a new UnbondingDelegationEntry. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IUnbondingDelegationEntry); + + /** UnbondingDelegationEntry creationHeight. */ + public creationHeight: Long; + + /** UnbondingDelegationEntry completionTime. */ + public completionTime?: google.protobuf.ITimestamp | null; + + /** UnbondingDelegationEntry initialBalance. */ + public initialBalance: string; + + /** UnbondingDelegationEntry balance. */ + public balance: string; + + /** + * Creates a new UnbondingDelegationEntry instance using the specified properties. + * @param [properties] Properties to set + * @returns UnbondingDelegationEntry instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IUnbondingDelegationEntry, + ): cosmos.staking.v1beta1.UnbondingDelegationEntry; + + /** + * Encodes the specified UnbondingDelegationEntry message. Does not implicitly {@link cosmos.staking.v1beta1.UnbondingDelegationEntry.verify|verify} messages. + * @param m UnbondingDelegationEntry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IUnbondingDelegationEntry, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an UnbondingDelegationEntry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns UnbondingDelegationEntry + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.UnbondingDelegationEntry; + } + + /** Properties of a RedelegationEntry. */ + interface IRedelegationEntry { + /** RedelegationEntry creationHeight */ + creationHeight?: Long | null; + + /** RedelegationEntry completionTime */ + completionTime?: google.protobuf.ITimestamp | null; + + /** RedelegationEntry initialBalance */ + initialBalance?: string | null; + + /** RedelegationEntry sharesDst */ + sharesDst?: string | null; + } + + /** Represents a RedelegationEntry. */ + class RedelegationEntry implements IRedelegationEntry { + /** + * Constructs a new RedelegationEntry. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegationEntry); + + /** RedelegationEntry creationHeight. */ + public creationHeight: Long; + + /** RedelegationEntry completionTime. */ + public completionTime?: google.protobuf.ITimestamp | null; + + /** RedelegationEntry initialBalance. */ + public initialBalance: string; + + /** RedelegationEntry sharesDst. */ + public sharesDst: string; + + /** + * Creates a new RedelegationEntry instance using the specified properties. + * @param [properties] Properties to set + * @returns RedelegationEntry instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegationEntry, + ): cosmos.staking.v1beta1.RedelegationEntry; + + /** + * Encodes the specified RedelegationEntry message. Does not implicitly {@link cosmos.staking.v1beta1.RedelegationEntry.verify|verify} messages. + * @param m RedelegationEntry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IRedelegationEntry, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a RedelegationEntry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns RedelegationEntry + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.RedelegationEntry; + } + + /** Properties of a Redelegation. */ + interface IRedelegation { + /** Redelegation delegatorAddress */ + delegatorAddress?: string | null; + + /** Redelegation validatorSrcAddress */ + validatorSrcAddress?: string | null; + + /** Redelegation validatorDstAddress */ + validatorDstAddress?: string | null; + + /** Redelegation entries */ + entries?: cosmos.staking.v1beta1.IRedelegationEntry[] | null; + } + + /** Represents a Redelegation. */ + class Redelegation implements IRedelegation { + /** + * Constructs a new Redelegation. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegation); + + /** Redelegation delegatorAddress. */ + public delegatorAddress: string; + + /** Redelegation validatorSrcAddress. */ + public validatorSrcAddress: string; + + /** Redelegation validatorDstAddress. */ + public validatorDstAddress: string; + + /** Redelegation entries. */ + public entries: cosmos.staking.v1beta1.IRedelegationEntry[]; + + /** + * Creates a new Redelegation instance using the specified properties. + * @param [properties] Properties to set + * @returns Redelegation instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegation, + ): cosmos.staking.v1beta1.Redelegation; + + /** + * Encodes the specified Redelegation message. Does not implicitly {@link cosmos.staking.v1beta1.Redelegation.verify|verify} messages. + * @param m Redelegation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IRedelegation, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Redelegation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Redelegation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.Redelegation; + } + + /** Properties of a Params. */ + interface IParams { + /** Params unbondingTime */ + unbondingTime?: google.protobuf.IDuration | null; + + /** Params maxValidators */ + maxValidators?: number | null; + + /** Params maxEntries */ + maxEntries?: number | null; + + /** Params historicalEntries */ + historicalEntries?: number | null; + + /** Params bondDenom */ + bondDenom?: string | null; + } + + /** Represents a Params. */ + class Params implements IParams { + /** + * Constructs a new Params. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IParams); + + /** Params unbondingTime. */ + public unbondingTime?: google.protobuf.IDuration | null; + + /** Params maxValidators. */ + public maxValidators: number; + + /** Params maxEntries. */ + public maxEntries: number; + + /** Params historicalEntries. */ + public historicalEntries: number; + + /** Params bondDenom. */ + public bondDenom: string; + + /** + * Creates a new Params instance using the specified properties. + * @param [properties] Properties to set + * @returns Params instance + */ + public static create(properties?: cosmos.staking.v1beta1.IParams): cosmos.staking.v1beta1.Params; + + /** + * Encodes the specified Params message. Does not implicitly {@link cosmos.staking.v1beta1.Params.verify|verify} messages. + * @param m Params message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IParams, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Params message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Params + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Params; + } + + /** Properties of a DelegationResponse. */ + interface IDelegationResponse { + /** DelegationResponse delegation */ + delegation?: cosmos.staking.v1beta1.IDelegation | null; + + /** DelegationResponse balance */ + balance?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a DelegationResponse. */ + class DelegationResponse implements IDelegationResponse { + /** + * Constructs a new DelegationResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IDelegationResponse); + + /** DelegationResponse delegation. */ + public delegation?: cosmos.staking.v1beta1.IDelegation | null; + + /** DelegationResponse balance. */ + public balance?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new DelegationResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns DelegationResponse instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IDelegationResponse, + ): cosmos.staking.v1beta1.DelegationResponse; + + /** + * Encodes the specified DelegationResponse message. Does not implicitly {@link cosmos.staking.v1beta1.DelegationResponse.verify|verify} messages. + * @param m DelegationResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IDelegationResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a DelegationResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DelegationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.DelegationResponse; + } + + /** Properties of a RedelegationEntryResponse. */ + interface IRedelegationEntryResponse { + /** RedelegationEntryResponse redelegationEntry */ + redelegationEntry?: cosmos.staking.v1beta1.IRedelegationEntry | null; + + /** RedelegationEntryResponse balance */ + balance?: string | null; + } + + /** Represents a RedelegationEntryResponse. */ + class RedelegationEntryResponse implements IRedelegationEntryResponse { + /** + * Constructs a new RedelegationEntryResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegationEntryResponse); + + /** RedelegationEntryResponse redelegationEntry. */ + public redelegationEntry?: cosmos.staking.v1beta1.IRedelegationEntry | null; + + /** RedelegationEntryResponse balance. */ + public balance: string; + + /** + * Creates a new RedelegationEntryResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns RedelegationEntryResponse instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegationEntryResponse, + ): cosmos.staking.v1beta1.RedelegationEntryResponse; + + /** + * Encodes the specified RedelegationEntryResponse message. Does not implicitly {@link cosmos.staking.v1beta1.RedelegationEntryResponse.verify|verify} messages. + * @param m RedelegationEntryResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IRedelegationEntryResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a RedelegationEntryResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns RedelegationEntryResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.RedelegationEntryResponse; + } + + /** Properties of a RedelegationResponse. */ + interface IRedelegationResponse { + /** RedelegationResponse redelegation */ + redelegation?: cosmos.staking.v1beta1.IRedelegation | null; + + /** RedelegationResponse entries */ + entries?: cosmos.staking.v1beta1.IRedelegationEntryResponse[] | null; + } + + /** Represents a RedelegationResponse. */ + class RedelegationResponse implements IRedelegationResponse { + /** + * Constructs a new RedelegationResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IRedelegationResponse); + + /** RedelegationResponse redelegation. */ + public redelegation?: cosmos.staking.v1beta1.IRedelegation | null; + + /** RedelegationResponse entries. */ + public entries: cosmos.staking.v1beta1.IRedelegationEntryResponse[]; + + /** + * Creates a new RedelegationResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns RedelegationResponse instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IRedelegationResponse, + ): cosmos.staking.v1beta1.RedelegationResponse; + + /** + * Encodes the specified RedelegationResponse message. Does not implicitly {@link cosmos.staking.v1beta1.RedelegationResponse.verify|verify} messages. + * @param m RedelegationResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IRedelegationResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a RedelegationResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns RedelegationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.RedelegationResponse; + } + + /** Properties of a Pool. */ + interface IPool { + /** Pool notBondedTokens */ + notBondedTokens?: string | null; + + /** Pool bondedTokens */ + bondedTokens?: string | null; + } + + /** Represents a Pool. */ + class Pool implements IPool { + /** + * Constructs a new Pool. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IPool); + + /** Pool notBondedTokens. */ + public notBondedTokens: string; + + /** Pool bondedTokens. */ + public bondedTokens: string; + + /** + * Creates a new Pool instance using the specified properties. + * @param [properties] Properties to set + * @returns Pool instance + */ + public static create(properties?: cosmos.staking.v1beta1.IPool): cosmos.staking.v1beta1.Pool; + + /** + * Encodes the specified Pool message. Does not implicitly {@link cosmos.staking.v1beta1.Pool.verify|verify} messages. + * @param m Pool message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IPool, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Pool message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Pool + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.staking.v1beta1.Pool; + } + + /** Properties of a MsgCreateValidator. */ + interface IMsgCreateValidator { + /** MsgCreateValidator description */ + description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgCreateValidator commission */ + commission?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** MsgCreateValidator minSelfDelegation */ + minSelfDelegation?: string | null; + + /** MsgCreateValidator delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgCreateValidator validatorAddress */ + validatorAddress?: string | null; + + /** MsgCreateValidator pubkey */ + pubkey?: string | null; + + /** MsgCreateValidator value */ + value?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgCreateValidator. */ + class MsgCreateValidator implements IMsgCreateValidator { + /** + * Constructs a new MsgCreateValidator. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgCreateValidator); + + /** MsgCreateValidator description. */ + public description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgCreateValidator commission. */ + public commission?: cosmos.staking.v1beta1.ICommissionRates | null; + + /** MsgCreateValidator minSelfDelegation. */ + public minSelfDelegation: string; + + /** MsgCreateValidator delegatorAddress. */ + public delegatorAddress: string; + + /** MsgCreateValidator validatorAddress. */ + public validatorAddress: string; + + /** MsgCreateValidator pubkey. */ + public pubkey: string; + + /** MsgCreateValidator value. */ + public value?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgCreateValidator instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgCreateValidator instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgCreateValidator, + ): cosmos.staking.v1beta1.MsgCreateValidator; + + /** + * Encodes the specified MsgCreateValidator message. Does not implicitly {@link cosmos.staking.v1beta1.MsgCreateValidator.verify|verify} messages. + * @param m MsgCreateValidator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgCreateValidator, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgCreateValidator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgCreateValidator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgCreateValidator; + } + + /** Properties of a MsgEditValidator. */ + interface IMsgEditValidator { + /** MsgEditValidator description */ + description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgEditValidator validatorAddress */ + validatorAddress?: string | null; + + /** MsgEditValidator commissionRate */ + commissionRate?: string | null; + + /** MsgEditValidator minSelfDelegation */ + minSelfDelegation?: string | null; + } + + /** Represents a MsgEditValidator. */ + class MsgEditValidator implements IMsgEditValidator { + /** + * Constructs a new MsgEditValidator. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgEditValidator); + + /** MsgEditValidator description. */ + public description?: cosmos.staking.v1beta1.IDescription | null; + + /** MsgEditValidator validatorAddress. */ + public validatorAddress: string; + + /** MsgEditValidator commissionRate. */ + public commissionRate: string; + + /** MsgEditValidator minSelfDelegation. */ + public minSelfDelegation: string; + + /** + * Creates a new MsgEditValidator instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgEditValidator instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgEditValidator, + ): cosmos.staking.v1beta1.MsgEditValidator; + + /** + * Encodes the specified MsgEditValidator message. Does not implicitly {@link cosmos.staking.v1beta1.MsgEditValidator.verify|verify} messages. + * @param m MsgEditValidator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgEditValidator, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgEditValidator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgEditValidator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgEditValidator; + } + + /** Properties of a MsgDelegate. */ + interface IMsgDelegate { + /** MsgDelegate delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgDelegate validatorAddress */ + validatorAddress?: string | null; + + /** MsgDelegate amount */ + amount?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgDelegate. */ + class MsgDelegate implements IMsgDelegate { + /** + * Constructs a new MsgDelegate. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgDelegate); + + /** MsgDelegate delegatorAddress. */ + public delegatorAddress: string; + + /** MsgDelegate validatorAddress. */ + public validatorAddress: string; + + /** MsgDelegate amount. */ + public amount?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgDelegate instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgDelegate instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgDelegate, + ): cosmos.staking.v1beta1.MsgDelegate; + + /** + * Encodes the specified MsgDelegate message. Does not implicitly {@link cosmos.staking.v1beta1.MsgDelegate.verify|verify} messages. + * @param m MsgDelegate message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.staking.v1beta1.IMsgDelegate, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgDelegate message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgDelegate + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgDelegate; + } + + /** Properties of a MsgBeginRedelegate. */ + interface IMsgBeginRedelegate { + /** MsgBeginRedelegate delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgBeginRedelegate validatorSrcAddress */ + validatorSrcAddress?: string | null; + + /** MsgBeginRedelegate validatorDstAddress */ + validatorDstAddress?: string | null; + + /** MsgBeginRedelegate amount */ + amount?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgBeginRedelegate. */ + class MsgBeginRedelegate implements IMsgBeginRedelegate { + /** + * Constructs a new MsgBeginRedelegate. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgBeginRedelegate); + + /** MsgBeginRedelegate delegatorAddress. */ + public delegatorAddress: string; + + /** MsgBeginRedelegate validatorSrcAddress. */ + public validatorSrcAddress: string; + + /** MsgBeginRedelegate validatorDstAddress. */ + public validatorDstAddress: string; + + /** MsgBeginRedelegate amount. */ + public amount?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgBeginRedelegate instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgBeginRedelegate instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgBeginRedelegate, + ): cosmos.staking.v1beta1.MsgBeginRedelegate; + + /** + * Encodes the specified MsgBeginRedelegate message. Does not implicitly {@link cosmos.staking.v1beta1.MsgBeginRedelegate.verify|verify} messages. + * @param m MsgBeginRedelegate message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgBeginRedelegate, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgBeginRedelegate message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgBeginRedelegate + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgBeginRedelegate; + } + + /** Properties of a MsgUndelegate. */ + interface IMsgUndelegate { + /** MsgUndelegate delegatorAddress */ + delegatorAddress?: string | null; + + /** MsgUndelegate validatorAddress */ + validatorAddress?: string | null; + + /** MsgUndelegate amount */ + amount?: cosmos.base.v1beta1.ICoin | null; + } + + /** Represents a MsgUndelegate. */ + class MsgUndelegate implements IMsgUndelegate { + /** + * Constructs a new MsgUndelegate. + * @param [p] Properties to set + */ + constructor(p?: cosmos.staking.v1beta1.IMsgUndelegate); + + /** MsgUndelegate delegatorAddress. */ + public delegatorAddress: string; + + /** MsgUndelegate validatorAddress. */ + public validatorAddress: string; + + /** MsgUndelegate amount. */ + public amount?: cosmos.base.v1beta1.ICoin | null; + + /** + * Creates a new MsgUndelegate instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgUndelegate instance + */ + public static create( + properties?: cosmos.staking.v1beta1.IMsgUndelegate, + ): cosmos.staking.v1beta1.MsgUndelegate; + + /** + * Encodes the specified MsgUndelegate message. Does not implicitly {@link cosmos.staking.v1beta1.MsgUndelegate.verify|verify} messages. + * @param m MsgUndelegate message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.staking.v1beta1.IMsgUndelegate, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgUndelegate message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgUndelegate + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.staking.v1beta1.MsgUndelegate; + } + } + } + /** Namespace tx. */ namespace tx { /** Namespace signing. */ @@ -4358,6 +5916,104 @@ export namespace google { ): google.protobuf.GeneratedCodeInfo.Annotation; } } + + /** Properties of a Timestamp. */ + interface ITimestamp { + /** Timestamp seconds */ + seconds?: Long | null; + + /** Timestamp nanos */ + nanos?: number | null; + } + + /** Represents a Timestamp. */ + class Timestamp implements ITimestamp { + /** + * Constructs a new Timestamp. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.ITimestamp); + + /** Timestamp seconds. */ + public seconds: Long; + + /** Timestamp nanos. */ + public nanos: number; + + /** + * Creates a new Timestamp instance using the specified properties. + * @param [properties] Properties to set + * @returns Timestamp instance + */ + public static create(properties?: google.protobuf.ITimestamp): google.protobuf.Timestamp; + + /** + * Encodes the specified Timestamp message. Does not implicitly {@link google.protobuf.Timestamp.verify|verify} messages. + * @param m Timestamp message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.ITimestamp, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Timestamp message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Timestamp + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.Timestamp; + } + + /** Properties of a Duration. */ + interface IDuration { + /** Duration seconds */ + seconds?: Long | null; + + /** Duration nanos */ + nanos?: number | null; + } + + /** Represents a Duration. */ + class Duration implements IDuration { + /** + * Constructs a new Duration. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IDuration); + + /** Duration seconds. */ + public seconds: Long; + + /** Duration nanos. */ + public nanos: number; + + /** + * Creates a new Duration instance using the specified properties. + * @param [properties] Properties to set + * @returns Duration instance + */ + public static create(properties?: google.protobuf.IDuration): google.protobuf.Duration; + + /** + * Encodes the specified Duration message. Does not implicitly {@link google.protobuf.Duration.verify|verify} messages. + * @param m Duration message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IDuration, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Duration message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Duration + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.Duration; + } } /** Namespace api. */ @@ -9880,6 +11536,52 @@ export namespace ibc { export namespace tendermint { /** Namespace crypto. */ namespace crypto { + /** Properties of a PublicKey. */ + interface IPublicKey { + /** PublicKey ed25519 */ + ed25519?: Uint8Array | null; + } + + /** Represents a PublicKey. */ + class PublicKey implements IPublicKey { + /** + * Constructs a new PublicKey. + * @param [p] Properties to set + */ + constructor(p?: tendermint.crypto.IPublicKey); + + /** PublicKey ed25519. */ + public ed25519: Uint8Array; + + /** PublicKey sum. */ + public sum?: "ed25519"; + + /** + * Creates a new PublicKey instance using the specified properties. + * @param [properties] Properties to set + * @returns PublicKey instance + */ + public static create(properties?: tendermint.crypto.IPublicKey): tendermint.crypto.PublicKey; + + /** + * Encodes the specified PublicKey message. Does not implicitly {@link tendermint.crypto.PublicKey.verify|verify} messages. + * @param m PublicKey message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.crypto.IPublicKey, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PublicKey message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PublicKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.crypto.PublicKey; + } + /** Properties of a Proof. */ interface IProof { /** Proof total */ @@ -10143,4 +11845,1179 @@ export namespace tendermint { public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.crypto.ProofOps; } } + + /** Namespace libs. */ + namespace libs { + /** Namespace bits. */ + namespace bits { + /** Properties of a BitArray. */ + interface IBitArray { + /** BitArray bits */ + bits?: Long | null; + + /** BitArray elems */ + elems?: Long[] | null; + } + + /** Represents a BitArray. */ + class BitArray implements IBitArray { + /** + * Constructs a new BitArray. + * @param [p] Properties to set + */ + constructor(p?: tendermint.libs.bits.IBitArray); + + /** BitArray bits. */ + public bits: Long; + + /** BitArray elems. */ + public elems: Long[]; + + /** + * Creates a new BitArray instance using the specified properties. + * @param [properties] Properties to set + * @returns BitArray instance + */ + public static create(properties?: tendermint.libs.bits.IBitArray): tendermint.libs.bits.BitArray; + + /** + * Encodes the specified BitArray message. Does not implicitly {@link tendermint.libs.bits.BitArray.verify|verify} messages. + * @param m BitArray message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.libs.bits.IBitArray, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a BitArray message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns BitArray + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.libs.bits.BitArray; + } + } + } + + /** Namespace types. */ + namespace types { + /** BlockIDFlag enum. */ + enum BlockIDFlag { + BLOCK_ID_FLAG_UNKNOWN = 0, + BLOCK_ID_FLAG_ABSENT = 1, + BLOCK_ID_FLAG_COMMIT = 2, + BLOCK_ID_FLAG_NIL = 3, + } + + /** SignedMsgType enum. */ + enum SignedMsgType { + SIGNED_MSG_TYPE_UNKNOWN = 0, + SIGNED_MSG_TYPE_PREVOTE = 1, + SIGNED_MSG_TYPE_PRECOMMIT = 2, + SIGNED_MSG_TYPE_PROPOSAL = 32, + } + + /** Properties of a PartSetHeader. */ + interface IPartSetHeader { + /** PartSetHeader total */ + total?: number | null; + + /** PartSetHeader hash */ + hash?: Uint8Array | null; + } + + /** Represents a PartSetHeader. */ + class PartSetHeader implements IPartSetHeader { + /** + * Constructs a new PartSetHeader. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IPartSetHeader); + + /** PartSetHeader total. */ + public total: number; + + /** PartSetHeader hash. */ + public hash: Uint8Array; + + /** + * Creates a new PartSetHeader instance using the specified properties. + * @param [properties] Properties to set + * @returns PartSetHeader instance + */ + public static create(properties?: tendermint.types.IPartSetHeader): tendermint.types.PartSetHeader; + + /** + * Encodes the specified PartSetHeader message. Does not implicitly {@link tendermint.types.PartSetHeader.verify|verify} messages. + * @param m PartSetHeader message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IPartSetHeader, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PartSetHeader message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PartSetHeader + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.PartSetHeader; + } + + /** Properties of a Part. */ + interface IPart { + /** Part index */ + index?: number | null; + + /** Part bytes */ + bytes?: Uint8Array | null; + + /** Part proof */ + proof?: tendermint.crypto.IProof | null; + } + + /** Represents a Part. */ + class Part implements IPart { + /** + * Constructs a new Part. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IPart); + + /** Part index. */ + public index: number; + + /** Part bytes. */ + public bytes: Uint8Array; + + /** Part proof. */ + public proof?: tendermint.crypto.IProof | null; + + /** + * Creates a new Part instance using the specified properties. + * @param [properties] Properties to set + * @returns Part instance + */ + public static create(properties?: tendermint.types.IPart): tendermint.types.Part; + + /** + * Encodes the specified Part message. Does not implicitly {@link tendermint.types.Part.verify|verify} messages. + * @param m Part message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IPart, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Part message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Part + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Part; + } + + /** Properties of a BlockID. */ + interface IBlockID { + /** BlockID hash */ + hash?: Uint8Array | null; + + /** BlockID partSetHeader */ + partSetHeader?: tendermint.types.IPartSetHeader | null; + } + + /** Represents a BlockID. */ + class BlockID implements IBlockID { + /** + * Constructs a new BlockID. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IBlockID); + + /** BlockID hash. */ + public hash: Uint8Array; + + /** BlockID partSetHeader. */ + public partSetHeader?: tendermint.types.IPartSetHeader | null; + + /** + * Creates a new BlockID instance using the specified properties. + * @param [properties] Properties to set + * @returns BlockID instance + */ + public static create(properties?: tendermint.types.IBlockID): tendermint.types.BlockID; + + /** + * Encodes the specified BlockID message. Does not implicitly {@link tendermint.types.BlockID.verify|verify} messages. + * @param m BlockID message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IBlockID, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a BlockID message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns BlockID + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.BlockID; + } + + /** Properties of a Header. */ + interface IHeader { + /** Header version */ + version?: tendermint.version.IConsensus | null; + + /** Header chainId */ + chainId?: string | null; + + /** Header height */ + height?: Long | null; + + /** Header time */ + time?: google.protobuf.ITimestamp | null; + + /** Header lastBlockId */ + lastBlockId?: tendermint.types.IBlockID | null; + + /** Header lastCommitHash */ + lastCommitHash?: Uint8Array | null; + + /** Header dataHash */ + dataHash?: Uint8Array | null; + + /** Header validatorsHash */ + validatorsHash?: Uint8Array | null; + + /** Header nextValidatorsHash */ + nextValidatorsHash?: Uint8Array | null; + + /** Header consensusHash */ + consensusHash?: Uint8Array | null; + + /** Header appHash */ + appHash?: Uint8Array | null; + + /** Header lastResultsHash */ + lastResultsHash?: Uint8Array | null; + + /** Header evidenceHash */ + evidenceHash?: Uint8Array | null; + + /** Header proposerAddress */ + proposerAddress?: Uint8Array | null; + } + + /** Represents a Header. */ + class Header implements IHeader { + /** + * Constructs a new Header. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IHeader); + + /** Header version. */ + public version?: tendermint.version.IConsensus | null; + + /** Header chainId. */ + public chainId: string; + + /** Header height. */ + public height: Long; + + /** Header time. */ + public time?: google.protobuf.ITimestamp | null; + + /** Header lastBlockId. */ + public lastBlockId?: tendermint.types.IBlockID | null; + + /** Header lastCommitHash. */ + public lastCommitHash: Uint8Array; + + /** Header dataHash. */ + public dataHash: Uint8Array; + + /** Header validatorsHash. */ + public validatorsHash: Uint8Array; + + /** Header nextValidatorsHash. */ + public nextValidatorsHash: Uint8Array; + + /** Header consensusHash. */ + public consensusHash: Uint8Array; + + /** Header appHash. */ + public appHash: Uint8Array; + + /** Header lastResultsHash. */ + public lastResultsHash: Uint8Array; + + /** Header evidenceHash. */ + public evidenceHash: Uint8Array; + + /** Header proposerAddress. */ + public proposerAddress: Uint8Array; + + /** + * Creates a new Header instance using the specified properties. + * @param [properties] Properties to set + * @returns Header instance + */ + public static create(properties?: tendermint.types.IHeader): tendermint.types.Header; + + /** + * Encodes the specified Header message. Does not implicitly {@link tendermint.types.Header.verify|verify} messages. + * @param m Header message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IHeader, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Header message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Header + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Header; + } + + /** Properties of a Data. */ + interface IData { + /** Data txs */ + txs?: Uint8Array[] | null; + + /** Data hash */ + hash?: Uint8Array | null; + } + + /** Represents a Data. */ + class Data implements IData { + /** + * Constructs a new Data. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IData); + + /** Data txs. */ + public txs: Uint8Array[]; + + /** Data hash. */ + public hash: Uint8Array; + + /** + * Creates a new Data instance using the specified properties. + * @param [properties] Properties to set + * @returns Data instance + */ + public static create(properties?: tendermint.types.IData): tendermint.types.Data; + + /** + * Encodes the specified Data message. Does not implicitly {@link tendermint.types.Data.verify|verify} messages. + * @param m Data message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IData, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Data message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Data + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Data; + } + + /** Properties of a Vote. */ + interface IVote { + /** Vote type */ + type?: tendermint.types.SignedMsgType | null; + + /** Vote height */ + height?: Long | null; + + /** Vote round */ + round?: number | null; + + /** Vote blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** Vote timestamp */ + timestamp?: google.protobuf.ITimestamp | null; + + /** Vote validatorAddress */ + validatorAddress?: Uint8Array | null; + + /** Vote validatorIndex */ + validatorIndex?: number | null; + + /** Vote signature */ + signature?: Uint8Array | null; + } + + /** Represents a Vote. */ + class Vote implements IVote { + /** + * Constructs a new Vote. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IVote); + + /** Vote type. */ + public type: tendermint.types.SignedMsgType; + + /** Vote height. */ + public height: Long; + + /** Vote round. */ + public round: number; + + /** Vote blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** Vote timestamp. */ + public timestamp?: google.protobuf.ITimestamp | null; + + /** Vote validatorAddress. */ + public validatorAddress: Uint8Array; + + /** Vote validatorIndex. */ + public validatorIndex: number; + + /** Vote signature. */ + public signature: Uint8Array; + + /** + * Creates a new Vote instance using the specified properties. + * @param [properties] Properties to set + * @returns Vote instance + */ + public static create(properties?: tendermint.types.IVote): tendermint.types.Vote; + + /** + * Encodes the specified Vote message. Does not implicitly {@link tendermint.types.Vote.verify|verify} messages. + * @param m Vote message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IVote, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Vote message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Vote + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Vote; + } + + /** Properties of a Commit. */ + interface ICommit { + /** Commit height */ + height?: Long | null; + + /** Commit round */ + round?: number | null; + + /** Commit blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** Commit signatures */ + signatures?: tendermint.types.ICommitSig[] | null; + + /** Commit hash */ + hash?: Uint8Array | null; + + /** Commit bitArray */ + bitArray?: tendermint.libs.bits.IBitArray | null; + } + + /** Represents a Commit. */ + class Commit implements ICommit { + /** + * Constructs a new Commit. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ICommit); + + /** Commit height. */ + public height: Long; + + /** Commit round. */ + public round: number; + + /** Commit blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** Commit signatures. */ + public signatures: tendermint.types.ICommitSig[]; + + /** Commit hash. */ + public hash: Uint8Array; + + /** Commit bitArray. */ + public bitArray?: tendermint.libs.bits.IBitArray | null; + + /** + * Creates a new Commit instance using the specified properties. + * @param [properties] Properties to set + * @returns Commit instance + */ + public static create(properties?: tendermint.types.ICommit): tendermint.types.Commit; + + /** + * Encodes the specified Commit message. Does not implicitly {@link tendermint.types.Commit.verify|verify} messages. + * @param m Commit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ICommit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Commit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Commit + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Commit; + } + + /** Properties of a CommitSig. */ + interface ICommitSig { + /** CommitSig blockIdFlag */ + blockIdFlag?: tendermint.types.BlockIDFlag | null; + + /** CommitSig validatorAddress */ + validatorAddress?: Uint8Array | null; + + /** CommitSig timestamp */ + timestamp?: google.protobuf.ITimestamp | null; + + /** CommitSig signature */ + signature?: Uint8Array | null; + } + + /** Represents a CommitSig. */ + class CommitSig implements ICommitSig { + /** + * Constructs a new CommitSig. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ICommitSig); + + /** CommitSig blockIdFlag. */ + public blockIdFlag: tendermint.types.BlockIDFlag; + + /** CommitSig validatorAddress. */ + public validatorAddress: Uint8Array; + + /** CommitSig timestamp. */ + public timestamp?: google.protobuf.ITimestamp | null; + + /** CommitSig signature. */ + public signature: Uint8Array; + + /** + * Creates a new CommitSig instance using the specified properties. + * @param [properties] Properties to set + * @returns CommitSig instance + */ + public static create(properties?: tendermint.types.ICommitSig): tendermint.types.CommitSig; + + /** + * Encodes the specified CommitSig message. Does not implicitly {@link tendermint.types.CommitSig.verify|verify} messages. + * @param m CommitSig message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ICommitSig, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a CommitSig message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CommitSig + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.CommitSig; + } + + /** Properties of a Proposal. */ + interface IProposal { + /** Proposal type */ + type?: tendermint.types.SignedMsgType | null; + + /** Proposal height */ + height?: Long | null; + + /** Proposal round */ + round?: number | null; + + /** Proposal polRound */ + polRound?: number | null; + + /** Proposal blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** Proposal timestamp */ + timestamp?: google.protobuf.ITimestamp | null; + + /** Proposal signature */ + signature?: Uint8Array | null; + } + + /** Represents a Proposal. */ + class Proposal implements IProposal { + /** + * Constructs a new Proposal. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IProposal); + + /** Proposal type. */ + public type: tendermint.types.SignedMsgType; + + /** Proposal height. */ + public height: Long; + + /** Proposal round. */ + public round: number; + + /** Proposal polRound. */ + public polRound: number; + + /** Proposal blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** Proposal timestamp. */ + public timestamp?: google.protobuf.ITimestamp | null; + + /** Proposal signature. */ + public signature: Uint8Array; + + /** + * Creates a new Proposal instance using the specified properties. + * @param [properties] Properties to set + * @returns Proposal instance + */ + public static create(properties?: tendermint.types.IProposal): tendermint.types.Proposal; + + /** + * Encodes the specified Proposal message. Does not implicitly {@link tendermint.types.Proposal.verify|verify} messages. + * @param m Proposal message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IProposal, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Proposal message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Proposal + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Proposal; + } + + /** Properties of a SignedHeader. */ + interface ISignedHeader { + /** SignedHeader header */ + header?: tendermint.types.IHeader | null; + + /** SignedHeader commit */ + commit?: tendermint.types.ICommit | null; + } + + /** Represents a SignedHeader. */ + class SignedHeader implements ISignedHeader { + /** + * Constructs a new SignedHeader. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ISignedHeader); + + /** SignedHeader header. */ + public header?: tendermint.types.IHeader | null; + + /** SignedHeader commit. */ + public commit?: tendermint.types.ICommit | null; + + /** + * Creates a new SignedHeader instance using the specified properties. + * @param [properties] Properties to set + * @returns SignedHeader instance + */ + public static create(properties?: tendermint.types.ISignedHeader): tendermint.types.SignedHeader; + + /** + * Encodes the specified SignedHeader message. Does not implicitly {@link tendermint.types.SignedHeader.verify|verify} messages. + * @param m SignedHeader message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ISignedHeader, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a SignedHeader message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SignedHeader + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.SignedHeader; + } + + /** Properties of a LightBlock. */ + interface ILightBlock { + /** LightBlock signedHeader */ + signedHeader?: tendermint.types.ISignedHeader | null; + + /** LightBlock validatorSet */ + validatorSet?: tendermint.types.IValidatorSet | null; + } + + /** Represents a LightBlock. */ + class LightBlock implements ILightBlock { + /** + * Constructs a new LightBlock. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ILightBlock); + + /** LightBlock signedHeader. */ + public signedHeader?: tendermint.types.ISignedHeader | null; + + /** LightBlock validatorSet. */ + public validatorSet?: tendermint.types.IValidatorSet | null; + + /** + * Creates a new LightBlock instance using the specified properties. + * @param [properties] Properties to set + * @returns LightBlock instance + */ + public static create(properties?: tendermint.types.ILightBlock): tendermint.types.LightBlock; + + /** + * Encodes the specified LightBlock message. Does not implicitly {@link tendermint.types.LightBlock.verify|verify} messages. + * @param m LightBlock message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ILightBlock, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a LightBlock message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns LightBlock + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.LightBlock; + } + + /** Properties of a BlockMeta. */ + interface IBlockMeta { + /** BlockMeta blockId */ + blockId?: tendermint.types.IBlockID | null; + + /** BlockMeta blockSize */ + blockSize?: Long | null; + + /** BlockMeta header */ + header?: tendermint.types.IHeader | null; + + /** BlockMeta numTxs */ + numTxs?: Long | null; + } + + /** Represents a BlockMeta. */ + class BlockMeta implements IBlockMeta { + /** + * Constructs a new BlockMeta. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IBlockMeta); + + /** BlockMeta blockId. */ + public blockId?: tendermint.types.IBlockID | null; + + /** BlockMeta blockSize. */ + public blockSize: Long; + + /** BlockMeta header. */ + public header?: tendermint.types.IHeader | null; + + /** BlockMeta numTxs. */ + public numTxs: Long; + + /** + * Creates a new BlockMeta instance using the specified properties. + * @param [properties] Properties to set + * @returns BlockMeta instance + */ + public static create(properties?: tendermint.types.IBlockMeta): tendermint.types.BlockMeta; + + /** + * Encodes the specified BlockMeta message. Does not implicitly {@link tendermint.types.BlockMeta.verify|verify} messages. + * @param m BlockMeta message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IBlockMeta, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a BlockMeta message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns BlockMeta + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.BlockMeta; + } + + /** Properties of a TxProof. */ + interface ITxProof { + /** TxProof rootHash */ + rootHash?: Uint8Array | null; + + /** TxProof data */ + data?: Uint8Array | null; + + /** TxProof proof */ + proof?: tendermint.crypto.IProof | null; + } + + /** Represents a TxProof. */ + class TxProof implements ITxProof { + /** + * Constructs a new TxProof. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ITxProof); + + /** TxProof rootHash. */ + public rootHash: Uint8Array; + + /** TxProof data. */ + public data: Uint8Array; + + /** TxProof proof. */ + public proof?: tendermint.crypto.IProof | null; + + /** + * Creates a new TxProof instance using the specified properties. + * @param [properties] Properties to set + * @returns TxProof instance + */ + public static create(properties?: tendermint.types.ITxProof): tendermint.types.TxProof; + + /** + * Encodes the specified TxProof message. Does not implicitly {@link tendermint.types.TxProof.verify|verify} messages. + * @param m TxProof message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ITxProof, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a TxProof message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns TxProof + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.TxProof; + } + + /** Properties of a ValidatorSet. */ + interface IValidatorSet { + /** ValidatorSet validators */ + validators?: tendermint.types.IValidator[] | null; + + /** ValidatorSet proposer */ + proposer?: tendermint.types.IValidator | null; + + /** ValidatorSet totalVotingPower */ + totalVotingPower?: Long | null; + } + + /** Represents a ValidatorSet. */ + class ValidatorSet implements IValidatorSet { + /** + * Constructs a new ValidatorSet. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IValidatorSet); + + /** ValidatorSet validators. */ + public validators: tendermint.types.IValidator[]; + + /** ValidatorSet proposer. */ + public proposer?: tendermint.types.IValidator | null; + + /** ValidatorSet totalVotingPower. */ + public totalVotingPower: Long; + + /** + * Creates a new ValidatorSet instance using the specified properties. + * @param [properties] Properties to set + * @returns ValidatorSet instance + */ + public static create(properties?: tendermint.types.IValidatorSet): tendermint.types.ValidatorSet; + + /** + * Encodes the specified ValidatorSet message. Does not implicitly {@link tendermint.types.ValidatorSet.verify|verify} messages. + * @param m ValidatorSet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IValidatorSet, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ValidatorSet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ValidatorSet + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.ValidatorSet; + } + + /** Properties of a Validator. */ + interface IValidator { + /** Validator address */ + address?: Uint8Array | null; + + /** Validator pubKey */ + pubKey?: tendermint.crypto.IPublicKey | null; + + /** Validator votingPower */ + votingPower?: Long | null; + + /** Validator proposerPriority */ + proposerPriority?: Long | null; + } + + /** Represents a Validator. */ + class Validator implements IValidator { + /** + * Constructs a new Validator. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.IValidator); + + /** Validator address. */ + public address: Uint8Array; + + /** Validator pubKey. */ + public pubKey?: tendermint.crypto.IPublicKey | null; + + /** Validator votingPower. */ + public votingPower: Long; + + /** Validator proposerPriority. */ + public proposerPriority: Long; + + /** + * Creates a new Validator instance using the specified properties. + * @param [properties] Properties to set + * @returns Validator instance + */ + public static create(properties?: tendermint.types.IValidator): tendermint.types.Validator; + + /** + * Encodes the specified Validator message. Does not implicitly {@link tendermint.types.Validator.verify|verify} messages. + * @param m Validator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.IValidator, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Validator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Validator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.Validator; + } + + /** Properties of a SimpleValidator. */ + interface ISimpleValidator { + /** SimpleValidator pubKey */ + pubKey?: tendermint.crypto.IPublicKey | null; + + /** SimpleValidator votingPower */ + votingPower?: Long | null; + } + + /** Represents a SimpleValidator. */ + class SimpleValidator implements ISimpleValidator { + /** + * Constructs a new SimpleValidator. + * @param [p] Properties to set + */ + constructor(p?: tendermint.types.ISimpleValidator); + + /** SimpleValidator pubKey. */ + public pubKey?: tendermint.crypto.IPublicKey | null; + + /** SimpleValidator votingPower. */ + public votingPower: Long; + + /** + * Creates a new SimpleValidator instance using the specified properties. + * @param [properties] Properties to set + * @returns SimpleValidator instance + */ + public static create(properties?: tendermint.types.ISimpleValidator): tendermint.types.SimpleValidator; + + /** + * Encodes the specified SimpleValidator message. Does not implicitly {@link tendermint.types.SimpleValidator.verify|verify} messages. + * @param m SimpleValidator message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.types.ISimpleValidator, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a SimpleValidator message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SimpleValidator + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.types.SimpleValidator; + } + } + + /** Namespace version. */ + namespace version { + /** Properties of an App. */ + interface IApp { + /** App protocol */ + protocol?: Long | null; + + /** App software */ + software?: string | null; + } + + /** Represents an App. */ + class App implements IApp { + /** + * Constructs a new App. + * @param [p] Properties to set + */ + constructor(p?: tendermint.version.IApp); + + /** App protocol. */ + public protocol: Long; + + /** App software. */ + public software: string; + + /** + * Creates a new App instance using the specified properties. + * @param [properties] Properties to set + * @returns App instance + */ + public static create(properties?: tendermint.version.IApp): tendermint.version.App; + + /** + * Encodes the specified App message. Does not implicitly {@link tendermint.version.App.verify|verify} messages. + * @param m App message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.version.IApp, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an App message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns App + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.version.App; + } + + /** Properties of a Consensus. */ + interface IConsensus { + /** Consensus block */ + block?: Long | null; + + /** Consensus app */ + app?: Long | null; + } + + /** Represents a Consensus. */ + class Consensus implements IConsensus { + /** + * Constructs a new Consensus. + * @param [p] Properties to set + */ + constructor(p?: tendermint.version.IConsensus); + + /** Consensus block. */ + public block: Long; + + /** Consensus app. */ + public app: Long; + + /** + * Creates a new Consensus instance using the specified properties. + * @param [properties] Properties to set + * @returns Consensus instance + */ + public static create(properties?: tendermint.version.IConsensus): tendermint.version.Consensus; + + /** + * Encodes the specified Consensus message. Does not implicitly {@link tendermint.version.Consensus.verify|verify} messages. + * @param m Consensus message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: tendermint.version.IConsensus, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Consensus message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Consensus + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): tendermint.version.Consensus; + } + } }