juno-network 0.15.0 → 0.17.0

package/src/codegen/osmosis/tokenfactory/v1beta1/authorityMetadata.ts

@@ -1,67 +1,104 @@
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../../../helpers";
+import { BinaryReader, BinaryWriter } from "../../../binary";
 /**
  * DenomAuthorityMetadata specifies metadata for addresses that have specific
  * capabilities over a token factory denom. Right now there is only one Admin
  * permission, but is planned to be extended to the future.
  */
-
 export interface DenomAuthorityMetadata {
   /** Can be empty for no admin, or a valid osmosis address */
   admin: string;
 }
+export interface DenomAuthorityMetadataProtoMsg {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata";
+  value: Uint8Array;
+}
 /**
  * DenomAuthorityMetadata specifies metadata for addresses that have specific
  * capabilities over a token factory denom. Right now there is only one Admin
  * permission, but is planned to be extended to the future.
  */
-
-export interface DenomAuthorityMetadataSDKType {
+export interface DenomAuthorityMetadataAmino {
   /** Can be empty for no admin, or a valid osmosis address */
+  admin?: string;
+}
+export interface DenomAuthorityMetadataAminoMsg {
+  type: "osmosis/tokenfactory/denom-authority-metadata";
+  value: DenomAuthorityMetadataAmino;
+}
+/**
+ * DenomAuthorityMetadata specifies metadata for addresses that have specific
+ * capabilities over a token factory denom. Right now there is only one Admin
+ * permission, but is planned to be extended to the future.
+ */
+export interface DenomAuthorityMetadataSDKType {
   admin: string;
 }
-
 function createBaseDenomAuthorityMetadata(): DenomAuthorityMetadata {
   return {
     admin: ""
   };
 }
-
 export const DenomAuthorityMetadata = {
-  encode(message: DenomAuthorityMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata",
+  encode(message: DenomAuthorityMetadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     if (message.admin !== "") {
       writer.uint32(10).string(message.admin);
     }
-
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): DenomAuthorityMetadata {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): DenomAuthorityMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseDenomAuthorityMetadata();
-
     while (reader.pos < end) {
       const tag = reader.uint32();
-
       switch (tag >>> 3) {
         case 1:
           message.admin = reader.string();
           break;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<DenomAuthorityMetadata>): DenomAuthorityMetadata {
+  fromPartial(object: Partial<DenomAuthorityMetadata>): DenomAuthorityMetadata {
     const message = createBaseDenomAuthorityMetadata();
     message.admin = object.admin ?? "";
     return message;
+  },
+  fromAmino(object: DenomAuthorityMetadataAmino): DenomAuthorityMetadata {
+    const message = createBaseDenomAuthorityMetadata();
+    if (object.admin !== undefined && object.admin !== null) {
+      message.admin = object.admin;
+    }
+    return message;
+  },
+  toAmino(message: DenomAuthorityMetadata): DenomAuthorityMetadataAmino {
+    const obj: any = {};
+    obj.admin = message.admin;
+    return obj;
+  },
+  fromAminoMsg(object: DenomAuthorityMetadataAminoMsg): DenomAuthorityMetadata {
+    return DenomAuthorityMetadata.fromAmino(object.value);
+  },
+  toAminoMsg(message: DenomAuthorityMetadata): DenomAuthorityMetadataAminoMsg {
+    return {
+      type: "osmosis/tokenfactory/denom-authority-metadata",
+      value: DenomAuthorityMetadata.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DenomAuthorityMetadataProtoMsg): DenomAuthorityMetadata {
+    return DenomAuthorityMetadata.decode(message.value);
+  },
+  toProto(message: DenomAuthorityMetadata): Uint8Array {
+    return DenomAuthorityMetadata.encode(message).finish();
+  },
+  toProtoMsg(message: DenomAuthorityMetadata): DenomAuthorityMetadataProtoMsg {
+    return {
+      typeUrl: "/osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata",
+      value: DenomAuthorityMetadata.encode(message).finish()
+    };
   }
-
 };

package/src/codegen/osmosis/tokenfactory/v1beta1/genesis.ts

@@ -1,19 +1,29 @@
-import { Params, ParamsSDKType } from "./params";
-import { DenomAuthorityMetadata, DenomAuthorityMetadataSDKType } from "./authorityMetadata";
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../../../helpers";
+import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { DenomAuthorityMetadata, DenomAuthorityMetadataAmino, DenomAuthorityMetadataSDKType } from "./authorityMetadata";
+import { BinaryReader, BinaryWriter } from "../../../binary";
 /** GenesisState defines the tokenfactory module's genesis state. */
-
 export interface GenesisState {
   /** params defines the paramaters of the module. */
-  params?: Params;
+  params: Params;
   factoryDenoms: GenesisDenom[];
 }
+export interface GenesisStateProtoMsg {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.GenesisState";
+  value: Uint8Array;
+}
 /** GenesisState defines the tokenfactory module's genesis state. */
-
-export interface GenesisStateSDKType {
+export interface GenesisStateAmino {
   /** params defines the paramaters of the module. */
-  params?: ParamsSDKType;
+  params?: ParamsAmino;
+  factory_denoms?: GenesisDenomAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "osmosis/tokenfactory/genesis-state";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the tokenfactory module's genesis state. */
+export interface GenesisStateSDKType {
+  params: ParamsSDKType;
   factory_denoms: GenesisDenomSDKType[];
 }
 /**
@@ -21,128 +31,197 @@ export interface GenesisStateSDKType {
  * state. The structure contains DenomAuthorityMetadata which defines the
  * denom's admin.
  */
-
 export interface GenesisDenom {
   denom: string;
-  authorityMetadata?: DenomAuthorityMetadata;
+  authorityMetadata: DenomAuthorityMetadata;
+}
+export interface GenesisDenomProtoMsg {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.GenesisDenom";
+  value: Uint8Array;
+}
+/**
+ * GenesisDenom defines a tokenfactory denom that is defined within genesis
+ * state. The structure contains DenomAuthorityMetadata which defines the
+ * denom's admin.
+ */
+export interface GenesisDenomAmino {
+  denom?: string;
+  authority_metadata?: DenomAuthorityMetadataAmino;
+}
+export interface GenesisDenomAminoMsg {
+  type: "osmosis/tokenfactory/genesis-denom";
+  value: GenesisDenomAmino;
 }
 /**
  * GenesisDenom defines a tokenfactory denom that is defined within genesis
  * state. The structure contains DenomAuthorityMetadata which defines the
  * denom's admin.
  */
-
 export interface GenesisDenomSDKType {
   denom: string;
-  authority_metadata?: DenomAuthorityMetadataSDKType;
+  authority_metadata: DenomAuthorityMetadataSDKType;
 }
-
 function createBaseGenesisState(): GenesisState {
   return {
-    params: undefined,
+    params: Params.fromPartial({}),
     factoryDenoms: []
   };
 }
-
 export const GenesisState = {
-  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/osmosis.tokenfactory.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.factoryDenoms) {
       GenesisDenom.encode(v!, writer.uint32(18).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.factoryDenoms.push(GenesisDenom.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.factoryDenoms = object.factoryDenoms?.map(e => GenesisDenom.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.factoryDenoms = object.factory_denoms?.map(e => GenesisDenom.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    if (message.factoryDenoms) {
+      obj.factory_denoms = message.factoryDenoms.map(e => e ? GenesisDenom.toAmino(e) : undefined);
+    } else {
+      obj.factory_denoms = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "osmosis/tokenfactory/genesis-state",
+      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: "/osmosis.tokenfactory.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
   }
-
 };
-
 function createBaseGenesisDenom(): GenesisDenom {
   return {
     denom: "",
-    authorityMetadata: undefined
+    authorityMetadata: DenomAuthorityMetadata.fromPartial({})
   };
 }
-
 export const GenesisDenom = {
-  encode(message: GenesisDenom, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.GenesisDenom",
+  encode(message: GenesisDenom, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     if (message.denom !== "") {
       writer.uint32(10).string(message.denom);
     }
-
     if (message.authorityMetadata !== undefined) {
       DenomAuthorityMetadata.encode(message.authorityMetadata, writer.uint32(18).fork()).ldelim();
     }
-
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisDenom {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisDenom {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGenesisDenom();
-
     while (reader.pos < end) {
       const tag = reader.uint32();
-
       switch (tag >>> 3) {
         case 1:
           message.denom = reader.string();
           break;
-
         case 2:
           message.authorityMetadata = DenomAuthorityMetadata.decode(reader, reader.uint32());
           break;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<GenesisDenom>): GenesisDenom {
+  fromPartial(object: Partial<GenesisDenom>): GenesisDenom {
     const message = createBaseGenesisDenom();
     message.denom = object.denom ?? "";
     message.authorityMetadata = object.authorityMetadata !== undefined && object.authorityMetadata !== null ? DenomAuthorityMetadata.fromPartial(object.authorityMetadata) : undefined;
     return message;
+  },
+  fromAmino(object: GenesisDenomAmino): GenesisDenom {
+    const message = createBaseGenesisDenom();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.authority_metadata !== undefined && object.authority_metadata !== null) {
+      message.authorityMetadata = DenomAuthorityMetadata.fromAmino(object.authority_metadata);
+    }
+    return message;
+  },
+  toAmino(message: GenesisDenom): GenesisDenomAmino {
+    const obj: any = {};
+    obj.denom = message.denom;
+    obj.authority_metadata = message.authorityMetadata ? DenomAuthorityMetadata.toAmino(message.authorityMetadata) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisDenomAminoMsg): GenesisDenom {
+    return GenesisDenom.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisDenom): GenesisDenomAminoMsg {
+    return {
+      type: "osmosis/tokenfactory/genesis-denom",
+      value: GenesisDenom.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisDenomProtoMsg): GenesisDenom {
+    return GenesisDenom.decode(message.value);
+  },
+  toProto(message: GenesisDenom): Uint8Array {
+    return GenesisDenom.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisDenom): GenesisDenomProtoMsg {
+    return {
+      typeUrl: "/osmosis.tokenfactory.v1beta1.GenesisDenom",
+      value: GenesisDenom.encode(message).finish()
+    };
   }
-
 };

package/src/codegen/osmosis/tokenfactory/v1beta1/params.ts

@@ -1,58 +1,118 @@
-import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../../../helpers";
+import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
 /** Params defines the parameters for the tokenfactory module. */
-
 export interface Params {
   denomCreationFee: Coin[];
+  /**
+   * if denom_creation_fee is an empty array, then this field is used to add more gas consumption
+   * to the base cost.
+   * https://github.com/CosmWasm/token-factory/issues/11
+   */
+  denomCreationGasConsume?: bigint;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.Params";
+  value: Uint8Array;
+}
+/** Params defines the parameters for the tokenfactory module. */
+export interface ParamsAmino {
+  denom_creation_fee?: CoinAmino[];
+  /**
+   * if denom_creation_fee is an empty array, then this field is used to add more gas consumption
+   * to the base cost.
+   * https://github.com/CosmWasm/token-factory/issues/11
+   */
+  denom_creation_gas_consume?: string;
+}
+export interface ParamsAminoMsg {
+  type: "osmosis/tokenfactory/params";
+  value: ParamsAmino;
 }
 /** Params defines the parameters for the tokenfactory module. */
-
 export interface ParamsSDKType {
   denom_creation_fee: CoinSDKType[];
+  denom_creation_gas_consume?: bigint;
 }
-
 function createBaseParams(): Params {
   return {
-    denomCreationFee: []
+    denomCreationFee: [],
+    denomCreationGasConsume: undefined
   };
 }
-
 export const Params = {
-  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/osmosis.tokenfactory.v1beta1.Params",
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     for (const v of message.denomCreationFee) {
       Coin.encode(v!, writer.uint32(10).fork()).ldelim();
     }
-
+    if (message.denomCreationGasConsume !== undefined) {
+      writer.uint32(16).uint64(message.denomCreationGasConsume);
+    }
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): Params {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseParams();
-
     while (reader.pos < end) {
       const tag = reader.uint32();
-
       switch (tag >>> 3) {
         case 1:
           message.denomCreationFee.push(Coin.decode(reader, reader.uint32()));
           break;
-
+        case 2:
+          message.denomCreationGasConsume = reader.uint64();
+          break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<Params>): Params {
+  fromPartial(object: Partial<Params>): Params {
     const message = createBaseParams();
     message.denomCreationFee = object.denomCreationFee?.map(e => Coin.fromPartial(e)) || [];
+    message.denomCreationGasConsume = object.denomCreationGasConsume !== undefined && object.denomCreationGasConsume !== null ? BigInt(object.denomCreationGasConsume.toString()) : undefined;
     return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    message.denomCreationFee = object.denom_creation_fee?.map(e => Coin.fromAmino(e)) || [];
+    if (object.denom_creation_gas_consume !== undefined && object.denom_creation_gas_consume !== null) {
+      message.denomCreationGasConsume = BigInt(object.denom_creation_gas_consume);
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    if (message.denomCreationFee) {
+      obj.denom_creation_fee = message.denomCreationFee.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.denom_creation_fee = [];
+    }
+    obj.denom_creation_gas_consume = message.denomCreationGasConsume ? message.denomCreationGasConsume.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "osmosis/tokenfactory/params",
+      value: Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: "/osmosis.tokenfactory.v1beta1.Params",
+      value: Params.encode(message).finish()
+    };
   }
-
 };

package/src/codegen/osmosis/tokenfactory/v1beta1/query.lcd.ts

@@ -1,8 +1,7 @@
-import { LCDClient } from "@osmonauts/lcd";
+import { LCDClient } from "@cosmology/lcd";
 import { QueryParamsRequest, QueryParamsResponseSDKType, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponseSDKType, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponseSDKType } from "./query";
 export class LCDQueryClient {
   req: LCDClient;
-
   constructor({
     requestClient
   }: {
@@ -15,27 +14,20 @@ export class LCDQueryClient {
   }
   /* Params defines a gRPC query method that returns the tokenfactory module's
    parameters. */
-
-
   async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
     const endpoint = `osmosis/tokenfactory/v1beta1/params`;
     return await this.req.get<QueryParamsResponseSDKType>(endpoint);
   }
   /* DenomAuthorityMetadata defines a gRPC query method for fetching
    DenomAuthorityMetadata for a particular denom. */
-
-
   async denomAuthorityMetadata(params: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponseSDKType> {
     const endpoint = `osmosis/tokenfactory/v1beta1/denoms/${params.denom}/authority_metadata`;
     return await this.req.get<QueryDenomAuthorityMetadataResponseSDKType>(endpoint);
   }
   /* DenomsFromCreator defines a gRPC query method for fetching all
    denominations created by a specific admin/creator. */
-
-
   async denomsFromCreator(params: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponseSDKType> {
     const endpoint = `osmosis/tokenfactory/v1beta1/denoms_from_creator/${params.creator}`;
     return await this.req.get<QueryDenomsFromCreatorResponseSDKType>(endpoint);
   }
-
 }

package/src/codegen/osmosis/tokenfactory/v1beta1/query.rpc.Query.ts

@@ -1,9 +1,8 @@
 import { Rpc } from "../../../helpers";
-import * as _m0 from "protobufjs/minimal";
+import { BinaryReader } from "../../../binary";
 import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
 import { QueryParamsRequest, QueryParamsResponse, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse } from "./query";
 /** Query defines the gRPC querier service. */
-
 export interface Query {
   /**
    * Params defines a gRPC query method that returns the tokenfactory module's
@@ -14,43 +13,36 @@ export interface Query {
    * DenomAuthorityMetadata defines a gRPC query method for fetching
    * DenomAuthorityMetadata for a particular denom.
    */
-
   denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse>;
   /**
    * DenomsFromCreator defines a gRPC query method for fetching all
    * denominations created by a specific admin/creator.
    */
-
   denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse>;
 }
 export class QueryClientImpl implements Query {
   private readonly rpc: Rpc;
-
   constructor(rpc: Rpc) {
     this.rpc = rpc;
     this.params = this.params.bind(this);
     this.denomAuthorityMetadata = this.denomAuthorityMetadata.bind(this);
     this.denomsFromCreator = this.denomsFromCreator.bind(this);
   }
-
   params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
     const data = QueryParamsRequest.encode(request).finish();
     const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Query", "Params", data);
-    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
   }
-
   denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse> {
     const data = QueryDenomAuthorityMetadataRequest.encode(request).finish();
     const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Query", "DenomAuthorityMetadata", data);
-    return promise.then(data => QueryDenomAuthorityMetadataResponse.decode(new _m0.Reader(data)));
+    return promise.then(data => QueryDenomAuthorityMetadataResponse.decode(new BinaryReader(data)));
   }
-
   denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse> {
     const data = QueryDenomsFromCreatorRequest.encode(request).finish();
     const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Query", "DenomsFromCreator", data);
-    return promise.then(data => QueryDenomsFromCreatorResponse.decode(new _m0.Reader(data)));
+    return promise.then(data => QueryDenomsFromCreatorResponse.decode(new BinaryReader(data)));
   }
-
 }
 export const createRpcQueryExtension = (base: QueryClient) => {
   const rpc = createProtobufRpcClient(base);
@@ -59,14 +51,11 @@ export const createRpcQueryExtension = (base: QueryClient) => {
     params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
       return queryService.params(request);
     },
-
     denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse> {
       return queryService.denomAuthorityMetadata(request);
     },
-
     denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse> {
       return queryService.denomsFromCreator(request);
     }
-
   };
 };