juno-network 0.15.0 → 0.17.0

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

@@ -1,194 +1,276 @@
-import { Params, ParamsSDKType, Metadata, MetadataSDKType } from "./bank";
-import { Coin, CoinSDKType } from "../../base/v1beta1/coin";
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../../../helpers";
+import { Params, ParamsAmino, ParamsSDKType, Metadata, MetadataAmino, MetadataSDKType } from "./bank";
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
 /** GenesisState defines the bank module's genesis state. */
-
 export interface GenesisState {
   /** params defines all the paramaters of the module. */
-  params?: Params;
+  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 differents coins. */
-
   denomMetadata: Metadata[];
 }
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.GenesisState";
+  value: Uint8Array;
+}
 /** GenesisState defines the bank module's genesis state. */
-
-export interface GenesisStateSDKType {
+export interface GenesisStateAmino {
   /** params defines all the paramaters of the module. */
-  params?: ParamsSDKType;
+  params?: ParamsAmino;
   /** balances is an array containing the balances of all the accounts. */
-
-  balances: BalanceSDKType[];
+  balances?: BalanceAmino[];
   /**
    * 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: CoinSDKType[];
+  supply?: CoinAmino[];
   /** denom_metadata defines the metadata of the differents coins. */
-
+  denom_metadata?: MetadataAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisStateSDKType {
+  params: ParamsSDKType;
+  balances: BalanceSDKType[];
+  supply: CoinSDKType[];
   denom_metadata: MetadataSDKType[];
 }
 /**
  * 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[];
 }
+export interface BalanceProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Balance";
+  value: Uint8Array;
+}
 /**
  * Balance defines an account address and balance pair used in the bank module's
  * genesis state.
  */
-
-export interface BalanceSDKType {
+export interface BalanceAmino {
   /** address is the address of the balance holder. */
-  address: string;
+  address?: string;
   /** coins defines the different coins this balance holds. */
-
+  coins?: CoinAmino[];
+}
+export interface BalanceAminoMsg {
+  type: "cosmos-sdk/Balance";
+  value: BalanceAmino;
+}
+/**
+ * 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,
+    params: Params.fromPartial({}),
     balances: [],
     supply: [],
     denomMetadata: []
   };
 }
-
 export const GenesisState = {
-  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/cosmos.bank.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     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();
     }
-
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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.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;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+  fromPartial(object: Partial<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)) || [];
     return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    message.balances = object.balances?.map(e => Balance.fromAmino(e)) || [];
+    message.supply = object.supply?.map(e => Coin.fromAmino(e)) || [];
+    message.denomMetadata = object.denom_metadata?.map(e => Metadata.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    if (message.balances) {
+      obj.balances = message.balances.map(e => e ? Balance.toAmino(e) : undefined);
+    } else {
+      obj.balances = [];
+    }
+    if (message.supply) {
+      obj.supply = message.supply.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.supply = [];
+    }
+    if (message.denomMetadata) {
+      obj.denom_metadata = message.denomMetadata.map(e => e ? Metadata.toAmino(e) : undefined);
+    } else {
+      obj.denom_metadata = [];
+    }
+    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: "/cosmos.bank.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
   }
-
 };
-
 function createBaseBalance(): Balance {
   return {
     address: "",
     coins: []
   };
 }
-
 export const Balance = {
-  encode(message: Balance, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/cosmos.bank.v1beta1.Balance",
+  encode(message: Balance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     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);
+  decode(input: BinaryReader | Uint8Array, length?: number): Balance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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 {
+  fromPartial(object: Partial<Balance>): Balance {
     const message = createBaseBalance();
     message.address = object.address ?? "";
     message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
     return message;
+  },
+  fromAmino(object: BalanceAmino): Balance {
+    const message = createBaseBalance();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Balance): BalanceAmino {
+    const obj: any = {};
+    obj.address = message.address;
+    if (message.coins) {
+      obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.coins = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object: BalanceAminoMsg): Balance {
+    return Balance.fromAmino(object.value);
+  },
+  toAminoMsg(message: Balance): BalanceAminoMsg {
+    return {
+      type: "cosmos-sdk/Balance",
+      value: Balance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BalanceProtoMsg): Balance {
+    return Balance.decode(message.value);
+  },
+  toProto(message: Balance): Uint8Array {
+    return Balance.encode(message).finish();
+  },
+  toProtoMsg(message: Balance): BalanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Balance",
+      value: Balance.encode(message).finish()
+    };
   }
-
 };

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

@@ -1,9 +1,8 @@
 import { setPaginationParams } from "../../../helpers";
-import { LCDClient } from "@osmonauts/lcd";
+import { LCDClient } from "@cosmology/lcd";
 import { QueryBalanceRequest, QueryBalanceResponseSDKType, QueryAllBalancesRequest, QueryAllBalancesResponseSDKType, QuerySpendableBalancesRequest, QuerySpendableBalancesResponseSDKType, QueryTotalSupplyRequest, QueryTotalSupplyResponseSDKType, QuerySupplyOfRequest, QuerySupplyOfResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryDenomMetadataRequest, QueryDenomMetadataResponseSDKType, QueryDenomsMetadataRequest, QueryDenomsMetadataResponseSDKType, QueryDenomOwnersRequest, QueryDenomOwnersResponseSDKType } from "./query";
 export class LCDQueryClient {
   req: LCDClient;
-
   constructor({
     requestClient
   }: {
@@ -21,130 +20,97 @@ export class LCDQueryClient {
     this.denomOwners = this.denomOwners.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. */
-
-
   async allBalances(params: QueryAllBalancesRequest): Promise<QueryAllBalancesResponseSDKType> {
     const options: any = {
       params: {}
     };
-
     if (typeof params?.pagination !== "undefined") {
       setPaginationParams(options, params.pagination);
     }
-
     const endpoint = `cosmos/bank/v1beta1/balances/${params.address}`;
     return await this.req.get<QueryAllBalancesResponseSDKType>(endpoint, options);
   }
   /* SpendableBalances queries the spenable balance of all coins for a single
    account. */
-
-
   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);
   }
   /* TotalSupply queries the total supply of all coins. */
-
-
   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. */
-
-
   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 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. */
-
-
   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);
   }
