@xpla/xplajs 1.7.0-beta.0

package/src/ibc/core/channel/v1/genesis.ts

@@ -0,0 +1,354 @@
+import { IdentifiedChannel, IdentifiedChannelAmino, PacketState, PacketStateAmino, Params, ParamsAmino } from "./channel";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** GenesisState defines the ibc channel submodule's genesis state. */
+export interface GenesisState {
+  channels: IdentifiedChannel[];
+  acknowledgements: PacketState[];
+  commitments: PacketState[];
+  receipts: PacketState[];
+  sendSequences: PacketSequence[];
+  recvSequences: PacketSequence[];
+  ackSequences: PacketSequence[];
+  /** the sequence for the next generated channel identifier */
+  nextChannelSequence: bigint;
+  params: Params;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/ibc.core.channel.v1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the ibc channel submodule's genesis state. */
+export interface GenesisStateAmino {
+  channels: IdentifiedChannelAmino[];
+  acknowledgements: PacketStateAmino[];
+  commitments: PacketStateAmino[];
+  receipts: PacketStateAmino[];
+  send_sequences: PacketSequenceAmino[];
+  recv_sequences: PacketSequenceAmino[];
+  ack_sequences: PacketSequenceAmino[];
+  /** the sequence for the next generated channel identifier */
+  next_channel_sequence: string;
+  params: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ */
+export interface PacketSequence {
+  portId: string;
+  channelId: string;
+  sequence: bigint;
+}
+export interface PacketSequenceProtoMsg {
+  typeUrl: "/ibc.core.channel.v1.PacketSequence";
+  value: Uint8Array;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ */
+export interface PacketSequenceAmino {
+  port_id: string;
+  channel_id: string;
+  sequence: string;
+}
+export interface PacketSequenceAminoMsg {
+  type: "cosmos-sdk/PacketSequence";
+  value: PacketSequenceAmino;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    channels: [],
+    acknowledgements: [],
+    commitments: [],
+    receipts: [],
+    sendSequences: [],
+    recvSequences: [],
+    ackSequences: [],
+    nextChannelSequence: BigInt(0),
+    params: Params.fromPartial({})
+  };
+}
+export const GenesisState = {
+  typeUrl: "/ibc.core.channel.v1.GenesisState",
+  aminoType: "cosmos-sdk/GenesisState",
+  is(o: any): o is GenesisState {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.channels) && (!o.channels.length || IdentifiedChannel.is(o.channels[0])) && Array.isArray(o.acknowledgements) && (!o.acknowledgements.length || PacketState.is(o.acknowledgements[0])) && Array.isArray(o.commitments) && (!o.commitments.length || PacketState.is(o.commitments[0])) && Array.isArray(o.receipts) && (!o.receipts.length || PacketState.is(o.receipts[0])) && Array.isArray(o.sendSequences) && (!o.sendSequences.length || PacketSequence.is(o.sendSequences[0])) && Array.isArray(o.recvSequences) && (!o.recvSequences.length || PacketSequence.is(o.recvSequences[0])) && Array.isArray(o.ackSequences) && (!o.ackSequences.length || PacketSequence.is(o.ackSequences[0])) && typeof o.nextChannelSequence === "bigint" && Params.is(o.params));
+  },
+  isAmino(o: any): o is GenesisStateAmino {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.channels) && (!o.channels.length || IdentifiedChannel.isAmino(o.channels[0])) && Array.isArray(o.acknowledgements) && (!o.acknowledgements.length || PacketState.isAmino(o.acknowledgements[0])) && Array.isArray(o.commitments) && (!o.commitments.length || PacketState.isAmino(o.commitments[0])) && Array.isArray(o.receipts) && (!o.receipts.length || PacketState.isAmino(o.receipts[0])) && Array.isArray(o.send_sequences) && (!o.send_sequences.length || PacketSequence.isAmino(o.send_sequences[0])) && Array.isArray(o.recv_sequences) && (!o.recv_sequences.length || PacketSequence.isAmino(o.recv_sequences[0])) && Array.isArray(o.ack_sequences) && (!o.ack_sequences.length || PacketSequence.isAmino(o.ack_sequences[0])) && typeof o.next_channel_sequence === "bigint" && Params.isAmino(o.params));
+  },
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.channels) {
+      IdentifiedChannel.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.acknowledgements) {
+      PacketState.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.commitments) {
+      PacketState.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.receipts) {
+      PacketState.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.sendSequences) {
+      PacketSequence.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+    for (const v of message.recvSequences) {
+      PacketSequence.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+    for (const v of message.ackSequences) {
+      PacketSequence.encode(v!, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.nextChannelSequence !== BigInt(0)) {
+      writer.uint32(64).uint64(message.nextChannelSequence);
+    }
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(74).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.channels.push(IdentifiedChannel.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.acknowledgements.push(PacketState.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.commitments.push(PacketState.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.receipts.push(PacketState.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.sendSequences.push(PacketSequence.decode(reader, reader.uint32()));
+          break;
+        case 6:
+          message.recvSequences.push(PacketSequence.decode(reader, reader.uint32()));
+          break;
+        case 7:
+          message.ackSequences.push(PacketSequence.decode(reader, reader.uint32()));
+          break;
+        case 8:
+          message.nextChannelSequence = reader.uint64();
+          break;
+        case 9:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.channels = object.channels?.map(e => IdentifiedChannel.fromPartial(e)) || [];
+    message.acknowledgements = object.acknowledgements?.map(e => PacketState.fromPartial(e)) || [];
+    message.commitments = object.commitments?.map(e => PacketState.fromPartial(e)) || [];
+    message.receipts = object.receipts?.map(e => PacketState.fromPartial(e)) || [];
+    message.sendSequences = object.sendSequences?.map(e => PacketSequence.fromPartial(e)) || [];
+    message.recvSequences = object.recvSequences?.map(e => PacketSequence.fromPartial(e)) || [];
+    message.ackSequences = object.ackSequences?.map(e => PacketSequence.fromPartial(e)) || [];
+    message.nextChannelSequence = object.nextChannelSequence !== undefined && object.nextChannelSequence !== null ? BigInt(object.nextChannelSequence.toString()) : BigInt(0);
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.channels = object.channels?.map(e => IdentifiedChannel.fromAmino(e)) || [];
+    message.acknowledgements = object.acknowledgements?.map(e => PacketState.fromAmino(e)) || [];
+    message.commitments = object.commitments?.map(e => PacketState.fromAmino(e)) || [];
+    message.receipts = object.receipts?.map(e => PacketState.fromAmino(e)) || [];
+    message.sendSequences = object.send_sequences?.map(e => PacketSequence.fromAmino(e)) || [];
+    message.recvSequences = object.recv_sequences?.map(e => PacketSequence.fromAmino(e)) || [];
+    message.ackSequences = object.ack_sequences?.map(e => PacketSequence.fromAmino(e)) || [];
+    if (object.next_channel_sequence !== undefined && object.next_channel_sequence !== null) {
+      message.nextChannelSequence = BigInt(object.next_channel_sequence);
+    }
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.channels) {
+      obj.channels = message.channels.map(e => e ? IdentifiedChannel.toAmino(e) : undefined);
+    } else {
+      obj.channels = message.channels;
+    }
+    if (message.acknowledgements) {
+      obj.acknowledgements = message.acknowledgements.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.acknowledgements = message.acknowledgements;
+    }
+    if (message.commitments) {
+      obj.commitments = message.commitments.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.commitments = message.commitments;
+    }
+    if (message.receipts) {
+      obj.receipts = message.receipts.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.receipts = message.receipts;
+    }
+    if (message.sendSequences) {
+      obj.send_sequences = message.sendSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.send_sequences = message.sendSequences;
+    }
+    if (message.recvSequences) {
+      obj.recv_sequences = message.recvSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.recv_sequences = message.recvSequences;
+    }
+    if (message.ackSequences) {
+      obj.ack_sequences = message.ackSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.ack_sequences = message.ackSequences;
+    }
+    obj.next_channel_sequence = message.nextChannelSequence !== BigInt(0) ? message.nextChannelSequence?.toString() : undefined;
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/ibc.core.channel.v1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
+GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);
+function createBasePacketSequence(): PacketSequence {
+  return {
+    portId: "",
+    channelId: "",
+    sequence: BigInt(0)
+  };
+}
+export const PacketSequence = {
+  typeUrl: "/ibc.core.channel.v1.PacketSequence",
+  aminoType: "cosmos-sdk/PacketSequence",
+  is(o: any): o is PacketSequence {
+    return o && (o.$typeUrl === PacketSequence.typeUrl || typeof o.portId === "string" && typeof o.channelId === "string" && typeof o.sequence === "bigint");
+  },
+  isAmino(o: any): o is PacketSequenceAmino {
+    return o && (o.$typeUrl === PacketSequence.typeUrl || typeof o.port_id === "string" && typeof o.channel_id === "string" && typeof o.sequence === "bigint");
+  },
+  encode(message: PacketSequence, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+    if (message.sequence !== BigInt(0)) {
+      writer.uint32(24).uint64(message.sequence);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PacketSequence {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePacketSequence();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+        case 2:
+          message.channelId = reader.string();
+          break;
+        case 3:
+          message.sequence = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<PacketSequence>): PacketSequence {
+    const message = createBasePacketSequence();
+    message.portId = object.portId ?? "";
+    message.channelId = object.channelId ?? "";
+    message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: PacketSequenceAmino): PacketSequence {
+    const message = createBasePacketSequence();
+    if (object.port_id !== undefined && object.port_id !== null) {
+      message.portId = object.port_id;
+    }
+    if (object.channel_id !== undefined && object.channel_id !== null) {
+      message.channelId = object.channel_id;
+    }
+    if (object.sequence !== undefined && object.sequence !== null) {
+      message.sequence = BigInt(object.sequence);
+    }
+    return message;
+  },
+  toAmino(message: PacketSequence): PacketSequenceAmino {
+    const obj: any = {};
+    obj.port_id = message.portId === "" ? undefined : message.portId;
+    obj.channel_id = message.channelId === "" ? undefined : message.channelId;
+    obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PacketSequenceAminoMsg): PacketSequence {
+    return PacketSequence.fromAmino(object.value);
+  },
+  toAminoMsg(message: PacketSequence): PacketSequenceAminoMsg {
+    return {
+      type: "cosmos-sdk/PacketSequence",
+      value: PacketSequence.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PacketSequenceProtoMsg): PacketSequence {
+    return PacketSequence.decode(message.value);
+  },
+  toProto(message: PacketSequence): Uint8Array {
+    return PacketSequence.encode(message).finish();
+  },
+  toProtoMsg(message: PacketSequence): PacketSequenceProtoMsg {
+    return {
+      typeUrl: "/ibc.core.channel.v1.PacketSequence",
+      value: PacketSequence.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(PacketSequence.typeUrl, PacketSequence);
+GlobalDecoderRegistry.registerAminoProtoMapping(PacketSequence.aminoType, PacketSequence.typeUrl);

package/src/ibc/core/channel/v1/query.lcd.ts

@@ -0,0 +1,135 @@
+import { setPaginationParams } from "../../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryChannelRequest, QueryChannelResponse, QueryChannelsRequest, QueryChannelsResponse, QueryConnectionChannelsRequest, QueryConnectionChannelsResponse, QueryChannelClientStateRequest, QueryChannelClientStateResponse, QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse, QueryPacketCommitmentRequest, QueryPacketCommitmentResponse, QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse, QueryPacketReceiptRequest, QueryPacketReceiptResponse, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse, QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse, QueryNextSequenceSendRequest, QueryNextSequenceSendResponse, QueryUpgradeErrorRequest, QueryUpgradeErrorResponse, QueryUpgradeRequest, QueryUpgradeResponse, QueryChannelParamsRequest, QueryChannelParamsResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* Channel queries an IBC Channel. */
+  channel = async (params: QueryChannelRequest): Promise<QueryChannelResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}`;
+    return await this.req.get<QueryChannelResponse>(endpoint);
+  };
+  /* Channels queries all the IBC channels of a chain. */
+  channels = async (params: QueryChannelsRequest = {
+    pagination: undefined
+  }): Promise<QueryChannelsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `ibc/core/channel/v1/channels`;
+    return await this.req.get<QueryChannelsResponse>(endpoint, options);
+  };
+  /* ConnectionChannels queries all the channels associated with a connection
+   end. */
+  connectionChannels = async (params: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `ibc/core/channel/v1/connections/${params.connection}/channels`;
+    return await this.req.get<QueryConnectionChannelsResponse>(endpoint, options);
+  };
+  /* ChannelClientState queries for the client state for the channel associated
+   with the provided channel identifiers. */
+  channelClientState = async (params: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/client_state`;
+    return await this.req.get<QueryChannelClientStateResponse>(endpoint);
+  };
+  /* ChannelConsensusState queries for the consensus state for the channel
+   associated with the provided channel identifiers. */
+  channelConsensusState = async (params: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/consensus_state/revision/${params.revisionNumber}/height/${params.revisionHeight}`;
+    return await this.req.get<QueryChannelConsensusStateResponse>(endpoint);
+  };
+  /* PacketCommitment queries a stored packet commitment hash. */
+  packetCommitment = async (params: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.sequence}`;
+    return await this.req.get<QueryPacketCommitmentResponse>(endpoint);
+  };
+  /* PacketCommitments returns all the packet commitments hashes associated
+   with a channel. */
+  packetCommitments = async (params: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments`;
+    return await this.req.get<QueryPacketCommitmentsResponse>(endpoint, options);
+  };
+  /* PacketReceipt queries if a given packet sequence has been received on the
+   queried chain */
+  packetReceipt = async (params: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_receipts/${params.sequence}`;
+    return await this.req.get<QueryPacketReceiptResponse>(endpoint);
+  };
+  /* PacketAcknowledgement queries a stored packet acknowledgement hash. */
+  packetAcknowledgement = async (params: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_acks/${params.sequence}`;
+    return await this.req.get<QueryPacketAcknowledgementResponse>(endpoint);
+  };
+  /* PacketAcknowledgements returns all the packet acknowledgements associated
+   with a channel. */
+  packetAcknowledgements = async (params: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.packetCommitmentSequences !== "undefined") {
+      options.params.packet_commitment_sequences = params.packetCommitmentSequences;
+    }
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_acknowledgements`;
+    return await this.req.get<QueryPacketAcknowledgementsResponse>(endpoint, options);
+  };
+  /* UnreceivedPackets returns all the unreceived IBC packets associated with a
+   channel and sequences. */
+  unreceivedPackets = async (params: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.packetCommitmentSequences}/unreceived_packets`;
+    return await this.req.get<QueryUnreceivedPacketsResponse>(endpoint);
+  };
+  /* UnreceivedAcks returns all the unreceived IBC acknowledgements associated
+   with a channel and sequences. */
+  unreceivedAcks = async (params: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.packetAckSequences}/unreceived_acks`;
+    return await this.req.get<QueryUnreceivedAcksResponse>(endpoint);
+  };
+  /* NextSequenceReceive returns the next receive sequence for a given channel. */
+  nextSequenceReceive = async (params: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/next_sequence`;
+    return await this.req.get<QueryNextSequenceReceiveResponse>(endpoint);
+  };
+  /* NextSequenceSend returns the next send sequence for a given channel. */
+  nextSequenceSend = async (params: QueryNextSequenceSendRequest): Promise<QueryNextSequenceSendResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/next_sequence_send`;
+    return await this.req.get<QueryNextSequenceSendResponse>(endpoint);
+  };
+  /* UpgradeError returns the error receipt if the upgrade handshake failed. */
+  upgradeError = async (params: QueryUpgradeErrorRequest): Promise<QueryUpgradeErrorResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/upgrade_error`;
+    return await this.req.get<QueryUpgradeErrorResponse>(endpoint);
+  };
+  /* Upgrade returns the upgrade for a given port and channel id. */
+  upgrade = async (params: QueryUpgradeRequest): Promise<QueryUpgradeResponse> => {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/upgrade`;
+    return await this.req.get<QueryUpgradeResponse>(endpoint);
+  };
+  /* ChannelParams queries all parameters of the ibc channel submodule. */
+  channelParams = async (_params: QueryChannelParamsRequest = {}): Promise<QueryChannelParamsResponse> => {
+    const endpoint = `ibc/core/channel/v1/params`;
+    return await this.req.get<QueryChannelParamsResponse>(endpoint);
+  };
+}