@xpla/xplajs 1.7.0-beta.0

package/src/ibc/applications/fee/v1/metadata.ts

@@ -0,0 +1,121 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/**
+ * Metadata defines the ICS29 channel specific metadata encoded into the channel version bytestring
+ * See ICS004: https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning
+ */
+export interface Metadata {
+  /** fee_version defines the ICS29 fee version */
+  feeVersion: string;
+  /** app_version defines the underlying application version, which may or may not be a JSON encoded bytestring */
+  appVersion: string;
+}
+export interface MetadataProtoMsg {
+  typeUrl: "/ibc.applications.fee.v1.Metadata";
+  value: Uint8Array;
+}
+/**
+ * Metadata defines the ICS29 channel specific metadata encoded into the channel version bytestring
+ * See ICS004: https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning
+ */
+export interface MetadataAmino {
+  /** fee_version defines the ICS29 fee version */
+  fee_version: string;
+  /** app_version defines the underlying application version, which may or may not be a JSON encoded bytestring */
+  app_version: string;
+}
+export interface MetadataAminoMsg {
+  type: "cosmos-sdk/Metadata";
+  value: MetadataAmino;
+}
+function createBaseMetadata(): Metadata {
+  return {
+    feeVersion: "",
+    appVersion: ""
+  };
+}
+export const Metadata = {
+  typeUrl: "/ibc.applications.fee.v1.Metadata",
+  aminoType: "cosmos-sdk/Metadata",
+  is(o: any): o is Metadata {
+    return o && (o.$typeUrl === Metadata.typeUrl || typeof o.feeVersion === "string" && typeof o.appVersion === "string");
+  },
+  isAmino(o: any): o is MetadataAmino {
+    return o && (o.$typeUrl === Metadata.typeUrl || typeof o.fee_version === "string" && typeof o.app_version === "string");
+  },
+  encode(message: Metadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.feeVersion !== "") {
+      writer.uint32(10).string(message.feeVersion);
+    }
+    if (message.appVersion !== "") {
+      writer.uint32(18).string(message.appVersion);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Metadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.feeVersion = reader.string();
+          break;
+        case 2:
+          message.appVersion = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Metadata>): Metadata {
+    const message = createBaseMetadata();
+    message.feeVersion = object.feeVersion ?? "";
+    message.appVersion = object.appVersion ?? "";
+    return message;
+  },
+  fromAmino(object: MetadataAmino): Metadata {
+    const message = createBaseMetadata();
+    if (object.fee_version !== undefined && object.fee_version !== null) {
+      message.feeVersion = object.fee_version;
+    }
+    if (object.app_version !== undefined && object.app_version !== null) {
+      message.appVersion = object.app_version;
+    }
+    return message;
+  },
+  toAmino(message: Metadata): MetadataAmino {
+    const obj: any = {};
+    obj.fee_version = message.feeVersion === "" ? undefined : message.feeVersion;
+    obj.app_version = message.appVersion === "" ? undefined : message.appVersion;
+    return obj;
+  },
+  fromAminoMsg(object: MetadataAminoMsg): Metadata {
+    return Metadata.fromAmino(object.value);
+  },
+  toAminoMsg(message: Metadata): MetadataAminoMsg {
+    return {
+      type: "cosmos-sdk/Metadata",
+      value: Metadata.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MetadataProtoMsg): Metadata {
+    return Metadata.decode(message.value);
+  },
+  toProto(message: Metadata): Uint8Array {
+    return Metadata.encode(message).finish();
+  },
+  toProtoMsg(message: Metadata): MetadataProtoMsg {
+    return {
+      typeUrl: "/ibc.applications.fee.v1.Metadata",
+      value: Metadata.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Metadata.typeUrl, Metadata);
+GlobalDecoderRegistry.registerAminoProtoMapping(Metadata.aminoType, Metadata.typeUrl);

package/src/ibc/applications/fee/v1/query.lcd.ts

@@ -0,0 +1,117 @@
+import { setPaginationParams } from "../../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryIncentivizedPacketsRequest, QueryIncentivizedPacketsResponse, QueryIncentivizedPacketRequest, QueryIncentivizedPacketResponse, QueryIncentivizedPacketsForChannelRequest, QueryIncentivizedPacketsForChannelResponse, QueryTotalRecvFeesRequest, QueryTotalRecvFeesResponse, QueryTotalAckFeesRequest, QueryTotalAckFeesResponse, QueryTotalTimeoutFeesRequest, QueryTotalTimeoutFeesResponse, QueryPayeeRequest, QueryPayeeResponse, QueryCounterpartyPayeeRequest, QueryCounterpartyPayeeResponse, QueryFeeEnabledChannelsRequest, QueryFeeEnabledChannelsResponse, QueryFeeEnabledChannelRequest, QueryFeeEnabledChannelResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* IncentivizedPackets returns all incentivized packets and their associated fees */
+  incentivizedPackets = async (params: QueryIncentivizedPacketsRequest): Promise<QueryIncentivizedPacketsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.queryHeight !== "undefined") {
+      options.params.query_height = params.queryHeight;
+    }
+    const endpoint = `ibc/apps/fee/v1/incentivized_packets`;
+    return await this.req.get<QueryIncentivizedPacketsResponse>(endpoint, options);
+  };
+  /* IncentivizedPacket returns all packet fees for a packet given its identifier */
+  incentivizedPacket = async (params: QueryIncentivizedPacketRequest): Promise<QueryIncentivizedPacketResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.packetId !== "undefined") {
+      options.params.packet_id = params.packetId;
+    }
+    if (typeof params?.queryHeight !== "undefined") {
+      options.params.query_height = params.queryHeight;
+    }
+    const endpoint = `ibc/apps/fee/v1/channels/${params.packetId.channelId}/ports/${params.packetId.portId}/sequences/${params.packetId.sequence}/incentivized_packet`;
+    return await this.req.get<QueryIncentivizedPacketResponse>(endpoint, options);
+  };
+  /* Gets all incentivized packets for a specific channel */
+  incentivizedPacketsForChannel = async (params: QueryIncentivizedPacketsForChannelRequest): Promise<QueryIncentivizedPacketsForChannelResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.queryHeight !== "undefined") {
+      options.params.query_height = params.queryHeight;
+    }
+    const endpoint = `ibc/apps/fee/v1/channels/${params.channelId}/ports/${params.portId}/incentivized_packets`;
+    return await this.req.get<QueryIncentivizedPacketsForChannelResponse>(endpoint, options);
+  };
+  /* TotalRecvFees returns the total receive fees for a packet given its identifier */
+  totalRecvFees = async (params: QueryTotalRecvFeesRequest): Promise<QueryTotalRecvFeesResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.packetId !== "undefined") {
+      options.params.packet_id = params.packetId;
+    }
+    const endpoint = `ibc/apps/fee/v1/channels/${params.packetId.channelId}/ports/${params.packetId.portId}/sequences/${params.packetId.sequence}/total_recv_fees`;
+    return await this.req.get<QueryTotalRecvFeesResponse>(endpoint, options);
+  };
+  /* TotalAckFees returns the total acknowledgement fees for a packet given its identifier */
+  totalAckFees = async (params: QueryTotalAckFeesRequest): Promise<QueryTotalAckFeesResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.packetId !== "undefined") {
+      options.params.packet_id = params.packetId;
+    }
+    const endpoint = `ibc/apps/fee/v1/channels/${params.packetId.channelId}/ports/${params.packetId.portId}/sequences/${params.packetId.sequence}/total_ack_fees`;
+    return await this.req.get<QueryTotalAckFeesResponse>(endpoint, options);
+  };
+  /* TotalTimeoutFees returns the total timeout fees for a packet given its identifier */
+  totalTimeoutFees = async (params: QueryTotalTimeoutFeesRequest): Promise<QueryTotalTimeoutFeesResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.packetId !== "undefined") {
+      options.params.packet_id = params.packetId;
+    }
+    const endpoint = `ibc/apps/fee/v1/channels/${params.packetId.channelId}/ports/${params.packetId.portId}/sequences/${params.packetId.sequence}/total_timeout_fees`;
+    return await this.req.get<QueryTotalTimeoutFeesResponse>(endpoint, options);
+  };
+  /* Payee returns the registered payee address for a specific channel given the relayer address */
+  payee = async (params: QueryPayeeRequest): Promise<QueryPayeeResponse> => {
+    const endpoint = `ibc/apps/fee/v1/channels/${params.channelId}/relayers/${params.relayer}/payee`;
+    return await this.req.get<QueryPayeeResponse>(endpoint);
+  };
+  /* CounterpartyPayee returns the registered counterparty payee for forward relaying */
+  counterpartyPayee = async (params: QueryCounterpartyPayeeRequest): Promise<QueryCounterpartyPayeeResponse> => {
+    const endpoint = `ibc/apps/fee/v1/channels/${params.channelId}/relayers/${params.relayer}/counterparty_payee`;
+    return await this.req.get<QueryCounterpartyPayeeResponse>(endpoint);
+  };
+  /* FeeEnabledChannels returns a list of all fee enabled channels */
+  feeEnabledChannels = async (params: QueryFeeEnabledChannelsRequest): Promise<QueryFeeEnabledChannelsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.queryHeight !== "undefined") {
+      options.params.query_height = params.queryHeight;
+    }
+    const endpoint = `ibc/apps/fee/v1/fee_enabled`;
+    return await this.req.get<QueryFeeEnabledChannelsResponse>(endpoint, options);
+  };
+  /* FeeEnabledChannel returns true if the provided port and channel identifiers belong to a fee enabled channel */
+  feeEnabledChannel = async (params: QueryFeeEnabledChannelRequest): Promise<QueryFeeEnabledChannelResponse> => {
+    const endpoint = `ibc/apps/fee/v1/channels/${params.channelId}/ports/${params.portId}/fee_enabled`;
+    return await this.req.get<QueryFeeEnabledChannelResponse>(endpoint);
+  };
+}