-
 }

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

@@ -1,49 +1,39 @@
 import { Rpc } from "../../../helpers";
-import * as _m0 from "protobufjs/minimal";
+import { BinaryReader } from "../../../binary";
 import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
 import { QueryBalanceRequest, QueryBalanceResponse, QueryAllBalancesRequest, QueryAllBalancesResponse, QuerySpendableBalancesRequest, QuerySpendableBalancesResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse, QuerySupplyOfRequest, QuerySupplyOfResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomsMetadataRequest, QueryDenomsMetadataResponse, QueryDenomOwnersRequest, QueryDenomOwnersResponse } 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. */
-
   allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse>;
   /**
    * SpendableBalances queries the spenable balance of all coins for a single
    * account.
    */
-
   spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse>;
   /** TotalSupply queries the total supply of all coins. */
-
   totalSupply(request?: QueryTotalSupplyRequest): Promise<QueryTotalSupplyResponse>;
   /** SupplyOf queries the supply of a single coin. */
-
   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 for all registered coin
    * denominations.
    */
-
   denomsMetadata(request?: QueryDenomsMetadataRequest): Promise<QueryDenomsMetadataResponse>;
   /**
    * DenomOwners queries for all account addresses that own a particular token
    * denomination.
    */
-
   denomOwners(request: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponse>;
 }
 export class QueryClientImpl implements Query {
   private readonly rpc: Rpc;
-
   constructor(rpc: Rpc) {
     this.rpc = rpc;
     this.balance = this.balance.bind(this);
@@ -56,65 +46,55 @@ export class QueryClientImpl implements Query {
     this.denomsMetadata = this.denomsMetadata.bind(this);
     this.denomOwners = this.denomOwners.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)));
+    return promise.then(data => QueryBalanceResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QueryAllBalancesResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QuerySpendableBalancesResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QueryTotalSupplyResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QuerySupplyOfResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QueryDenomMetadataResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QueryDenomsMetadataResponse.decode(new BinaryReader(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)));
+    return promise.then(data => QueryDenomOwnersResponse.decode(new BinaryReader(data)));
   }
-
 }
 export const createRpcQueryExtension = (base: QueryClient) => {
   const rpc = createProtobufRpcClient(base);
@@ -123,38 +103,29 @@ export const createRpcQueryExtension = (base: QueryClient) => {
     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);
     },
-
     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);
     },
-
     denomsMetadata(request?: QueryDenomsMetadataRequest): Promise<QueryDenomsMetadataResponse> {
       return queryService.denomsMetadata(request);
     },
-
     denomOwners(request: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponse> {
       return queryService.denomOwners(request);
     }
-
   };
 };