@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/bank/v1beta1/genesis.ts

@@ -0,0 +1,199 @@
+import { Params, ParamsSDKType, Metadata, MetadataSDKType, SendEnabled, SendEnabledSDKType } from "./bank";
+import { Coin, CoinSDKType } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** GenesisState defines the bank module's genesis state. */
+
+export interface GenesisState {
+  /** params defines all the parameters of the module. */
+  params?: Params;
+  /** balances is an array containing the balances of all the accounts. */
+
+  balances: Balance[];
+  /**
+   * supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+   * balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+   */
+
+  supply: Coin[];
+  /** denom_metadata defines the metadata of the different coins. */
+
+  denomMetadata: Metadata[];
+  /**
+   * send_enabled defines the denoms where send is enabled or disabled.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+
+  sendEnabled: SendEnabled[];
+}
+/** GenesisState defines the bank module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: ParamsSDKType;
+  balances: BalanceSDKType[];
+  supply: CoinSDKType[];
+  denom_metadata: MetadataSDKType[];
+  send_enabled: SendEnabledSDKType[];
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+
+export interface Balance {
+  /** address is the address of the balance holder. */
+  address: string;
+  /** coins defines the different coins this balance holds. */
+
+  coins: Coin[];
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+
+export interface BalanceSDKType {
+  address: string;
+  coins: CoinSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    balances: [],
+    supply: [],
+    denomMetadata: [],
+    sendEnabled: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.balances) {
+      Balance.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.supply) {
+      Coin.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    for (const v of message.denomMetadata) {
+      Metadata.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+
+    for (const v of message.sendEnabled) {
+      SendEnabled.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+
+    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.params = Params.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.balances.push(Balance.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.supply.push(Coin.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.denomMetadata.push(Metadata.decode(reader, reader.uint32()));
+          break;
+
+        case 5:
+          message.sendEnabled.push(SendEnabled.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.balances = object.balances?.map(e => Balance.fromPartial(e)) || [];
+    message.supply = object.supply?.map(e => Coin.fromPartial(e)) || [];
+    message.denomMetadata = object.denomMetadata?.map(e => Metadata.fromPartial(e)) || [];
+    message.sendEnabled = object.sendEnabled?.map(e => SendEnabled.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseBalance(): Balance {
+  return {
+    address: "",
+    coins: []
+  };
+}
+
+export const Balance = {
+  encode(message: Balance, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    for (const v of message.coins) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Balance {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBalance();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        case 2:
+          message.coins.push(Coin.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Balance>): Balance {
+    const message = createBaseBalance();
+    message.address = object.address ?? "";
+    message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  }
+
+};

package/src/codegen/cosmos/bank/v1beta1/query.lcd.ts

@@ -0,0 +1,237 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryBalanceRequest, QueryBalanceResponseSDKType, QueryAllBalancesRequest, QueryAllBalancesResponseSDKType, QuerySpendableBalancesRequest, QuerySpendableBalancesResponseSDKType, QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponseSDKType, QueryTotalSupplyRequest, QueryTotalSupplyResponseSDKType, QuerySupplyOfRequest, QuerySupplyOfResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryDenomMetadataRequest, QueryDenomMetadataResponseSDKType, QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponseSDKType, QueryDenomsMetadataRequest, QueryDenomsMetadataResponseSDKType, QueryDenomOwnersRequest, QueryDenomOwnersResponseSDKType, QuerySendEnabledRequest, QuerySendEnabledResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.balance = this.balance.bind(this);
+    this.allBalances = this.allBalances.bind(this);
+    this.spendableBalances = this.spendableBalances.bind(this);
+    this.spendableBalanceByDenom = this.spendableBalanceByDenom.bind(this);
+    this.totalSupply = this.totalSupply.bind(this);
+    this.supplyOf = this.supplyOf.bind(this);
+    this.params = this.params.bind(this);
+    this.denomMetadata = this.denomMetadata.bind(this);
+    this.denomMetadataByQueryString = this.denomMetadataByQueryString.bind(this);
+    this.denomsMetadata = this.denomsMetadata.bind(this);
+    this.denomOwners = this.denomOwners.bind(this);
+    this.sendEnabled = this.sendEnabled.bind(this);
+  }
+  /* Balance queries the balance of a single coin for a single account. */
+
+
+  async balance(params: QueryBalanceRequest): Promise<QueryBalanceResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/balances/${params.address}/by_denom`;
+    return await this.req.get<QueryBalanceResponseSDKType>(endpoint, options);
+  }
+  /* AllBalances queries the balance of all coins for a single account.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async allBalances(params: QueryAllBalancesRequest): Promise<QueryAllBalancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    if (typeof params?.resolveDenom !== "undefined") {
+      options.params.resolve_denom = params.resolveDenom;
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/balances/${params.address}`;
+    return await this.req.get<QueryAllBalancesResponseSDKType>(endpoint, options);
+  }
+  /* SpendableBalances queries the spendable balance of all coins for a single
+   account.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set.
+  
+   Since: cosmos-sdk 0.46 */
+
+
+  async spendableBalances(params: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}`;
+    return await this.req.get<QuerySpendableBalancesResponseSDKType>(endpoint, options);
+  }
+  /* SpendableBalanceByDenom queries the spendable balance of a single denom for
+   a single account.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set.
+  
+   Since: cosmos-sdk 0.47 */
+
+
+  async spendableBalanceByDenom(params: QuerySpendableBalanceByDenomRequest): Promise<QuerySpendableBalanceByDenomResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}/by_denom`;
+    return await this.req.get<QuerySpendableBalanceByDenomResponseSDKType>(endpoint, options);
+  }
+  /* TotalSupply queries the total supply of all coins.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async totalSupply(params: QueryTotalSupplyRequest = {
+    pagination: undefined
+  }): Promise<QueryTotalSupplyResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/supply`;
+    return await this.req.get<QueryTotalSupplyResponseSDKType>(endpoint, options);
+  }
+  /* SupplyOf queries the supply of a single coin.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async supplyOf(params: QuerySupplyOfRequest): Promise<QuerySupplyOfResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/supply/by_denom`;
+    return await this.req.get<QuerySupplyOfResponseSDKType>(endpoint, options);
+  }
+  /* Params queries the parameters of x/bank module. */
+
+
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/bank/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* DenomsMetadata queries the client metadata of a given coin denomination. */
+
+
+  async denomMetadata(params: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponseSDKType> {
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata/${params.denom}`;
+    return await this.req.get<QueryDenomMetadataResponseSDKType>(endpoint);
+  }
+  /* DenomsMetadata queries the client metadata of a given coin denomination. */
+
+
+  async denomMetadataByQueryString(params: QueryDenomMetadataByQueryStringRequest): Promise<QueryDenomMetadataByQueryStringResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata_by_query_string`;
+    return await this.req.get<QueryDenomMetadataByQueryStringResponseSDKType>(endpoint, options);
+  }
+  /* DenomsMetadata queries the client metadata for all registered coin
+   denominations. */
+
+
+  async denomsMetadata(params: QueryDenomsMetadataRequest = {
+    pagination: undefined
+  }): Promise<QueryDenomsMetadataResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata`;
+    return await this.req.get<QueryDenomsMetadataResponseSDKType>(endpoint, options);
+  }
+  /* DenomOwners queries for all account addresses that own a particular token
+   denomination.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set.
+  
+   Since: cosmos-sdk 0.46 */
+
+
+  async denomOwners(params: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/denom_owners/${params.denom}`;
+    return await this.req.get<QueryDenomOwnersResponseSDKType>(endpoint, options);
+  }
+  /* SendEnabled queries for SendEnabled entries.
+  
+   This query only returns denominations that have specific SendEnabled settings.
+   Any denomination that does not have a specific setting will use the default
+   params.default_send_enabled, and will not be returned by this query.
+  
+   Since: cosmos-sdk 0.47 */
+
+
+  async sendEnabled(params: QuerySendEnabledRequest): Promise<QuerySendEnabledResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.denoms !== "undefined") {
+      options.params.denoms = params.denoms;
+    }
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/bank/v1beta1/send_enabled`;
+    return await this.req.get<QuerySendEnabledResponseSDKType>(endpoint, options);
+  }
+
+}

package/src/codegen/cosmos/bank/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,243 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryBalanceRequest, QueryBalanceResponse, QueryAllBalancesRequest, QueryAllBalancesResponse, QuerySpendableBalancesRequest, QuerySpendableBalancesResponse, QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse, QuerySupplyOfRequest, QuerySupplyOfResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse, QueryDenomsMetadataRequest, QueryDenomsMetadataResponse, QueryDenomOwnersRequest, QueryDenomOwnersResponse, QuerySendEnabledRequest, QuerySendEnabledResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Balance queries the balance of a single coin for a single account. */
+  balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+  /**
+   * AllBalances queries the balance of all coins for a single account.
+   * 
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
+   */
+
+  allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse>;
+  /**
+   * SpendableBalances queries the spendable balance of all coins for a single
+   * account.
+   * 
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
+   * 
+   * Since: cosmos-sdk 0.46
+   */
+
+  spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse>;
+  /**
+   * SpendableBalanceByDenom queries the spendable balance of a single denom for
+   * a single account.
+   * 
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+
+  spendableBalanceByDenom(request: QuerySpendableBalanceByDenomRequest): Promise<QuerySpendableBalanceByDenomResponse>;
+  /**
+   * TotalSupply queries the total supply of all coins.
+   * 
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
+   */
+
+  totalSupply(request?: QueryTotalSupplyRequest): Promise<QueryTotalSupplyResponse>;
+  /**
+   * SupplyOf queries the supply of a single coin.
+   * 
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
+   */
+
+  supplyOf(request: QuerySupplyOfRequest): Promise<QuerySupplyOfResponse>;
+  /** Params queries the parameters of x/bank module. */
+
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** DenomsMetadata queries the client metadata of a given coin denomination. */
+
+  denomMetadata(request: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponse>;
+  /** DenomsMetadata queries the client metadata of a given coin denomination. */
+
+  denomMetadataByQueryString(request: QueryDenomMetadataByQueryStringRequest): Promise<QueryDenomMetadataByQueryStringResponse>;
+  /**
+   * DenomsMetadata queries the client metadata for all registered coin
+   * denominations.
+   */
+
+  denomsMetadata(request?: QueryDenomsMetadataRequest): Promise<QueryDenomsMetadataResponse>;
+  /**
+   * DenomOwners queries for all account addresses that own a particular token
+   * denomination.
+   * 
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
+   * 
+   * Since: cosmos-sdk 0.46
+   */
+
+  denomOwners(request: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponse>;
+  /**
+   * SendEnabled queries for SendEnabled entries.
+   * 
+   * This query only returns denominations that have specific SendEnabled settings.
+   * Any denomination that does not have a specific setting will use the default
+   * params.default_send_enabled, and will not be returned by this query.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+
+  sendEnabled(request: QuerySendEnabledRequest): Promise<QuerySendEnabledResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.balance = this.balance.bind(this);
+    this.allBalances = this.allBalances.bind(this);
+    this.spendableBalances = this.spendableBalances.bind(this);
+    this.spendableBalanceByDenom = this.spendableBalanceByDenom.bind(this);
+    this.totalSupply = this.totalSupply.bind(this);
+    this.supplyOf = this.supplyOf.bind(this);
+    this.params = this.params.bind(this);
+    this.denomMetadata = this.denomMetadata.bind(this);
+    this.denomMetadataByQueryString = this.denomMetadataByQueryString.bind(this);
+    this.denomsMetadata = this.denomsMetadata.bind(this);
+    this.denomOwners = this.denomOwners.bind(this);
+    this.sendEnabled = this.sendEnabled.bind(this);
+  }
+
+  balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+    const data = QueryBalanceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Balance", data);
+    return promise.then(data => QueryBalanceResponse.decode(new _m0.Reader(data)));
+  }
+
+  allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse> {
+    const data = QueryAllBalancesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "AllBalances", data);
+    return promise.then(data => QueryAllBalancesResponse.decode(new _m0.Reader(data)));
+  }
+
+  spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse> {
+    const data = QuerySpendableBalancesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SpendableBalances", data);
+    return promise.then(data => QuerySpendableBalancesResponse.decode(new _m0.Reader(data)));
+  }
+
+  spendableBalanceByDenom(request: QuerySpendableBalanceByDenomRequest): Promise<QuerySpendableBalanceByDenomResponse> {
+    const data = QuerySpendableBalanceByDenomRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SpendableBalanceByDenom", data);
+    return promise.then(data => QuerySpendableBalanceByDenomResponse.decode(new _m0.Reader(data)));
+  }
+
+  totalSupply(request: QueryTotalSupplyRequest = {
+    pagination: undefined
+  }): Promise<QueryTotalSupplyResponse> {
+    const data = QueryTotalSupplyRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "TotalSupply", data);
+    return promise.then(data => QueryTotalSupplyResponse.decode(new _m0.Reader(data)));
+  }
+
+  supplyOf(request: QuerySupplyOfRequest): Promise<QuerySupplyOfResponse> {
+    const data = QuerySupplyOfRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SupplyOf", data);
+    return promise.then(data => QuerySupplyOfResponse.decode(new _m0.Reader(data)));
+  }
+
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomMetadata(request: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponse> {
+    const data = QueryDenomMetadataRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomMetadata", data);
+    return promise.then(data => QueryDenomMetadataResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomMetadataByQueryString(request: QueryDenomMetadataByQueryStringRequest): Promise<QueryDenomMetadataByQueryStringResponse> {
+    const data = QueryDenomMetadataByQueryStringRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomMetadataByQueryString", data);
+    return promise.then(data => QueryDenomMetadataByQueryStringResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomsMetadata(request: QueryDenomsMetadataRequest = {
+    pagination: undefined
+  }): Promise<QueryDenomsMetadataResponse> {
+    const data = QueryDenomsMetadataRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomsMetadata", data);
+    return promise.then(data => QueryDenomsMetadataResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomOwners(request: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponse> {
+    const data = QueryDenomOwnersRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomOwners", data);
+    return promise.then(data => QueryDenomOwnersResponse.decode(new _m0.Reader(data)));
+  }
+
+  sendEnabled(request: QuerySendEnabledRequest): Promise<QuerySendEnabledResponse> {
+    const data = QuerySendEnabledRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SendEnabled", data);
+    return promise.then(data => QuerySendEnabledResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+      return queryService.balance(request);
+    },
+
+    allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse> {
+      return queryService.allBalances(request);
+    },
+
+    spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse> {
+      return queryService.spendableBalances(request);
+    },
+
+    spendableBalanceByDenom(request: QuerySpendableBalanceByDenomRequest): Promise<QuerySpendableBalanceByDenomResponse> {
+      return queryService.spendableBalanceByDenom(request);
+    },
+
+    totalSupply(request?: QueryTotalSupplyRequest): Promise<QueryTotalSupplyResponse> {
+      return queryService.totalSupply(request);
+    },
+
+    supplyOf(request: QuerySupplyOfRequest): Promise<QuerySupplyOfResponse> {
+      return queryService.supplyOf(request);
+    },
+
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+
+    denomMetadata(request: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponse> {
+      return queryService.denomMetadata(request);
+    },
+
+    denomMetadataByQueryString(request: QueryDenomMetadataByQueryStringRequest): Promise<QueryDenomMetadataByQueryStringResponse> {
+      return queryService.denomMetadataByQueryString(request);
+    },
+
+    denomsMetadata(request?: QueryDenomsMetadataRequest): Promise<QueryDenomsMetadataResponse> {
+      return queryService.denomsMetadata(request);
+    },
+
+    denomOwners(request: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponse> {
+      return queryService.denomOwners(request);
+    },
+
+    sendEnabled(request: QuerySendEnabledRequest): Promise<QuerySendEnabledResponse> {
+      return queryService.sendEnabled(request);
+    }
+
+  };
+};