package/src/ibc/applications/fee/v1/query.rpc.Query.ts

@@ -0,0 +1,129 @@
+import { TxRpc } from "../../../../types";
+import { BinaryReader } from "../../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryIncentivizedPacketsRequest, QueryIncentivizedPacketsResponse, QueryIncentivizedPacketRequest, QueryIncentivizedPacketResponse, QueryIncentivizedPacketsForChannelRequest, QueryIncentivizedPacketsForChannelResponse, QueryTotalRecvFeesRequest, QueryTotalRecvFeesResponse, QueryTotalAckFeesRequest, QueryTotalAckFeesResponse, QueryTotalTimeoutFeesRequest, QueryTotalTimeoutFeesResponse, QueryPayeeRequest, QueryPayeeResponse, QueryCounterpartyPayeeRequest, QueryCounterpartyPayeeResponse, QueryFeeEnabledChannelsRequest, QueryFeeEnabledChannelsResponse, QueryFeeEnabledChannelRequest, QueryFeeEnabledChannelResponse } from "./query";
+/** Query defines the ICS29 gRPC querier service. */
+export interface Query {
+  /** IncentivizedPackets returns all incentivized packets and their associated fees */
+  incentivizedPackets(request: QueryIncentivizedPacketsRequest): Promise<QueryIncentivizedPacketsResponse>;
+  /** IncentivizedPacket returns all packet fees for a packet given its identifier */
+  incentivizedPacket(request: QueryIncentivizedPacketRequest): Promise<QueryIncentivizedPacketResponse>;
+  /** Gets all incentivized packets for a specific channel */
+  incentivizedPacketsForChannel(request: QueryIncentivizedPacketsForChannelRequest): Promise<QueryIncentivizedPacketsForChannelResponse>;
+  /** TotalRecvFees returns the total receive fees for a packet given its identifier */
+  totalRecvFees(request: QueryTotalRecvFeesRequest): Promise<QueryTotalRecvFeesResponse>;
+  /** TotalAckFees returns the total acknowledgement fees for a packet given its identifier */
+  totalAckFees(request: QueryTotalAckFeesRequest): Promise<QueryTotalAckFeesResponse>;
+  /** TotalTimeoutFees returns the total timeout fees for a packet given its identifier */
+  totalTimeoutFees(request: QueryTotalTimeoutFeesRequest): Promise<QueryTotalTimeoutFeesResponse>;
+  /** Payee returns the registered payee address for a specific channel given the relayer address */
+  payee(request: QueryPayeeRequest): Promise<QueryPayeeResponse>;
+  /** CounterpartyPayee returns the registered counterparty payee for forward relaying */
+  counterpartyPayee(request: QueryCounterpartyPayeeRequest): Promise<QueryCounterpartyPayeeResponse>;
+  /** FeeEnabledChannels returns a list of all fee enabled channels */
+  feeEnabledChannels(request: QueryFeeEnabledChannelsRequest): Promise<QueryFeeEnabledChannelsResponse>;
+  /** FeeEnabledChannel returns true if the provided port and channel identifiers belong to a fee enabled channel */
+  feeEnabledChannel(request: QueryFeeEnabledChannelRequest): Promise<QueryFeeEnabledChannelResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* IncentivizedPackets returns all incentivized packets and their associated fees */
+  incentivizedPackets = async (request: QueryIncentivizedPacketsRequest): Promise<QueryIncentivizedPacketsResponse> => {
+    const data = QueryIncentivizedPacketsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "IncentivizedPackets", data);
+    return promise.then(data => QueryIncentivizedPacketsResponse.decode(new BinaryReader(data)));
+  };
+  /* IncentivizedPacket returns all packet fees for a packet given its identifier */
+  incentivizedPacket = async (request: QueryIncentivizedPacketRequest): Promise<QueryIncentivizedPacketResponse> => {
+    const data = QueryIncentivizedPacketRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "IncentivizedPacket", data);
+    return promise.then(data => QueryIncentivizedPacketResponse.decode(new BinaryReader(data)));
+  };
+  /* Gets all incentivized packets for a specific channel */
+  incentivizedPacketsForChannel = async (request: QueryIncentivizedPacketsForChannelRequest): Promise<QueryIncentivizedPacketsForChannelResponse> => {
+    const data = QueryIncentivizedPacketsForChannelRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "IncentivizedPacketsForChannel", data);
+    return promise.then(data => QueryIncentivizedPacketsForChannelResponse.decode(new BinaryReader(data)));
+  };
+  /* TotalRecvFees returns the total receive fees for a packet given its identifier */
+  totalRecvFees = async (request: QueryTotalRecvFeesRequest): Promise<QueryTotalRecvFeesResponse> => {
+    const data = QueryTotalRecvFeesRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "TotalRecvFees", data);
+    return promise.then(data => QueryTotalRecvFeesResponse.decode(new BinaryReader(data)));
+  };
+  /* TotalAckFees returns the total acknowledgement fees for a packet given its identifier */
+  totalAckFees = async (request: QueryTotalAckFeesRequest): Promise<QueryTotalAckFeesResponse> => {
+    const data = QueryTotalAckFeesRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "TotalAckFees", data);
+    return promise.then(data => QueryTotalAckFeesResponse.decode(new BinaryReader(data)));
+  };
+  /* TotalTimeoutFees returns the total timeout fees for a packet given its identifier */
+  totalTimeoutFees = async (request: QueryTotalTimeoutFeesRequest): Promise<QueryTotalTimeoutFeesResponse> => {
+    const data = QueryTotalTimeoutFeesRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "TotalTimeoutFees", data);
+    return promise.then(data => QueryTotalTimeoutFeesResponse.decode(new BinaryReader(data)));
+  };
+  /* Payee returns the registered payee address for a specific channel given the relayer address */
+  payee = async (request: QueryPayeeRequest): Promise<QueryPayeeResponse> => {
+    const data = QueryPayeeRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "Payee", data);
+    return promise.then(data => QueryPayeeResponse.decode(new BinaryReader(data)));
+  };
+  /* CounterpartyPayee returns the registered counterparty payee for forward relaying */
+  counterpartyPayee = async (request: QueryCounterpartyPayeeRequest): Promise<QueryCounterpartyPayeeResponse> => {
+    const data = QueryCounterpartyPayeeRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "CounterpartyPayee", data);
+    return promise.then(data => QueryCounterpartyPayeeResponse.decode(new BinaryReader(data)));
+  };
+  /* FeeEnabledChannels returns a list of all fee enabled channels */
+  feeEnabledChannels = async (request: QueryFeeEnabledChannelsRequest): Promise<QueryFeeEnabledChannelsResponse> => {
+    const data = QueryFeeEnabledChannelsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "FeeEnabledChannels", data);
+    return promise.then(data => QueryFeeEnabledChannelsResponse.decode(new BinaryReader(data)));
+  };
+  /* FeeEnabledChannel returns true if the provided port and channel identifiers belong to a fee enabled channel */
+  feeEnabledChannel = async (request: QueryFeeEnabledChannelRequest): Promise<QueryFeeEnabledChannelResponse> => {
+    const data = QueryFeeEnabledChannelRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.fee.v1.Query", "FeeEnabledChannel", data);
+    return promise.then(data => QueryFeeEnabledChannelResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    incentivizedPackets(request: QueryIncentivizedPacketsRequest): Promise<QueryIncentivizedPacketsResponse> {
+      return queryService.incentivizedPackets(request);
+    },
+    incentivizedPacket(request: QueryIncentivizedPacketRequest): Promise<QueryIncentivizedPacketResponse> {
+      return queryService.incentivizedPacket(request);
+    },
+    incentivizedPacketsForChannel(request: QueryIncentivizedPacketsForChannelRequest): Promise<QueryIncentivizedPacketsForChannelResponse> {
+      return queryService.incentivizedPacketsForChannel(request);
+    },
+    totalRecvFees(request: QueryTotalRecvFeesRequest): Promise<QueryTotalRecvFeesResponse> {
+      return queryService.totalRecvFees(request);
+    },
+    totalAckFees(request: QueryTotalAckFeesRequest): Promise<QueryTotalAckFeesResponse> {
+      return queryService.totalAckFees(request);
+    },
+    totalTimeoutFees(request: QueryTotalTimeoutFeesRequest): Promise<QueryTotalTimeoutFeesResponse> {
+      return queryService.totalTimeoutFees(request);
+    },
+    payee(request: QueryPayeeRequest): Promise<QueryPayeeResponse> {
+      return queryService.payee(request);
+    },
+    counterpartyPayee(request: QueryCounterpartyPayeeRequest): Promise<QueryCounterpartyPayeeResponse> {
+      return queryService.counterpartyPayee(request);
+    },
+    feeEnabledChannels(request: QueryFeeEnabledChannelsRequest): Promise<QueryFeeEnabledChannelsResponse> {
+      return queryService.feeEnabledChannels(request);
+    },
+    feeEnabledChannel(request: QueryFeeEnabledChannelRequest): Promise<QueryFeeEnabledChannelResponse> {
+      return queryService.feeEnabledChannel(request);
+    }
+  };
+};

