From a08c8d77598f5a328c53c1e4dd42513286eca0d7 Mon Sep 17 00:00:00 2001 From: Simon Warta Date: Tue, 18 Aug 2020 11:36:46 +0200 Subject: [PATCH] Add IBC types to codec --- packages/stargate/scripts/predefine-proto.sh | 4 + .../src/codec/generated/codecimpl.d.ts | 3681 +++++++++++++++++ .../stargate/src/codec/generated/codecimpl.js | 2877 ++++++++++++- .../types/codec/generated/codecimpl.d.ts | 3681 +++++++++++++++++ 4 files changed, 10242 insertions(+), 1 deletion(-) diff --git a/packages/stargate/scripts/predefine-proto.sh b/packages/stargate/scripts/predefine-proto.sh index 3bc39794..c6f116ec 100755 --- a/packages/stargate/scripts/predefine-proto.sh +++ b/packages/stargate/scripts/predefine-proto.sh @@ -5,6 +5,7 @@ command -v shellcheck > /dev/null && shellcheck "$0" GENERATED_DIR="./tmp" ROOT_PROTO_DIR="./proto/cosmos/cosmos-sdk" COSMOS_PROTO_DIR="$ROOT_PROTO_DIR/proto/cosmos" +IBC_PROTO_DIR="$ROOT_PROTO_DIR/proto/ibc" TENDERMINT_PROTO_DIR="$ROOT_PROTO_DIR/third_party/proto/tendermint" GOOGLE_PROTO_DIR="$ROOT_PROTO_DIR/third_party/proto/google" @@ -27,6 +28,9 @@ yarn pbjs \ "$COSMOS_PROTO_DIR/query/pagination.proto" \ "$COSMOS_PROTO_DIR/tx/tx.proto" \ "$COSMOS_PROTO_DIR/tx/signing/signing.proto" \ + "$IBC_PROTO_DIR/channel/{channel,query}.proto" \ + "$IBC_PROTO_DIR/commitment/commitment.proto" \ + "$IBC_PROTO_DIR/connection/{connection,query}.proto" \ "$TENDERMINT_PROTO_DIR/abci/types/types.proto" \ "$TENDERMINT_PROTO_DIR/crypto/merkle/merkle.proto" \ "$TENDERMINT_PROTO_DIR/libs/kv/types.proto" \ diff --git a/packages/stargate/src/codec/generated/codecimpl.d.ts b/packages/stargate/src/codec/generated/codecimpl.d.ts index 43c0b29b..e205516f 100644 --- a/packages/stargate/src/codec/generated/codecimpl.d.ts +++ b/packages/stargate/src/codec/generated/codecimpl.d.ts @@ -3303,6 +3303,3687 @@ export namespace cosmos { } } +/** Namespace ibc. */ +export namespace ibc { + /** Namespace channel. */ + namespace channel { + /** Properties of a MsgChannelOpenInit. */ + interface IMsgChannelOpenInit { + /** MsgChannelOpenInit portId */ + portId?: string | null; + + /** MsgChannelOpenInit channelId */ + channelId?: string | null; + + /** MsgChannelOpenInit channel */ + channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenInit signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenInit. */ + class MsgChannelOpenInit implements IMsgChannelOpenInit { + /** + * Constructs a new MsgChannelOpenInit. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenInit); + + /** MsgChannelOpenInit portId. */ + public portId: string; + + /** MsgChannelOpenInit channelId. */ + public channelId: string; + + /** MsgChannelOpenInit channel. */ + public channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenInit signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenInit instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenInit instance + */ + public static create(properties?: ibc.channel.IMsgChannelOpenInit): ibc.channel.MsgChannelOpenInit; + + /** + * Encodes the specified MsgChannelOpenInit message. Does not implicitly {@link ibc.channel.MsgChannelOpenInit.verify|verify} messages. + * @param m MsgChannelOpenInit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenInit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenInit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenInit + * @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): ibc.channel.MsgChannelOpenInit; + } + + /** Properties of a MsgChannelOpenTry. */ + interface IMsgChannelOpenTry { + /** MsgChannelOpenTry portId */ + portId?: string | null; + + /** MsgChannelOpenTry channelId */ + channelId?: string | null; + + /** MsgChannelOpenTry channel */ + channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenTry counterpartyVersion */ + counterpartyVersion?: string | null; + + /** MsgChannelOpenTry proofInit */ + proofInit?: Uint8Array | null; + + /** MsgChannelOpenTry proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelOpenTry signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenTry. */ + class MsgChannelOpenTry implements IMsgChannelOpenTry { + /** + * Constructs a new MsgChannelOpenTry. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenTry); + + /** MsgChannelOpenTry portId. */ + public portId: string; + + /** MsgChannelOpenTry channelId. */ + public channelId: string; + + /** MsgChannelOpenTry channel. */ + public channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenTry counterpartyVersion. */ + public counterpartyVersion: string; + + /** MsgChannelOpenTry proofInit. */ + public proofInit: Uint8Array; + + /** MsgChannelOpenTry proofHeight. */ + public proofHeight: Long; + + /** MsgChannelOpenTry signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenTry instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenTry instance + */ + public static create(properties?: ibc.channel.IMsgChannelOpenTry): ibc.channel.MsgChannelOpenTry; + + /** + * Encodes the specified MsgChannelOpenTry message. Does not implicitly {@link ibc.channel.MsgChannelOpenTry.verify|verify} messages. + * @param m MsgChannelOpenTry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenTry, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenTry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenTry + * @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): ibc.channel.MsgChannelOpenTry; + } + + /** Properties of a MsgChannelOpenAck. */ + interface IMsgChannelOpenAck { + /** MsgChannelOpenAck portId */ + portId?: string | null; + + /** MsgChannelOpenAck channelId */ + channelId?: string | null; + + /** MsgChannelOpenAck counterpartyVersion */ + counterpartyVersion?: string | null; + + /** MsgChannelOpenAck proofTry */ + proofTry?: Uint8Array | null; + + /** MsgChannelOpenAck proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelOpenAck signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenAck. */ + class MsgChannelOpenAck implements IMsgChannelOpenAck { + /** + * Constructs a new MsgChannelOpenAck. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenAck); + + /** MsgChannelOpenAck portId. */ + public portId: string; + + /** MsgChannelOpenAck channelId. */ + public channelId: string; + + /** MsgChannelOpenAck counterpartyVersion. */ + public counterpartyVersion: string; + + /** MsgChannelOpenAck proofTry. */ + public proofTry: Uint8Array; + + /** MsgChannelOpenAck proofHeight. */ + public proofHeight: Long; + + /** MsgChannelOpenAck signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenAck instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenAck instance + */ + public static create(properties?: ibc.channel.IMsgChannelOpenAck): ibc.channel.MsgChannelOpenAck; + + /** + * Encodes the specified MsgChannelOpenAck message. Does not implicitly {@link ibc.channel.MsgChannelOpenAck.verify|verify} messages. + * @param m MsgChannelOpenAck message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenAck, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenAck message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenAck + * @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): ibc.channel.MsgChannelOpenAck; + } + + /** Properties of a MsgChannelOpenConfirm. */ + interface IMsgChannelOpenConfirm { + /** MsgChannelOpenConfirm portId */ + portId?: string | null; + + /** MsgChannelOpenConfirm channelId */ + channelId?: string | null; + + /** MsgChannelOpenConfirm proofAck */ + proofAck?: Uint8Array | null; + + /** MsgChannelOpenConfirm proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelOpenConfirm signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenConfirm. */ + class MsgChannelOpenConfirm implements IMsgChannelOpenConfirm { + /** + * Constructs a new MsgChannelOpenConfirm. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenConfirm); + + /** MsgChannelOpenConfirm portId. */ + public portId: string; + + /** MsgChannelOpenConfirm channelId. */ + public channelId: string; + + /** MsgChannelOpenConfirm proofAck. */ + public proofAck: Uint8Array; + + /** MsgChannelOpenConfirm proofHeight. */ + public proofHeight: Long; + + /** MsgChannelOpenConfirm signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenConfirm instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenConfirm instance + */ + public static create( + properties?: ibc.channel.IMsgChannelOpenConfirm, + ): ibc.channel.MsgChannelOpenConfirm; + + /** + * Encodes the specified MsgChannelOpenConfirm message. Does not implicitly {@link ibc.channel.MsgChannelOpenConfirm.verify|verify} messages. + * @param m MsgChannelOpenConfirm message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenConfirm, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenConfirm message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenConfirm + * @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): ibc.channel.MsgChannelOpenConfirm; + } + + /** Properties of a MsgChannelCloseInit. */ + interface IMsgChannelCloseInit { + /** MsgChannelCloseInit portId */ + portId?: string | null; + + /** MsgChannelCloseInit channelId */ + channelId?: string | null; + + /** MsgChannelCloseInit signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelCloseInit. */ + class MsgChannelCloseInit implements IMsgChannelCloseInit { + /** + * Constructs a new MsgChannelCloseInit. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelCloseInit); + + /** MsgChannelCloseInit portId. */ + public portId: string; + + /** MsgChannelCloseInit channelId. */ + public channelId: string; + + /** MsgChannelCloseInit signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelCloseInit instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelCloseInit instance + */ + public static create(properties?: ibc.channel.IMsgChannelCloseInit): ibc.channel.MsgChannelCloseInit; + + /** + * Encodes the specified MsgChannelCloseInit message. Does not implicitly {@link ibc.channel.MsgChannelCloseInit.verify|verify} messages. + * @param m MsgChannelCloseInit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelCloseInit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelCloseInit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelCloseInit + * @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): ibc.channel.MsgChannelCloseInit; + } + + /** Properties of a MsgChannelCloseConfirm. */ + interface IMsgChannelCloseConfirm { + /** MsgChannelCloseConfirm portId */ + portId?: string | null; + + /** MsgChannelCloseConfirm channelId */ + channelId?: string | null; + + /** MsgChannelCloseConfirm proofInit */ + proofInit?: Uint8Array | null; + + /** MsgChannelCloseConfirm proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelCloseConfirm signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelCloseConfirm. */ + class MsgChannelCloseConfirm implements IMsgChannelCloseConfirm { + /** + * Constructs a new MsgChannelCloseConfirm. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelCloseConfirm); + + /** MsgChannelCloseConfirm portId. */ + public portId: string; + + /** MsgChannelCloseConfirm channelId. */ + public channelId: string; + + /** MsgChannelCloseConfirm proofInit. */ + public proofInit: Uint8Array; + + /** MsgChannelCloseConfirm proofHeight. */ + public proofHeight: Long; + + /** MsgChannelCloseConfirm signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelCloseConfirm instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelCloseConfirm instance + */ + public static create( + properties?: ibc.channel.IMsgChannelCloseConfirm, + ): ibc.channel.MsgChannelCloseConfirm; + + /** + * Encodes the specified MsgChannelCloseConfirm message. Does not implicitly {@link ibc.channel.MsgChannelCloseConfirm.verify|verify} messages. + * @param m MsgChannelCloseConfirm message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelCloseConfirm, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelCloseConfirm message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelCloseConfirm + * @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): ibc.channel.MsgChannelCloseConfirm; + } + + /** Properties of a MsgRecvPacket. */ + interface IMsgRecvPacket { + /** MsgRecvPacket packet */ + packet?: ibc.channel.IPacket | null; + + /** MsgRecvPacket proof */ + proof?: Uint8Array | null; + + /** MsgRecvPacket proofHeight */ + proofHeight?: Long | null; + + /** MsgRecvPacket signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgRecvPacket. */ + class MsgRecvPacket implements IMsgRecvPacket { + /** + * Constructs a new MsgRecvPacket. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgRecvPacket); + + /** MsgRecvPacket packet. */ + public packet?: ibc.channel.IPacket | null; + + /** MsgRecvPacket proof. */ + public proof: Uint8Array; + + /** MsgRecvPacket proofHeight. */ + public proofHeight: Long; + + /** MsgRecvPacket signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgRecvPacket instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgRecvPacket instance + */ + public static create(properties?: ibc.channel.IMsgRecvPacket): ibc.channel.MsgRecvPacket; + + /** + * Encodes the specified MsgRecvPacket message. Does not implicitly {@link ibc.channel.MsgRecvPacket.verify|verify} messages. + * @param m MsgRecvPacket message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgRecvPacket, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgRecvPacket message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgRecvPacket + * @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): ibc.channel.MsgRecvPacket; + } + + /** Properties of a MsgTimeout. */ + interface IMsgTimeout { + /** MsgTimeout packet */ + packet?: ibc.channel.IPacket | null; + + /** MsgTimeout proof */ + proof?: Uint8Array | null; + + /** MsgTimeout proofHeight */ + proofHeight?: Long | null; + + /** MsgTimeout nextSequenceRecv */ + nextSequenceRecv?: Long | null; + + /** MsgTimeout signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgTimeout. */ + class MsgTimeout implements IMsgTimeout { + /** + * Constructs a new MsgTimeout. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgTimeout); + + /** MsgTimeout packet. */ + public packet?: ibc.channel.IPacket | null; + + /** MsgTimeout proof. */ + public proof: Uint8Array; + + /** MsgTimeout proofHeight. */ + public proofHeight: Long; + + /** MsgTimeout nextSequenceRecv. */ + public nextSequenceRecv: Long; + + /** MsgTimeout signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgTimeout instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgTimeout instance + */ + public static create(properties?: ibc.channel.IMsgTimeout): ibc.channel.MsgTimeout; + + /** + * Encodes the specified MsgTimeout message. Does not implicitly {@link ibc.channel.MsgTimeout.verify|verify} messages. + * @param m MsgTimeout message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgTimeout, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgTimeout message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgTimeout + * @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): ibc.channel.MsgTimeout; + } + + /** Properties of a MsgAcknowledgement. */ + interface IMsgAcknowledgement { + /** MsgAcknowledgement packet */ + packet?: ibc.channel.IPacket | null; + + /** MsgAcknowledgement acknowledgement */ + acknowledgement?: Uint8Array | null; + + /** MsgAcknowledgement proof */ + proof?: Uint8Array | null; + + /** MsgAcknowledgement proofHeight */ + proofHeight?: Long | null; + + /** MsgAcknowledgement signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgAcknowledgement. */ + class MsgAcknowledgement implements IMsgAcknowledgement { + /** + * Constructs a new MsgAcknowledgement. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgAcknowledgement); + + /** MsgAcknowledgement packet. */ + public packet?: ibc.channel.IPacket | null; + + /** MsgAcknowledgement acknowledgement. */ + public acknowledgement: Uint8Array; + + /** MsgAcknowledgement proof. */ + public proof: Uint8Array; + + /** MsgAcknowledgement proofHeight. */ + public proofHeight: Long; + + /** MsgAcknowledgement signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgAcknowledgement instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgAcknowledgement instance + */ + public static create(properties?: ibc.channel.IMsgAcknowledgement): ibc.channel.MsgAcknowledgement; + + /** + * Encodes the specified MsgAcknowledgement message. Does not implicitly {@link ibc.channel.MsgAcknowledgement.verify|verify} messages. + * @param m MsgAcknowledgement message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgAcknowledgement, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgAcknowledgement message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgAcknowledgement + * @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): ibc.channel.MsgAcknowledgement; + } + + /** Properties of a Channel. */ + interface IChannel { + /** Channel state */ + state?: ibc.channel.State | null; + + /** Channel ordering */ + ordering?: ibc.channel.Order | null; + + /** Channel counterparty */ + counterparty?: ibc.channel.ICounterparty | null; + + /** Channel connectionHops */ + connectionHops?: string[] | null; + + /** Channel version */ + version?: string | null; + } + + /** Represents a Channel. */ + class Channel implements IChannel { + /** + * Constructs a new Channel. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IChannel); + + /** Channel state. */ + public state: ibc.channel.State; + + /** Channel ordering. */ + public ordering: ibc.channel.Order; + + /** Channel counterparty. */ + public counterparty?: ibc.channel.ICounterparty | null; + + /** Channel connectionHops. */ + public connectionHops: string[]; + + /** Channel version. */ + public version: string; + + /** + * Creates a new Channel instance using the specified properties. + * @param [properties] Properties to set + * @returns Channel instance + */ + public static create(properties?: ibc.channel.IChannel): ibc.channel.Channel; + + /** + * Encodes the specified Channel message. Does not implicitly {@link ibc.channel.Channel.verify|verify} messages. + * @param m Channel message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IChannel, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Channel message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Channel + * @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): ibc.channel.Channel; + } + + /** Properties of an IdentifiedChannel. */ + interface IIdentifiedChannel { + /** IdentifiedChannel state */ + state?: ibc.channel.State | null; + + /** IdentifiedChannel ordering */ + ordering?: ibc.channel.Order | null; + + /** IdentifiedChannel counterparty */ + counterparty?: ibc.channel.ICounterparty | null; + + /** IdentifiedChannel connectionHops */ + connectionHops?: string[] | null; + + /** IdentifiedChannel version */ + version?: string | null; + + /** IdentifiedChannel portId */ + portId?: string | null; + + /** IdentifiedChannel channelId */ + channelId?: string | null; + } + + /** Represents an IdentifiedChannel. */ + class IdentifiedChannel implements IIdentifiedChannel { + /** + * Constructs a new IdentifiedChannel. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IIdentifiedChannel); + + /** IdentifiedChannel state. */ + public state: ibc.channel.State; + + /** IdentifiedChannel ordering. */ + public ordering: ibc.channel.Order; + + /** IdentifiedChannel counterparty. */ + public counterparty?: ibc.channel.ICounterparty | null; + + /** IdentifiedChannel connectionHops. */ + public connectionHops: string[]; + + /** IdentifiedChannel version. */ + public version: string; + + /** IdentifiedChannel portId. */ + public portId: string; + + /** IdentifiedChannel channelId. */ + public channelId: string; + + /** + * Creates a new IdentifiedChannel instance using the specified properties. + * @param [properties] Properties to set + * @returns IdentifiedChannel instance + */ + public static create(properties?: ibc.channel.IIdentifiedChannel): ibc.channel.IdentifiedChannel; + + /** + * Encodes the specified IdentifiedChannel message. Does not implicitly {@link ibc.channel.IdentifiedChannel.verify|verify} messages. + * @param m IdentifiedChannel message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IIdentifiedChannel, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IdentifiedChannel message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns IdentifiedChannel + * @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): ibc.channel.IdentifiedChannel; + } + + /** State enum. */ + enum State { + STATE_UNINITIALIZED_UNSPECIFIED = 0, + STATE_INIT = 1, + STATE_TRYOPEN = 2, + STATE_OPEN = 3, + STATE_CLOSED = 4, + } + + /** Order enum. */ + enum Order { + ORDER_NONE_UNSPECIFIED = 0, + ORDER_UNORDERED = 1, + ORDER_ORDERED = 2, + } + + /** Properties of a Counterparty. */ + interface ICounterparty { + /** Counterparty portId */ + portId?: string | null; + + /** Counterparty channelId */ + channelId?: string | null; + } + + /** Represents a Counterparty. */ + class Counterparty implements ICounterparty { + /** + * Constructs a new Counterparty. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.ICounterparty); + + /** Counterparty portId. */ + public portId: string; + + /** Counterparty channelId. */ + public channelId: string; + + /** + * Creates a new Counterparty instance using the specified properties. + * @param [properties] Properties to set + * @returns Counterparty instance + */ + public static create(properties?: ibc.channel.ICounterparty): ibc.channel.Counterparty; + + /** + * Encodes the specified Counterparty message. Does not implicitly {@link ibc.channel.Counterparty.verify|verify} messages. + * @param m Counterparty message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.ICounterparty, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Counterparty message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Counterparty + * @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): ibc.channel.Counterparty; + } + + /** Properties of a Packet. */ + interface IPacket { + /** Packet sequence */ + sequence?: Long | null; + + /** Packet sourcePort */ + sourcePort?: string | null; + + /** Packet sourceChannel */ + sourceChannel?: string | null; + + /** Packet destinationPort */ + destinationPort?: string | null; + + /** Packet destinationChannel */ + destinationChannel?: string | null; + + /** Packet data */ + data?: Uint8Array | null; + + /** Packet timeoutHeight */ + timeoutHeight?: Long | null; + + /** Packet timeoutTimestamp */ + timeoutTimestamp?: Long | null; + } + + /** Represents a Packet. */ + class Packet implements IPacket { + /** + * Constructs a new Packet. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IPacket); + + /** Packet sequence. */ + public sequence: Long; + + /** Packet sourcePort. */ + public sourcePort: string; + + /** Packet sourceChannel. */ + public sourceChannel: string; + + /** Packet destinationPort. */ + public destinationPort: string; + + /** Packet destinationChannel. */ + public destinationChannel: string; + + /** Packet data. */ + public data: Uint8Array; + + /** Packet timeoutHeight. */ + public timeoutHeight: Long; + + /** Packet timeoutTimestamp. */ + public timeoutTimestamp: Long; + + /** + * Creates a new Packet instance using the specified properties. + * @param [properties] Properties to set + * @returns Packet instance + */ + public static create(properties?: ibc.channel.IPacket): ibc.channel.Packet; + + /** + * Encodes the specified Packet message. Does not implicitly {@link ibc.channel.Packet.verify|verify} messages. + * @param m Packet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IPacket, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Packet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Packet + * @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): ibc.channel.Packet; + } + + /** Properties of a PacketAckCommitment. */ + interface IPacketAckCommitment { + /** PacketAckCommitment portId */ + portId?: string | null; + + /** PacketAckCommitment channelId */ + channelId?: string | null; + + /** PacketAckCommitment sequence */ + sequence?: Long | null; + + /** PacketAckCommitment hash */ + hash?: Uint8Array | null; + } + + /** Represents a PacketAckCommitment. */ + class PacketAckCommitment implements IPacketAckCommitment { + /** + * Constructs a new PacketAckCommitment. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IPacketAckCommitment); + + /** PacketAckCommitment portId. */ + public portId: string; + + /** PacketAckCommitment channelId. */ + public channelId: string; + + /** PacketAckCommitment sequence. */ + public sequence: Long; + + /** PacketAckCommitment hash. */ + public hash: Uint8Array; + + /** + * Creates a new PacketAckCommitment instance using the specified properties. + * @param [properties] Properties to set + * @returns PacketAckCommitment instance + */ + public static create(properties?: ibc.channel.IPacketAckCommitment): ibc.channel.PacketAckCommitment; + + /** + * Encodes the specified PacketAckCommitment message. Does not implicitly {@link ibc.channel.PacketAckCommitment.verify|verify} messages. + * @param m PacketAckCommitment message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IPacketAckCommitment, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PacketAckCommitment message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PacketAckCommitment + * @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): ibc.channel.PacketAckCommitment; + } + + /** Represents a Query */ + class Query extends $protobuf.rpc.Service { + /** + * Constructs a new Query service. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + */ + constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean); + + /** + * Creates new Query service using the specified rpc implementation. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + * @returns RPC service. Useful where requests and/or responses are streamed. + */ + public static create( + rpcImpl: $protobuf.RPCImpl, + requestDelimited?: boolean, + responseDelimited?: boolean, + ): Query; + + /** + * Calls Channel. + * @param request QueryChannelRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryChannelResponse + */ + public channel( + request: ibc.channel.IQueryChannelRequest, + callback: ibc.channel.Query.ChannelCallback, + ): void; + + /** + * Calls Channel. + * @param request QueryChannelRequest message or plain object + * @returns Promise + */ + public channel(request: ibc.channel.IQueryChannelRequest): Promise; + + /** + * Calls Channels. + * @param request QueryChannelsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryChannelsResponse + */ + public channels( + request: ibc.channel.IQueryChannelsRequest, + callback: ibc.channel.Query.ChannelsCallback, + ): void; + + /** + * Calls Channels. + * @param request QueryChannelsRequest message or plain object + * @returns Promise + */ + public channels(request: ibc.channel.IQueryChannelsRequest): Promise; + + /** + * Calls ConnectionChannels. + * @param request QueryConnectionChannelsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryConnectionChannelsResponse + */ + public connectionChannels( + request: ibc.channel.IQueryConnectionChannelsRequest, + callback: ibc.channel.Query.ConnectionChannelsCallback, + ): void; + + /** + * Calls ConnectionChannels. + * @param request QueryConnectionChannelsRequest message or plain object + * @returns Promise + */ + public connectionChannels( + request: ibc.channel.IQueryConnectionChannelsRequest, + ): Promise; + + /** + * Calls PacketCommitment. + * @param request QueryPacketCommitmentRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryPacketCommitmentResponse + */ + public packetCommitment( + request: ibc.channel.IQueryPacketCommitmentRequest, + callback: ibc.channel.Query.PacketCommitmentCallback, + ): void; + + /** + * Calls PacketCommitment. + * @param request QueryPacketCommitmentRequest message or plain object + * @returns Promise + */ + public packetCommitment( + request: ibc.channel.IQueryPacketCommitmentRequest, + ): Promise; + + /** + * Calls PacketCommitments. + * @param request QueryPacketCommitmentsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryPacketCommitmentsResponse + */ + public packetCommitments( + request: ibc.channel.IQueryPacketCommitmentsRequest, + callback: ibc.channel.Query.PacketCommitmentsCallback, + ): void; + + /** + * Calls PacketCommitments. + * @param request QueryPacketCommitmentsRequest message or plain object + * @returns Promise + */ + public packetCommitments( + request: ibc.channel.IQueryPacketCommitmentsRequest, + ): Promise; + + /** + * Calls PacketAcknowledgement. + * @param request QueryPacketAcknowledgementRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryPacketAcknowledgementResponse + */ + public packetAcknowledgement( + request: ibc.channel.IQueryPacketAcknowledgementRequest, + callback: ibc.channel.Query.PacketAcknowledgementCallback, + ): void; + + /** + * Calls PacketAcknowledgement. + * @param request QueryPacketAcknowledgementRequest message or plain object + * @returns Promise + */ + public packetAcknowledgement( + request: ibc.channel.IQueryPacketAcknowledgementRequest, + ): Promise; + + /** + * Calls UnrelayedPackets. + * @param request QueryUnrelayedPacketsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryUnrelayedPacketsResponse + */ + public unrelayedPackets( + request: ibc.channel.IQueryUnrelayedPacketsRequest, + callback: ibc.channel.Query.UnrelayedPacketsCallback, + ): void; + + /** + * Calls UnrelayedPackets. + * @param request QueryUnrelayedPacketsRequest message or plain object + * @returns Promise + */ + public unrelayedPackets( + request: ibc.channel.IQueryUnrelayedPacketsRequest, + ): Promise; + + /** + * Calls NextSequenceReceive. + * @param request QueryNextSequenceReceiveRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryNextSequenceReceiveResponse + */ + public nextSequenceReceive( + request: ibc.channel.IQueryNextSequenceReceiveRequest, + callback: ibc.channel.Query.NextSequenceReceiveCallback, + ): void; + + /** + * Calls NextSequenceReceive. + * @param request QueryNextSequenceReceiveRequest message or plain object + * @returns Promise + */ + public nextSequenceReceive( + request: ibc.channel.IQueryNextSequenceReceiveRequest, + ): Promise; + } + + namespace Query { + /** + * Callback as used by {@link ibc.channel.Query#channel}. + * @param error Error, if any + * @param [response] QueryChannelResponse + */ + type ChannelCallback = (error: Error | null, response?: ibc.channel.QueryChannelResponse) => void; + + /** + * Callback as used by {@link ibc.channel.Query#channels}. + * @param error Error, if any + * @param [response] QueryChannelsResponse + */ + type ChannelsCallback = (error: Error | null, response?: ibc.channel.QueryChannelsResponse) => void; + + /** + * Callback as used by {@link ibc.channel.Query#connectionChannels}. + * @param error Error, if any + * @param [response] QueryConnectionChannelsResponse + */ + type ConnectionChannelsCallback = ( + error: Error | null, + response?: ibc.channel.QueryConnectionChannelsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#packetCommitment}. + * @param error Error, if any + * @param [response] QueryPacketCommitmentResponse + */ + type PacketCommitmentCallback = ( + error: Error | null, + response?: ibc.channel.QueryPacketCommitmentResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#packetCommitments}. + * @param error Error, if any + * @param [response] QueryPacketCommitmentsResponse + */ + type PacketCommitmentsCallback = ( + error: Error | null, + response?: ibc.channel.QueryPacketCommitmentsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#packetAcknowledgement}. + * @param error Error, if any + * @param [response] QueryPacketAcknowledgementResponse + */ + type PacketAcknowledgementCallback = ( + error: Error | null, + response?: ibc.channel.QueryPacketAcknowledgementResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#unrelayedPackets}. + * @param error Error, if any + * @param [response] QueryUnrelayedPacketsResponse + */ + type UnrelayedPacketsCallback = ( + error: Error | null, + response?: ibc.channel.QueryUnrelayedPacketsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#nextSequenceReceive}. + * @param error Error, if any + * @param [response] QueryNextSequenceReceiveResponse + */ + type NextSequenceReceiveCallback = ( + error: Error | null, + response?: ibc.channel.QueryNextSequenceReceiveResponse, + ) => void; + } + + /** Properties of a QueryChannelRequest. */ + interface IQueryChannelRequest { + /** QueryChannelRequest portId */ + portId?: string | null; + + /** QueryChannelRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryChannelRequest. */ + class QueryChannelRequest implements IQueryChannelRequest { + /** + * Constructs a new QueryChannelRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelRequest); + + /** QueryChannelRequest portId. */ + public portId: string; + + /** QueryChannelRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryChannelRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelRequest instance + */ + public static create(properties?: ibc.channel.IQueryChannelRequest): ibc.channel.QueryChannelRequest; + + /** + * Encodes the specified QueryChannelRequest message. Does not implicitly {@link ibc.channel.QueryChannelRequest.verify|verify} messages. + * @param m QueryChannelRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelRequest, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelRequest + * @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): ibc.channel.QueryChannelRequest; + } + + /** Properties of a QueryChannelResponse. */ + interface IQueryChannelResponse { + /** QueryChannelResponse channel */ + channel?: ibc.channel.IChannel | null; + + /** QueryChannelResponse proof */ + proof?: Uint8Array | null; + + /** QueryChannelResponse proofPath */ + proofPath?: string | null; + + /** QueryChannelResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryChannelResponse. */ + class QueryChannelResponse implements IQueryChannelResponse { + /** + * Constructs a new QueryChannelResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelResponse); + + /** QueryChannelResponse channel. */ + public channel?: ibc.channel.IChannel | null; + + /** QueryChannelResponse proof. */ + public proof: Uint8Array; + + /** QueryChannelResponse proofPath. */ + public proofPath: string; + + /** QueryChannelResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryChannelResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelResponse instance + */ + public static create(properties?: ibc.channel.IQueryChannelResponse): ibc.channel.QueryChannelResponse; + + /** + * Encodes the specified QueryChannelResponse message. Does not implicitly {@link ibc.channel.QueryChannelResponse.verify|verify} messages. + * @param m QueryChannelResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelResponse, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelResponse + * @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): ibc.channel.QueryChannelResponse; + } + + /** Properties of a QueryChannelsRequest. */ + interface IQueryChannelsRequest { + /** QueryChannelsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryChannelsRequest. */ + class QueryChannelsRequest implements IQueryChannelsRequest { + /** + * Constructs a new QueryChannelsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelsRequest); + + /** QueryChannelsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryChannelsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelsRequest instance + */ + public static create(properties?: ibc.channel.IQueryChannelsRequest): ibc.channel.QueryChannelsRequest; + + /** + * Encodes the specified QueryChannelsRequest message. Does not implicitly {@link ibc.channel.QueryChannelsRequest.verify|verify} messages. + * @param m QueryChannelsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelsRequest, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelsRequest + * @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): ibc.channel.QueryChannelsRequest; + } + + /** Properties of a QueryChannelsResponse. */ + interface IQueryChannelsResponse { + /** QueryChannelsResponse channels */ + channels?: ibc.channel.IIdentifiedChannel[] | null; + + /** QueryChannelsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryChannelsResponse height */ + height?: Long | null; + } + + /** Represents a QueryChannelsResponse. */ + class QueryChannelsResponse implements IQueryChannelsResponse { + /** + * Constructs a new QueryChannelsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelsResponse); + + /** QueryChannelsResponse channels. */ + public channels: ibc.channel.IIdentifiedChannel[]; + + /** QueryChannelsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryChannelsResponse height. */ + public height: Long; + + /** + * Creates a new QueryChannelsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryChannelsResponse, + ): ibc.channel.QueryChannelsResponse; + + /** + * Encodes the specified QueryChannelsResponse message. Does not implicitly {@link ibc.channel.QueryChannelsResponse.verify|verify} messages. + * @param m QueryChannelsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelsResponse, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelsResponse + * @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): ibc.channel.QueryChannelsResponse; + } + + /** Properties of a QueryConnectionChannelsRequest. */ + interface IQueryConnectionChannelsRequest { + /** QueryConnectionChannelsRequest connection */ + connection?: string | null; + + /** QueryConnectionChannelsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryConnectionChannelsRequest. */ + class QueryConnectionChannelsRequest implements IQueryConnectionChannelsRequest { + /** + * Constructs a new QueryConnectionChannelsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryConnectionChannelsRequest); + + /** QueryConnectionChannelsRequest connection. */ + public connection: string; + + /** QueryConnectionChannelsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryConnectionChannelsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionChannelsRequest instance + */ + public static create( + properties?: ibc.channel.IQueryConnectionChannelsRequest, + ): ibc.channel.QueryConnectionChannelsRequest; + + /** + * Encodes the specified QueryConnectionChannelsRequest message. Does not implicitly {@link ibc.channel.QueryConnectionChannelsRequest.verify|verify} messages. + * @param m QueryConnectionChannelsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryConnectionChannelsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionChannelsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionChannelsRequest + * @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, + ): ibc.channel.QueryConnectionChannelsRequest; + } + + /** Properties of a QueryConnectionChannelsResponse. */ + interface IQueryConnectionChannelsResponse { + /** QueryConnectionChannelsResponse channels */ + channels?: ibc.channel.IIdentifiedChannel[] | null; + + /** QueryConnectionChannelsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionChannelsResponse height */ + height?: Long | null; + } + + /** Represents a QueryConnectionChannelsResponse. */ + class QueryConnectionChannelsResponse implements IQueryConnectionChannelsResponse { + /** + * Constructs a new QueryConnectionChannelsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryConnectionChannelsResponse); + + /** QueryConnectionChannelsResponse channels. */ + public channels: ibc.channel.IIdentifiedChannel[]; + + /** QueryConnectionChannelsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionChannelsResponse height. */ + public height: Long; + + /** + * Creates a new QueryConnectionChannelsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionChannelsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryConnectionChannelsResponse, + ): ibc.channel.QueryConnectionChannelsResponse; + + /** + * Encodes the specified QueryConnectionChannelsResponse message. Does not implicitly {@link ibc.channel.QueryConnectionChannelsResponse.verify|verify} messages. + * @param m QueryConnectionChannelsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryConnectionChannelsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionChannelsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionChannelsResponse + * @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, + ): ibc.channel.QueryConnectionChannelsResponse; + } + + /** Properties of a QueryPacketCommitmentRequest. */ + interface IQueryPacketCommitmentRequest { + /** QueryPacketCommitmentRequest portId */ + portId?: string | null; + + /** QueryPacketCommitmentRequest channelId */ + channelId?: string | null; + + /** QueryPacketCommitmentRequest sequence */ + sequence?: Long | null; + } + + /** Represents a QueryPacketCommitmentRequest. */ + class QueryPacketCommitmentRequest implements IQueryPacketCommitmentRequest { + /** + * Constructs a new QueryPacketCommitmentRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentRequest); + + /** QueryPacketCommitmentRequest portId. */ + public portId: string; + + /** QueryPacketCommitmentRequest channelId. */ + public channelId: string; + + /** QueryPacketCommitmentRequest sequence. */ + public sequence: Long; + + /** + * Creates a new QueryPacketCommitmentRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentRequest instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentRequest, + ): ibc.channel.QueryPacketCommitmentRequest; + + /** + * Encodes the specified QueryPacketCommitmentRequest message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentRequest.verify|verify} messages. + * @param m QueryPacketCommitmentRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentRequest + * @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, + ): ibc.channel.QueryPacketCommitmentRequest; + } + + /** Properties of a QueryPacketCommitmentResponse. */ + interface IQueryPacketCommitmentResponse { + /** QueryPacketCommitmentResponse commitment */ + commitment?: Uint8Array | null; + + /** QueryPacketCommitmentResponse proof */ + proof?: Uint8Array | null; + + /** QueryPacketCommitmentResponse proofPath */ + proofPath?: string | null; + + /** QueryPacketCommitmentResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryPacketCommitmentResponse. */ + class QueryPacketCommitmentResponse implements IQueryPacketCommitmentResponse { + /** + * Constructs a new QueryPacketCommitmentResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentResponse); + + /** QueryPacketCommitmentResponse commitment. */ + public commitment: Uint8Array; + + /** QueryPacketCommitmentResponse proof. */ + public proof: Uint8Array; + + /** QueryPacketCommitmentResponse proofPath. */ + public proofPath: string; + + /** QueryPacketCommitmentResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryPacketCommitmentResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentResponse instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentResponse, + ): ibc.channel.QueryPacketCommitmentResponse; + + /** + * Encodes the specified QueryPacketCommitmentResponse message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentResponse.verify|verify} messages. + * @param m QueryPacketCommitmentResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentResponse + * @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, + ): ibc.channel.QueryPacketCommitmentResponse; + } + + /** Properties of a QueryPacketCommitmentsRequest. */ + interface IQueryPacketCommitmentsRequest { + /** QueryPacketCommitmentsRequest portId */ + portId?: string | null; + + /** QueryPacketCommitmentsRequest channelId */ + channelId?: string | null; + + /** QueryPacketCommitmentsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryPacketCommitmentsRequest. */ + class QueryPacketCommitmentsRequest implements IQueryPacketCommitmentsRequest { + /** + * Constructs a new QueryPacketCommitmentsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentsRequest); + + /** QueryPacketCommitmentsRequest portId. */ + public portId: string; + + /** QueryPacketCommitmentsRequest channelId. */ + public channelId: string; + + /** QueryPacketCommitmentsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryPacketCommitmentsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentsRequest instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentsRequest, + ): ibc.channel.QueryPacketCommitmentsRequest; + + /** + * Encodes the specified QueryPacketCommitmentsRequest message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentsRequest.verify|verify} messages. + * @param m QueryPacketCommitmentsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentsRequest + * @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, + ): ibc.channel.QueryPacketCommitmentsRequest; + } + + /** Properties of a QueryPacketCommitmentsResponse. */ + interface IQueryPacketCommitmentsResponse { + /** QueryPacketCommitmentsResponse commitments */ + commitments?: ibc.channel.IPacketAckCommitment[] | null; + + /** QueryPacketCommitmentsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryPacketCommitmentsResponse height */ + height?: Long | null; + } + + /** Represents a QueryPacketCommitmentsResponse. */ + class QueryPacketCommitmentsResponse implements IQueryPacketCommitmentsResponse { + /** + * Constructs a new QueryPacketCommitmentsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentsResponse); + + /** QueryPacketCommitmentsResponse commitments. */ + public commitments: ibc.channel.IPacketAckCommitment[]; + + /** QueryPacketCommitmentsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryPacketCommitmentsResponse height. */ + public height: Long; + + /** + * Creates a new QueryPacketCommitmentsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentsResponse, + ): ibc.channel.QueryPacketCommitmentsResponse; + + /** + * Encodes the specified QueryPacketCommitmentsResponse message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentsResponse.verify|verify} messages. + * @param m QueryPacketCommitmentsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentsResponse + * @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, + ): ibc.channel.QueryPacketCommitmentsResponse; + } + + /** Properties of a QueryPacketAcknowledgementRequest. */ + interface IQueryPacketAcknowledgementRequest { + /** QueryPacketAcknowledgementRequest portId */ + portId?: string | null; + + /** QueryPacketAcknowledgementRequest channelId */ + channelId?: string | null; + + /** QueryPacketAcknowledgementRequest sequence */ + sequence?: Long | null; + } + + /** Represents a QueryPacketAcknowledgementRequest. */ + class QueryPacketAcknowledgementRequest implements IQueryPacketAcknowledgementRequest { + /** + * Constructs a new QueryPacketAcknowledgementRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketAcknowledgementRequest); + + /** QueryPacketAcknowledgementRequest portId. */ + public portId: string; + + /** QueryPacketAcknowledgementRequest channelId. */ + public channelId: string; + + /** QueryPacketAcknowledgementRequest sequence. */ + public sequence: Long; + + /** + * Creates a new QueryPacketAcknowledgementRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketAcknowledgementRequest instance + */ + public static create( + properties?: ibc.channel.IQueryPacketAcknowledgementRequest, + ): ibc.channel.QueryPacketAcknowledgementRequest; + + /** + * Encodes the specified QueryPacketAcknowledgementRequest message. Does not implicitly {@link ibc.channel.QueryPacketAcknowledgementRequest.verify|verify} messages. + * @param m QueryPacketAcknowledgementRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketAcknowledgementRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketAcknowledgementRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketAcknowledgementRequest + * @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, + ): ibc.channel.QueryPacketAcknowledgementRequest; + } + + /** Properties of a QueryPacketAcknowledgementResponse. */ + interface IQueryPacketAcknowledgementResponse { + /** QueryPacketAcknowledgementResponse acknowledgement */ + acknowledgement?: Uint8Array | null; + + /** QueryPacketAcknowledgementResponse proof */ + proof?: Uint8Array | null; + + /** QueryPacketAcknowledgementResponse proofPath */ + proofPath?: string | null; + + /** QueryPacketAcknowledgementResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryPacketAcknowledgementResponse. */ + class QueryPacketAcknowledgementResponse implements IQueryPacketAcknowledgementResponse { + /** + * Constructs a new QueryPacketAcknowledgementResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketAcknowledgementResponse); + + /** QueryPacketAcknowledgementResponse acknowledgement. */ + public acknowledgement: Uint8Array; + + /** QueryPacketAcknowledgementResponse proof. */ + public proof: Uint8Array; + + /** QueryPacketAcknowledgementResponse proofPath. */ + public proofPath: string; + + /** QueryPacketAcknowledgementResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryPacketAcknowledgementResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketAcknowledgementResponse instance + */ + public static create( + properties?: ibc.channel.IQueryPacketAcknowledgementResponse, + ): ibc.channel.QueryPacketAcknowledgementResponse; + + /** + * Encodes the specified QueryPacketAcknowledgementResponse message. Does not implicitly {@link ibc.channel.QueryPacketAcknowledgementResponse.verify|verify} messages. + * @param m QueryPacketAcknowledgementResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketAcknowledgementResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketAcknowledgementResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketAcknowledgementResponse + * @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, + ): ibc.channel.QueryPacketAcknowledgementResponse; + } + + /** Properties of a QueryUnrelayedPacketsRequest. */ + interface IQueryUnrelayedPacketsRequest { + /** QueryUnrelayedPacketsRequest portId */ + portId?: string | null; + + /** QueryUnrelayedPacketsRequest channelId */ + channelId?: string | null; + + /** QueryUnrelayedPacketsRequest packetCommitmentSequences */ + packetCommitmentSequences?: Long[] | null; + + /** QueryUnrelayedPacketsRequest acknowledgements */ + acknowledgements?: boolean | null; + } + + /** Represents a QueryUnrelayedPacketsRequest. */ + class QueryUnrelayedPacketsRequest implements IQueryUnrelayedPacketsRequest { + /** + * Constructs a new QueryUnrelayedPacketsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryUnrelayedPacketsRequest); + + /** QueryUnrelayedPacketsRequest portId. */ + public portId: string; + + /** QueryUnrelayedPacketsRequest channelId. */ + public channelId: string; + + /** QueryUnrelayedPacketsRequest packetCommitmentSequences. */ + public packetCommitmentSequences: Long[]; + + /** QueryUnrelayedPacketsRequest acknowledgements. */ + public acknowledgements: boolean; + + /** + * Creates a new QueryUnrelayedPacketsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryUnrelayedPacketsRequest instance + */ + public static create( + properties?: ibc.channel.IQueryUnrelayedPacketsRequest, + ): ibc.channel.QueryUnrelayedPacketsRequest; + + /** + * Encodes the specified QueryUnrelayedPacketsRequest message. Does not implicitly {@link ibc.channel.QueryUnrelayedPacketsRequest.verify|verify} messages. + * @param m QueryUnrelayedPacketsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryUnrelayedPacketsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryUnrelayedPacketsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryUnrelayedPacketsRequest + * @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, + ): ibc.channel.QueryUnrelayedPacketsRequest; + } + + /** Properties of a QueryUnrelayedPacketsResponse. */ + interface IQueryUnrelayedPacketsResponse { + /** QueryUnrelayedPacketsResponse sequences */ + sequences?: Long[] | null; + + /** QueryUnrelayedPacketsResponse height */ + height?: Long | null; + } + + /** Represents a QueryUnrelayedPacketsResponse. */ + class QueryUnrelayedPacketsResponse implements IQueryUnrelayedPacketsResponse { + /** + * Constructs a new QueryUnrelayedPacketsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryUnrelayedPacketsResponse); + + /** QueryUnrelayedPacketsResponse sequences. */ + public sequences: Long[]; + + /** QueryUnrelayedPacketsResponse height. */ + public height: Long; + + /** + * Creates a new QueryUnrelayedPacketsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryUnrelayedPacketsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryUnrelayedPacketsResponse, + ): ibc.channel.QueryUnrelayedPacketsResponse; + + /** + * Encodes the specified QueryUnrelayedPacketsResponse message. Does not implicitly {@link ibc.channel.QueryUnrelayedPacketsResponse.verify|verify} messages. + * @param m QueryUnrelayedPacketsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryUnrelayedPacketsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryUnrelayedPacketsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryUnrelayedPacketsResponse + * @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, + ): ibc.channel.QueryUnrelayedPacketsResponse; + } + + /** Properties of a QueryNextSequenceReceiveRequest. */ + interface IQueryNextSequenceReceiveRequest { + /** QueryNextSequenceReceiveRequest portId */ + portId?: string | null; + + /** QueryNextSequenceReceiveRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryNextSequenceReceiveRequest. */ + class QueryNextSequenceReceiveRequest implements IQueryNextSequenceReceiveRequest { + /** + * Constructs a new QueryNextSequenceReceiveRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryNextSequenceReceiveRequest); + + /** QueryNextSequenceReceiveRequest portId. */ + public portId: string; + + /** QueryNextSequenceReceiveRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryNextSequenceReceiveRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryNextSequenceReceiveRequest instance + */ + public static create( + properties?: ibc.channel.IQueryNextSequenceReceiveRequest, + ): ibc.channel.QueryNextSequenceReceiveRequest; + + /** + * Encodes the specified QueryNextSequenceReceiveRequest message. Does not implicitly {@link ibc.channel.QueryNextSequenceReceiveRequest.verify|verify} messages. + * @param m QueryNextSequenceReceiveRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryNextSequenceReceiveRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryNextSequenceReceiveRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryNextSequenceReceiveRequest + * @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, + ): ibc.channel.QueryNextSequenceReceiveRequest; + } + + /** Properties of a QueryNextSequenceReceiveResponse. */ + interface IQueryNextSequenceReceiveResponse { + /** QueryNextSequenceReceiveResponse nextSequenceReceive */ + nextSequenceReceive?: Long | null; + + /** QueryNextSequenceReceiveResponse proof */ + proof?: Uint8Array | null; + + /** QueryNextSequenceReceiveResponse proofPath */ + proofPath?: string | null; + + /** QueryNextSequenceReceiveResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryNextSequenceReceiveResponse. */ + class QueryNextSequenceReceiveResponse implements IQueryNextSequenceReceiveResponse { + /** + * Constructs a new QueryNextSequenceReceiveResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryNextSequenceReceiveResponse); + + /** QueryNextSequenceReceiveResponse nextSequenceReceive. */ + public nextSequenceReceive: Long; + + /** QueryNextSequenceReceiveResponse proof. */ + public proof: Uint8Array; + + /** QueryNextSequenceReceiveResponse proofPath. */ + public proofPath: string; + + /** QueryNextSequenceReceiveResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryNextSequenceReceiveResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryNextSequenceReceiveResponse instance + */ + public static create( + properties?: ibc.channel.IQueryNextSequenceReceiveResponse, + ): ibc.channel.QueryNextSequenceReceiveResponse; + + /** + * Encodes the specified QueryNextSequenceReceiveResponse message. Does not implicitly {@link ibc.channel.QueryNextSequenceReceiveResponse.verify|verify} messages. + * @param m QueryNextSequenceReceiveResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryNextSequenceReceiveResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryNextSequenceReceiveResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryNextSequenceReceiveResponse + * @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, + ): ibc.channel.QueryNextSequenceReceiveResponse; + } + + /** Properties of a QueryChannelClientStateRequest. */ + interface IQueryChannelClientStateRequest { + /** QueryChannelClientStateRequest portId */ + portId?: string | null; + + /** QueryChannelClientStateRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryChannelClientStateRequest. */ + class QueryChannelClientStateRequest implements IQueryChannelClientStateRequest { + /** + * Constructs a new QueryChannelClientStateRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelClientStateRequest); + + /** QueryChannelClientStateRequest portId. */ + public portId: string; + + /** QueryChannelClientStateRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryChannelClientStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelClientStateRequest instance + */ + public static create( + properties?: ibc.channel.IQueryChannelClientStateRequest, + ): ibc.channel.QueryChannelClientStateRequest; + + /** + * Encodes the specified QueryChannelClientStateRequest message. Does not implicitly {@link ibc.channel.QueryChannelClientStateRequest.verify|verify} messages. + * @param m QueryChannelClientStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryChannelClientStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryChannelClientStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelClientStateRequest + * @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, + ): ibc.channel.QueryChannelClientStateRequest; + } + + /** Properties of a QueryChannelConsensusStateRequest. */ + interface IQueryChannelConsensusStateRequest { + /** QueryChannelConsensusStateRequest portId */ + portId?: string | null; + + /** QueryChannelConsensusStateRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryChannelConsensusStateRequest. */ + class QueryChannelConsensusStateRequest implements IQueryChannelConsensusStateRequest { + /** + * Constructs a new QueryChannelConsensusStateRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelConsensusStateRequest); + + /** QueryChannelConsensusStateRequest portId. */ + public portId: string; + + /** QueryChannelConsensusStateRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryChannelConsensusStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelConsensusStateRequest instance + */ + public static create( + properties?: ibc.channel.IQueryChannelConsensusStateRequest, + ): ibc.channel.QueryChannelConsensusStateRequest; + + /** + * Encodes the specified QueryChannelConsensusStateRequest message. Does not implicitly {@link ibc.channel.QueryChannelConsensusStateRequest.verify|verify} messages. + * @param m QueryChannelConsensusStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryChannelConsensusStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryChannelConsensusStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelConsensusStateRequest + * @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, + ): ibc.channel.QueryChannelConsensusStateRequest; + } + } + + /** Namespace commitment. */ + namespace commitment { + /** Properties of a MerkleRoot. */ + interface IMerkleRoot { + /** MerkleRoot hash */ + hash?: Uint8Array | null; + } + + /** Represents a MerkleRoot. */ + class MerkleRoot implements IMerkleRoot { + /** + * Constructs a new MerkleRoot. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerkleRoot); + + /** MerkleRoot hash. */ + public hash: Uint8Array; + + /** + * Creates a new MerkleRoot instance using the specified properties. + * @param [properties] Properties to set + * @returns MerkleRoot instance + */ + public static create(properties?: ibc.commitment.IMerkleRoot): ibc.commitment.MerkleRoot; + + /** + * Encodes the specified MerkleRoot message. Does not implicitly {@link ibc.commitment.MerkleRoot.verify|verify} messages. + * @param m MerkleRoot message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerkleRoot, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerkleRoot message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerkleRoot + * @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): ibc.commitment.MerkleRoot; + } + + /** Properties of a MerklePrefix. */ + interface IMerklePrefix { + /** MerklePrefix keyPrefix */ + keyPrefix?: Uint8Array | null; + } + + /** Represents a MerklePrefix. */ + class MerklePrefix implements IMerklePrefix { + /** + * Constructs a new MerklePrefix. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerklePrefix); + + /** MerklePrefix keyPrefix. */ + public keyPrefix: Uint8Array; + + /** + * Creates a new MerklePrefix instance using the specified properties. + * @param [properties] Properties to set + * @returns MerklePrefix instance + */ + public static create(properties?: ibc.commitment.IMerklePrefix): ibc.commitment.MerklePrefix; + + /** + * Encodes the specified MerklePrefix message. Does not implicitly {@link ibc.commitment.MerklePrefix.verify|verify} messages. + * @param m MerklePrefix message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerklePrefix, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerklePrefix message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerklePrefix + * @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): ibc.commitment.MerklePrefix; + } + + /** Properties of a MerklePath. */ + interface IMerklePath { + /** MerklePath keyPath */ + keyPath?: ibc.commitment.IKeyPath | null; + } + + /** Represents a MerklePath. */ + class MerklePath implements IMerklePath { + /** + * Constructs a new MerklePath. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerklePath); + + /** MerklePath keyPath. */ + public keyPath?: ibc.commitment.IKeyPath | null; + + /** + * Creates a new MerklePath instance using the specified properties. + * @param [properties] Properties to set + * @returns MerklePath instance + */ + public static create(properties?: ibc.commitment.IMerklePath): ibc.commitment.MerklePath; + + /** + * Encodes the specified MerklePath message. Does not implicitly {@link ibc.commitment.MerklePath.verify|verify} messages. + * @param m MerklePath message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerklePath, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerklePath message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerklePath + * @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): ibc.commitment.MerklePath; + } + + /** Properties of a MerkleProof. */ + interface IMerkleProof { + /** MerkleProof proof */ + proof?: tendermint.crypto.merkle.IProof | null; + } + + /** Represents a MerkleProof. */ + class MerkleProof implements IMerkleProof { + /** + * Constructs a new MerkleProof. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerkleProof); + + /** MerkleProof proof. */ + public proof?: tendermint.crypto.merkle.IProof | null; + + /** + * Creates a new MerkleProof instance using the specified properties. + * @param [properties] Properties to set + * @returns MerkleProof instance + */ + public static create(properties?: ibc.commitment.IMerkleProof): ibc.commitment.MerkleProof; + + /** + * Encodes the specified MerkleProof message. Does not implicitly {@link ibc.commitment.MerkleProof.verify|verify} messages. + * @param m MerkleProof message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerkleProof, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerkleProof message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerkleProof + * @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): ibc.commitment.MerkleProof; + } + + /** Properties of a KeyPath. */ + interface IKeyPath { + /** KeyPath keys */ + keys?: ibc.commitment.IKey[] | null; + } + + /** Represents a KeyPath. */ + class KeyPath implements IKeyPath { + /** + * Constructs a new KeyPath. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IKeyPath); + + /** KeyPath keys. */ + public keys: ibc.commitment.IKey[]; + + /** + * Creates a new KeyPath instance using the specified properties. + * @param [properties] Properties to set + * @returns KeyPath instance + */ + public static create(properties?: ibc.commitment.IKeyPath): ibc.commitment.KeyPath; + + /** + * Encodes the specified KeyPath message. Does not implicitly {@link ibc.commitment.KeyPath.verify|verify} messages. + * @param m KeyPath message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IKeyPath, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a KeyPath message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns KeyPath + * @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): ibc.commitment.KeyPath; + } + + /** Properties of a Key. */ + interface IKey { + /** Key name */ + name?: Uint8Array | null; + + /** Key enc */ + enc?: ibc.commitment.KeyEncoding | null; + } + + /** Represents a Key. */ + class Key implements IKey { + /** + * Constructs a new Key. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IKey); + + /** Key name. */ + public name: Uint8Array; + + /** Key enc. */ + public enc: ibc.commitment.KeyEncoding; + + /** + * Creates a new Key instance using the specified properties. + * @param [properties] Properties to set + * @returns Key instance + */ + public static create(properties?: ibc.commitment.IKey): ibc.commitment.Key; + + /** + * Encodes the specified Key message. Does not implicitly {@link ibc.commitment.Key.verify|verify} messages. + * @param m Key message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IKey, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Key message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Key + * @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): ibc.commitment.Key; + } + + /** KeyEncoding enum. */ + enum KeyEncoding { + KEY_ENCODING_URL_UNSPECIFIED = 0, + KEY_ENCODING_HEX = 1, + } + } + + /** Namespace connection. */ + namespace connection { + /** Properties of a MsgConnectionOpenInit. */ + interface IMsgConnectionOpenInit { + /** MsgConnectionOpenInit clientId */ + clientId?: string | null; + + /** MsgConnectionOpenInit connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenInit counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenInit signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenInit. */ + class MsgConnectionOpenInit implements IMsgConnectionOpenInit { + /** + * Constructs a new MsgConnectionOpenInit. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenInit); + + /** MsgConnectionOpenInit clientId. */ + public clientId: string; + + /** MsgConnectionOpenInit connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenInit counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenInit signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenInit instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenInit instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenInit, + ): ibc.connection.MsgConnectionOpenInit; + + /** + * Encodes the specified MsgConnectionOpenInit message. Does not implicitly {@link ibc.connection.MsgConnectionOpenInit.verify|verify} messages. + * @param m MsgConnectionOpenInit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IMsgConnectionOpenInit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenInit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenInit + * @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, + ): ibc.connection.MsgConnectionOpenInit; + } + + /** Properties of a MsgConnectionOpenTry. */ + interface IMsgConnectionOpenTry { + /** MsgConnectionOpenTry clientId */ + clientId?: string | null; + + /** MsgConnectionOpenTry connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenTry counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenTry counterpartyVersions */ + counterpartyVersions?: string[] | null; + + /** MsgConnectionOpenTry proofInit */ + proofInit?: Uint8Array | null; + + /** MsgConnectionOpenTry proofHeight */ + proofHeight?: Long | null; + + /** MsgConnectionOpenTry proofConsensus */ + proofConsensus?: Uint8Array | null; + + /** MsgConnectionOpenTry consensusHeight */ + consensusHeight?: Long | null; + + /** MsgConnectionOpenTry signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenTry. */ + class MsgConnectionOpenTry implements IMsgConnectionOpenTry { + /** + * Constructs a new MsgConnectionOpenTry. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenTry); + + /** MsgConnectionOpenTry clientId. */ + public clientId: string; + + /** MsgConnectionOpenTry connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenTry counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenTry counterpartyVersions. */ + public counterpartyVersions: string[]; + + /** MsgConnectionOpenTry proofInit. */ + public proofInit: Uint8Array; + + /** MsgConnectionOpenTry proofHeight. */ + public proofHeight: Long; + + /** MsgConnectionOpenTry proofConsensus. */ + public proofConsensus: Uint8Array; + + /** MsgConnectionOpenTry consensusHeight. */ + public consensusHeight: Long; + + /** MsgConnectionOpenTry signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenTry instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenTry instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenTry, + ): ibc.connection.MsgConnectionOpenTry; + + /** + * Encodes the specified MsgConnectionOpenTry message. Does not implicitly {@link ibc.connection.MsgConnectionOpenTry.verify|verify} messages. + * @param m MsgConnectionOpenTry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IMsgConnectionOpenTry, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenTry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenTry + * @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): ibc.connection.MsgConnectionOpenTry; + } + + /** Properties of a MsgConnectionOpenAck. */ + interface IMsgConnectionOpenAck { + /** MsgConnectionOpenAck connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenAck version */ + version?: string | null; + + /** MsgConnectionOpenAck proofTry */ + proofTry?: Uint8Array | null; + + /** MsgConnectionOpenAck proofHeight */ + proofHeight?: Long | null; + + /** MsgConnectionOpenAck proofConsensus */ + proofConsensus?: Uint8Array | null; + + /** MsgConnectionOpenAck consensusHeight */ + consensusHeight?: Long | null; + + /** MsgConnectionOpenAck signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenAck. */ + class MsgConnectionOpenAck implements IMsgConnectionOpenAck { + /** + * Constructs a new MsgConnectionOpenAck. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenAck); + + /** MsgConnectionOpenAck connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenAck version. */ + public version: string; + + /** MsgConnectionOpenAck proofTry. */ + public proofTry: Uint8Array; + + /** MsgConnectionOpenAck proofHeight. */ + public proofHeight: Long; + + /** MsgConnectionOpenAck proofConsensus. */ + public proofConsensus: Uint8Array; + + /** MsgConnectionOpenAck consensusHeight. */ + public consensusHeight: Long; + + /** MsgConnectionOpenAck signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenAck instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenAck instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenAck, + ): ibc.connection.MsgConnectionOpenAck; + + /** + * Encodes the specified MsgConnectionOpenAck message. Does not implicitly {@link ibc.connection.MsgConnectionOpenAck.verify|verify} messages. + * @param m MsgConnectionOpenAck message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IMsgConnectionOpenAck, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenAck message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenAck + * @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): ibc.connection.MsgConnectionOpenAck; + } + + /** Properties of a MsgConnectionOpenConfirm. */ + interface IMsgConnectionOpenConfirm { + /** MsgConnectionOpenConfirm connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenConfirm proofAck */ + proofAck?: Uint8Array | null; + + /** MsgConnectionOpenConfirm proofHeight */ + proofHeight?: Long | null; + + /** MsgConnectionOpenConfirm signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenConfirm. */ + class MsgConnectionOpenConfirm implements IMsgConnectionOpenConfirm { + /** + * Constructs a new MsgConnectionOpenConfirm. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenConfirm); + + /** MsgConnectionOpenConfirm connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenConfirm proofAck. */ + public proofAck: Uint8Array; + + /** MsgConnectionOpenConfirm proofHeight. */ + public proofHeight: Long; + + /** MsgConnectionOpenConfirm signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenConfirm instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenConfirm instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenConfirm, + ): ibc.connection.MsgConnectionOpenConfirm; + + /** + * Encodes the specified MsgConnectionOpenConfirm message. Does not implicitly {@link ibc.connection.MsgConnectionOpenConfirm.verify|verify} messages. + * @param m MsgConnectionOpenConfirm message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IMsgConnectionOpenConfirm, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenConfirm message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenConfirm + * @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, + ): ibc.connection.MsgConnectionOpenConfirm; + } + + /** Properties of a ConnectionEnd. */ + interface IConnectionEnd { + /** ConnectionEnd clientId */ + clientId?: string | null; + + /** ConnectionEnd versions */ + versions?: string[] | null; + + /** ConnectionEnd state */ + state?: ibc.connection.State | null; + + /** ConnectionEnd counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + } + + /** Represents a ConnectionEnd. */ + class ConnectionEnd implements IConnectionEnd { + /** + * Constructs a new ConnectionEnd. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IConnectionEnd); + + /** ConnectionEnd clientId. */ + public clientId: string; + + /** ConnectionEnd versions. */ + public versions: string[]; + + /** ConnectionEnd state. */ + public state: ibc.connection.State; + + /** ConnectionEnd counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** + * Creates a new ConnectionEnd instance using the specified properties. + * @param [properties] Properties to set + * @returns ConnectionEnd instance + */ + public static create(properties?: ibc.connection.IConnectionEnd): ibc.connection.ConnectionEnd; + + /** + * Encodes the specified ConnectionEnd message. Does not implicitly {@link ibc.connection.ConnectionEnd.verify|verify} messages. + * @param m ConnectionEnd message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IConnectionEnd, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ConnectionEnd message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ConnectionEnd + * @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): ibc.connection.ConnectionEnd; + } + + /** Properties of an IdentifiedConnection. */ + interface IIdentifiedConnection { + /** IdentifiedConnection id */ + id?: string | null; + + /** IdentifiedConnection clientId */ + clientId?: string | null; + + /** IdentifiedConnection versions */ + versions?: string[] | null; + + /** IdentifiedConnection state */ + state?: ibc.connection.State | null; + + /** IdentifiedConnection counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + } + + /** Represents an IdentifiedConnection. */ + class IdentifiedConnection implements IIdentifiedConnection { + /** + * Constructs a new IdentifiedConnection. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IIdentifiedConnection); + + /** IdentifiedConnection id. */ + public id: string; + + /** IdentifiedConnection clientId. */ + public clientId: string; + + /** IdentifiedConnection versions. */ + public versions: string[]; + + /** IdentifiedConnection state. */ + public state: ibc.connection.State; + + /** IdentifiedConnection counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** + * Creates a new IdentifiedConnection instance using the specified properties. + * @param [properties] Properties to set + * @returns IdentifiedConnection instance + */ + public static create( + properties?: ibc.connection.IIdentifiedConnection, + ): ibc.connection.IdentifiedConnection; + + /** + * Encodes the specified IdentifiedConnection message. Does not implicitly {@link ibc.connection.IdentifiedConnection.verify|verify} messages. + * @param m IdentifiedConnection message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IIdentifiedConnection, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IdentifiedConnection message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns IdentifiedConnection + * @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): ibc.connection.IdentifiedConnection; + } + + /** State enum. */ + enum State { + STATE_UNINITIALIZED_UNSPECIFIED = 0, + STATE_INIT = 1, + STATE_TRYOPEN = 2, + STATE_OPEN = 3, + } + + /** Properties of a Counterparty. */ + interface ICounterparty { + /** Counterparty clientId */ + clientId?: string | null; + + /** Counterparty connectionId */ + connectionId?: string | null; + + /** Counterparty prefix */ + prefix?: ibc.commitment.IMerklePrefix | null; + } + + /** Represents a Counterparty. */ + class Counterparty implements ICounterparty { + /** + * Constructs a new Counterparty. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.ICounterparty); + + /** Counterparty clientId. */ + public clientId: string; + + /** Counterparty connectionId. */ + public connectionId: string; + + /** Counterparty prefix. */ + public prefix?: ibc.commitment.IMerklePrefix | null; + + /** + * Creates a new Counterparty instance using the specified properties. + * @param [properties] Properties to set + * @returns Counterparty instance + */ + public static create(properties?: ibc.connection.ICounterparty): ibc.connection.Counterparty; + + /** + * Encodes the specified Counterparty message. Does not implicitly {@link ibc.connection.Counterparty.verify|verify} messages. + * @param m Counterparty message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.ICounterparty, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Counterparty message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Counterparty + * @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): ibc.connection.Counterparty; + } + + /** Properties of a ClientPaths. */ + interface IClientPaths { + /** ClientPaths paths */ + paths?: string[] | null; + } + + /** Represents a ClientPaths. */ + class ClientPaths implements IClientPaths { + /** + * Constructs a new ClientPaths. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IClientPaths); + + /** ClientPaths paths. */ + public paths: string[]; + + /** + * Creates a new ClientPaths instance using the specified properties. + * @param [properties] Properties to set + * @returns ClientPaths instance + */ + public static create(properties?: ibc.connection.IClientPaths): ibc.connection.ClientPaths; + + /** + * Encodes the specified ClientPaths message. Does not implicitly {@link ibc.connection.ClientPaths.verify|verify} messages. + * @param m ClientPaths message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IClientPaths, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ClientPaths message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ClientPaths + * @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): ibc.connection.ClientPaths; + } + + /** Properties of a ConnectionPaths. */ + interface IConnectionPaths { + /** ConnectionPaths clientId */ + clientId?: string | null; + + /** ConnectionPaths paths */ + paths?: string[] | null; + } + + /** Represents a ConnectionPaths. */ + class ConnectionPaths implements IConnectionPaths { + /** + * Constructs a new ConnectionPaths. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IConnectionPaths); + + /** ConnectionPaths clientId. */ + public clientId: string; + + /** ConnectionPaths paths. */ + public paths: string[]; + + /** + * Creates a new ConnectionPaths instance using the specified properties. + * @param [properties] Properties to set + * @returns ConnectionPaths instance + */ + public static create(properties?: ibc.connection.IConnectionPaths): ibc.connection.ConnectionPaths; + + /** + * Encodes the specified ConnectionPaths message. Does not implicitly {@link ibc.connection.ConnectionPaths.verify|verify} messages. + * @param m ConnectionPaths message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IConnectionPaths, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ConnectionPaths message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ConnectionPaths + * @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): ibc.connection.ConnectionPaths; + } + + /** Properties of a Version. */ + interface IVersion { + /** Version identifier */ + identifier?: string | null; + + /** Version features */ + features?: string[] | null; + } + + /** Represents a Version. */ + class Version implements IVersion { + /** + * Constructs a new Version. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IVersion); + + /** Version identifier. */ + public identifier: string; + + /** Version features. */ + public features: string[]; + + /** + * Creates a new Version instance using the specified properties. + * @param [properties] Properties to set + * @returns Version instance + */ + public static create(properties?: ibc.connection.IVersion): ibc.connection.Version; + + /** + * Encodes the specified Version message. Does not implicitly {@link ibc.connection.Version.verify|verify} messages. + * @param m Version message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IVersion, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Version message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Version + * @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): ibc.connection.Version; + } + + /** Represents a Query */ + class Query extends $protobuf.rpc.Service { + /** + * Constructs a new Query service. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + */ + constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean); + + /** + * Creates new Query service using the specified rpc implementation. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + * @returns RPC service. Useful where requests and/or responses are streamed. + */ + public static create( + rpcImpl: $protobuf.RPCImpl, + requestDelimited?: boolean, + responseDelimited?: boolean, + ): Query; + + /** + * Calls Connection. + * @param request QueryConnectionRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryConnectionResponse + */ + public connection( + request: ibc.connection.IQueryConnectionRequest, + callback: ibc.connection.Query.ConnectionCallback, + ): void; + + /** + * Calls Connection. + * @param request QueryConnectionRequest message or plain object + * @returns Promise + */ + public connection( + request: ibc.connection.IQueryConnectionRequest, + ): Promise; + + /** + * Calls Connections. + * @param request QueryConnectionsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryConnectionsResponse + */ + public connections( + request: ibc.connection.IQueryConnectionsRequest, + callback: ibc.connection.Query.ConnectionsCallback, + ): void; + + /** + * Calls Connections. + * @param request QueryConnectionsRequest message or plain object + * @returns Promise + */ + public connections( + request: ibc.connection.IQueryConnectionsRequest, + ): Promise; + + /** + * Calls ClientConnections. + * @param request QueryClientConnectionsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryClientConnectionsResponse + */ + public clientConnections( + request: ibc.connection.IQueryClientConnectionsRequest, + callback: ibc.connection.Query.ClientConnectionsCallback, + ): void; + + /** + * Calls ClientConnections. + * @param request QueryClientConnectionsRequest message or plain object + * @returns Promise + */ + public clientConnections( + request: ibc.connection.IQueryClientConnectionsRequest, + ): Promise; + } + + namespace Query { + /** + * Callback as used by {@link ibc.connection.Query#connection}. + * @param error Error, if any + * @param [response] QueryConnectionResponse + */ + type ConnectionCallback = ( + error: Error | null, + response?: ibc.connection.QueryConnectionResponse, + ) => void; + + /** + * Callback as used by {@link ibc.connection.Query#connections}. + * @param error Error, if any + * @param [response] QueryConnectionsResponse + */ + type ConnectionsCallback = ( + error: Error | null, + response?: ibc.connection.QueryConnectionsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.connection.Query#clientConnections}. + * @param error Error, if any + * @param [response] QueryClientConnectionsResponse + */ + type ClientConnectionsCallback = ( + error: Error | null, + response?: ibc.connection.QueryClientConnectionsResponse, + ) => void; + } + + /** Properties of a QueryConnectionRequest. */ + interface IQueryConnectionRequest { + /** QueryConnectionRequest connectionId */ + connectionId?: string | null; + } + + /** Represents a QueryConnectionRequest. */ + class QueryConnectionRequest implements IQueryConnectionRequest { + /** + * Constructs a new QueryConnectionRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionRequest); + + /** QueryConnectionRequest connectionId. */ + public connectionId: string; + + /** + * Creates a new QueryConnectionRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionRequest instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionRequest, + ): ibc.connection.QueryConnectionRequest; + + /** + * Encodes the specified QueryConnectionRequest message. Does not implicitly {@link ibc.connection.QueryConnectionRequest.verify|verify} messages. + * @param m QueryConnectionRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IQueryConnectionRequest, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryConnectionRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionRequest + * @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, + ): ibc.connection.QueryConnectionRequest; + } + + /** Properties of a QueryConnectionResponse. */ + interface IQueryConnectionResponse { + /** QueryConnectionResponse connection */ + connection?: ibc.connection.IConnectionEnd | null; + + /** QueryConnectionResponse proof */ + proof?: Uint8Array | null; + + /** QueryConnectionResponse proofPath */ + proofPath?: string | null; + + /** QueryConnectionResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryConnectionResponse. */ + class QueryConnectionResponse implements IQueryConnectionResponse { + /** + * Constructs a new QueryConnectionResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionResponse); + + /** QueryConnectionResponse connection. */ + public connection?: ibc.connection.IConnectionEnd | null; + + /** QueryConnectionResponse proof. */ + public proof: Uint8Array; + + /** QueryConnectionResponse proofPath. */ + public proofPath: string; + + /** QueryConnectionResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryConnectionResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionResponse instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionResponse, + ): ibc.connection.QueryConnectionResponse; + + /** + * Encodes the specified QueryConnectionResponse message. Does not implicitly {@link ibc.connection.QueryConnectionResponse.verify|verify} messages. + * @param m QueryConnectionResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryConnectionResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionResponse + * @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, + ): ibc.connection.QueryConnectionResponse; + } + + /** Properties of a QueryConnectionsRequest. */ + interface IQueryConnectionsRequest { + /** QueryConnectionsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryConnectionsRequest. */ + class QueryConnectionsRequest implements IQueryConnectionsRequest { + /** + * Constructs a new QueryConnectionsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionsRequest); + + /** QueryConnectionsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryConnectionsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionsRequest instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionsRequest, + ): ibc.connection.QueryConnectionsRequest; + + /** + * Encodes the specified QueryConnectionsRequest message. Does not implicitly {@link ibc.connection.QueryConnectionsRequest.verify|verify} messages. + * @param m QueryConnectionsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryConnectionsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionsRequest + * @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, + ): ibc.connection.QueryConnectionsRequest; + } + + /** Properties of a QueryConnectionsResponse. */ + interface IQueryConnectionsResponse { + /** QueryConnectionsResponse connections */ + connections?: ibc.connection.IIdentifiedConnection[] | null; + + /** QueryConnectionsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionsResponse height */ + height?: Long | null; + } + + /** Represents a QueryConnectionsResponse. */ + class QueryConnectionsResponse implements IQueryConnectionsResponse { + /** + * Constructs a new QueryConnectionsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionsResponse); + + /** QueryConnectionsResponse connections. */ + public connections: ibc.connection.IIdentifiedConnection[]; + + /** QueryConnectionsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionsResponse height. */ + public height: Long; + + /** + * Creates a new QueryConnectionsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionsResponse instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionsResponse, + ): ibc.connection.QueryConnectionsResponse; + + /** + * Encodes the specified QueryConnectionsResponse message. Does not implicitly {@link ibc.connection.QueryConnectionsResponse.verify|verify} messages. + * @param m QueryConnectionsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryConnectionsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionsResponse + * @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, + ): ibc.connection.QueryConnectionsResponse; + } + + /** Properties of a QueryClientConnectionsRequest. */ + interface IQueryClientConnectionsRequest { + /** QueryClientConnectionsRequest clientId */ + clientId?: string | null; + } + + /** Represents a QueryClientConnectionsRequest. */ + class QueryClientConnectionsRequest implements IQueryClientConnectionsRequest { + /** + * Constructs a new QueryClientConnectionsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryClientConnectionsRequest); + + /** QueryClientConnectionsRequest clientId. */ + public clientId: string; + + /** + * Creates a new QueryClientConnectionsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryClientConnectionsRequest instance + */ + public static create( + properties?: ibc.connection.IQueryClientConnectionsRequest, + ): ibc.connection.QueryClientConnectionsRequest; + + /** + * Encodes the specified QueryClientConnectionsRequest message. Does not implicitly {@link ibc.connection.QueryClientConnectionsRequest.verify|verify} messages. + * @param m QueryClientConnectionsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryClientConnectionsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryClientConnectionsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryClientConnectionsRequest + * @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, + ): ibc.connection.QueryClientConnectionsRequest; + } + + /** Properties of a QueryClientConnectionsResponse. */ + interface IQueryClientConnectionsResponse { + /** QueryClientConnectionsResponse connectionPaths */ + connectionPaths?: string[] | null; + + /** QueryClientConnectionsResponse proof */ + proof?: Uint8Array | null; + + /** QueryClientConnectionsResponse proofPath */ + proofPath?: string | null; + + /** QueryClientConnectionsResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryClientConnectionsResponse. */ + class QueryClientConnectionsResponse implements IQueryClientConnectionsResponse { + /** + * Constructs a new QueryClientConnectionsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryClientConnectionsResponse); + + /** QueryClientConnectionsResponse connectionPaths. */ + public connectionPaths: string[]; + + /** QueryClientConnectionsResponse proof. */ + public proof: Uint8Array; + + /** QueryClientConnectionsResponse proofPath. */ + public proofPath: string; + + /** QueryClientConnectionsResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryClientConnectionsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryClientConnectionsResponse instance + */ + public static create( + properties?: ibc.connection.IQueryClientConnectionsResponse, + ): ibc.connection.QueryClientConnectionsResponse; + + /** + * Encodes the specified QueryClientConnectionsResponse message. Does not implicitly {@link ibc.connection.QueryClientConnectionsResponse.verify|verify} messages. + * @param m QueryClientConnectionsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryClientConnectionsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryClientConnectionsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryClientConnectionsResponse + * @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, + ): ibc.connection.QueryClientConnectionsResponse; + } + } +} + /** Namespace tendermint. */ export namespace tendermint { /** Namespace abci. */ diff --git a/packages/stargate/src/codec/generated/codecimpl.js b/packages/stargate/src/codec/generated/codecimpl.js index d89f93c5..0225239d 100644 --- a/packages/stargate/src/codec/generated/codecimpl.js +++ b/packages/stargate/src/codec/generated/codecimpl.js @@ -1,6 +1,6 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.google = exports.tendermint = exports.cosmos = void 0; +exports.google = exports.tendermint = exports.ibc = exports.cosmos = void 0; var $protobuf = require("protobufjs/minimal"); const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, @@ -2738,6 +2738,2881 @@ exports.cosmos = $root.cosmos = (() => { })(); return cosmos; })(); +exports.ibc = $root.ibc = (() => { + const ibc = {}; + ibc.channel = (function () { + const channel = {}; + channel.MsgChannelOpenInit = (function () { + function MsgChannelOpenInit(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]]; + } + MsgChannelOpenInit.prototype.portId = ""; + MsgChannelOpenInit.prototype.channelId = ""; + MsgChannelOpenInit.prototype.channel = null; + MsgChannelOpenInit.prototype.signer = $util.newBuffer([]); + MsgChannelOpenInit.create = function create(properties) { + return new MsgChannelOpenInit(properties); + }; + MsgChannelOpenInit.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.channel != null && Object.hasOwnProperty.call(m, "channel")) + $root.ibc.channel.Channel.encode(m.channel, w.uint32(26).fork()).ldelim(); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(34).bytes(m.signer); + return w; + }; + MsgChannelOpenInit.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.ibc.channel.MsgChannelOpenInit(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.channel = $root.ibc.channel.Channel.decode(r, r.uint32()); + break; + case 4: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgChannelOpenInit; + })(); + channel.MsgChannelOpenTry = (function () { + function MsgChannelOpenTry(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]]; + } + MsgChannelOpenTry.prototype.portId = ""; + MsgChannelOpenTry.prototype.channelId = ""; + MsgChannelOpenTry.prototype.channel = null; + MsgChannelOpenTry.prototype.counterpartyVersion = ""; + MsgChannelOpenTry.prototype.proofInit = $util.newBuffer([]); + MsgChannelOpenTry.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgChannelOpenTry.prototype.signer = $util.newBuffer([]); + MsgChannelOpenTry.create = function create(properties) { + return new MsgChannelOpenTry(properties); + }; + MsgChannelOpenTry.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.channel != null && Object.hasOwnProperty.call(m, "channel")) + $root.ibc.channel.Channel.encode(m.channel, w.uint32(26).fork()).ldelim(); + if (m.counterpartyVersion != null && Object.hasOwnProperty.call(m, "counterpartyVersion")) + w.uint32(34).string(m.counterpartyVersion); + if (m.proofInit != null && Object.hasOwnProperty.call(m, "proofInit")) + w.uint32(42).bytes(m.proofInit); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(48).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(58).bytes(m.signer); + return w; + }; + MsgChannelOpenTry.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.ibc.channel.MsgChannelOpenTry(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.channel = $root.ibc.channel.Channel.decode(r, r.uint32()); + break; + case 4: + m.counterpartyVersion = r.string(); + break; + case 5: + m.proofInit = r.bytes(); + break; + case 6: + m.proofHeight = r.uint64(); + break; + case 7: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgChannelOpenTry; + })(); + channel.MsgChannelOpenAck = (function () { + function MsgChannelOpenAck(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]]; + } + MsgChannelOpenAck.prototype.portId = ""; + MsgChannelOpenAck.prototype.channelId = ""; + MsgChannelOpenAck.prototype.counterpartyVersion = ""; + MsgChannelOpenAck.prototype.proofTry = $util.newBuffer([]); + MsgChannelOpenAck.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgChannelOpenAck.prototype.signer = $util.newBuffer([]); + MsgChannelOpenAck.create = function create(properties) { + return new MsgChannelOpenAck(properties); + }; + MsgChannelOpenAck.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.counterpartyVersion != null && Object.hasOwnProperty.call(m, "counterpartyVersion")) + w.uint32(26).string(m.counterpartyVersion); + if (m.proofTry != null && Object.hasOwnProperty.call(m, "proofTry")) w.uint32(34).bytes(m.proofTry); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(40).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(50).bytes(m.signer); + return w; + }; + MsgChannelOpenAck.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.ibc.channel.MsgChannelOpenAck(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.counterpartyVersion = r.string(); + break; + case 4: + m.proofTry = r.bytes(); + break; + case 5: + m.proofHeight = r.uint64(); + break; + case 6: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgChannelOpenAck; + })(); + channel.MsgChannelOpenConfirm = (function () { + function MsgChannelOpenConfirm(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]]; + } + MsgChannelOpenConfirm.prototype.portId = ""; + MsgChannelOpenConfirm.prototype.channelId = ""; + MsgChannelOpenConfirm.prototype.proofAck = $util.newBuffer([]); + MsgChannelOpenConfirm.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgChannelOpenConfirm.prototype.signer = $util.newBuffer([]); + MsgChannelOpenConfirm.create = function create(properties) { + return new MsgChannelOpenConfirm(properties); + }; + MsgChannelOpenConfirm.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.proofAck != null && Object.hasOwnProperty.call(m, "proofAck")) w.uint32(26).bytes(m.proofAck); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(42).bytes(m.signer); + return w; + }; + MsgChannelOpenConfirm.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.ibc.channel.MsgChannelOpenConfirm(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.proofAck = r.bytes(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + case 5: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgChannelOpenConfirm; + })(); + channel.MsgChannelCloseInit = (function () { + function MsgChannelCloseInit(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]]; + } + MsgChannelCloseInit.prototype.portId = ""; + MsgChannelCloseInit.prototype.channelId = ""; + MsgChannelCloseInit.prototype.signer = $util.newBuffer([]); + MsgChannelCloseInit.create = function create(properties) { + return new MsgChannelCloseInit(properties); + }; + MsgChannelCloseInit.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(26).bytes(m.signer); + return w; + }; + MsgChannelCloseInit.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.ibc.channel.MsgChannelCloseInit(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgChannelCloseInit; + })(); + channel.MsgChannelCloseConfirm = (function () { + function MsgChannelCloseConfirm(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]]; + } + MsgChannelCloseConfirm.prototype.portId = ""; + MsgChannelCloseConfirm.prototype.channelId = ""; + MsgChannelCloseConfirm.prototype.proofInit = $util.newBuffer([]); + MsgChannelCloseConfirm.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgChannelCloseConfirm.prototype.signer = $util.newBuffer([]); + MsgChannelCloseConfirm.create = function create(properties) { + return new MsgChannelCloseConfirm(properties); + }; + MsgChannelCloseConfirm.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.proofInit != null && Object.hasOwnProperty.call(m, "proofInit")) + w.uint32(26).bytes(m.proofInit); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(42).bytes(m.signer); + return w; + }; + MsgChannelCloseConfirm.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.ibc.channel.MsgChannelCloseConfirm(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.proofInit = r.bytes(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + case 5: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgChannelCloseConfirm; + })(); + channel.MsgRecvPacket = (function () { + function MsgRecvPacket(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]]; + } + MsgRecvPacket.prototype.packet = null; + MsgRecvPacket.prototype.proof = $util.newBuffer([]); + MsgRecvPacket.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgRecvPacket.prototype.signer = $util.newBuffer([]); + MsgRecvPacket.create = function create(properties) { + return new MsgRecvPacket(properties); + }; + MsgRecvPacket.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.packet != null && Object.hasOwnProperty.call(m, "packet")) + $root.ibc.channel.Packet.encode(m.packet, w.uint32(10).fork()).ldelim(); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(24).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(34).bytes(m.signer); + return w; + }; + MsgRecvPacket.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.ibc.channel.MsgRecvPacket(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.packet = $root.ibc.channel.Packet.decode(r, r.uint32()); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofHeight = r.uint64(); + break; + case 4: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgRecvPacket; + })(); + channel.MsgTimeout = (function () { + function MsgTimeout(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]]; + } + MsgTimeout.prototype.packet = null; + MsgTimeout.prototype.proof = $util.newBuffer([]); + MsgTimeout.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgTimeout.prototype.nextSequenceRecv = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgTimeout.prototype.signer = $util.newBuffer([]); + MsgTimeout.create = function create(properties) { + return new MsgTimeout(properties); + }; + MsgTimeout.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.packet != null && Object.hasOwnProperty.call(m, "packet")) + $root.ibc.channel.Packet.encode(m.packet, w.uint32(10).fork()).ldelim(); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(24).uint64(m.proofHeight); + if (m.nextSequenceRecv != null && Object.hasOwnProperty.call(m, "nextSequenceRecv")) + w.uint32(32).uint64(m.nextSequenceRecv); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(42).bytes(m.signer); + return w; + }; + MsgTimeout.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.ibc.channel.MsgTimeout(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.packet = $root.ibc.channel.Packet.decode(r, r.uint32()); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofHeight = r.uint64(); + break; + case 4: + m.nextSequenceRecv = r.uint64(); + break; + case 5: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgTimeout; + })(); + channel.MsgAcknowledgement = (function () { + function MsgAcknowledgement(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]]; + } + MsgAcknowledgement.prototype.packet = null; + MsgAcknowledgement.prototype.acknowledgement = $util.newBuffer([]); + MsgAcknowledgement.prototype.proof = $util.newBuffer([]); + MsgAcknowledgement.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgAcknowledgement.prototype.signer = $util.newBuffer([]); + MsgAcknowledgement.create = function create(properties) { + return new MsgAcknowledgement(properties); + }; + MsgAcknowledgement.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.packet != null && Object.hasOwnProperty.call(m, "packet")) + $root.ibc.channel.Packet.encode(m.packet, w.uint32(10).fork()).ldelim(); + if (m.acknowledgement != null && Object.hasOwnProperty.call(m, "acknowledgement")) + w.uint32(18).bytes(m.acknowledgement); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(26).bytes(m.proof); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(42).bytes(m.signer); + return w; + }; + MsgAcknowledgement.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.ibc.channel.MsgAcknowledgement(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.packet = $root.ibc.channel.Packet.decode(r, r.uint32()); + break; + case 2: + m.acknowledgement = r.bytes(); + break; + case 3: + m.proof = r.bytes(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + case 5: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgAcknowledgement; + })(); + channel.Channel = (function () { + function Channel(p) { + this.connectionHops = []; + 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]]; + } + Channel.prototype.state = 0; + Channel.prototype.ordering = 0; + Channel.prototype.counterparty = null; + Channel.prototype.connectionHops = $util.emptyArray; + Channel.prototype.version = ""; + Channel.create = function create(properties) { + return new Channel(properties); + }; + Channel.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.state != null && Object.hasOwnProperty.call(m, "state")) w.uint32(8).int32(m.state); + if (m.ordering != null && Object.hasOwnProperty.call(m, "ordering")) w.uint32(16).int32(m.ordering); + if (m.counterparty != null && Object.hasOwnProperty.call(m, "counterparty")) + $root.ibc.channel.Counterparty.encode(m.counterparty, w.uint32(26).fork()).ldelim(); + if (m.connectionHops != null && m.connectionHops.length) { + for (var i = 0; i < m.connectionHops.length; ++i) w.uint32(34).string(m.connectionHops[i]); + } + if (m.version != null && Object.hasOwnProperty.call(m, "version")) w.uint32(42).string(m.version); + return w; + }; + Channel.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.ibc.channel.Channel(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.state = r.int32(); + break; + case 2: + m.ordering = r.int32(); + break; + case 3: + m.counterparty = $root.ibc.channel.Counterparty.decode(r, r.uint32()); + break; + case 4: + if (!(m.connectionHops && m.connectionHops.length)) m.connectionHops = []; + m.connectionHops.push(r.string()); + break; + case 5: + m.version = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Channel; + })(); + channel.IdentifiedChannel = (function () { + function IdentifiedChannel(p) { + this.connectionHops = []; + 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]]; + } + IdentifiedChannel.prototype.state = 0; + IdentifiedChannel.prototype.ordering = 0; + IdentifiedChannel.prototype.counterparty = null; + IdentifiedChannel.prototype.connectionHops = $util.emptyArray; + IdentifiedChannel.prototype.version = ""; + IdentifiedChannel.prototype.portId = ""; + IdentifiedChannel.prototype.channelId = ""; + IdentifiedChannel.create = function create(properties) { + return new IdentifiedChannel(properties); + }; + IdentifiedChannel.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.state != null && Object.hasOwnProperty.call(m, "state")) w.uint32(8).int32(m.state); + if (m.ordering != null && Object.hasOwnProperty.call(m, "ordering")) w.uint32(16).int32(m.ordering); + if (m.counterparty != null && Object.hasOwnProperty.call(m, "counterparty")) + $root.ibc.channel.Counterparty.encode(m.counterparty, w.uint32(26).fork()).ldelim(); + if (m.connectionHops != null && m.connectionHops.length) { + for (var i = 0; i < m.connectionHops.length; ++i) w.uint32(34).string(m.connectionHops[i]); + } + if (m.version != null && Object.hasOwnProperty.call(m, "version")) w.uint32(42).string(m.version); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(50).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(58).string(m.channelId); + return w; + }; + IdentifiedChannel.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.ibc.channel.IdentifiedChannel(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.state = r.int32(); + break; + case 2: + m.ordering = r.int32(); + break; + case 3: + m.counterparty = $root.ibc.channel.Counterparty.decode(r, r.uint32()); + break; + case 4: + if (!(m.connectionHops && m.connectionHops.length)) m.connectionHops = []; + m.connectionHops.push(r.string()); + break; + case 5: + m.version = r.string(); + break; + case 6: + m.portId = r.string(); + break; + case 7: + m.channelId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return IdentifiedChannel; + })(); + channel.State = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "STATE_UNINITIALIZED_UNSPECIFIED")] = 0; + values[(valuesById[1] = "STATE_INIT")] = 1; + values[(valuesById[2] = "STATE_TRYOPEN")] = 2; + values[(valuesById[3] = "STATE_OPEN")] = 3; + values[(valuesById[4] = "STATE_CLOSED")] = 4; + return values; + })(); + channel.Order = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "ORDER_NONE_UNSPECIFIED")] = 0; + values[(valuesById[1] = "ORDER_UNORDERED")] = 1; + values[(valuesById[2] = "ORDER_ORDERED")] = 2; + return values; + })(); + channel.Counterparty = (function () { + function Counterparty(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]]; + } + Counterparty.prototype.portId = ""; + Counterparty.prototype.channelId = ""; + Counterparty.create = function create(properties) { + return new Counterparty(properties); + }; + Counterparty.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + return w; + }; + Counterparty.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.ibc.channel.Counterparty(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Counterparty; + })(); + channel.Packet = (function () { + function Packet(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]]; + } + Packet.prototype.sequence = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Packet.prototype.sourcePort = ""; + Packet.prototype.sourceChannel = ""; + Packet.prototype.destinationPort = ""; + Packet.prototype.destinationChannel = ""; + Packet.prototype.data = $util.newBuffer([]); + Packet.prototype.timeoutHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Packet.prototype.timeoutTimestamp = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Packet.create = function create(properties) { + return new Packet(properties); + }; + Packet.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sequence != null && Object.hasOwnProperty.call(m, "sequence")) w.uint32(8).uint64(m.sequence); + if (m.sourcePort != null && Object.hasOwnProperty.call(m, "sourcePort")) + w.uint32(18).string(m.sourcePort); + if (m.sourceChannel != null && Object.hasOwnProperty.call(m, "sourceChannel")) + w.uint32(26).string(m.sourceChannel); + if (m.destinationPort != null && Object.hasOwnProperty.call(m, "destinationPort")) + w.uint32(34).string(m.destinationPort); + if (m.destinationChannel != null && Object.hasOwnProperty.call(m, "destinationChannel")) + w.uint32(42).string(m.destinationChannel); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) w.uint32(50).bytes(m.data); + if (m.timeoutHeight != null && Object.hasOwnProperty.call(m, "timeoutHeight")) + w.uint32(56).uint64(m.timeoutHeight); + if (m.timeoutTimestamp != null && Object.hasOwnProperty.call(m, "timeoutTimestamp")) + w.uint32(64).uint64(m.timeoutTimestamp); + return w; + }; + Packet.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.ibc.channel.Packet(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sequence = r.uint64(); + break; + case 2: + m.sourcePort = r.string(); + break; + case 3: + m.sourceChannel = r.string(); + break; + case 4: + m.destinationPort = r.string(); + break; + case 5: + m.destinationChannel = r.string(); + break; + case 6: + m.data = r.bytes(); + break; + case 7: + m.timeoutHeight = r.uint64(); + break; + case 8: + m.timeoutTimestamp = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Packet; + })(); + channel.PacketAckCommitment = (function () { + function PacketAckCommitment(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]]; + } + PacketAckCommitment.prototype.portId = ""; + PacketAckCommitment.prototype.channelId = ""; + PacketAckCommitment.prototype.sequence = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + PacketAckCommitment.prototype.hash = $util.newBuffer([]); + PacketAckCommitment.create = function create(properties) { + return new PacketAckCommitment(properties); + }; + PacketAckCommitment.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.sequence != null && Object.hasOwnProperty.call(m, "sequence")) w.uint32(24).uint64(m.sequence); + if (m.hash != null && Object.hasOwnProperty.call(m, "hash")) w.uint32(34).bytes(m.hash); + return w; + }; + PacketAckCommitment.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.ibc.channel.PacketAckCommitment(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.sequence = r.uint64(); + break; + case 4: + m.hash = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return PacketAckCommitment; + })(); + channel.Query = (function () { + function Query(rpcImpl, requestDelimited, responseDelimited) { + $protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited); + } + (Query.prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = Query; + Query.create = function create(rpcImpl, requestDelimited, responseDelimited) { + return new this(rpcImpl, requestDelimited, responseDelimited); + }; + Object.defineProperty( + (Query.prototype.channel = function channel(request, callback) { + return this.rpcCall( + channel, + $root.ibc.channel.QueryChannelRequest, + $root.ibc.channel.QueryChannelResponse, + request, + callback, + ); + }), + "name", + { value: "Channel" }, + ); + Object.defineProperty( + (Query.prototype.channels = function channels(request, callback) { + return this.rpcCall( + channels, + $root.ibc.channel.QueryChannelsRequest, + $root.ibc.channel.QueryChannelsResponse, + request, + callback, + ); + }), + "name", + { value: "Channels" }, + ); + Object.defineProperty( + (Query.prototype.connectionChannels = function connectionChannels(request, callback) { + return this.rpcCall( + connectionChannels, + $root.ibc.channel.QueryConnectionChannelsRequest, + $root.ibc.channel.QueryConnectionChannelsResponse, + request, + callback, + ); + }), + "name", + { value: "ConnectionChannels" }, + ); + Object.defineProperty( + (Query.prototype.packetCommitment = function packetCommitment(request, callback) { + return this.rpcCall( + packetCommitment, + $root.ibc.channel.QueryPacketCommitmentRequest, + $root.ibc.channel.QueryPacketCommitmentResponse, + request, + callback, + ); + }), + "name", + { value: "PacketCommitment" }, + ); + Object.defineProperty( + (Query.prototype.packetCommitments = function packetCommitments(request, callback) { + return this.rpcCall( + packetCommitments, + $root.ibc.channel.QueryPacketCommitmentsRequest, + $root.ibc.channel.QueryPacketCommitmentsResponse, + request, + callback, + ); + }), + "name", + { value: "PacketCommitments" }, + ); + Object.defineProperty( + (Query.prototype.packetAcknowledgement = function packetAcknowledgement(request, callback) { + return this.rpcCall( + packetAcknowledgement, + $root.ibc.channel.QueryPacketAcknowledgementRequest, + $root.ibc.channel.QueryPacketAcknowledgementResponse, + request, + callback, + ); + }), + "name", + { value: "PacketAcknowledgement" }, + ); + Object.defineProperty( + (Query.prototype.unrelayedPackets = function unrelayedPackets(request, callback) { + return this.rpcCall( + unrelayedPackets, + $root.ibc.channel.QueryUnrelayedPacketsRequest, + $root.ibc.channel.QueryUnrelayedPacketsResponse, + request, + callback, + ); + }), + "name", + { value: "UnrelayedPackets" }, + ); + Object.defineProperty( + (Query.prototype.nextSequenceReceive = function nextSequenceReceive(request, callback) { + return this.rpcCall( + nextSequenceReceive, + $root.ibc.channel.QueryNextSequenceReceiveRequest, + $root.ibc.channel.QueryNextSequenceReceiveResponse, + request, + callback, + ); + }), + "name", + { value: "NextSequenceReceive" }, + ); + return Query; + })(); + channel.QueryChannelRequest = (function () { + function QueryChannelRequest(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]]; + } + QueryChannelRequest.prototype.portId = ""; + QueryChannelRequest.prototype.channelId = ""; + QueryChannelRequest.create = function create(properties) { + return new QueryChannelRequest(properties); + }; + QueryChannelRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + return w; + }; + QueryChannelRequest.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.ibc.channel.QueryChannelRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryChannelRequest; + })(); + channel.QueryChannelResponse = (function () { + function QueryChannelResponse(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]]; + } + QueryChannelResponse.prototype.channel = null; + QueryChannelResponse.prototype.proof = $util.newBuffer([]); + QueryChannelResponse.prototype.proofPath = ""; + QueryChannelResponse.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryChannelResponse.create = function create(properties) { + return new QueryChannelResponse(properties); + }; + QueryChannelResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.channel != null && Object.hasOwnProperty.call(m, "channel")) + $root.ibc.channel.Channel.encode(m.channel, w.uint32(10).fork()).ldelim(); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofPath != null && Object.hasOwnProperty.call(m, "proofPath")) + w.uint32(26).string(m.proofPath); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + return w; + }; + QueryChannelResponse.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.ibc.channel.QueryChannelResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.channel = $root.ibc.channel.Channel.decode(r, r.uint32()); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofPath = r.string(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryChannelResponse; + })(); + channel.QueryChannelsRequest = (function () { + function QueryChannelsRequest(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]]; + } + QueryChannelsRequest.prototype.pagination = null; + QueryChannelsRequest.create = function create(properties) { + return new QueryChannelsRequest(properties); + }; + QueryChannelsRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageRequest.encode(m.pagination, w.uint32(10).fork()).ldelim(); + return w; + }; + QueryChannelsRequest.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.ibc.channel.QueryChannelsRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.pagination = $root.cosmos.query.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryChannelsRequest; + })(); + channel.QueryChannelsResponse = (function () { + function QueryChannelsResponse(p) { + this.channels = []; + 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]]; + } + QueryChannelsResponse.prototype.channels = $util.emptyArray; + QueryChannelsResponse.prototype.pagination = null; + QueryChannelsResponse.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + QueryChannelsResponse.create = function create(properties) { + return new QueryChannelsResponse(properties); + }; + QueryChannelsResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.channels != null && m.channels.length) { + for (var i = 0; i < m.channels.length; ++i) + $root.ibc.channel.IdentifiedChannel.encode(m.channels[i], w.uint32(10).fork()).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(24).int64(m.height); + return w; + }; + QueryChannelsResponse.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.ibc.channel.QueryChannelsResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.channels && m.channels.length)) m.channels = []; + m.channels.push($root.ibc.channel.IdentifiedChannel.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.query.PageResponse.decode(r, r.uint32()); + break; + case 3: + m.height = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryChannelsResponse; + })(); + channel.QueryConnectionChannelsRequest = (function () { + function QueryConnectionChannelsRequest(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]]; + } + QueryConnectionChannelsRequest.prototype.connection = ""; + QueryConnectionChannelsRequest.prototype.pagination = null; + QueryConnectionChannelsRequest.create = function create(properties) { + return new QueryConnectionChannelsRequest(properties); + }; + QueryConnectionChannelsRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connection != null && Object.hasOwnProperty.call(m, "connection")) + w.uint32(10).string(m.connection); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageRequest.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryConnectionChannelsRequest.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.ibc.channel.QueryConnectionChannelsRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.connection = r.string(); + break; + case 2: + m.pagination = $root.cosmos.query.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryConnectionChannelsRequest; + })(); + channel.QueryConnectionChannelsResponse = (function () { + function QueryConnectionChannelsResponse(p) { + this.channels = []; + 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]]; + } + QueryConnectionChannelsResponse.prototype.channels = $util.emptyArray; + QueryConnectionChannelsResponse.prototype.pagination = null; + QueryConnectionChannelsResponse.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + QueryConnectionChannelsResponse.create = function create(properties) { + return new QueryConnectionChannelsResponse(properties); + }; + QueryConnectionChannelsResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.channels != null && m.channels.length) { + for (var i = 0; i < m.channels.length; ++i) + $root.ibc.channel.IdentifiedChannel.encode(m.channels[i], w.uint32(10).fork()).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(24).int64(m.height); + return w; + }; + QueryConnectionChannelsResponse.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.ibc.channel.QueryConnectionChannelsResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.channels && m.channels.length)) m.channels = []; + m.channels.push($root.ibc.channel.IdentifiedChannel.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.query.PageResponse.decode(r, r.uint32()); + break; + case 3: + m.height = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryConnectionChannelsResponse; + })(); + channel.QueryPacketCommitmentRequest = (function () { + function QueryPacketCommitmentRequest(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]]; + } + QueryPacketCommitmentRequest.prototype.portId = ""; + QueryPacketCommitmentRequest.prototype.channelId = ""; + QueryPacketCommitmentRequest.prototype.sequence = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryPacketCommitmentRequest.create = function create(properties) { + return new QueryPacketCommitmentRequest(properties); + }; + QueryPacketCommitmentRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.sequence != null && Object.hasOwnProperty.call(m, "sequence")) w.uint32(24).uint64(m.sequence); + return w; + }; + QueryPacketCommitmentRequest.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.ibc.channel.QueryPacketCommitmentRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.sequence = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryPacketCommitmentRequest; + })(); + channel.QueryPacketCommitmentResponse = (function () { + function QueryPacketCommitmentResponse(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]]; + } + QueryPacketCommitmentResponse.prototype.commitment = $util.newBuffer([]); + QueryPacketCommitmentResponse.prototype.proof = $util.newBuffer([]); + QueryPacketCommitmentResponse.prototype.proofPath = ""; + QueryPacketCommitmentResponse.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryPacketCommitmentResponse.create = function create(properties) { + return new QueryPacketCommitmentResponse(properties); + }; + QueryPacketCommitmentResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.commitment != null && Object.hasOwnProperty.call(m, "commitment")) + w.uint32(10).bytes(m.commitment); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofPath != null && Object.hasOwnProperty.call(m, "proofPath")) + w.uint32(26).string(m.proofPath); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + return w; + }; + QueryPacketCommitmentResponse.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.ibc.channel.QueryPacketCommitmentResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.commitment = r.bytes(); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofPath = r.string(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryPacketCommitmentResponse; + })(); + channel.QueryPacketCommitmentsRequest = (function () { + function QueryPacketCommitmentsRequest(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]]; + } + QueryPacketCommitmentsRequest.prototype.portId = ""; + QueryPacketCommitmentsRequest.prototype.channelId = ""; + QueryPacketCommitmentsRequest.prototype.pagination = null; + QueryPacketCommitmentsRequest.create = function create(properties) { + return new QueryPacketCommitmentsRequest(properties); + }; + QueryPacketCommitmentsRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageRequest.encode(m.pagination, w.uint32(26).fork()).ldelim(); + return w; + }; + QueryPacketCommitmentsRequest.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.ibc.channel.QueryPacketCommitmentsRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.pagination = $root.cosmos.query.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryPacketCommitmentsRequest; + })(); + channel.QueryPacketCommitmentsResponse = (function () { + function QueryPacketCommitmentsResponse(p) { + this.commitments = []; + 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]]; + } + QueryPacketCommitmentsResponse.prototype.commitments = $util.emptyArray; + QueryPacketCommitmentsResponse.prototype.pagination = null; + QueryPacketCommitmentsResponse.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + QueryPacketCommitmentsResponse.create = function create(properties) { + return new QueryPacketCommitmentsResponse(properties); + }; + QueryPacketCommitmentsResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.commitments != null && m.commitments.length) { + for (var i = 0; i < m.commitments.length; ++i) + $root.ibc.channel.PacketAckCommitment.encode(m.commitments[i], w.uint32(10).fork()).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(24).int64(m.height); + return w; + }; + QueryPacketCommitmentsResponse.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.ibc.channel.QueryPacketCommitmentsResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.commitments && m.commitments.length)) m.commitments = []; + m.commitments.push($root.ibc.channel.PacketAckCommitment.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.query.PageResponse.decode(r, r.uint32()); + break; + case 3: + m.height = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryPacketCommitmentsResponse; + })(); + channel.QueryPacketAcknowledgementRequest = (function () { + function QueryPacketAcknowledgementRequest(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]]; + } + QueryPacketAcknowledgementRequest.prototype.portId = ""; + QueryPacketAcknowledgementRequest.prototype.channelId = ""; + QueryPacketAcknowledgementRequest.prototype.sequence = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryPacketAcknowledgementRequest.create = function create(properties) { + return new QueryPacketAcknowledgementRequest(properties); + }; + QueryPacketAcknowledgementRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.sequence != null && Object.hasOwnProperty.call(m, "sequence")) w.uint32(24).uint64(m.sequence); + return w; + }; + QueryPacketAcknowledgementRequest.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.ibc.channel.QueryPacketAcknowledgementRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + m.sequence = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryPacketAcknowledgementRequest; + })(); + channel.QueryPacketAcknowledgementResponse = (function () { + function QueryPacketAcknowledgementResponse(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]]; + } + QueryPacketAcknowledgementResponse.prototype.acknowledgement = $util.newBuffer([]); + QueryPacketAcknowledgementResponse.prototype.proof = $util.newBuffer([]); + QueryPacketAcknowledgementResponse.prototype.proofPath = ""; + QueryPacketAcknowledgementResponse.prototype.proofHeight = $util.Long + ? $util.Long.fromBits(0, 0, true) + : 0; + QueryPacketAcknowledgementResponse.create = function create(properties) { + return new QueryPacketAcknowledgementResponse(properties); + }; + QueryPacketAcknowledgementResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.acknowledgement != null && Object.hasOwnProperty.call(m, "acknowledgement")) + w.uint32(10).bytes(m.acknowledgement); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofPath != null && Object.hasOwnProperty.call(m, "proofPath")) + w.uint32(26).string(m.proofPath); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + return w; + }; + QueryPacketAcknowledgementResponse.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.ibc.channel.QueryPacketAcknowledgementResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.acknowledgement = r.bytes(); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofPath = r.string(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryPacketAcknowledgementResponse; + })(); + channel.QueryUnrelayedPacketsRequest = (function () { + function QueryUnrelayedPacketsRequest(p) { + this.packetCommitmentSequences = []; + 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]]; + } + QueryUnrelayedPacketsRequest.prototype.portId = ""; + QueryUnrelayedPacketsRequest.prototype.channelId = ""; + QueryUnrelayedPacketsRequest.prototype.packetCommitmentSequences = $util.emptyArray; + QueryUnrelayedPacketsRequest.prototype.acknowledgements = false; + QueryUnrelayedPacketsRequest.create = function create(properties) { + return new QueryUnrelayedPacketsRequest(properties); + }; + QueryUnrelayedPacketsRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + if (m.packetCommitmentSequences != null && m.packetCommitmentSequences.length) { + w.uint32(26).fork(); + for (var i = 0; i < m.packetCommitmentSequences.length; ++i) + w.uint64(m.packetCommitmentSequences[i]); + w.ldelim(); + } + if (m.acknowledgements != null && Object.hasOwnProperty.call(m, "acknowledgements")) + w.uint32(32).bool(m.acknowledgements); + return w; + }; + QueryUnrelayedPacketsRequest.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.ibc.channel.QueryUnrelayedPacketsRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + case 3: + if (!(m.packetCommitmentSequences && m.packetCommitmentSequences.length)) + m.packetCommitmentSequences = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.packetCommitmentSequences.push(r.uint64()); + } else m.packetCommitmentSequences.push(r.uint64()); + break; + case 4: + m.acknowledgements = r.bool(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryUnrelayedPacketsRequest; + })(); + channel.QueryUnrelayedPacketsResponse = (function () { + function QueryUnrelayedPacketsResponse(p) { + this.sequences = []; + 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]]; + } + QueryUnrelayedPacketsResponse.prototype.sequences = $util.emptyArray; + QueryUnrelayedPacketsResponse.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + QueryUnrelayedPacketsResponse.create = function create(properties) { + return new QueryUnrelayedPacketsResponse(properties); + }; + QueryUnrelayedPacketsResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sequences != null && m.sequences.length) { + w.uint32(10).fork(); + for (var i = 0; i < m.sequences.length; ++i) w.uint64(m.sequences[i]); + w.ldelim(); + } + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(16).int64(m.height); + return w; + }; + QueryUnrelayedPacketsResponse.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.ibc.channel.QueryUnrelayedPacketsResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.sequences && m.sequences.length)) m.sequences = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.sequences.push(r.uint64()); + } else m.sequences.push(r.uint64()); + break; + case 2: + m.height = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryUnrelayedPacketsResponse; + })(); + channel.QueryNextSequenceReceiveRequest = (function () { + function QueryNextSequenceReceiveRequest(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]]; + } + QueryNextSequenceReceiveRequest.prototype.portId = ""; + QueryNextSequenceReceiveRequest.prototype.channelId = ""; + QueryNextSequenceReceiveRequest.create = function create(properties) { + return new QueryNextSequenceReceiveRequest(properties); + }; + QueryNextSequenceReceiveRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + return w; + }; + QueryNextSequenceReceiveRequest.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.ibc.channel.QueryNextSequenceReceiveRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryNextSequenceReceiveRequest; + })(); + channel.QueryNextSequenceReceiveResponse = (function () { + function QueryNextSequenceReceiveResponse(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]]; + } + QueryNextSequenceReceiveResponse.prototype.nextSequenceReceive = $util.Long + ? $util.Long.fromBits(0, 0, true) + : 0; + QueryNextSequenceReceiveResponse.prototype.proof = $util.newBuffer([]); + QueryNextSequenceReceiveResponse.prototype.proofPath = ""; + QueryNextSequenceReceiveResponse.prototype.proofHeight = $util.Long + ? $util.Long.fromBits(0, 0, true) + : 0; + QueryNextSequenceReceiveResponse.create = function create(properties) { + return new QueryNextSequenceReceiveResponse(properties); + }; + QueryNextSequenceReceiveResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.nextSequenceReceive != null && Object.hasOwnProperty.call(m, "nextSequenceReceive")) + w.uint32(8).uint64(m.nextSequenceReceive); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofPath != null && Object.hasOwnProperty.call(m, "proofPath")) + w.uint32(26).string(m.proofPath); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + return w; + }; + QueryNextSequenceReceiveResponse.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.ibc.channel.QueryNextSequenceReceiveResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.nextSequenceReceive = r.uint64(); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofPath = r.string(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryNextSequenceReceiveResponse; + })(); + channel.QueryChannelClientStateRequest = (function () { + function QueryChannelClientStateRequest(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]]; + } + QueryChannelClientStateRequest.prototype.portId = ""; + QueryChannelClientStateRequest.prototype.channelId = ""; + QueryChannelClientStateRequest.create = function create(properties) { + return new QueryChannelClientStateRequest(properties); + }; + QueryChannelClientStateRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + return w; + }; + QueryChannelClientStateRequest.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.ibc.channel.QueryChannelClientStateRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryChannelClientStateRequest; + })(); + channel.QueryChannelConsensusStateRequest = (function () { + function QueryChannelConsensusStateRequest(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]]; + } + QueryChannelConsensusStateRequest.prototype.portId = ""; + QueryChannelConsensusStateRequest.prototype.channelId = ""; + QueryChannelConsensusStateRequest.create = function create(properties) { + return new QueryChannelConsensusStateRequest(properties); + }; + QueryChannelConsensusStateRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.portId != null && Object.hasOwnProperty.call(m, "portId")) w.uint32(10).string(m.portId); + if (m.channelId != null && Object.hasOwnProperty.call(m, "channelId")) + w.uint32(18).string(m.channelId); + return w; + }; + QueryChannelConsensusStateRequest.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.ibc.channel.QueryChannelConsensusStateRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.portId = r.string(); + break; + case 2: + m.channelId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryChannelConsensusStateRequest; + })(); + return channel; + })(); + ibc.commitment = (function () { + const commitment = {}; + commitment.MerkleRoot = (function () { + function MerkleRoot(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]]; + } + MerkleRoot.prototype.hash = $util.newBuffer([]); + MerkleRoot.create = function create(properties) { + return new MerkleRoot(properties); + }; + MerkleRoot.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); + return w; + }; + MerkleRoot.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.ibc.commitment.MerkleRoot(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.hash = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MerkleRoot; + })(); + commitment.MerklePrefix = (function () { + function MerklePrefix(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]]; + } + MerklePrefix.prototype.keyPrefix = $util.newBuffer([]); + MerklePrefix.create = function create(properties) { + return new MerklePrefix(properties); + }; + MerklePrefix.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.keyPrefix != null && Object.hasOwnProperty.call(m, "keyPrefix")) + w.uint32(10).bytes(m.keyPrefix); + return w; + }; + MerklePrefix.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.ibc.commitment.MerklePrefix(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.keyPrefix = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MerklePrefix; + })(); + commitment.MerklePath = (function () { + function MerklePath(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]]; + } + MerklePath.prototype.keyPath = null; + MerklePath.create = function create(properties) { + return new MerklePath(properties); + }; + MerklePath.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.keyPath != null && Object.hasOwnProperty.call(m, "keyPath")) + $root.ibc.commitment.KeyPath.encode(m.keyPath, w.uint32(10).fork()).ldelim(); + return w; + }; + MerklePath.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.ibc.commitment.MerklePath(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.keyPath = $root.ibc.commitment.KeyPath.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MerklePath; + })(); + commitment.MerkleProof = (function () { + function MerkleProof(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]]; + } + MerkleProof.prototype.proof = null; + MerkleProof.create = function create(properties) { + return new MerkleProof(properties); + }; + MerkleProof.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) + $root.tendermint.crypto.merkle.Proof.encode(m.proof, w.uint32(10).fork()).ldelim(); + return w; + }; + MerkleProof.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.ibc.commitment.MerkleProof(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.proof = $root.tendermint.crypto.merkle.Proof.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MerkleProof; + })(); + commitment.KeyPath = (function () { + function KeyPath(p) { + this.keys = []; + 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]]; + } + KeyPath.prototype.keys = $util.emptyArray; + KeyPath.create = function create(properties) { + return new KeyPath(properties); + }; + KeyPath.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.keys != null && m.keys.length) { + for (var i = 0; i < m.keys.length; ++i) + $root.ibc.commitment.Key.encode(m.keys[i], w.uint32(10).fork()).ldelim(); + } + return w; + }; + KeyPath.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.ibc.commitment.KeyPath(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.keys && m.keys.length)) m.keys = []; + m.keys.push($root.ibc.commitment.Key.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return KeyPath; + })(); + commitment.Key = (function () { + function Key(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]]; + } + Key.prototype.name = $util.newBuffer([]); + Key.prototype.enc = 0; + Key.create = function create(properties) { + return new Key(properties); + }; + Key.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).bytes(m.name); + if (m.enc != null && Object.hasOwnProperty.call(m, "enc")) w.uint32(16).int32(m.enc); + return w; + }; + Key.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.ibc.commitment.Key(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.bytes(); + break; + case 2: + m.enc = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Key; + })(); + commitment.KeyEncoding = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "KEY_ENCODING_URL_UNSPECIFIED")] = 0; + values[(valuesById[1] = "KEY_ENCODING_HEX")] = 1; + return values; + })(); + return commitment; + })(); + ibc.connection = (function () { + const connection = {}; + connection.MsgConnectionOpenInit = (function () { + function MsgConnectionOpenInit(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]]; + } + MsgConnectionOpenInit.prototype.clientId = ""; + MsgConnectionOpenInit.prototype.connectionId = ""; + MsgConnectionOpenInit.prototype.counterparty = null; + MsgConnectionOpenInit.prototype.signer = $util.newBuffer([]); + MsgConnectionOpenInit.create = function create(properties) { + return new MsgConnectionOpenInit(properties); + }; + MsgConnectionOpenInit.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(10).string(m.clientId); + if (m.connectionId != null && Object.hasOwnProperty.call(m, "connectionId")) + w.uint32(18).string(m.connectionId); + if (m.counterparty != null && Object.hasOwnProperty.call(m, "counterparty")) + $root.ibc.connection.Counterparty.encode(m.counterparty, w.uint32(26).fork()).ldelim(); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(34).bytes(m.signer); + return w; + }; + MsgConnectionOpenInit.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.ibc.connection.MsgConnectionOpenInit(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.clientId = r.string(); + break; + case 2: + m.connectionId = r.string(); + break; + case 3: + m.counterparty = $root.ibc.connection.Counterparty.decode(r, r.uint32()); + break; + case 4: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgConnectionOpenInit; + })(); + connection.MsgConnectionOpenTry = (function () { + function MsgConnectionOpenTry(p) { + this.counterpartyVersions = []; + 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]]; + } + MsgConnectionOpenTry.prototype.clientId = ""; + MsgConnectionOpenTry.prototype.connectionId = ""; + MsgConnectionOpenTry.prototype.counterparty = null; + MsgConnectionOpenTry.prototype.counterpartyVersions = $util.emptyArray; + MsgConnectionOpenTry.prototype.proofInit = $util.newBuffer([]); + MsgConnectionOpenTry.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgConnectionOpenTry.prototype.proofConsensus = $util.newBuffer([]); + MsgConnectionOpenTry.prototype.consensusHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgConnectionOpenTry.prototype.signer = $util.newBuffer([]); + MsgConnectionOpenTry.create = function create(properties) { + return new MsgConnectionOpenTry(properties); + }; + MsgConnectionOpenTry.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(10).string(m.clientId); + if (m.connectionId != null && Object.hasOwnProperty.call(m, "connectionId")) + w.uint32(18).string(m.connectionId); + if (m.counterparty != null && Object.hasOwnProperty.call(m, "counterparty")) + $root.ibc.connection.Counterparty.encode(m.counterparty, w.uint32(26).fork()).ldelim(); + if (m.counterpartyVersions != null && m.counterpartyVersions.length) { + for (var i = 0; i < m.counterpartyVersions.length; ++i) + w.uint32(34).string(m.counterpartyVersions[i]); + } + if (m.proofInit != null && Object.hasOwnProperty.call(m, "proofInit")) + w.uint32(42).bytes(m.proofInit); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(48).uint64(m.proofHeight); + if (m.proofConsensus != null && Object.hasOwnProperty.call(m, "proofConsensus")) + w.uint32(58).bytes(m.proofConsensus); + if (m.consensusHeight != null && Object.hasOwnProperty.call(m, "consensusHeight")) + w.uint32(64).uint64(m.consensusHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(74).bytes(m.signer); + return w; + }; + MsgConnectionOpenTry.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.ibc.connection.MsgConnectionOpenTry(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.clientId = r.string(); + break; + case 2: + m.connectionId = r.string(); + break; + case 3: + m.counterparty = $root.ibc.connection.Counterparty.decode(r, r.uint32()); + break; + case 4: + if (!(m.counterpartyVersions && m.counterpartyVersions.length)) m.counterpartyVersions = []; + m.counterpartyVersions.push(r.string()); + break; + case 5: + m.proofInit = r.bytes(); + break; + case 6: + m.proofHeight = r.uint64(); + break; + case 7: + m.proofConsensus = r.bytes(); + break; + case 8: + m.consensusHeight = r.uint64(); + break; + case 9: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgConnectionOpenTry; + })(); + connection.MsgConnectionOpenAck = (function () { + function MsgConnectionOpenAck(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]]; + } + MsgConnectionOpenAck.prototype.connectionId = ""; + MsgConnectionOpenAck.prototype.version = ""; + MsgConnectionOpenAck.prototype.proofTry = $util.newBuffer([]); + MsgConnectionOpenAck.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgConnectionOpenAck.prototype.proofConsensus = $util.newBuffer([]); + MsgConnectionOpenAck.prototype.consensusHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgConnectionOpenAck.prototype.signer = $util.newBuffer([]); + MsgConnectionOpenAck.create = function create(properties) { + return new MsgConnectionOpenAck(properties); + }; + MsgConnectionOpenAck.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connectionId != null && Object.hasOwnProperty.call(m, "connectionId")) + w.uint32(10).string(m.connectionId); + if (m.version != null && Object.hasOwnProperty.call(m, "version")) w.uint32(18).string(m.version); + if (m.proofTry != null && Object.hasOwnProperty.call(m, "proofTry")) w.uint32(26).bytes(m.proofTry); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + if (m.proofConsensus != null && Object.hasOwnProperty.call(m, "proofConsensus")) + w.uint32(42).bytes(m.proofConsensus); + if (m.consensusHeight != null && Object.hasOwnProperty.call(m, "consensusHeight")) + w.uint32(48).uint64(m.consensusHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(58).bytes(m.signer); + return w; + }; + MsgConnectionOpenAck.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.ibc.connection.MsgConnectionOpenAck(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.connectionId = r.string(); + break; + case 2: + m.version = r.string(); + break; + case 3: + m.proofTry = r.bytes(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + case 5: + m.proofConsensus = r.bytes(); + break; + case 6: + m.consensusHeight = r.uint64(); + break; + case 7: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgConnectionOpenAck; + })(); + connection.MsgConnectionOpenConfirm = (function () { + function MsgConnectionOpenConfirm(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]]; + } + MsgConnectionOpenConfirm.prototype.connectionId = ""; + MsgConnectionOpenConfirm.prototype.proofAck = $util.newBuffer([]); + MsgConnectionOpenConfirm.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgConnectionOpenConfirm.prototype.signer = $util.newBuffer([]); + MsgConnectionOpenConfirm.create = function create(properties) { + return new MsgConnectionOpenConfirm(properties); + }; + MsgConnectionOpenConfirm.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connectionId != null && Object.hasOwnProperty.call(m, "connectionId")) + w.uint32(10).string(m.connectionId); + if (m.proofAck != null && Object.hasOwnProperty.call(m, "proofAck")) w.uint32(18).bytes(m.proofAck); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(24).uint64(m.proofHeight); + if (m.signer != null && Object.hasOwnProperty.call(m, "signer")) w.uint32(34).bytes(m.signer); + return w; + }; + MsgConnectionOpenConfirm.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.ibc.connection.MsgConnectionOpenConfirm(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.connectionId = r.string(); + break; + case 2: + m.proofAck = r.bytes(); + break; + case 3: + m.proofHeight = r.uint64(); + break; + case 4: + m.signer = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgConnectionOpenConfirm; + })(); + connection.ConnectionEnd = (function () { + function ConnectionEnd(p) { + this.versions = []; + 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]]; + } + ConnectionEnd.prototype.clientId = ""; + ConnectionEnd.prototype.versions = $util.emptyArray; + ConnectionEnd.prototype.state = 0; + ConnectionEnd.prototype.counterparty = null; + ConnectionEnd.create = function create(properties) { + return new ConnectionEnd(properties); + }; + ConnectionEnd.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(10).string(m.clientId); + if (m.versions != null && m.versions.length) { + for (var i = 0; i < m.versions.length; ++i) w.uint32(18).string(m.versions[i]); + } + if (m.state != null && Object.hasOwnProperty.call(m, "state")) w.uint32(24).int32(m.state); + if (m.counterparty != null && Object.hasOwnProperty.call(m, "counterparty")) + $root.ibc.connection.Counterparty.encode(m.counterparty, w.uint32(34).fork()).ldelim(); + return w; + }; + ConnectionEnd.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.ibc.connection.ConnectionEnd(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.clientId = r.string(); + break; + case 2: + if (!(m.versions && m.versions.length)) m.versions = []; + m.versions.push(r.string()); + break; + case 3: + m.state = r.int32(); + break; + case 4: + m.counterparty = $root.ibc.connection.Counterparty.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ConnectionEnd; + })(); + connection.IdentifiedConnection = (function () { + function IdentifiedConnection(p) { + this.versions = []; + 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]]; + } + IdentifiedConnection.prototype.id = ""; + IdentifiedConnection.prototype.clientId = ""; + IdentifiedConnection.prototype.versions = $util.emptyArray; + IdentifiedConnection.prototype.state = 0; + IdentifiedConnection.prototype.counterparty = null; + IdentifiedConnection.create = function create(properties) { + return new IdentifiedConnection(properties); + }; + IdentifiedConnection.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.id != null && Object.hasOwnProperty.call(m, "id")) w.uint32(10).string(m.id); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(18).string(m.clientId); + if (m.versions != null && m.versions.length) { + for (var i = 0; i < m.versions.length; ++i) w.uint32(26).string(m.versions[i]); + } + if (m.state != null && Object.hasOwnProperty.call(m, "state")) w.uint32(32).int32(m.state); + if (m.counterparty != null && Object.hasOwnProperty.call(m, "counterparty")) + $root.ibc.connection.Counterparty.encode(m.counterparty, w.uint32(42).fork()).ldelim(); + return w; + }; + IdentifiedConnection.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.ibc.connection.IdentifiedConnection(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.id = r.string(); + break; + case 2: + m.clientId = r.string(); + break; + case 3: + if (!(m.versions && m.versions.length)) m.versions = []; + m.versions.push(r.string()); + break; + case 4: + m.state = r.int32(); + break; + case 5: + m.counterparty = $root.ibc.connection.Counterparty.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return IdentifiedConnection; + })(); + connection.State = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "STATE_UNINITIALIZED_UNSPECIFIED")] = 0; + values[(valuesById[1] = "STATE_INIT")] = 1; + values[(valuesById[2] = "STATE_TRYOPEN")] = 2; + values[(valuesById[3] = "STATE_OPEN")] = 3; + return values; + })(); + connection.Counterparty = (function () { + function Counterparty(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]]; + } + Counterparty.prototype.clientId = ""; + Counterparty.prototype.connectionId = ""; + Counterparty.prototype.prefix = null; + Counterparty.create = function create(properties) { + return new Counterparty(properties); + }; + Counterparty.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(10).string(m.clientId); + if (m.connectionId != null && Object.hasOwnProperty.call(m, "connectionId")) + w.uint32(18).string(m.connectionId); + if (m.prefix != null && Object.hasOwnProperty.call(m, "prefix")) + $root.ibc.commitment.MerklePrefix.encode(m.prefix, w.uint32(26).fork()).ldelim(); + return w; + }; + Counterparty.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.ibc.connection.Counterparty(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.clientId = r.string(); + break; + case 2: + m.connectionId = r.string(); + break; + case 3: + m.prefix = $root.ibc.commitment.MerklePrefix.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Counterparty; + })(); + connection.ClientPaths = (function () { + function ClientPaths(p) { + this.paths = []; + 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]]; + } + ClientPaths.prototype.paths = $util.emptyArray; + ClientPaths.create = function create(properties) { + return new ClientPaths(properties); + }; + ClientPaths.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.paths != null && m.paths.length) { + for (var i = 0; i < m.paths.length; ++i) w.uint32(10).string(m.paths[i]); + } + return w; + }; + ClientPaths.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.ibc.connection.ClientPaths(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.paths && m.paths.length)) m.paths = []; + m.paths.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ClientPaths; + })(); + connection.ConnectionPaths = (function () { + function ConnectionPaths(p) { + this.paths = []; + 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]]; + } + ConnectionPaths.prototype.clientId = ""; + ConnectionPaths.prototype.paths = $util.emptyArray; + ConnectionPaths.create = function create(properties) { + return new ConnectionPaths(properties); + }; + ConnectionPaths.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(10).string(m.clientId); + if (m.paths != null && m.paths.length) { + for (var i = 0; i < m.paths.length; ++i) w.uint32(18).string(m.paths[i]); + } + return w; + }; + ConnectionPaths.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.ibc.connection.ConnectionPaths(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.clientId = r.string(); + break; + case 2: + if (!(m.paths && m.paths.length)) m.paths = []; + m.paths.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ConnectionPaths; + })(); + connection.Version = (function () { + function Version(p) { + this.features = []; + 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]]; + } + Version.prototype.identifier = ""; + Version.prototype.features = $util.emptyArray; + Version.create = function create(properties) { + return new Version(properties); + }; + Version.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.identifier != null && Object.hasOwnProperty.call(m, "identifier")) + w.uint32(10).string(m.identifier); + if (m.features != null && m.features.length) { + for (var i = 0; i < m.features.length; ++i) w.uint32(18).string(m.features[i]); + } + return w; + }; + Version.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.ibc.connection.Version(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.identifier = r.string(); + break; + case 2: + if (!(m.features && m.features.length)) m.features = []; + m.features.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Version; + })(); + connection.Query = (function () { + function Query(rpcImpl, requestDelimited, responseDelimited) { + $protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited); + } + (Query.prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = Query; + Query.create = function create(rpcImpl, requestDelimited, responseDelimited) { + return new this(rpcImpl, requestDelimited, responseDelimited); + }; + Object.defineProperty( + (Query.prototype.connection = function connection(request, callback) { + return this.rpcCall( + connection, + $root.ibc.connection.QueryConnectionRequest, + $root.ibc.connection.QueryConnectionResponse, + request, + callback, + ); + }), + "name", + { value: "Connection" }, + ); + Object.defineProperty( + (Query.prototype.connections = function connections(request, callback) { + return this.rpcCall( + connections, + $root.ibc.connection.QueryConnectionsRequest, + $root.ibc.connection.QueryConnectionsResponse, + request, + callback, + ); + }), + "name", + { value: "Connections" }, + ); + Object.defineProperty( + (Query.prototype.clientConnections = function clientConnections(request, callback) { + return this.rpcCall( + clientConnections, + $root.ibc.connection.QueryClientConnectionsRequest, + $root.ibc.connection.QueryClientConnectionsResponse, + request, + callback, + ); + }), + "name", + { value: "ClientConnections" }, + ); + return Query; + })(); + connection.QueryConnectionRequest = (function () { + function QueryConnectionRequest(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]]; + } + QueryConnectionRequest.prototype.connectionId = ""; + QueryConnectionRequest.create = function create(properties) { + return new QueryConnectionRequest(properties); + }; + QueryConnectionRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connectionId != null && Object.hasOwnProperty.call(m, "connectionId")) + w.uint32(10).string(m.connectionId); + return w; + }; + QueryConnectionRequest.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.ibc.connection.QueryConnectionRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.connectionId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryConnectionRequest; + })(); + connection.QueryConnectionResponse = (function () { + function QueryConnectionResponse(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]]; + } + QueryConnectionResponse.prototype.connection = null; + QueryConnectionResponse.prototype.proof = $util.newBuffer([]); + QueryConnectionResponse.prototype.proofPath = ""; + QueryConnectionResponse.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryConnectionResponse.create = function create(properties) { + return new QueryConnectionResponse(properties); + }; + QueryConnectionResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connection != null && Object.hasOwnProperty.call(m, "connection")) + $root.ibc.connection.ConnectionEnd.encode(m.connection, w.uint32(10).fork()).ldelim(); + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofPath != null && Object.hasOwnProperty.call(m, "proofPath")) + w.uint32(26).string(m.proofPath); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + return w; + }; + QueryConnectionResponse.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.ibc.connection.QueryConnectionResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.connection = $root.ibc.connection.ConnectionEnd.decode(r, r.uint32()); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofPath = r.string(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryConnectionResponse; + })(); + connection.QueryConnectionsRequest = (function () { + function QueryConnectionsRequest(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]]; + } + QueryConnectionsRequest.prototype.pagination = null; + QueryConnectionsRequest.create = function create(properties) { + return new QueryConnectionsRequest(properties); + }; + QueryConnectionsRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageRequest.encode(m.pagination, w.uint32(10).fork()).ldelim(); + return w; + }; + QueryConnectionsRequest.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.ibc.connection.QueryConnectionsRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.pagination = $root.cosmos.query.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryConnectionsRequest; + })(); + connection.QueryConnectionsResponse = (function () { + function QueryConnectionsResponse(p) { + this.connections = []; + 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]]; + } + QueryConnectionsResponse.prototype.connections = $util.emptyArray; + QueryConnectionsResponse.prototype.pagination = null; + QueryConnectionsResponse.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + QueryConnectionsResponse.create = function create(properties) { + return new QueryConnectionsResponse(properties); + }; + QueryConnectionsResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connections != null && m.connections.length) { + for (var i = 0; i < m.connections.length; ++i) + $root.ibc.connection.IdentifiedConnection.encode(m.connections[i], w.uint32(10).fork()).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.query.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(24).int64(m.height); + return w; + }; + QueryConnectionsResponse.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.ibc.connection.QueryConnectionsResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.connections && m.connections.length)) m.connections = []; + m.connections.push($root.ibc.connection.IdentifiedConnection.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.query.PageResponse.decode(r, r.uint32()); + break; + case 3: + m.height = r.int64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryConnectionsResponse; + })(); + connection.QueryClientConnectionsRequest = (function () { + function QueryClientConnectionsRequest(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]]; + } + QueryClientConnectionsRequest.prototype.clientId = ""; + QueryClientConnectionsRequest.create = function create(properties) { + return new QueryClientConnectionsRequest(properties); + }; + QueryClientConnectionsRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.clientId != null && Object.hasOwnProperty.call(m, "clientId")) w.uint32(10).string(m.clientId); + return w; + }; + QueryClientConnectionsRequest.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.ibc.connection.QueryClientConnectionsRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.clientId = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryClientConnectionsRequest; + })(); + connection.QueryClientConnectionsResponse = (function () { + function QueryClientConnectionsResponse(p) { + this.connectionPaths = []; + 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]]; + } + QueryClientConnectionsResponse.prototype.connectionPaths = $util.emptyArray; + QueryClientConnectionsResponse.prototype.proof = $util.newBuffer([]); + QueryClientConnectionsResponse.prototype.proofPath = ""; + QueryClientConnectionsResponse.prototype.proofHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryClientConnectionsResponse.create = function create(properties) { + return new QueryClientConnectionsResponse(properties); + }; + QueryClientConnectionsResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.connectionPaths != null && m.connectionPaths.length) { + for (var i = 0; i < m.connectionPaths.length; ++i) w.uint32(10).string(m.connectionPaths[i]); + } + if (m.proof != null && Object.hasOwnProperty.call(m, "proof")) w.uint32(18).bytes(m.proof); + if (m.proofPath != null && Object.hasOwnProperty.call(m, "proofPath")) + w.uint32(26).string(m.proofPath); + if (m.proofHeight != null && Object.hasOwnProperty.call(m, "proofHeight")) + w.uint32(32).uint64(m.proofHeight); + return w; + }; + QueryClientConnectionsResponse.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.ibc.connection.QueryClientConnectionsResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.connectionPaths && m.connectionPaths.length)) m.connectionPaths = []; + m.connectionPaths.push(r.string()); + break; + case 2: + m.proof = r.bytes(); + break; + case 3: + m.proofPath = r.string(); + break; + case 4: + m.proofHeight = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryClientConnectionsResponse; + })(); + return connection; + })(); + return ibc; +})(); exports.tendermint = $root.tendermint = (() => { const tendermint = {}; tendermint.abci = (function () { diff --git a/packages/stargate/types/codec/generated/codecimpl.d.ts b/packages/stargate/types/codec/generated/codecimpl.d.ts index 43c0b29b..e205516f 100644 --- a/packages/stargate/types/codec/generated/codecimpl.d.ts +++ b/packages/stargate/types/codec/generated/codecimpl.d.ts @@ -3303,6 +3303,3687 @@ export namespace cosmos { } } +/** Namespace ibc. */ +export namespace ibc { + /** Namespace channel. */ + namespace channel { + /** Properties of a MsgChannelOpenInit. */ + interface IMsgChannelOpenInit { + /** MsgChannelOpenInit portId */ + portId?: string | null; + + /** MsgChannelOpenInit channelId */ + channelId?: string | null; + + /** MsgChannelOpenInit channel */ + channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenInit signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenInit. */ + class MsgChannelOpenInit implements IMsgChannelOpenInit { + /** + * Constructs a new MsgChannelOpenInit. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenInit); + + /** MsgChannelOpenInit portId. */ + public portId: string; + + /** MsgChannelOpenInit channelId. */ + public channelId: string; + + /** MsgChannelOpenInit channel. */ + public channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenInit signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenInit instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenInit instance + */ + public static create(properties?: ibc.channel.IMsgChannelOpenInit): ibc.channel.MsgChannelOpenInit; + + /** + * Encodes the specified MsgChannelOpenInit message. Does not implicitly {@link ibc.channel.MsgChannelOpenInit.verify|verify} messages. + * @param m MsgChannelOpenInit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenInit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenInit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenInit + * @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): ibc.channel.MsgChannelOpenInit; + } + + /** Properties of a MsgChannelOpenTry. */ + interface IMsgChannelOpenTry { + /** MsgChannelOpenTry portId */ + portId?: string | null; + + /** MsgChannelOpenTry channelId */ + channelId?: string | null; + + /** MsgChannelOpenTry channel */ + channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenTry counterpartyVersion */ + counterpartyVersion?: string | null; + + /** MsgChannelOpenTry proofInit */ + proofInit?: Uint8Array | null; + + /** MsgChannelOpenTry proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelOpenTry signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenTry. */ + class MsgChannelOpenTry implements IMsgChannelOpenTry { + /** + * Constructs a new MsgChannelOpenTry. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenTry); + + /** MsgChannelOpenTry portId. */ + public portId: string; + + /** MsgChannelOpenTry channelId. */ + public channelId: string; + + /** MsgChannelOpenTry channel. */ + public channel?: ibc.channel.IChannel | null; + + /** MsgChannelOpenTry counterpartyVersion. */ + public counterpartyVersion: string; + + /** MsgChannelOpenTry proofInit. */ + public proofInit: Uint8Array; + + /** MsgChannelOpenTry proofHeight. */ + public proofHeight: Long; + + /** MsgChannelOpenTry signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenTry instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenTry instance + */ + public static create(properties?: ibc.channel.IMsgChannelOpenTry): ibc.channel.MsgChannelOpenTry; + + /** + * Encodes the specified MsgChannelOpenTry message. Does not implicitly {@link ibc.channel.MsgChannelOpenTry.verify|verify} messages. + * @param m MsgChannelOpenTry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenTry, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenTry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenTry + * @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): ibc.channel.MsgChannelOpenTry; + } + + /** Properties of a MsgChannelOpenAck. */ + interface IMsgChannelOpenAck { + /** MsgChannelOpenAck portId */ + portId?: string | null; + + /** MsgChannelOpenAck channelId */ + channelId?: string | null; + + /** MsgChannelOpenAck counterpartyVersion */ + counterpartyVersion?: string | null; + + /** MsgChannelOpenAck proofTry */ + proofTry?: Uint8Array | null; + + /** MsgChannelOpenAck proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelOpenAck signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenAck. */ + class MsgChannelOpenAck implements IMsgChannelOpenAck { + /** + * Constructs a new MsgChannelOpenAck. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenAck); + + /** MsgChannelOpenAck portId. */ + public portId: string; + + /** MsgChannelOpenAck channelId. */ + public channelId: string; + + /** MsgChannelOpenAck counterpartyVersion. */ + public counterpartyVersion: string; + + /** MsgChannelOpenAck proofTry. */ + public proofTry: Uint8Array; + + /** MsgChannelOpenAck proofHeight. */ + public proofHeight: Long; + + /** MsgChannelOpenAck signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenAck instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenAck instance + */ + public static create(properties?: ibc.channel.IMsgChannelOpenAck): ibc.channel.MsgChannelOpenAck; + + /** + * Encodes the specified MsgChannelOpenAck message. Does not implicitly {@link ibc.channel.MsgChannelOpenAck.verify|verify} messages. + * @param m MsgChannelOpenAck message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenAck, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenAck message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenAck + * @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): ibc.channel.MsgChannelOpenAck; + } + + /** Properties of a MsgChannelOpenConfirm. */ + interface IMsgChannelOpenConfirm { + /** MsgChannelOpenConfirm portId */ + portId?: string | null; + + /** MsgChannelOpenConfirm channelId */ + channelId?: string | null; + + /** MsgChannelOpenConfirm proofAck */ + proofAck?: Uint8Array | null; + + /** MsgChannelOpenConfirm proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelOpenConfirm signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelOpenConfirm. */ + class MsgChannelOpenConfirm implements IMsgChannelOpenConfirm { + /** + * Constructs a new MsgChannelOpenConfirm. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelOpenConfirm); + + /** MsgChannelOpenConfirm portId. */ + public portId: string; + + /** MsgChannelOpenConfirm channelId. */ + public channelId: string; + + /** MsgChannelOpenConfirm proofAck. */ + public proofAck: Uint8Array; + + /** MsgChannelOpenConfirm proofHeight. */ + public proofHeight: Long; + + /** MsgChannelOpenConfirm signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelOpenConfirm instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelOpenConfirm instance + */ + public static create( + properties?: ibc.channel.IMsgChannelOpenConfirm, + ): ibc.channel.MsgChannelOpenConfirm; + + /** + * Encodes the specified MsgChannelOpenConfirm message. Does not implicitly {@link ibc.channel.MsgChannelOpenConfirm.verify|verify} messages. + * @param m MsgChannelOpenConfirm message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelOpenConfirm, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelOpenConfirm message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelOpenConfirm + * @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): ibc.channel.MsgChannelOpenConfirm; + } + + /** Properties of a MsgChannelCloseInit. */ + interface IMsgChannelCloseInit { + /** MsgChannelCloseInit portId */ + portId?: string | null; + + /** MsgChannelCloseInit channelId */ + channelId?: string | null; + + /** MsgChannelCloseInit signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelCloseInit. */ + class MsgChannelCloseInit implements IMsgChannelCloseInit { + /** + * Constructs a new MsgChannelCloseInit. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelCloseInit); + + /** MsgChannelCloseInit portId. */ + public portId: string; + + /** MsgChannelCloseInit channelId. */ + public channelId: string; + + /** MsgChannelCloseInit signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelCloseInit instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelCloseInit instance + */ + public static create(properties?: ibc.channel.IMsgChannelCloseInit): ibc.channel.MsgChannelCloseInit; + + /** + * Encodes the specified MsgChannelCloseInit message. Does not implicitly {@link ibc.channel.MsgChannelCloseInit.verify|verify} messages. + * @param m MsgChannelCloseInit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelCloseInit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelCloseInit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelCloseInit + * @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): ibc.channel.MsgChannelCloseInit; + } + + /** Properties of a MsgChannelCloseConfirm. */ + interface IMsgChannelCloseConfirm { + /** MsgChannelCloseConfirm portId */ + portId?: string | null; + + /** MsgChannelCloseConfirm channelId */ + channelId?: string | null; + + /** MsgChannelCloseConfirm proofInit */ + proofInit?: Uint8Array | null; + + /** MsgChannelCloseConfirm proofHeight */ + proofHeight?: Long | null; + + /** MsgChannelCloseConfirm signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgChannelCloseConfirm. */ + class MsgChannelCloseConfirm implements IMsgChannelCloseConfirm { + /** + * Constructs a new MsgChannelCloseConfirm. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgChannelCloseConfirm); + + /** MsgChannelCloseConfirm portId. */ + public portId: string; + + /** MsgChannelCloseConfirm channelId. */ + public channelId: string; + + /** MsgChannelCloseConfirm proofInit. */ + public proofInit: Uint8Array; + + /** MsgChannelCloseConfirm proofHeight. */ + public proofHeight: Long; + + /** MsgChannelCloseConfirm signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgChannelCloseConfirm instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgChannelCloseConfirm instance + */ + public static create( + properties?: ibc.channel.IMsgChannelCloseConfirm, + ): ibc.channel.MsgChannelCloseConfirm; + + /** + * Encodes the specified MsgChannelCloseConfirm message. Does not implicitly {@link ibc.channel.MsgChannelCloseConfirm.verify|verify} messages. + * @param m MsgChannelCloseConfirm message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgChannelCloseConfirm, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgChannelCloseConfirm message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgChannelCloseConfirm + * @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): ibc.channel.MsgChannelCloseConfirm; + } + + /** Properties of a MsgRecvPacket. */ + interface IMsgRecvPacket { + /** MsgRecvPacket packet */ + packet?: ibc.channel.IPacket | null; + + /** MsgRecvPacket proof */ + proof?: Uint8Array | null; + + /** MsgRecvPacket proofHeight */ + proofHeight?: Long | null; + + /** MsgRecvPacket signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgRecvPacket. */ + class MsgRecvPacket implements IMsgRecvPacket { + /** + * Constructs a new MsgRecvPacket. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgRecvPacket); + + /** MsgRecvPacket packet. */ + public packet?: ibc.channel.IPacket | null; + + /** MsgRecvPacket proof. */ + public proof: Uint8Array; + + /** MsgRecvPacket proofHeight. */ + public proofHeight: Long; + + /** MsgRecvPacket signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgRecvPacket instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgRecvPacket instance + */ + public static create(properties?: ibc.channel.IMsgRecvPacket): ibc.channel.MsgRecvPacket; + + /** + * Encodes the specified MsgRecvPacket message. Does not implicitly {@link ibc.channel.MsgRecvPacket.verify|verify} messages. + * @param m MsgRecvPacket message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgRecvPacket, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgRecvPacket message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgRecvPacket + * @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): ibc.channel.MsgRecvPacket; + } + + /** Properties of a MsgTimeout. */ + interface IMsgTimeout { + /** MsgTimeout packet */ + packet?: ibc.channel.IPacket | null; + + /** MsgTimeout proof */ + proof?: Uint8Array | null; + + /** MsgTimeout proofHeight */ + proofHeight?: Long | null; + + /** MsgTimeout nextSequenceRecv */ + nextSequenceRecv?: Long | null; + + /** MsgTimeout signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgTimeout. */ + class MsgTimeout implements IMsgTimeout { + /** + * Constructs a new MsgTimeout. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgTimeout); + + /** MsgTimeout packet. */ + public packet?: ibc.channel.IPacket | null; + + /** MsgTimeout proof. */ + public proof: Uint8Array; + + /** MsgTimeout proofHeight. */ + public proofHeight: Long; + + /** MsgTimeout nextSequenceRecv. */ + public nextSequenceRecv: Long; + + /** MsgTimeout signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgTimeout instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgTimeout instance + */ + public static create(properties?: ibc.channel.IMsgTimeout): ibc.channel.MsgTimeout; + + /** + * Encodes the specified MsgTimeout message. Does not implicitly {@link ibc.channel.MsgTimeout.verify|verify} messages. + * @param m MsgTimeout message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgTimeout, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgTimeout message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgTimeout + * @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): ibc.channel.MsgTimeout; + } + + /** Properties of a MsgAcknowledgement. */ + interface IMsgAcknowledgement { + /** MsgAcknowledgement packet */ + packet?: ibc.channel.IPacket | null; + + /** MsgAcknowledgement acknowledgement */ + acknowledgement?: Uint8Array | null; + + /** MsgAcknowledgement proof */ + proof?: Uint8Array | null; + + /** MsgAcknowledgement proofHeight */ + proofHeight?: Long | null; + + /** MsgAcknowledgement signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgAcknowledgement. */ + class MsgAcknowledgement implements IMsgAcknowledgement { + /** + * Constructs a new MsgAcknowledgement. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IMsgAcknowledgement); + + /** MsgAcknowledgement packet. */ + public packet?: ibc.channel.IPacket | null; + + /** MsgAcknowledgement acknowledgement. */ + public acknowledgement: Uint8Array; + + /** MsgAcknowledgement proof. */ + public proof: Uint8Array; + + /** MsgAcknowledgement proofHeight. */ + public proofHeight: Long; + + /** MsgAcknowledgement signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgAcknowledgement instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgAcknowledgement instance + */ + public static create(properties?: ibc.channel.IMsgAcknowledgement): ibc.channel.MsgAcknowledgement; + + /** + * Encodes the specified MsgAcknowledgement message. Does not implicitly {@link ibc.channel.MsgAcknowledgement.verify|verify} messages. + * @param m MsgAcknowledgement message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IMsgAcknowledgement, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgAcknowledgement message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgAcknowledgement + * @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): ibc.channel.MsgAcknowledgement; + } + + /** Properties of a Channel. */ + interface IChannel { + /** Channel state */ + state?: ibc.channel.State | null; + + /** Channel ordering */ + ordering?: ibc.channel.Order | null; + + /** Channel counterparty */ + counterparty?: ibc.channel.ICounterparty | null; + + /** Channel connectionHops */ + connectionHops?: string[] | null; + + /** Channel version */ + version?: string | null; + } + + /** Represents a Channel. */ + class Channel implements IChannel { + /** + * Constructs a new Channel. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IChannel); + + /** Channel state. */ + public state: ibc.channel.State; + + /** Channel ordering. */ + public ordering: ibc.channel.Order; + + /** Channel counterparty. */ + public counterparty?: ibc.channel.ICounterparty | null; + + /** Channel connectionHops. */ + public connectionHops: string[]; + + /** Channel version. */ + public version: string; + + /** + * Creates a new Channel instance using the specified properties. + * @param [properties] Properties to set + * @returns Channel instance + */ + public static create(properties?: ibc.channel.IChannel): ibc.channel.Channel; + + /** + * Encodes the specified Channel message. Does not implicitly {@link ibc.channel.Channel.verify|verify} messages. + * @param m Channel message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IChannel, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Channel message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Channel + * @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): ibc.channel.Channel; + } + + /** Properties of an IdentifiedChannel. */ + interface IIdentifiedChannel { + /** IdentifiedChannel state */ + state?: ibc.channel.State | null; + + /** IdentifiedChannel ordering */ + ordering?: ibc.channel.Order | null; + + /** IdentifiedChannel counterparty */ + counterparty?: ibc.channel.ICounterparty | null; + + /** IdentifiedChannel connectionHops */ + connectionHops?: string[] | null; + + /** IdentifiedChannel version */ + version?: string | null; + + /** IdentifiedChannel portId */ + portId?: string | null; + + /** IdentifiedChannel channelId */ + channelId?: string | null; + } + + /** Represents an IdentifiedChannel. */ + class IdentifiedChannel implements IIdentifiedChannel { + /** + * Constructs a new IdentifiedChannel. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IIdentifiedChannel); + + /** IdentifiedChannel state. */ + public state: ibc.channel.State; + + /** IdentifiedChannel ordering. */ + public ordering: ibc.channel.Order; + + /** IdentifiedChannel counterparty. */ + public counterparty?: ibc.channel.ICounterparty | null; + + /** IdentifiedChannel connectionHops. */ + public connectionHops: string[]; + + /** IdentifiedChannel version. */ + public version: string; + + /** IdentifiedChannel portId. */ + public portId: string; + + /** IdentifiedChannel channelId. */ + public channelId: string; + + /** + * Creates a new IdentifiedChannel instance using the specified properties. + * @param [properties] Properties to set + * @returns IdentifiedChannel instance + */ + public static create(properties?: ibc.channel.IIdentifiedChannel): ibc.channel.IdentifiedChannel; + + /** + * Encodes the specified IdentifiedChannel message. Does not implicitly {@link ibc.channel.IdentifiedChannel.verify|verify} messages. + * @param m IdentifiedChannel message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IIdentifiedChannel, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IdentifiedChannel message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns IdentifiedChannel + * @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): ibc.channel.IdentifiedChannel; + } + + /** State enum. */ + enum State { + STATE_UNINITIALIZED_UNSPECIFIED = 0, + STATE_INIT = 1, + STATE_TRYOPEN = 2, + STATE_OPEN = 3, + STATE_CLOSED = 4, + } + + /** Order enum. */ + enum Order { + ORDER_NONE_UNSPECIFIED = 0, + ORDER_UNORDERED = 1, + ORDER_ORDERED = 2, + } + + /** Properties of a Counterparty. */ + interface ICounterparty { + /** Counterparty portId */ + portId?: string | null; + + /** Counterparty channelId */ + channelId?: string | null; + } + + /** Represents a Counterparty. */ + class Counterparty implements ICounterparty { + /** + * Constructs a new Counterparty. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.ICounterparty); + + /** Counterparty portId. */ + public portId: string; + + /** Counterparty channelId. */ + public channelId: string; + + /** + * Creates a new Counterparty instance using the specified properties. + * @param [properties] Properties to set + * @returns Counterparty instance + */ + public static create(properties?: ibc.channel.ICounterparty): ibc.channel.Counterparty; + + /** + * Encodes the specified Counterparty message. Does not implicitly {@link ibc.channel.Counterparty.verify|verify} messages. + * @param m Counterparty message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.ICounterparty, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Counterparty message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Counterparty + * @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): ibc.channel.Counterparty; + } + + /** Properties of a Packet. */ + interface IPacket { + /** Packet sequence */ + sequence?: Long | null; + + /** Packet sourcePort */ + sourcePort?: string | null; + + /** Packet sourceChannel */ + sourceChannel?: string | null; + + /** Packet destinationPort */ + destinationPort?: string | null; + + /** Packet destinationChannel */ + destinationChannel?: string | null; + + /** Packet data */ + data?: Uint8Array | null; + + /** Packet timeoutHeight */ + timeoutHeight?: Long | null; + + /** Packet timeoutTimestamp */ + timeoutTimestamp?: Long | null; + } + + /** Represents a Packet. */ + class Packet implements IPacket { + /** + * Constructs a new Packet. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IPacket); + + /** Packet sequence. */ + public sequence: Long; + + /** Packet sourcePort. */ + public sourcePort: string; + + /** Packet sourceChannel. */ + public sourceChannel: string; + + /** Packet destinationPort. */ + public destinationPort: string; + + /** Packet destinationChannel. */ + public destinationChannel: string; + + /** Packet data. */ + public data: Uint8Array; + + /** Packet timeoutHeight. */ + public timeoutHeight: Long; + + /** Packet timeoutTimestamp. */ + public timeoutTimestamp: Long; + + /** + * Creates a new Packet instance using the specified properties. + * @param [properties] Properties to set + * @returns Packet instance + */ + public static create(properties?: ibc.channel.IPacket): ibc.channel.Packet; + + /** + * Encodes the specified Packet message. Does not implicitly {@link ibc.channel.Packet.verify|verify} messages. + * @param m Packet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IPacket, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Packet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Packet + * @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): ibc.channel.Packet; + } + + /** Properties of a PacketAckCommitment. */ + interface IPacketAckCommitment { + /** PacketAckCommitment portId */ + portId?: string | null; + + /** PacketAckCommitment channelId */ + channelId?: string | null; + + /** PacketAckCommitment sequence */ + sequence?: Long | null; + + /** PacketAckCommitment hash */ + hash?: Uint8Array | null; + } + + /** Represents a PacketAckCommitment. */ + class PacketAckCommitment implements IPacketAckCommitment { + /** + * Constructs a new PacketAckCommitment. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IPacketAckCommitment); + + /** PacketAckCommitment portId. */ + public portId: string; + + /** PacketAckCommitment channelId. */ + public channelId: string; + + /** PacketAckCommitment sequence. */ + public sequence: Long; + + /** PacketAckCommitment hash. */ + public hash: Uint8Array; + + /** + * Creates a new PacketAckCommitment instance using the specified properties. + * @param [properties] Properties to set + * @returns PacketAckCommitment instance + */ + public static create(properties?: ibc.channel.IPacketAckCommitment): ibc.channel.PacketAckCommitment; + + /** + * Encodes the specified PacketAckCommitment message. Does not implicitly {@link ibc.channel.PacketAckCommitment.verify|verify} messages. + * @param m PacketAckCommitment message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IPacketAckCommitment, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PacketAckCommitment message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PacketAckCommitment + * @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): ibc.channel.PacketAckCommitment; + } + + /** Represents a Query */ + class Query extends $protobuf.rpc.Service { + /** + * Constructs a new Query service. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + */ + constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean); + + /** + * Creates new Query service using the specified rpc implementation. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + * @returns RPC service. Useful where requests and/or responses are streamed. + */ + public static create( + rpcImpl: $protobuf.RPCImpl, + requestDelimited?: boolean, + responseDelimited?: boolean, + ): Query; + + /** + * Calls Channel. + * @param request QueryChannelRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryChannelResponse + */ + public channel( + request: ibc.channel.IQueryChannelRequest, + callback: ibc.channel.Query.ChannelCallback, + ): void; + + /** + * Calls Channel. + * @param request QueryChannelRequest message or plain object + * @returns Promise + */ + public channel(request: ibc.channel.IQueryChannelRequest): Promise; + + /** + * Calls Channels. + * @param request QueryChannelsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryChannelsResponse + */ + public channels( + request: ibc.channel.IQueryChannelsRequest, + callback: ibc.channel.Query.ChannelsCallback, + ): void; + + /** + * Calls Channels. + * @param request QueryChannelsRequest message or plain object + * @returns Promise + */ + public channels(request: ibc.channel.IQueryChannelsRequest): Promise; + + /** + * Calls ConnectionChannels. + * @param request QueryConnectionChannelsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryConnectionChannelsResponse + */ + public connectionChannels( + request: ibc.channel.IQueryConnectionChannelsRequest, + callback: ibc.channel.Query.ConnectionChannelsCallback, + ): void; + + /** + * Calls ConnectionChannels. + * @param request QueryConnectionChannelsRequest message or plain object + * @returns Promise + */ + public connectionChannels( + request: ibc.channel.IQueryConnectionChannelsRequest, + ): Promise; + + /** + * Calls PacketCommitment. + * @param request QueryPacketCommitmentRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryPacketCommitmentResponse + */ + public packetCommitment( + request: ibc.channel.IQueryPacketCommitmentRequest, + callback: ibc.channel.Query.PacketCommitmentCallback, + ): void; + + /** + * Calls PacketCommitment. + * @param request QueryPacketCommitmentRequest message or plain object + * @returns Promise + */ + public packetCommitment( + request: ibc.channel.IQueryPacketCommitmentRequest, + ): Promise; + + /** + * Calls PacketCommitments. + * @param request QueryPacketCommitmentsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryPacketCommitmentsResponse + */ + public packetCommitments( + request: ibc.channel.IQueryPacketCommitmentsRequest, + callback: ibc.channel.Query.PacketCommitmentsCallback, + ): void; + + /** + * Calls PacketCommitments. + * @param request QueryPacketCommitmentsRequest message or plain object + * @returns Promise + */ + public packetCommitments( + request: ibc.channel.IQueryPacketCommitmentsRequest, + ): Promise; + + /** + * Calls PacketAcknowledgement. + * @param request QueryPacketAcknowledgementRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryPacketAcknowledgementResponse + */ + public packetAcknowledgement( + request: ibc.channel.IQueryPacketAcknowledgementRequest, + callback: ibc.channel.Query.PacketAcknowledgementCallback, + ): void; + + /** + * Calls PacketAcknowledgement. + * @param request QueryPacketAcknowledgementRequest message or plain object + * @returns Promise + */ + public packetAcknowledgement( + request: ibc.channel.IQueryPacketAcknowledgementRequest, + ): Promise; + + /** + * Calls UnrelayedPackets. + * @param request QueryUnrelayedPacketsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryUnrelayedPacketsResponse + */ + public unrelayedPackets( + request: ibc.channel.IQueryUnrelayedPacketsRequest, + callback: ibc.channel.Query.UnrelayedPacketsCallback, + ): void; + + /** + * Calls UnrelayedPackets. + * @param request QueryUnrelayedPacketsRequest message or plain object + * @returns Promise + */ + public unrelayedPackets( + request: ibc.channel.IQueryUnrelayedPacketsRequest, + ): Promise; + + /** + * Calls NextSequenceReceive. + * @param request QueryNextSequenceReceiveRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryNextSequenceReceiveResponse + */ + public nextSequenceReceive( + request: ibc.channel.IQueryNextSequenceReceiveRequest, + callback: ibc.channel.Query.NextSequenceReceiveCallback, + ): void; + + /** + * Calls NextSequenceReceive. + * @param request QueryNextSequenceReceiveRequest message or plain object + * @returns Promise + */ + public nextSequenceReceive( + request: ibc.channel.IQueryNextSequenceReceiveRequest, + ): Promise; + } + + namespace Query { + /** + * Callback as used by {@link ibc.channel.Query#channel}. + * @param error Error, if any + * @param [response] QueryChannelResponse + */ + type ChannelCallback = (error: Error | null, response?: ibc.channel.QueryChannelResponse) => void; + + /** + * Callback as used by {@link ibc.channel.Query#channels}. + * @param error Error, if any + * @param [response] QueryChannelsResponse + */ + type ChannelsCallback = (error: Error | null, response?: ibc.channel.QueryChannelsResponse) => void; + + /** + * Callback as used by {@link ibc.channel.Query#connectionChannels}. + * @param error Error, if any + * @param [response] QueryConnectionChannelsResponse + */ + type ConnectionChannelsCallback = ( + error: Error | null, + response?: ibc.channel.QueryConnectionChannelsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#packetCommitment}. + * @param error Error, if any + * @param [response] QueryPacketCommitmentResponse + */ + type PacketCommitmentCallback = ( + error: Error | null, + response?: ibc.channel.QueryPacketCommitmentResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#packetCommitments}. + * @param error Error, if any + * @param [response] QueryPacketCommitmentsResponse + */ + type PacketCommitmentsCallback = ( + error: Error | null, + response?: ibc.channel.QueryPacketCommitmentsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#packetAcknowledgement}. + * @param error Error, if any + * @param [response] QueryPacketAcknowledgementResponse + */ + type PacketAcknowledgementCallback = ( + error: Error | null, + response?: ibc.channel.QueryPacketAcknowledgementResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#unrelayedPackets}. + * @param error Error, if any + * @param [response] QueryUnrelayedPacketsResponse + */ + type UnrelayedPacketsCallback = ( + error: Error | null, + response?: ibc.channel.QueryUnrelayedPacketsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.channel.Query#nextSequenceReceive}. + * @param error Error, if any + * @param [response] QueryNextSequenceReceiveResponse + */ + type NextSequenceReceiveCallback = ( + error: Error | null, + response?: ibc.channel.QueryNextSequenceReceiveResponse, + ) => void; + } + + /** Properties of a QueryChannelRequest. */ + interface IQueryChannelRequest { + /** QueryChannelRequest portId */ + portId?: string | null; + + /** QueryChannelRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryChannelRequest. */ + class QueryChannelRequest implements IQueryChannelRequest { + /** + * Constructs a new QueryChannelRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelRequest); + + /** QueryChannelRequest portId. */ + public portId: string; + + /** QueryChannelRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryChannelRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelRequest instance + */ + public static create(properties?: ibc.channel.IQueryChannelRequest): ibc.channel.QueryChannelRequest; + + /** + * Encodes the specified QueryChannelRequest message. Does not implicitly {@link ibc.channel.QueryChannelRequest.verify|verify} messages. + * @param m QueryChannelRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelRequest, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelRequest + * @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): ibc.channel.QueryChannelRequest; + } + + /** Properties of a QueryChannelResponse. */ + interface IQueryChannelResponse { + /** QueryChannelResponse channel */ + channel?: ibc.channel.IChannel | null; + + /** QueryChannelResponse proof */ + proof?: Uint8Array | null; + + /** QueryChannelResponse proofPath */ + proofPath?: string | null; + + /** QueryChannelResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryChannelResponse. */ + class QueryChannelResponse implements IQueryChannelResponse { + /** + * Constructs a new QueryChannelResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelResponse); + + /** QueryChannelResponse channel. */ + public channel?: ibc.channel.IChannel | null; + + /** QueryChannelResponse proof. */ + public proof: Uint8Array; + + /** QueryChannelResponse proofPath. */ + public proofPath: string; + + /** QueryChannelResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryChannelResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelResponse instance + */ + public static create(properties?: ibc.channel.IQueryChannelResponse): ibc.channel.QueryChannelResponse; + + /** + * Encodes the specified QueryChannelResponse message. Does not implicitly {@link ibc.channel.QueryChannelResponse.verify|verify} messages. + * @param m QueryChannelResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelResponse, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelResponse + * @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): ibc.channel.QueryChannelResponse; + } + + /** Properties of a QueryChannelsRequest. */ + interface IQueryChannelsRequest { + /** QueryChannelsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryChannelsRequest. */ + class QueryChannelsRequest implements IQueryChannelsRequest { + /** + * Constructs a new QueryChannelsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelsRequest); + + /** QueryChannelsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryChannelsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelsRequest instance + */ + public static create(properties?: ibc.channel.IQueryChannelsRequest): ibc.channel.QueryChannelsRequest; + + /** + * Encodes the specified QueryChannelsRequest message. Does not implicitly {@link ibc.channel.QueryChannelsRequest.verify|verify} messages. + * @param m QueryChannelsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelsRequest, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelsRequest + * @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): ibc.channel.QueryChannelsRequest; + } + + /** Properties of a QueryChannelsResponse. */ + interface IQueryChannelsResponse { + /** QueryChannelsResponse channels */ + channels?: ibc.channel.IIdentifiedChannel[] | null; + + /** QueryChannelsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryChannelsResponse height */ + height?: Long | null; + } + + /** Represents a QueryChannelsResponse. */ + class QueryChannelsResponse implements IQueryChannelsResponse { + /** + * Constructs a new QueryChannelsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelsResponse); + + /** QueryChannelsResponse channels. */ + public channels: ibc.channel.IIdentifiedChannel[]; + + /** QueryChannelsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryChannelsResponse height. */ + public height: Long; + + /** + * Creates a new QueryChannelsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryChannelsResponse, + ): ibc.channel.QueryChannelsResponse; + + /** + * Encodes the specified QueryChannelsResponse message. Does not implicitly {@link ibc.channel.QueryChannelsResponse.verify|verify} messages. + * @param m QueryChannelsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.channel.IQueryChannelsResponse, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryChannelsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelsResponse + * @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): ibc.channel.QueryChannelsResponse; + } + + /** Properties of a QueryConnectionChannelsRequest. */ + interface IQueryConnectionChannelsRequest { + /** QueryConnectionChannelsRequest connection */ + connection?: string | null; + + /** QueryConnectionChannelsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryConnectionChannelsRequest. */ + class QueryConnectionChannelsRequest implements IQueryConnectionChannelsRequest { + /** + * Constructs a new QueryConnectionChannelsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryConnectionChannelsRequest); + + /** QueryConnectionChannelsRequest connection. */ + public connection: string; + + /** QueryConnectionChannelsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryConnectionChannelsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionChannelsRequest instance + */ + public static create( + properties?: ibc.channel.IQueryConnectionChannelsRequest, + ): ibc.channel.QueryConnectionChannelsRequest; + + /** + * Encodes the specified QueryConnectionChannelsRequest message. Does not implicitly {@link ibc.channel.QueryConnectionChannelsRequest.verify|verify} messages. + * @param m QueryConnectionChannelsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryConnectionChannelsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionChannelsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionChannelsRequest + * @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, + ): ibc.channel.QueryConnectionChannelsRequest; + } + + /** Properties of a QueryConnectionChannelsResponse. */ + interface IQueryConnectionChannelsResponse { + /** QueryConnectionChannelsResponse channels */ + channels?: ibc.channel.IIdentifiedChannel[] | null; + + /** QueryConnectionChannelsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionChannelsResponse height */ + height?: Long | null; + } + + /** Represents a QueryConnectionChannelsResponse. */ + class QueryConnectionChannelsResponse implements IQueryConnectionChannelsResponse { + /** + * Constructs a new QueryConnectionChannelsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryConnectionChannelsResponse); + + /** QueryConnectionChannelsResponse channels. */ + public channels: ibc.channel.IIdentifiedChannel[]; + + /** QueryConnectionChannelsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionChannelsResponse height. */ + public height: Long; + + /** + * Creates a new QueryConnectionChannelsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionChannelsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryConnectionChannelsResponse, + ): ibc.channel.QueryConnectionChannelsResponse; + + /** + * Encodes the specified QueryConnectionChannelsResponse message. Does not implicitly {@link ibc.channel.QueryConnectionChannelsResponse.verify|verify} messages. + * @param m QueryConnectionChannelsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryConnectionChannelsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionChannelsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionChannelsResponse + * @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, + ): ibc.channel.QueryConnectionChannelsResponse; + } + + /** Properties of a QueryPacketCommitmentRequest. */ + interface IQueryPacketCommitmentRequest { + /** QueryPacketCommitmentRequest portId */ + portId?: string | null; + + /** QueryPacketCommitmentRequest channelId */ + channelId?: string | null; + + /** QueryPacketCommitmentRequest sequence */ + sequence?: Long | null; + } + + /** Represents a QueryPacketCommitmentRequest. */ + class QueryPacketCommitmentRequest implements IQueryPacketCommitmentRequest { + /** + * Constructs a new QueryPacketCommitmentRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentRequest); + + /** QueryPacketCommitmentRequest portId. */ + public portId: string; + + /** QueryPacketCommitmentRequest channelId. */ + public channelId: string; + + /** QueryPacketCommitmentRequest sequence. */ + public sequence: Long; + + /** + * Creates a new QueryPacketCommitmentRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentRequest instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentRequest, + ): ibc.channel.QueryPacketCommitmentRequest; + + /** + * Encodes the specified QueryPacketCommitmentRequest message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentRequest.verify|verify} messages. + * @param m QueryPacketCommitmentRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentRequest + * @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, + ): ibc.channel.QueryPacketCommitmentRequest; + } + + /** Properties of a QueryPacketCommitmentResponse. */ + interface IQueryPacketCommitmentResponse { + /** QueryPacketCommitmentResponse commitment */ + commitment?: Uint8Array | null; + + /** QueryPacketCommitmentResponse proof */ + proof?: Uint8Array | null; + + /** QueryPacketCommitmentResponse proofPath */ + proofPath?: string | null; + + /** QueryPacketCommitmentResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryPacketCommitmentResponse. */ + class QueryPacketCommitmentResponse implements IQueryPacketCommitmentResponse { + /** + * Constructs a new QueryPacketCommitmentResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentResponse); + + /** QueryPacketCommitmentResponse commitment. */ + public commitment: Uint8Array; + + /** QueryPacketCommitmentResponse proof. */ + public proof: Uint8Array; + + /** QueryPacketCommitmentResponse proofPath. */ + public proofPath: string; + + /** QueryPacketCommitmentResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryPacketCommitmentResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentResponse instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentResponse, + ): ibc.channel.QueryPacketCommitmentResponse; + + /** + * Encodes the specified QueryPacketCommitmentResponse message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentResponse.verify|verify} messages. + * @param m QueryPacketCommitmentResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentResponse + * @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, + ): ibc.channel.QueryPacketCommitmentResponse; + } + + /** Properties of a QueryPacketCommitmentsRequest. */ + interface IQueryPacketCommitmentsRequest { + /** QueryPacketCommitmentsRequest portId */ + portId?: string | null; + + /** QueryPacketCommitmentsRequest channelId */ + channelId?: string | null; + + /** QueryPacketCommitmentsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryPacketCommitmentsRequest. */ + class QueryPacketCommitmentsRequest implements IQueryPacketCommitmentsRequest { + /** + * Constructs a new QueryPacketCommitmentsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentsRequest); + + /** QueryPacketCommitmentsRequest portId. */ + public portId: string; + + /** QueryPacketCommitmentsRequest channelId. */ + public channelId: string; + + /** QueryPacketCommitmentsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryPacketCommitmentsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentsRequest instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentsRequest, + ): ibc.channel.QueryPacketCommitmentsRequest; + + /** + * Encodes the specified QueryPacketCommitmentsRequest message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentsRequest.verify|verify} messages. + * @param m QueryPacketCommitmentsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentsRequest + * @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, + ): ibc.channel.QueryPacketCommitmentsRequest; + } + + /** Properties of a QueryPacketCommitmentsResponse. */ + interface IQueryPacketCommitmentsResponse { + /** QueryPacketCommitmentsResponse commitments */ + commitments?: ibc.channel.IPacketAckCommitment[] | null; + + /** QueryPacketCommitmentsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryPacketCommitmentsResponse height */ + height?: Long | null; + } + + /** Represents a QueryPacketCommitmentsResponse. */ + class QueryPacketCommitmentsResponse implements IQueryPacketCommitmentsResponse { + /** + * Constructs a new QueryPacketCommitmentsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketCommitmentsResponse); + + /** QueryPacketCommitmentsResponse commitments. */ + public commitments: ibc.channel.IPacketAckCommitment[]; + + /** QueryPacketCommitmentsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryPacketCommitmentsResponse height. */ + public height: Long; + + /** + * Creates a new QueryPacketCommitmentsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketCommitmentsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryPacketCommitmentsResponse, + ): ibc.channel.QueryPacketCommitmentsResponse; + + /** + * Encodes the specified QueryPacketCommitmentsResponse message. Does not implicitly {@link ibc.channel.QueryPacketCommitmentsResponse.verify|verify} messages. + * @param m QueryPacketCommitmentsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketCommitmentsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketCommitmentsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketCommitmentsResponse + * @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, + ): ibc.channel.QueryPacketCommitmentsResponse; + } + + /** Properties of a QueryPacketAcknowledgementRequest. */ + interface IQueryPacketAcknowledgementRequest { + /** QueryPacketAcknowledgementRequest portId */ + portId?: string | null; + + /** QueryPacketAcknowledgementRequest channelId */ + channelId?: string | null; + + /** QueryPacketAcknowledgementRequest sequence */ + sequence?: Long | null; + } + + /** Represents a QueryPacketAcknowledgementRequest. */ + class QueryPacketAcknowledgementRequest implements IQueryPacketAcknowledgementRequest { + /** + * Constructs a new QueryPacketAcknowledgementRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketAcknowledgementRequest); + + /** QueryPacketAcknowledgementRequest portId. */ + public portId: string; + + /** QueryPacketAcknowledgementRequest channelId. */ + public channelId: string; + + /** QueryPacketAcknowledgementRequest sequence. */ + public sequence: Long; + + /** + * Creates a new QueryPacketAcknowledgementRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketAcknowledgementRequest instance + */ + public static create( + properties?: ibc.channel.IQueryPacketAcknowledgementRequest, + ): ibc.channel.QueryPacketAcknowledgementRequest; + + /** + * Encodes the specified QueryPacketAcknowledgementRequest message. Does not implicitly {@link ibc.channel.QueryPacketAcknowledgementRequest.verify|verify} messages. + * @param m QueryPacketAcknowledgementRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketAcknowledgementRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketAcknowledgementRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketAcknowledgementRequest + * @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, + ): ibc.channel.QueryPacketAcknowledgementRequest; + } + + /** Properties of a QueryPacketAcknowledgementResponse. */ + interface IQueryPacketAcknowledgementResponse { + /** QueryPacketAcknowledgementResponse acknowledgement */ + acknowledgement?: Uint8Array | null; + + /** QueryPacketAcknowledgementResponse proof */ + proof?: Uint8Array | null; + + /** QueryPacketAcknowledgementResponse proofPath */ + proofPath?: string | null; + + /** QueryPacketAcknowledgementResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryPacketAcknowledgementResponse. */ + class QueryPacketAcknowledgementResponse implements IQueryPacketAcknowledgementResponse { + /** + * Constructs a new QueryPacketAcknowledgementResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryPacketAcknowledgementResponse); + + /** QueryPacketAcknowledgementResponse acknowledgement. */ + public acknowledgement: Uint8Array; + + /** QueryPacketAcknowledgementResponse proof. */ + public proof: Uint8Array; + + /** QueryPacketAcknowledgementResponse proofPath. */ + public proofPath: string; + + /** QueryPacketAcknowledgementResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryPacketAcknowledgementResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryPacketAcknowledgementResponse instance + */ + public static create( + properties?: ibc.channel.IQueryPacketAcknowledgementResponse, + ): ibc.channel.QueryPacketAcknowledgementResponse; + + /** + * Encodes the specified QueryPacketAcknowledgementResponse message. Does not implicitly {@link ibc.channel.QueryPacketAcknowledgementResponse.verify|verify} messages. + * @param m QueryPacketAcknowledgementResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryPacketAcknowledgementResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryPacketAcknowledgementResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryPacketAcknowledgementResponse + * @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, + ): ibc.channel.QueryPacketAcknowledgementResponse; + } + + /** Properties of a QueryUnrelayedPacketsRequest. */ + interface IQueryUnrelayedPacketsRequest { + /** QueryUnrelayedPacketsRequest portId */ + portId?: string | null; + + /** QueryUnrelayedPacketsRequest channelId */ + channelId?: string | null; + + /** QueryUnrelayedPacketsRequest packetCommitmentSequences */ + packetCommitmentSequences?: Long[] | null; + + /** QueryUnrelayedPacketsRequest acknowledgements */ + acknowledgements?: boolean | null; + } + + /** Represents a QueryUnrelayedPacketsRequest. */ + class QueryUnrelayedPacketsRequest implements IQueryUnrelayedPacketsRequest { + /** + * Constructs a new QueryUnrelayedPacketsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryUnrelayedPacketsRequest); + + /** QueryUnrelayedPacketsRequest portId. */ + public portId: string; + + /** QueryUnrelayedPacketsRequest channelId. */ + public channelId: string; + + /** QueryUnrelayedPacketsRequest packetCommitmentSequences. */ + public packetCommitmentSequences: Long[]; + + /** QueryUnrelayedPacketsRequest acknowledgements. */ + public acknowledgements: boolean; + + /** + * Creates a new QueryUnrelayedPacketsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryUnrelayedPacketsRequest instance + */ + public static create( + properties?: ibc.channel.IQueryUnrelayedPacketsRequest, + ): ibc.channel.QueryUnrelayedPacketsRequest; + + /** + * Encodes the specified QueryUnrelayedPacketsRequest message. Does not implicitly {@link ibc.channel.QueryUnrelayedPacketsRequest.verify|verify} messages. + * @param m QueryUnrelayedPacketsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryUnrelayedPacketsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryUnrelayedPacketsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryUnrelayedPacketsRequest + * @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, + ): ibc.channel.QueryUnrelayedPacketsRequest; + } + + /** Properties of a QueryUnrelayedPacketsResponse. */ + interface IQueryUnrelayedPacketsResponse { + /** QueryUnrelayedPacketsResponse sequences */ + sequences?: Long[] | null; + + /** QueryUnrelayedPacketsResponse height */ + height?: Long | null; + } + + /** Represents a QueryUnrelayedPacketsResponse. */ + class QueryUnrelayedPacketsResponse implements IQueryUnrelayedPacketsResponse { + /** + * Constructs a new QueryUnrelayedPacketsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryUnrelayedPacketsResponse); + + /** QueryUnrelayedPacketsResponse sequences. */ + public sequences: Long[]; + + /** QueryUnrelayedPacketsResponse height. */ + public height: Long; + + /** + * Creates a new QueryUnrelayedPacketsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryUnrelayedPacketsResponse instance + */ + public static create( + properties?: ibc.channel.IQueryUnrelayedPacketsResponse, + ): ibc.channel.QueryUnrelayedPacketsResponse; + + /** + * Encodes the specified QueryUnrelayedPacketsResponse message. Does not implicitly {@link ibc.channel.QueryUnrelayedPacketsResponse.verify|verify} messages. + * @param m QueryUnrelayedPacketsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryUnrelayedPacketsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryUnrelayedPacketsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryUnrelayedPacketsResponse + * @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, + ): ibc.channel.QueryUnrelayedPacketsResponse; + } + + /** Properties of a QueryNextSequenceReceiveRequest. */ + interface IQueryNextSequenceReceiveRequest { + /** QueryNextSequenceReceiveRequest portId */ + portId?: string | null; + + /** QueryNextSequenceReceiveRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryNextSequenceReceiveRequest. */ + class QueryNextSequenceReceiveRequest implements IQueryNextSequenceReceiveRequest { + /** + * Constructs a new QueryNextSequenceReceiveRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryNextSequenceReceiveRequest); + + /** QueryNextSequenceReceiveRequest portId. */ + public portId: string; + + /** QueryNextSequenceReceiveRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryNextSequenceReceiveRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryNextSequenceReceiveRequest instance + */ + public static create( + properties?: ibc.channel.IQueryNextSequenceReceiveRequest, + ): ibc.channel.QueryNextSequenceReceiveRequest; + + /** + * Encodes the specified QueryNextSequenceReceiveRequest message. Does not implicitly {@link ibc.channel.QueryNextSequenceReceiveRequest.verify|verify} messages. + * @param m QueryNextSequenceReceiveRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryNextSequenceReceiveRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryNextSequenceReceiveRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryNextSequenceReceiveRequest + * @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, + ): ibc.channel.QueryNextSequenceReceiveRequest; + } + + /** Properties of a QueryNextSequenceReceiveResponse. */ + interface IQueryNextSequenceReceiveResponse { + /** QueryNextSequenceReceiveResponse nextSequenceReceive */ + nextSequenceReceive?: Long | null; + + /** QueryNextSequenceReceiveResponse proof */ + proof?: Uint8Array | null; + + /** QueryNextSequenceReceiveResponse proofPath */ + proofPath?: string | null; + + /** QueryNextSequenceReceiveResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryNextSequenceReceiveResponse. */ + class QueryNextSequenceReceiveResponse implements IQueryNextSequenceReceiveResponse { + /** + * Constructs a new QueryNextSequenceReceiveResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryNextSequenceReceiveResponse); + + /** QueryNextSequenceReceiveResponse nextSequenceReceive. */ + public nextSequenceReceive: Long; + + /** QueryNextSequenceReceiveResponse proof. */ + public proof: Uint8Array; + + /** QueryNextSequenceReceiveResponse proofPath. */ + public proofPath: string; + + /** QueryNextSequenceReceiveResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryNextSequenceReceiveResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryNextSequenceReceiveResponse instance + */ + public static create( + properties?: ibc.channel.IQueryNextSequenceReceiveResponse, + ): ibc.channel.QueryNextSequenceReceiveResponse; + + /** + * Encodes the specified QueryNextSequenceReceiveResponse message. Does not implicitly {@link ibc.channel.QueryNextSequenceReceiveResponse.verify|verify} messages. + * @param m QueryNextSequenceReceiveResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryNextSequenceReceiveResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryNextSequenceReceiveResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryNextSequenceReceiveResponse + * @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, + ): ibc.channel.QueryNextSequenceReceiveResponse; + } + + /** Properties of a QueryChannelClientStateRequest. */ + interface IQueryChannelClientStateRequest { + /** QueryChannelClientStateRequest portId */ + portId?: string | null; + + /** QueryChannelClientStateRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryChannelClientStateRequest. */ + class QueryChannelClientStateRequest implements IQueryChannelClientStateRequest { + /** + * Constructs a new QueryChannelClientStateRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelClientStateRequest); + + /** QueryChannelClientStateRequest portId. */ + public portId: string; + + /** QueryChannelClientStateRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryChannelClientStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelClientStateRequest instance + */ + public static create( + properties?: ibc.channel.IQueryChannelClientStateRequest, + ): ibc.channel.QueryChannelClientStateRequest; + + /** + * Encodes the specified QueryChannelClientStateRequest message. Does not implicitly {@link ibc.channel.QueryChannelClientStateRequest.verify|verify} messages. + * @param m QueryChannelClientStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryChannelClientStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryChannelClientStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelClientStateRequest + * @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, + ): ibc.channel.QueryChannelClientStateRequest; + } + + /** Properties of a QueryChannelConsensusStateRequest. */ + interface IQueryChannelConsensusStateRequest { + /** QueryChannelConsensusStateRequest portId */ + portId?: string | null; + + /** QueryChannelConsensusStateRequest channelId */ + channelId?: string | null; + } + + /** Represents a QueryChannelConsensusStateRequest. */ + class QueryChannelConsensusStateRequest implements IQueryChannelConsensusStateRequest { + /** + * Constructs a new QueryChannelConsensusStateRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.channel.IQueryChannelConsensusStateRequest); + + /** QueryChannelConsensusStateRequest portId. */ + public portId: string; + + /** QueryChannelConsensusStateRequest channelId. */ + public channelId: string; + + /** + * Creates a new QueryChannelConsensusStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryChannelConsensusStateRequest instance + */ + public static create( + properties?: ibc.channel.IQueryChannelConsensusStateRequest, + ): ibc.channel.QueryChannelConsensusStateRequest; + + /** + * Encodes the specified QueryChannelConsensusStateRequest message. Does not implicitly {@link ibc.channel.QueryChannelConsensusStateRequest.verify|verify} messages. + * @param m QueryChannelConsensusStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.channel.IQueryChannelConsensusStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryChannelConsensusStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryChannelConsensusStateRequest + * @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, + ): ibc.channel.QueryChannelConsensusStateRequest; + } + } + + /** Namespace commitment. */ + namespace commitment { + /** Properties of a MerkleRoot. */ + interface IMerkleRoot { + /** MerkleRoot hash */ + hash?: Uint8Array | null; + } + + /** Represents a MerkleRoot. */ + class MerkleRoot implements IMerkleRoot { + /** + * Constructs a new MerkleRoot. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerkleRoot); + + /** MerkleRoot hash. */ + public hash: Uint8Array; + + /** + * Creates a new MerkleRoot instance using the specified properties. + * @param [properties] Properties to set + * @returns MerkleRoot instance + */ + public static create(properties?: ibc.commitment.IMerkleRoot): ibc.commitment.MerkleRoot; + + /** + * Encodes the specified MerkleRoot message. Does not implicitly {@link ibc.commitment.MerkleRoot.verify|verify} messages. + * @param m MerkleRoot message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerkleRoot, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerkleRoot message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerkleRoot + * @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): ibc.commitment.MerkleRoot; + } + + /** Properties of a MerklePrefix. */ + interface IMerklePrefix { + /** MerklePrefix keyPrefix */ + keyPrefix?: Uint8Array | null; + } + + /** Represents a MerklePrefix. */ + class MerklePrefix implements IMerklePrefix { + /** + * Constructs a new MerklePrefix. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerklePrefix); + + /** MerklePrefix keyPrefix. */ + public keyPrefix: Uint8Array; + + /** + * Creates a new MerklePrefix instance using the specified properties. + * @param [properties] Properties to set + * @returns MerklePrefix instance + */ + public static create(properties?: ibc.commitment.IMerklePrefix): ibc.commitment.MerklePrefix; + + /** + * Encodes the specified MerklePrefix message. Does not implicitly {@link ibc.commitment.MerklePrefix.verify|verify} messages. + * @param m MerklePrefix message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerklePrefix, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerklePrefix message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerklePrefix + * @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): ibc.commitment.MerklePrefix; + } + + /** Properties of a MerklePath. */ + interface IMerklePath { + /** MerklePath keyPath */ + keyPath?: ibc.commitment.IKeyPath | null; + } + + /** Represents a MerklePath. */ + class MerklePath implements IMerklePath { + /** + * Constructs a new MerklePath. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerklePath); + + /** MerklePath keyPath. */ + public keyPath?: ibc.commitment.IKeyPath | null; + + /** + * Creates a new MerklePath instance using the specified properties. + * @param [properties] Properties to set + * @returns MerklePath instance + */ + public static create(properties?: ibc.commitment.IMerklePath): ibc.commitment.MerklePath; + + /** + * Encodes the specified MerklePath message. Does not implicitly {@link ibc.commitment.MerklePath.verify|verify} messages. + * @param m MerklePath message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerklePath, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerklePath message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerklePath + * @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): ibc.commitment.MerklePath; + } + + /** Properties of a MerkleProof. */ + interface IMerkleProof { + /** MerkleProof proof */ + proof?: tendermint.crypto.merkle.IProof | null; + } + + /** Represents a MerkleProof. */ + class MerkleProof implements IMerkleProof { + /** + * Constructs a new MerkleProof. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IMerkleProof); + + /** MerkleProof proof. */ + public proof?: tendermint.crypto.merkle.IProof | null; + + /** + * Creates a new MerkleProof instance using the specified properties. + * @param [properties] Properties to set + * @returns MerkleProof instance + */ + public static create(properties?: ibc.commitment.IMerkleProof): ibc.commitment.MerkleProof; + + /** + * Encodes the specified MerkleProof message. Does not implicitly {@link ibc.commitment.MerkleProof.verify|verify} messages. + * @param m MerkleProof message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IMerkleProof, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MerkleProof message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MerkleProof + * @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): ibc.commitment.MerkleProof; + } + + /** Properties of a KeyPath. */ + interface IKeyPath { + /** KeyPath keys */ + keys?: ibc.commitment.IKey[] | null; + } + + /** Represents a KeyPath. */ + class KeyPath implements IKeyPath { + /** + * Constructs a new KeyPath. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IKeyPath); + + /** KeyPath keys. */ + public keys: ibc.commitment.IKey[]; + + /** + * Creates a new KeyPath instance using the specified properties. + * @param [properties] Properties to set + * @returns KeyPath instance + */ + public static create(properties?: ibc.commitment.IKeyPath): ibc.commitment.KeyPath; + + /** + * Encodes the specified KeyPath message. Does not implicitly {@link ibc.commitment.KeyPath.verify|verify} messages. + * @param m KeyPath message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IKeyPath, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a KeyPath message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns KeyPath + * @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): ibc.commitment.KeyPath; + } + + /** Properties of a Key. */ + interface IKey { + /** Key name */ + name?: Uint8Array | null; + + /** Key enc */ + enc?: ibc.commitment.KeyEncoding | null; + } + + /** Represents a Key. */ + class Key implements IKey { + /** + * Constructs a new Key. + * @param [p] Properties to set + */ + constructor(p?: ibc.commitment.IKey); + + /** Key name. */ + public name: Uint8Array; + + /** Key enc. */ + public enc: ibc.commitment.KeyEncoding; + + /** + * Creates a new Key instance using the specified properties. + * @param [properties] Properties to set + * @returns Key instance + */ + public static create(properties?: ibc.commitment.IKey): ibc.commitment.Key; + + /** + * Encodes the specified Key message. Does not implicitly {@link ibc.commitment.Key.verify|verify} messages. + * @param m Key message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.commitment.IKey, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Key message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Key + * @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): ibc.commitment.Key; + } + + /** KeyEncoding enum. */ + enum KeyEncoding { + KEY_ENCODING_URL_UNSPECIFIED = 0, + KEY_ENCODING_HEX = 1, + } + } + + /** Namespace connection. */ + namespace connection { + /** Properties of a MsgConnectionOpenInit. */ + interface IMsgConnectionOpenInit { + /** MsgConnectionOpenInit clientId */ + clientId?: string | null; + + /** MsgConnectionOpenInit connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenInit counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenInit signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenInit. */ + class MsgConnectionOpenInit implements IMsgConnectionOpenInit { + /** + * Constructs a new MsgConnectionOpenInit. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenInit); + + /** MsgConnectionOpenInit clientId. */ + public clientId: string; + + /** MsgConnectionOpenInit connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenInit counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenInit signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenInit instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenInit instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenInit, + ): ibc.connection.MsgConnectionOpenInit; + + /** + * Encodes the specified MsgConnectionOpenInit message. Does not implicitly {@link ibc.connection.MsgConnectionOpenInit.verify|verify} messages. + * @param m MsgConnectionOpenInit message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IMsgConnectionOpenInit, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenInit message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenInit + * @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, + ): ibc.connection.MsgConnectionOpenInit; + } + + /** Properties of a MsgConnectionOpenTry. */ + interface IMsgConnectionOpenTry { + /** MsgConnectionOpenTry clientId */ + clientId?: string | null; + + /** MsgConnectionOpenTry connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenTry counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenTry counterpartyVersions */ + counterpartyVersions?: string[] | null; + + /** MsgConnectionOpenTry proofInit */ + proofInit?: Uint8Array | null; + + /** MsgConnectionOpenTry proofHeight */ + proofHeight?: Long | null; + + /** MsgConnectionOpenTry proofConsensus */ + proofConsensus?: Uint8Array | null; + + /** MsgConnectionOpenTry consensusHeight */ + consensusHeight?: Long | null; + + /** MsgConnectionOpenTry signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenTry. */ + class MsgConnectionOpenTry implements IMsgConnectionOpenTry { + /** + * Constructs a new MsgConnectionOpenTry. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenTry); + + /** MsgConnectionOpenTry clientId. */ + public clientId: string; + + /** MsgConnectionOpenTry connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenTry counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** MsgConnectionOpenTry counterpartyVersions. */ + public counterpartyVersions: string[]; + + /** MsgConnectionOpenTry proofInit. */ + public proofInit: Uint8Array; + + /** MsgConnectionOpenTry proofHeight. */ + public proofHeight: Long; + + /** MsgConnectionOpenTry proofConsensus. */ + public proofConsensus: Uint8Array; + + /** MsgConnectionOpenTry consensusHeight. */ + public consensusHeight: Long; + + /** MsgConnectionOpenTry signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenTry instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenTry instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenTry, + ): ibc.connection.MsgConnectionOpenTry; + + /** + * Encodes the specified MsgConnectionOpenTry message. Does not implicitly {@link ibc.connection.MsgConnectionOpenTry.verify|verify} messages. + * @param m MsgConnectionOpenTry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IMsgConnectionOpenTry, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenTry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenTry + * @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): ibc.connection.MsgConnectionOpenTry; + } + + /** Properties of a MsgConnectionOpenAck. */ + interface IMsgConnectionOpenAck { + /** MsgConnectionOpenAck connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenAck version */ + version?: string | null; + + /** MsgConnectionOpenAck proofTry */ + proofTry?: Uint8Array | null; + + /** MsgConnectionOpenAck proofHeight */ + proofHeight?: Long | null; + + /** MsgConnectionOpenAck proofConsensus */ + proofConsensus?: Uint8Array | null; + + /** MsgConnectionOpenAck consensusHeight */ + consensusHeight?: Long | null; + + /** MsgConnectionOpenAck signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenAck. */ + class MsgConnectionOpenAck implements IMsgConnectionOpenAck { + /** + * Constructs a new MsgConnectionOpenAck. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenAck); + + /** MsgConnectionOpenAck connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenAck version. */ + public version: string; + + /** MsgConnectionOpenAck proofTry. */ + public proofTry: Uint8Array; + + /** MsgConnectionOpenAck proofHeight. */ + public proofHeight: Long; + + /** MsgConnectionOpenAck proofConsensus. */ + public proofConsensus: Uint8Array; + + /** MsgConnectionOpenAck consensusHeight. */ + public consensusHeight: Long; + + /** MsgConnectionOpenAck signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenAck instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenAck instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenAck, + ): ibc.connection.MsgConnectionOpenAck; + + /** + * Encodes the specified MsgConnectionOpenAck message. Does not implicitly {@link ibc.connection.MsgConnectionOpenAck.verify|verify} messages. + * @param m MsgConnectionOpenAck message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IMsgConnectionOpenAck, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenAck message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenAck + * @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): ibc.connection.MsgConnectionOpenAck; + } + + /** Properties of a MsgConnectionOpenConfirm. */ + interface IMsgConnectionOpenConfirm { + /** MsgConnectionOpenConfirm connectionId */ + connectionId?: string | null; + + /** MsgConnectionOpenConfirm proofAck */ + proofAck?: Uint8Array | null; + + /** MsgConnectionOpenConfirm proofHeight */ + proofHeight?: Long | null; + + /** MsgConnectionOpenConfirm signer */ + signer?: Uint8Array | null; + } + + /** Represents a MsgConnectionOpenConfirm. */ + class MsgConnectionOpenConfirm implements IMsgConnectionOpenConfirm { + /** + * Constructs a new MsgConnectionOpenConfirm. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IMsgConnectionOpenConfirm); + + /** MsgConnectionOpenConfirm connectionId. */ + public connectionId: string; + + /** MsgConnectionOpenConfirm proofAck. */ + public proofAck: Uint8Array; + + /** MsgConnectionOpenConfirm proofHeight. */ + public proofHeight: Long; + + /** MsgConnectionOpenConfirm signer. */ + public signer: Uint8Array; + + /** + * Creates a new MsgConnectionOpenConfirm instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgConnectionOpenConfirm instance + */ + public static create( + properties?: ibc.connection.IMsgConnectionOpenConfirm, + ): ibc.connection.MsgConnectionOpenConfirm; + + /** + * Encodes the specified MsgConnectionOpenConfirm message. Does not implicitly {@link ibc.connection.MsgConnectionOpenConfirm.verify|verify} messages. + * @param m MsgConnectionOpenConfirm message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IMsgConnectionOpenConfirm, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgConnectionOpenConfirm message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgConnectionOpenConfirm + * @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, + ): ibc.connection.MsgConnectionOpenConfirm; + } + + /** Properties of a ConnectionEnd. */ + interface IConnectionEnd { + /** ConnectionEnd clientId */ + clientId?: string | null; + + /** ConnectionEnd versions */ + versions?: string[] | null; + + /** ConnectionEnd state */ + state?: ibc.connection.State | null; + + /** ConnectionEnd counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + } + + /** Represents a ConnectionEnd. */ + class ConnectionEnd implements IConnectionEnd { + /** + * Constructs a new ConnectionEnd. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IConnectionEnd); + + /** ConnectionEnd clientId. */ + public clientId: string; + + /** ConnectionEnd versions. */ + public versions: string[]; + + /** ConnectionEnd state. */ + public state: ibc.connection.State; + + /** ConnectionEnd counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** + * Creates a new ConnectionEnd instance using the specified properties. + * @param [properties] Properties to set + * @returns ConnectionEnd instance + */ + public static create(properties?: ibc.connection.IConnectionEnd): ibc.connection.ConnectionEnd; + + /** + * Encodes the specified ConnectionEnd message. Does not implicitly {@link ibc.connection.ConnectionEnd.verify|verify} messages. + * @param m ConnectionEnd message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IConnectionEnd, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ConnectionEnd message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ConnectionEnd + * @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): ibc.connection.ConnectionEnd; + } + + /** Properties of an IdentifiedConnection. */ + interface IIdentifiedConnection { + /** IdentifiedConnection id */ + id?: string | null; + + /** IdentifiedConnection clientId */ + clientId?: string | null; + + /** IdentifiedConnection versions */ + versions?: string[] | null; + + /** IdentifiedConnection state */ + state?: ibc.connection.State | null; + + /** IdentifiedConnection counterparty */ + counterparty?: ibc.connection.ICounterparty | null; + } + + /** Represents an IdentifiedConnection. */ + class IdentifiedConnection implements IIdentifiedConnection { + /** + * Constructs a new IdentifiedConnection. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IIdentifiedConnection); + + /** IdentifiedConnection id. */ + public id: string; + + /** IdentifiedConnection clientId. */ + public clientId: string; + + /** IdentifiedConnection versions. */ + public versions: string[]; + + /** IdentifiedConnection state. */ + public state: ibc.connection.State; + + /** IdentifiedConnection counterparty. */ + public counterparty?: ibc.connection.ICounterparty | null; + + /** + * Creates a new IdentifiedConnection instance using the specified properties. + * @param [properties] Properties to set + * @returns IdentifiedConnection instance + */ + public static create( + properties?: ibc.connection.IIdentifiedConnection, + ): ibc.connection.IdentifiedConnection; + + /** + * Encodes the specified IdentifiedConnection message. Does not implicitly {@link ibc.connection.IdentifiedConnection.verify|verify} messages. + * @param m IdentifiedConnection message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IIdentifiedConnection, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IdentifiedConnection message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns IdentifiedConnection + * @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): ibc.connection.IdentifiedConnection; + } + + /** State enum. */ + enum State { + STATE_UNINITIALIZED_UNSPECIFIED = 0, + STATE_INIT = 1, + STATE_TRYOPEN = 2, + STATE_OPEN = 3, + } + + /** Properties of a Counterparty. */ + interface ICounterparty { + /** Counterparty clientId */ + clientId?: string | null; + + /** Counterparty connectionId */ + connectionId?: string | null; + + /** Counterparty prefix */ + prefix?: ibc.commitment.IMerklePrefix | null; + } + + /** Represents a Counterparty. */ + class Counterparty implements ICounterparty { + /** + * Constructs a new Counterparty. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.ICounterparty); + + /** Counterparty clientId. */ + public clientId: string; + + /** Counterparty connectionId. */ + public connectionId: string; + + /** Counterparty prefix. */ + public prefix?: ibc.commitment.IMerklePrefix | null; + + /** + * Creates a new Counterparty instance using the specified properties. + * @param [properties] Properties to set + * @returns Counterparty instance + */ + public static create(properties?: ibc.connection.ICounterparty): ibc.connection.Counterparty; + + /** + * Encodes the specified Counterparty message. Does not implicitly {@link ibc.connection.Counterparty.verify|verify} messages. + * @param m Counterparty message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.ICounterparty, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Counterparty message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Counterparty + * @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): ibc.connection.Counterparty; + } + + /** Properties of a ClientPaths. */ + interface IClientPaths { + /** ClientPaths paths */ + paths?: string[] | null; + } + + /** Represents a ClientPaths. */ + class ClientPaths implements IClientPaths { + /** + * Constructs a new ClientPaths. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IClientPaths); + + /** ClientPaths paths. */ + public paths: string[]; + + /** + * Creates a new ClientPaths instance using the specified properties. + * @param [properties] Properties to set + * @returns ClientPaths instance + */ + public static create(properties?: ibc.connection.IClientPaths): ibc.connection.ClientPaths; + + /** + * Encodes the specified ClientPaths message. Does not implicitly {@link ibc.connection.ClientPaths.verify|verify} messages. + * @param m ClientPaths message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IClientPaths, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ClientPaths message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ClientPaths + * @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): ibc.connection.ClientPaths; + } + + /** Properties of a ConnectionPaths. */ + interface IConnectionPaths { + /** ConnectionPaths clientId */ + clientId?: string | null; + + /** ConnectionPaths paths */ + paths?: string[] | null; + } + + /** Represents a ConnectionPaths. */ + class ConnectionPaths implements IConnectionPaths { + /** + * Constructs a new ConnectionPaths. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IConnectionPaths); + + /** ConnectionPaths clientId. */ + public clientId: string; + + /** ConnectionPaths paths. */ + public paths: string[]; + + /** + * Creates a new ConnectionPaths instance using the specified properties. + * @param [properties] Properties to set + * @returns ConnectionPaths instance + */ + public static create(properties?: ibc.connection.IConnectionPaths): ibc.connection.ConnectionPaths; + + /** + * Encodes the specified ConnectionPaths message. Does not implicitly {@link ibc.connection.ConnectionPaths.verify|verify} messages. + * @param m ConnectionPaths message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IConnectionPaths, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ConnectionPaths message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ConnectionPaths + * @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): ibc.connection.ConnectionPaths; + } + + /** Properties of a Version. */ + interface IVersion { + /** Version identifier */ + identifier?: string | null; + + /** Version features */ + features?: string[] | null; + } + + /** Represents a Version. */ + class Version implements IVersion { + /** + * Constructs a new Version. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IVersion); + + /** Version identifier. */ + public identifier: string; + + /** Version features. */ + public features: string[]; + + /** + * Creates a new Version instance using the specified properties. + * @param [properties] Properties to set + * @returns Version instance + */ + public static create(properties?: ibc.connection.IVersion): ibc.connection.Version; + + /** + * Encodes the specified Version message. Does not implicitly {@link ibc.connection.Version.verify|verify} messages. + * @param m Version message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IVersion, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Version message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Version + * @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): ibc.connection.Version; + } + + /** Represents a Query */ + class Query extends $protobuf.rpc.Service { + /** + * Constructs a new Query service. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + */ + constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean); + + /** + * Creates new Query service using the specified rpc implementation. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + * @returns RPC service. Useful where requests and/or responses are streamed. + */ + public static create( + rpcImpl: $protobuf.RPCImpl, + requestDelimited?: boolean, + responseDelimited?: boolean, + ): Query; + + /** + * Calls Connection. + * @param request QueryConnectionRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryConnectionResponse + */ + public connection( + request: ibc.connection.IQueryConnectionRequest, + callback: ibc.connection.Query.ConnectionCallback, + ): void; + + /** + * Calls Connection. + * @param request QueryConnectionRequest message or plain object + * @returns Promise + */ + public connection( + request: ibc.connection.IQueryConnectionRequest, + ): Promise; + + /** + * Calls Connections. + * @param request QueryConnectionsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryConnectionsResponse + */ + public connections( + request: ibc.connection.IQueryConnectionsRequest, + callback: ibc.connection.Query.ConnectionsCallback, + ): void; + + /** + * Calls Connections. + * @param request QueryConnectionsRequest message or plain object + * @returns Promise + */ + public connections( + request: ibc.connection.IQueryConnectionsRequest, + ): Promise; + + /** + * Calls ClientConnections. + * @param request QueryClientConnectionsRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryClientConnectionsResponse + */ + public clientConnections( + request: ibc.connection.IQueryClientConnectionsRequest, + callback: ibc.connection.Query.ClientConnectionsCallback, + ): void; + + /** + * Calls ClientConnections. + * @param request QueryClientConnectionsRequest message or plain object + * @returns Promise + */ + public clientConnections( + request: ibc.connection.IQueryClientConnectionsRequest, + ): Promise; + } + + namespace Query { + /** + * Callback as used by {@link ibc.connection.Query#connection}. + * @param error Error, if any + * @param [response] QueryConnectionResponse + */ + type ConnectionCallback = ( + error: Error | null, + response?: ibc.connection.QueryConnectionResponse, + ) => void; + + /** + * Callback as used by {@link ibc.connection.Query#connections}. + * @param error Error, if any + * @param [response] QueryConnectionsResponse + */ + type ConnectionsCallback = ( + error: Error | null, + response?: ibc.connection.QueryConnectionsResponse, + ) => void; + + /** + * Callback as used by {@link ibc.connection.Query#clientConnections}. + * @param error Error, if any + * @param [response] QueryClientConnectionsResponse + */ + type ClientConnectionsCallback = ( + error: Error | null, + response?: ibc.connection.QueryClientConnectionsResponse, + ) => void; + } + + /** Properties of a QueryConnectionRequest. */ + interface IQueryConnectionRequest { + /** QueryConnectionRequest connectionId */ + connectionId?: string | null; + } + + /** Represents a QueryConnectionRequest. */ + class QueryConnectionRequest implements IQueryConnectionRequest { + /** + * Constructs a new QueryConnectionRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionRequest); + + /** QueryConnectionRequest connectionId. */ + public connectionId: string; + + /** + * Creates a new QueryConnectionRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionRequest instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionRequest, + ): ibc.connection.QueryConnectionRequest; + + /** + * Encodes the specified QueryConnectionRequest message. Does not implicitly {@link ibc.connection.QueryConnectionRequest.verify|verify} messages. + * @param m QueryConnectionRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: ibc.connection.IQueryConnectionRequest, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a QueryConnectionRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionRequest + * @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, + ): ibc.connection.QueryConnectionRequest; + } + + /** Properties of a QueryConnectionResponse. */ + interface IQueryConnectionResponse { + /** QueryConnectionResponse connection */ + connection?: ibc.connection.IConnectionEnd | null; + + /** QueryConnectionResponse proof */ + proof?: Uint8Array | null; + + /** QueryConnectionResponse proofPath */ + proofPath?: string | null; + + /** QueryConnectionResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryConnectionResponse. */ + class QueryConnectionResponse implements IQueryConnectionResponse { + /** + * Constructs a new QueryConnectionResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionResponse); + + /** QueryConnectionResponse connection. */ + public connection?: ibc.connection.IConnectionEnd | null; + + /** QueryConnectionResponse proof. */ + public proof: Uint8Array; + + /** QueryConnectionResponse proofPath. */ + public proofPath: string; + + /** QueryConnectionResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryConnectionResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionResponse instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionResponse, + ): ibc.connection.QueryConnectionResponse; + + /** + * Encodes the specified QueryConnectionResponse message. Does not implicitly {@link ibc.connection.QueryConnectionResponse.verify|verify} messages. + * @param m QueryConnectionResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryConnectionResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionResponse + * @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, + ): ibc.connection.QueryConnectionResponse; + } + + /** Properties of a QueryConnectionsRequest. */ + interface IQueryConnectionsRequest { + /** QueryConnectionsRequest pagination */ + pagination?: cosmos.query.IPageRequest | null; + } + + /** Represents a QueryConnectionsRequest. */ + class QueryConnectionsRequest implements IQueryConnectionsRequest { + /** + * Constructs a new QueryConnectionsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionsRequest); + + /** QueryConnectionsRequest pagination. */ + public pagination?: cosmos.query.IPageRequest | null; + + /** + * Creates a new QueryConnectionsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionsRequest instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionsRequest, + ): ibc.connection.QueryConnectionsRequest; + + /** + * Encodes the specified QueryConnectionsRequest message. Does not implicitly {@link ibc.connection.QueryConnectionsRequest.verify|verify} messages. + * @param m QueryConnectionsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryConnectionsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionsRequest + * @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, + ): ibc.connection.QueryConnectionsRequest; + } + + /** Properties of a QueryConnectionsResponse. */ + interface IQueryConnectionsResponse { + /** QueryConnectionsResponse connections */ + connections?: ibc.connection.IIdentifiedConnection[] | null; + + /** QueryConnectionsResponse pagination */ + pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionsResponse height */ + height?: Long | null; + } + + /** Represents a QueryConnectionsResponse. */ + class QueryConnectionsResponse implements IQueryConnectionsResponse { + /** + * Constructs a new QueryConnectionsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryConnectionsResponse); + + /** QueryConnectionsResponse connections. */ + public connections: ibc.connection.IIdentifiedConnection[]; + + /** QueryConnectionsResponse pagination. */ + public pagination?: cosmos.query.IPageResponse | null; + + /** QueryConnectionsResponse height. */ + public height: Long; + + /** + * Creates a new QueryConnectionsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryConnectionsResponse instance + */ + public static create( + properties?: ibc.connection.IQueryConnectionsResponse, + ): ibc.connection.QueryConnectionsResponse; + + /** + * Encodes the specified QueryConnectionsResponse message. Does not implicitly {@link ibc.connection.QueryConnectionsResponse.verify|verify} messages. + * @param m QueryConnectionsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryConnectionsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryConnectionsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryConnectionsResponse + * @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, + ): ibc.connection.QueryConnectionsResponse; + } + + /** Properties of a QueryClientConnectionsRequest. */ + interface IQueryClientConnectionsRequest { + /** QueryClientConnectionsRequest clientId */ + clientId?: string | null; + } + + /** Represents a QueryClientConnectionsRequest. */ + class QueryClientConnectionsRequest implements IQueryClientConnectionsRequest { + /** + * Constructs a new QueryClientConnectionsRequest. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryClientConnectionsRequest); + + /** QueryClientConnectionsRequest clientId. */ + public clientId: string; + + /** + * Creates a new QueryClientConnectionsRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryClientConnectionsRequest instance + */ + public static create( + properties?: ibc.connection.IQueryClientConnectionsRequest, + ): ibc.connection.QueryClientConnectionsRequest; + + /** + * Encodes the specified QueryClientConnectionsRequest message. Does not implicitly {@link ibc.connection.QueryClientConnectionsRequest.verify|verify} messages. + * @param m QueryClientConnectionsRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryClientConnectionsRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryClientConnectionsRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryClientConnectionsRequest + * @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, + ): ibc.connection.QueryClientConnectionsRequest; + } + + /** Properties of a QueryClientConnectionsResponse. */ + interface IQueryClientConnectionsResponse { + /** QueryClientConnectionsResponse connectionPaths */ + connectionPaths?: string[] | null; + + /** QueryClientConnectionsResponse proof */ + proof?: Uint8Array | null; + + /** QueryClientConnectionsResponse proofPath */ + proofPath?: string | null; + + /** QueryClientConnectionsResponse proofHeight */ + proofHeight?: Long | null; + } + + /** Represents a QueryClientConnectionsResponse. */ + class QueryClientConnectionsResponse implements IQueryClientConnectionsResponse { + /** + * Constructs a new QueryClientConnectionsResponse. + * @param [p] Properties to set + */ + constructor(p?: ibc.connection.IQueryClientConnectionsResponse); + + /** QueryClientConnectionsResponse connectionPaths. */ + public connectionPaths: string[]; + + /** QueryClientConnectionsResponse proof. */ + public proof: Uint8Array; + + /** QueryClientConnectionsResponse proofPath. */ + public proofPath: string; + + /** QueryClientConnectionsResponse proofHeight. */ + public proofHeight: Long; + + /** + * Creates a new QueryClientConnectionsResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryClientConnectionsResponse instance + */ + public static create( + properties?: ibc.connection.IQueryClientConnectionsResponse, + ): ibc.connection.QueryClientConnectionsResponse; + + /** + * Encodes the specified QueryClientConnectionsResponse message. Does not implicitly {@link ibc.connection.QueryClientConnectionsResponse.verify|verify} messages. + * @param m QueryClientConnectionsResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: ibc.connection.IQueryClientConnectionsResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryClientConnectionsResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryClientConnectionsResponse + * @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, + ): ibc.connection.QueryClientConnectionsResponse; + } + } +} + /** Namespace tendermint. */ export namespace tendermint { /** Namespace abci. */