juno-network 0.5.3 → 0.6.0

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

@@ -0,0 +1,231 @@
+import { IdentifiedChannel, IdentifiedChannelSDKType, PacketState, PacketStateSDKType } from "./channel";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/** 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: Long;
+}
+/** GenesisState defines the ibc channel submodule's genesis state. */
+
+export interface GenesisStateSDKType {
+  channels: IdentifiedChannelSDKType[];
+  acknowledgements: PacketStateSDKType[];
+  commitments: PacketStateSDKType[];
+  receipts: PacketStateSDKType[];
+  send_sequences: PacketSequenceSDKType[];
+  recv_sequences: PacketSequenceSDKType[];
+  ack_sequences: PacketSequenceSDKType[];
+  /** the sequence for the next generated channel identifier */
+
+  next_channel_sequence: Long;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ */
+
+export interface PacketSequence {
+  portId: string;
+  channelId: string;
+  sequence: Long;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ */
+
+export interface PacketSequenceSDKType {
+  port_id: string;
+  channel_id: string;
+  sequence: Long;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    channels: [],
+    acknowledgements: [],
+    commitments: [],
+    receipts: [],
+    sendSequences: [],
+    recvSequences: [],
+    ackSequences: [],
+    nextChannelSequence: Long.UZERO
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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.isZero()) {
+      writer.uint32(64).uint64(message.nextChannelSequence);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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() as Long);
+          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 ? Long.fromValue(object.nextChannelSequence) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBasePacketSequence(): PacketSequence {
+  return {
+    portId: "",
+    channelId: "",
+    sequence: Long.UZERO
+  };
+}
+
+export const PacketSequence = {
+  encode(message: PacketSequence, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+
+    if (!message.sequence.isZero()) {
+      writer.uint32(24).uint64(message.sequence);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PacketSequence {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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() as Long);
+          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 ? Long.fromValue(object.sequence) : Long.UZERO;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,165 @@
+import { setPaginationParams } from "@osmonauts/helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryChannelRequest, QueryChannelResponseSDKType, QueryChannelsRequest, QueryChannelsResponseSDKType, QueryConnectionChannelsRequest, QueryConnectionChannelsResponseSDKType, QueryChannelClientStateRequest, QueryChannelClientStateResponseSDKType, QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponseSDKType, QueryPacketCommitmentRequest, QueryPacketCommitmentResponseSDKType, QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponseSDKType, QueryPacketReceiptRequest, QueryPacketReceiptResponseSDKType, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponseSDKType, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponseSDKType, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponseSDKType, QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponseSDKType, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.channel = this.channel.bind(this);
+    this.channels = this.channels.bind(this);
+    this.connectionChannels = this.connectionChannels.bind(this);
+    this.channelClientState = this.channelClientState.bind(this);
+    this.channelConsensusState = this.channelConsensusState.bind(this);
+    this.packetCommitment = this.packetCommitment.bind(this);
+    this.packetCommitments = this.packetCommitments.bind(this);
+    this.packetReceipt = this.packetReceipt.bind(this);
+    this.packetAcknowledgement = this.packetAcknowledgement.bind(this);
+    this.packetAcknowledgements = this.packetAcknowledgements.bind(this);
+    this.unreceivedPackets = this.unreceivedPackets.bind(this);
+    this.unreceivedAcks = this.unreceivedAcks.bind(this);
+    this.nextSequenceReceive = this.nextSequenceReceive.bind(this);
+  }
+  /* Channel queries an IBC Channel. */
+
+
+  async channel(params: QueryChannelRequest): Promise<QueryChannelResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}ports/${params.portId}`;
+    return await this.req.get<QueryChannelResponseSDKType>(endpoint);
+  }
+  /* Channels queries all the IBC channels of a chain. */
+
+
+  async channels(params: QueryChannelsRequest = {
+    pagination: undefined
+  }): Promise<QueryChannelsResponseSDKType> {
+    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<QueryChannelsResponseSDKType>(endpoint, options);
+  }
+  /* ConnectionChannels queries all the channels associated with a connection
+  end. */
+
+
+  async connectionChannels(params: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponseSDKType> {
+    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<QueryConnectionChannelsResponseSDKType>(endpoint, options);
+  }
+  /* ChannelClientState queries for the client state for the channel associated
+  with the provided channel identifiers. */
+
+
+  async channelClientState(params: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/client_state`;
+    return await this.req.get<QueryChannelClientStateResponseSDKType>(endpoint);
+  }
+  /* ChannelConsensusState queries for the consensus state for the channel
+  associated with the provided channel identifiers. */
+
+
+  async channelConsensusState(params: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponseSDKType> {
+    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<QueryChannelConsensusStateResponseSDKType>(endpoint);
+  }
+  /* PacketCommitment queries a stored packet commitment hash. */
+
+
+  async packetCommitment(params: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}packet_commitments/${params.sequence}`;
+    return await this.req.get<QueryPacketCommitmentResponseSDKType>(endpoint);
+  }
+  /* PacketCommitments returns all the packet commitments hashes associated
+  with a channel. */
+
+
+  async packetCommitments(params: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponseSDKType> {
+    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<QueryPacketCommitmentsResponseSDKType>(endpoint, options);
+  }
+  /* PacketReceipt queries if a given packet sequence has been received on the
+  queried chain */
+
+
+  async packetReceipt(params: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}packet_receipts/${params.sequence}`;
+    return await this.req.get<QueryPacketReceiptResponseSDKType>(endpoint);
+  }
+  /* PacketAcknowledgement queries a stored packet acknowledgement hash. */
+
+
+  async packetAcknowledgement(params: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}packet_acks/${params.sequence}`;
+    return await this.req.get<QueryPacketAcknowledgementResponseSDKType>(endpoint);
+  }
+  /* PacketAcknowledgements returns all the packet acknowledgements associated
+  with a channel. */
+
+
+  async packetAcknowledgements(params: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponseSDKType> {
+    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<QueryPacketAcknowledgementsResponseSDKType>(endpoint, options);
+  }
+  /* UnreceivedPackets returns all the unreceived IBC packets associated with a
+  channel and sequences. */
+
+
+  async unreceivedPackets(params: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.packetCommitmentSequences}/unreceived_packets`;
+    return await this.req.get<QueryUnreceivedPacketsResponseSDKType>(endpoint);
+  }
+  /* UnreceivedAcks returns all the unreceived IBC acknowledgements associated
+  with a channel and sequences. */
+
+
+  async unreceivedAcks(params: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.packetAckSequences}/unreceived_acks`;
+    return await this.req.get<QueryUnreceivedAcksResponseSDKType>(endpoint);
+  }
+  /* NextSequenceReceive returns the next receive sequence for a given channel. */
+
+
+  async nextSequenceReceive(params: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/next_sequence`;
+    return await this.req.get<QueryNextSequenceReceiveResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/ibc/core/channel/v1/query.rpc.query.ts

@@ -0,0 +1,214 @@
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+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 } from "./query";
+/** Query defines the RPC service */
+
+export interface Query {
+  channel(request: QueryChannelRequest): Promise<QueryChannelResponse>;
+  /*Channel queries an IBC Channel.*/
+
+  channels(request?: QueryChannelsRequest): Promise<QueryChannelsResponse>;
+  /*Channels queries all the IBC channels of a chain.*/
+
+  connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse>;
+  /*ConnectionChannels queries all the channels associated with a connection
+  end.*/
+
+  channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse>;
+  /*ChannelClientState queries for the client state for the channel associated
+  with the provided channel identifiers.*/
+
+  channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse>;
+  /*ChannelConsensusState queries for the consensus state for the channel
+  associated with the provided channel identifiers.*/
+
+  packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse>;
+  /*PacketCommitment queries a stored packet commitment hash.*/
+
+  packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse>;
+  /*PacketCommitments returns all the packet commitments hashes associated
+  with a channel.*/
+
+  packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse>;
+  /*PacketReceipt queries if a given packet sequence has been received on the
+  queried chain*/
+
+  packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse>;
+  /*PacketAcknowledgement queries a stored packet acknowledgement hash.*/
+
+  packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse>;
+  /*PacketAcknowledgements returns all the packet acknowledgements associated
+  with a channel.*/
+
+  unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse>;
+  /*UnreceivedPackets returns all the unreceived IBC packets associated with a
+  channel and sequences.*/
+
+  unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse>;
+  /*UnreceivedAcks returns all the unreceived IBC acknowledgements associated
+  with a channel and sequences.*/
+
+  nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse>;
+  /*NextSequenceReceive returns the next receive sequence for a given channel.*/
+
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.channel = this.channel.bind(this);
+    this.channels = this.channels.bind(this);
+    this.connectionChannels = this.connectionChannels.bind(this);
+    this.channelClientState = this.channelClientState.bind(this);
+    this.channelConsensusState = this.channelConsensusState.bind(this);
+    this.packetCommitment = this.packetCommitment.bind(this);
+    this.packetCommitments = this.packetCommitments.bind(this);
+    this.packetReceipt = this.packetReceipt.bind(this);
+    this.packetAcknowledgement = this.packetAcknowledgement.bind(this);
+    this.packetAcknowledgements = this.packetAcknowledgements.bind(this);
+    this.unreceivedPackets = this.unreceivedPackets.bind(this);
+    this.unreceivedAcks = this.unreceivedAcks.bind(this);
+    this.nextSequenceReceive = this.nextSequenceReceive.bind(this);
+  }
+
+  channel(request: QueryChannelRequest): Promise<QueryChannelResponse> {
+    const data = QueryChannelRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "Channel", data);
+    return promise.then(data => QueryChannelResponse.decode(new _m0.Reader(data)));
+  }
+
+  channels(request: QueryChannelsRequest = {
+    pagination: undefined
+  }): Promise<QueryChannelsResponse> {
+    const data = QueryChannelsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "Channels", data);
+    return promise.then(data => QueryChannelsResponse.decode(new _m0.Reader(data)));
+  }
+
+  connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse> {
+    const data = QueryConnectionChannelsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "ConnectionChannels", data);
+    return promise.then(data => QueryConnectionChannelsResponse.decode(new _m0.Reader(data)));
+  }
+
+  channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse> {
+    const data = QueryChannelClientStateRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "ChannelClientState", data);
+    return promise.then(data => QueryChannelClientStateResponse.decode(new _m0.Reader(data)));
+  }
+
+  channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse> {
+    const data = QueryChannelConsensusStateRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "ChannelConsensusState", data);
+    return promise.then(data => QueryChannelConsensusStateResponse.decode(new _m0.Reader(data)));
+  }
+
+  packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse> {
+    const data = QueryPacketCommitmentRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketCommitment", data);
+    return promise.then(data => QueryPacketCommitmentResponse.decode(new _m0.Reader(data)));
+  }
+
+  packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse> {
+    const data = QueryPacketCommitmentsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketCommitments", data);
+    return promise.then(data => QueryPacketCommitmentsResponse.decode(new _m0.Reader(data)));
+  }
+
+  packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse> {
+    const data = QueryPacketReceiptRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketReceipt", data);
+    return promise.then(data => QueryPacketReceiptResponse.decode(new _m0.Reader(data)));
+  }
+
+  packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse> {
+    const data = QueryPacketAcknowledgementRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketAcknowledgement", data);
+    return promise.then(data => QueryPacketAcknowledgementResponse.decode(new _m0.Reader(data)));
+  }
+
+  packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse> {
+    const data = QueryPacketAcknowledgementsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketAcknowledgements", data);
+    return promise.then(data => QueryPacketAcknowledgementsResponse.decode(new _m0.Reader(data)));
+  }
+
+  unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse> {
+    const data = QueryUnreceivedPacketsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "UnreceivedPackets", data);
+    return promise.then(data => QueryUnreceivedPacketsResponse.decode(new _m0.Reader(data)));
+  }
+
+  unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse> {
+    const data = QueryUnreceivedAcksRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "UnreceivedAcks", data);
+    return promise.then(data => QueryUnreceivedAcksResponse.decode(new _m0.Reader(data)));
+  }
+
+  nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse> {
+    const data = QueryNextSequenceReceiveRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Query", "NextSequenceReceive", data);
+    return promise.then(data => QueryNextSequenceReceiveResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    channel(request: QueryChannelRequest): Promise<QueryChannelResponse> {
+      return queryService.channel(request);
+    },
+
+    channels(request?: QueryChannelsRequest): Promise<QueryChannelsResponse> {
+      return queryService.channels(request);
+    },
+
+    connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse> {
+      return queryService.connectionChannels(request);
+    },
+
+    channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse> {
+      return queryService.channelClientState(request);
+    },
+
+    channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse> {
+      return queryService.channelConsensusState(request);
+    },
+
+    packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse> {
+      return queryService.packetCommitment(request);
+    },
+
+    packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse> {
+      return queryService.packetCommitments(request);
+    },
+
+    packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse> {
+      return queryService.packetReceipt(request);
+    },
+
+    packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse> {
+      return queryService.packetAcknowledgement(request);
+    },
+
+    packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse> {
+      return queryService.packetAcknowledgements(request);
+    },
+
+    unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse> {
+      return queryService.unreceivedPackets(request);
+    },
+
+    unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse> {
+      return queryService.unreceivedAcks(request);
+    },
+
+    nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse> {
+      return queryService.nextSequenceReceive(request);
+    }
+
+  };
+};