package/src/ibc/applications/fee/v1/query.rpc.func.ts

@@ -0,0 +1,72 @@
+import { RpcResolver, buildQuery } from "../../../../helper-func-types";
+import { QueryIncentivizedPacketsRequest, QueryIncentivizedPacketsResponse, QueryIncentivizedPacketRequest, QueryIncentivizedPacketResponse, QueryIncentivizedPacketsForChannelRequest, QueryIncentivizedPacketsForChannelResponse, QueryTotalRecvFeesRequest, QueryTotalRecvFeesResponse, QueryTotalAckFeesRequest, QueryTotalAckFeesResponse, QueryTotalTimeoutFeesRequest, QueryTotalTimeoutFeesResponse, QueryPayeeRequest, QueryPayeeResponse, QueryCounterpartyPayeeRequest, QueryCounterpartyPayeeResponse, QueryFeeEnabledChannelsRequest, QueryFeeEnabledChannelsResponse, QueryFeeEnabledChannelRequest, QueryFeeEnabledChannelResponse } from "./query";
+export const createGetIncentivizedPackets = (clientResolver?: RpcResolver) => buildQuery<QueryIncentivizedPacketsRequest, QueryIncentivizedPacketsResponse>({
+  encode: QueryIncentivizedPacketsRequest.encode,
+  decode: QueryIncentivizedPacketsResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "IncentivizedPackets",
+  clientResolver
+});
+export const createGetIncentivizedPacket = (clientResolver?: RpcResolver) => buildQuery<QueryIncentivizedPacketRequest, QueryIncentivizedPacketResponse>({
+  encode: QueryIncentivizedPacketRequest.encode,
+  decode: QueryIncentivizedPacketResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "IncentivizedPacket",
+  clientResolver
+});
+export const createGetIncentivizedPacketsForChannel = (clientResolver?: RpcResolver) => buildQuery<QueryIncentivizedPacketsForChannelRequest, QueryIncentivizedPacketsForChannelResponse>({
+  encode: QueryIncentivizedPacketsForChannelRequest.encode,
+  decode: QueryIncentivizedPacketsForChannelResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "IncentivizedPacketsForChannel",
+  clientResolver
+});
+export const createGetTotalRecvFees = (clientResolver?: RpcResolver) => buildQuery<QueryTotalRecvFeesRequest, QueryTotalRecvFeesResponse>({
+  encode: QueryTotalRecvFeesRequest.encode,
+  decode: QueryTotalRecvFeesResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "TotalRecvFees",
+  clientResolver
+});
+export const createGetTotalAckFees = (clientResolver?: RpcResolver) => buildQuery<QueryTotalAckFeesRequest, QueryTotalAckFeesResponse>({
+  encode: QueryTotalAckFeesRequest.encode,
+  decode: QueryTotalAckFeesResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "TotalAckFees",
+  clientResolver
+});
+export const createGetTotalTimeoutFees = (clientResolver?: RpcResolver) => buildQuery<QueryTotalTimeoutFeesRequest, QueryTotalTimeoutFeesResponse>({
+  encode: QueryTotalTimeoutFeesRequest.encode,
+  decode: QueryTotalTimeoutFeesResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "TotalTimeoutFees",
+  clientResolver
+});
+export const createGetPayee = (clientResolver?: RpcResolver) => buildQuery<QueryPayeeRequest, QueryPayeeResponse>({
+  encode: QueryPayeeRequest.encode,
+  decode: QueryPayeeResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "Payee",
+  clientResolver
+});
+export const createGetCounterpartyPayee = (clientResolver?: RpcResolver) => buildQuery<QueryCounterpartyPayeeRequest, QueryCounterpartyPayeeResponse>({
+  encode: QueryCounterpartyPayeeRequest.encode,
+  decode: QueryCounterpartyPayeeResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "CounterpartyPayee",
+  clientResolver
+});
+export const createGetFeeEnabledChannels = (clientResolver?: RpcResolver) => buildQuery<QueryFeeEnabledChannelsRequest, QueryFeeEnabledChannelsResponse>({
+  encode: QueryFeeEnabledChannelsRequest.encode,
+  decode: QueryFeeEnabledChannelsResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "FeeEnabledChannels",
+  clientResolver
+});
+export const createGetFeeEnabledChannel = (clientResolver?: RpcResolver) => buildQuery<QueryFeeEnabledChannelRequest, QueryFeeEnabledChannelResponse>({
+  encode: QueryFeeEnabledChannelRequest.encode,
+  decode: QueryFeeEnabledChannelResponse.decode,
+  service: "ibc.applications.fee.v1.Query",
+  method: "FeeEnabledChannel",
+  clientResolver
+});