@xpla/xpla-react 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.rpc.func.ts

@@ -0,0 +1,190 @@
+import { RpcResolver, buildQuery } from "../../../../helper-func-types";
+import { buildUseQuery } from "../../../../react-query";
+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 const createGetChannel = (clientResolver?: RpcResolver) => buildQuery<QueryChannelRequest, QueryChannelResponse>({
+  encode: QueryChannelRequest.encode,
+  decode: QueryChannelResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "Channel",
+  clientResolver
+});
+export const useGetChannel = buildUseQuery<QueryChannelRequest, QueryChannelResponse>({
+  builderQueryFn: createGetChannel,
+  queryKeyPrefix: "ChannelQuery"
+});
+export const createGetChannels = (clientResolver?: RpcResolver) => buildQuery<QueryChannelsRequest, QueryChannelsResponse>({
+  encode: QueryChannelsRequest.encode,
+  decode: QueryChannelsResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "Channels",
+  clientResolver
+});
+export const useGetChannels = buildUseQuery<QueryChannelsRequest, QueryChannelsResponse>({
+  builderQueryFn: createGetChannels,
+  queryKeyPrefix: "ChannelsQuery"
+});
+export const createGetConnectionChannels = (clientResolver?: RpcResolver) => buildQuery<QueryConnectionChannelsRequest, QueryConnectionChannelsResponse>({
+  encode: QueryConnectionChannelsRequest.encode,
+  decode: QueryConnectionChannelsResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "ConnectionChannels",
+  clientResolver
+});
+export const useGetConnectionChannels = buildUseQuery<QueryConnectionChannelsRequest, QueryConnectionChannelsResponse>({
+  builderQueryFn: createGetConnectionChannels,
+  queryKeyPrefix: "ConnectionChannelsQuery"
+});
+export const createGetChannelClientState = (clientResolver?: RpcResolver) => buildQuery<QueryChannelClientStateRequest, QueryChannelClientStateResponse>({
+  encode: QueryChannelClientStateRequest.encode,
+  decode: QueryChannelClientStateResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "ChannelClientState",
+  clientResolver
+});
+export const useGetChannelClientState = buildUseQuery<QueryChannelClientStateRequest, QueryChannelClientStateResponse>({
+  builderQueryFn: createGetChannelClientState,
+  queryKeyPrefix: "ChannelClientStateQuery"
+});
+export const createGetChannelConsensusState = (clientResolver?: RpcResolver) => buildQuery<QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse>({
+  encode: QueryChannelConsensusStateRequest.encode,
+  decode: QueryChannelConsensusStateResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "ChannelConsensusState",
+  clientResolver
+});
+export const useGetChannelConsensusState = buildUseQuery<QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse>({
+  builderQueryFn: createGetChannelConsensusState,
+  queryKeyPrefix: "ChannelConsensusStateQuery"
+});
+export const createGetPacketCommitment = (clientResolver?: RpcResolver) => buildQuery<QueryPacketCommitmentRequest, QueryPacketCommitmentResponse>({
+  encode: QueryPacketCommitmentRequest.encode,
+  decode: QueryPacketCommitmentResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "PacketCommitment",
+  clientResolver
+});
+export const useGetPacketCommitment = buildUseQuery<QueryPacketCommitmentRequest, QueryPacketCommitmentResponse>({
+  builderQueryFn: createGetPacketCommitment,
+  queryKeyPrefix: "PacketCommitmentQuery"
+});
+export const createGetPacketCommitments = (clientResolver?: RpcResolver) => buildQuery<QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse>({
+  encode: QueryPacketCommitmentsRequest.encode,
+  decode: QueryPacketCommitmentsResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "PacketCommitments",
+  clientResolver
+});
+export const useGetPacketCommitments = buildUseQuery<QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse>({
+  builderQueryFn: createGetPacketCommitments,
+  queryKeyPrefix: "PacketCommitmentsQuery"
+});
+export const createGetPacketReceipt = (clientResolver?: RpcResolver) => buildQuery<QueryPacketReceiptRequest, QueryPacketReceiptResponse>({
+  encode: QueryPacketReceiptRequest.encode,
+  decode: QueryPacketReceiptResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "PacketReceipt",
+  clientResolver
+});
+export const useGetPacketReceipt = buildUseQuery<QueryPacketReceiptRequest, QueryPacketReceiptResponse>({
+  builderQueryFn: createGetPacketReceipt,
+  queryKeyPrefix: "PacketReceiptQuery"
+});
+export const createGetPacketAcknowledgement = (clientResolver?: RpcResolver) => buildQuery<QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse>({
+  encode: QueryPacketAcknowledgementRequest.encode,
+  decode: QueryPacketAcknowledgementResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "PacketAcknowledgement",
+  clientResolver
+});
+export const useGetPacketAcknowledgement = buildUseQuery<QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse>({
+  builderQueryFn: createGetPacketAcknowledgement,
+  queryKeyPrefix: "PacketAcknowledgementQuery"
+});
+export const createGetPacketAcknowledgements = (clientResolver?: RpcResolver) => buildQuery<QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse>({
+  encode: QueryPacketAcknowledgementsRequest.encode,
+  decode: QueryPacketAcknowledgementsResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "PacketAcknowledgements",
+  clientResolver
+});
+export const useGetPacketAcknowledgements = buildUseQuery<QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse>({
+  builderQueryFn: createGetPacketAcknowledgements,
+  queryKeyPrefix: "PacketAcknowledgementsQuery"
+});
+export const createGetUnreceivedPackets = (clientResolver?: RpcResolver) => buildQuery<QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse>({
+  encode: QueryUnreceivedPacketsRequest.encode,
+  decode: QueryUnreceivedPacketsResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "UnreceivedPackets",
+  clientResolver
+});
+export const useGetUnreceivedPackets = buildUseQuery<QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse>({
+  builderQueryFn: createGetUnreceivedPackets,
+  queryKeyPrefix: "UnreceivedPacketsQuery"
+});
+export const createGetUnreceivedAcks = (clientResolver?: RpcResolver) => buildQuery<QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse>({
+  encode: QueryUnreceivedAcksRequest.encode,
+  decode: QueryUnreceivedAcksResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "UnreceivedAcks",
+  clientResolver
+});
+export const useGetUnreceivedAcks = buildUseQuery<QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse>({
+  builderQueryFn: createGetUnreceivedAcks,
+  queryKeyPrefix: "UnreceivedAcksQuery"
+});
+export const createGetNextSequenceReceive = (clientResolver?: RpcResolver) => buildQuery<QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse>({
+  encode: QueryNextSequenceReceiveRequest.encode,
+  decode: QueryNextSequenceReceiveResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "NextSequenceReceive",
+  clientResolver
+});
+export const useGetNextSequenceReceive = buildUseQuery<QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse>({
+  builderQueryFn: createGetNextSequenceReceive,
+  queryKeyPrefix: "NextSequenceReceiveQuery"
+});
+export const createGetNextSequenceSend = (clientResolver?: RpcResolver) => buildQuery<QueryNextSequenceSendRequest, QueryNextSequenceSendResponse>({
+  encode: QueryNextSequenceSendRequest.encode,
+  decode: QueryNextSequenceSendResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "NextSequenceSend",
+  clientResolver
+});
+export const useGetNextSequenceSend = buildUseQuery<QueryNextSequenceSendRequest, QueryNextSequenceSendResponse>({
+  builderQueryFn: createGetNextSequenceSend,
+  queryKeyPrefix: "NextSequenceSendQuery"
+});
+export const createGetUpgradeError = (clientResolver?: RpcResolver) => buildQuery<QueryUpgradeErrorRequest, QueryUpgradeErrorResponse>({
+  encode: QueryUpgradeErrorRequest.encode,
+  decode: QueryUpgradeErrorResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "UpgradeError",
+  clientResolver
+});
+export const useGetUpgradeError = buildUseQuery<QueryUpgradeErrorRequest, QueryUpgradeErrorResponse>({
+  builderQueryFn: createGetUpgradeError,
+  queryKeyPrefix: "UpgradeErrorQuery"
+});
+export const createGetUpgrade = (clientResolver?: RpcResolver) => buildQuery<QueryUpgradeRequest, QueryUpgradeResponse>({
+  encode: QueryUpgradeRequest.encode,
+  decode: QueryUpgradeResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "Upgrade",
+  clientResolver
+});
+export const useGetUpgrade = buildUseQuery<QueryUpgradeRequest, QueryUpgradeResponse>({
+  builderQueryFn: createGetUpgrade,
+  queryKeyPrefix: "UpgradeQuery"
+});
+export const createGetChannelParams = (clientResolver?: RpcResolver) => buildQuery<QueryChannelParamsRequest, QueryChannelParamsResponse>({
+  encode: QueryChannelParamsRequest.encode,
+  decode: QueryChannelParamsResponse.decode,
+  service: "ibc.core.channel.v1.Query",
+  method: "ChannelParams",
+  clientResolver
+});
+export const useGetChannelParams = buildUseQuery<QueryChannelParamsRequest, QueryChannelParamsResponse>({
+  builderQueryFn: createGetChannelParams,
+  queryKeyPrefix: "ChannelParamsQuery"
+});