@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/mint/v1beta1/query.ts

@@ -0,0 +1,541 @@
+import { Params, ParamsAmino } from "./mint";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {}
+export interface QueryParamsRequestProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest";
+  value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {}
+export interface QueryParamsRequestAminoMsg {
+  type: "cosmos-sdk/QueryParamsRequest";
+  value: QueryParamsRequestAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+  /** params defines the parameters of the module. */
+  params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse";
+  value: Uint8Array;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseAmino {
+  /** params defines the parameters of the module. */
+  params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+  type: "cosmos-sdk/QueryParamsResponse";
+  value: QueryParamsResponseAmino;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequest {}
+export interface QueryInflationRequestProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest";
+  value: Uint8Array;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequestAmino {}
+export interface QueryInflationRequestAminoMsg {
+  type: "cosmos-sdk/QueryInflationRequest";
+  value: QueryInflationRequestAmino;
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponse {
+  /** inflation is the current minting inflation value. */
+  inflation: Uint8Array;
+}
+export interface QueryInflationResponseProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponseAmino {
+  /** inflation is the current minting inflation value. */
+  inflation: string;
+}
+export interface QueryInflationResponseAminoMsg {
+  type: "cosmos-sdk/QueryInflationResponse";
+  value: QueryInflationResponseAmino;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequest {}
+export interface QueryAnnualProvisionsRequestProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest";
+  value: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequestAmino {}
+export interface QueryAnnualProvisionsRequestAminoMsg {
+  type: "cosmos-sdk/QueryAnnualProvisionsRequest";
+  value: QueryAnnualProvisionsRequestAmino;
+}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponse {
+  /** annual_provisions is the current minting annual provisions value. */
+  annualProvisions: Uint8Array;
+}
+export interface QueryAnnualProvisionsResponseProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponseAmino {
+  /** annual_provisions is the current minting annual provisions value. */
+  annual_provisions: string;
+}
+export interface QueryAnnualProvisionsResponseAminoMsg {
+  type: "cosmos-sdk/QueryAnnualProvisionsResponse";
+  value: QueryAnnualProvisionsResponseAmino;
+}
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+export const QueryParamsRequest = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest",
+  aminoType: "cosmos-sdk/QueryParamsRequest",
+  is(o: any): o is QueryParamsRequest {
+    return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryParamsRequestAmino {
+    return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+  },
+  encode(_: QueryParamsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  toAmino(_: QueryParamsRequest): QueryParamsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest {
+    return QueryParamsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryParamsRequest",
+      value: QueryParamsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest {
+    return QueryParamsRequest.decode(message.value);
+  },
+  toProto(message: QueryParamsRequest): Uint8Array {
+    return QueryParamsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest",
+      value: QueryParamsRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsRequest.aminoType, QueryParamsRequest.typeUrl);
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: Params.fromPartial({})
+  };
+}
+export const QueryParamsResponse = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse",
+  aminoType: "cosmos-sdk/QueryParamsResponse",
+  is(o: any): o is QueryParamsResponse {
+    return o && (o.$typeUrl === QueryParamsResponse.typeUrl || Params.is(o.params));
+  },
+  isAmino(o: any): o is QueryParamsResponseAmino {
+    return o && (o.$typeUrl === QueryParamsResponse.typeUrl || Params.isAmino(o.params));
+  },
+  encode(message: QueryParamsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: QueryParamsResponse): QueryParamsResponseAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse {
+    return QueryParamsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryParamsResponse",
+      value: QueryParamsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse {
+    return QueryParamsResponse.decode(message.value);
+  },
+  toProto(message: QueryParamsResponse): Uint8Array {
+    return QueryParamsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse",
+      value: QueryParamsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsResponse.aminoType, QueryParamsResponse.typeUrl);
+function createBaseQueryInflationRequest(): QueryInflationRequest {
+  return {};
+}
+export const QueryInflationRequest = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest",
+  aminoType: "cosmos-sdk/QueryInflationRequest",
+  is(o: any): o is QueryInflationRequest {
+    return o && o.$typeUrl === QueryInflationRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryInflationRequestAmino {
+    return o && o.$typeUrl === QueryInflationRequest.typeUrl;
+  },
+  encode(_: QueryInflationRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryInflationRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryInflationRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<QueryInflationRequest>): QueryInflationRequest {
+    const message = createBaseQueryInflationRequest();
+    return message;
+  },
+  fromAmino(_: QueryInflationRequestAmino): QueryInflationRequest {
+    const message = createBaseQueryInflationRequest();
+    return message;
+  },
+  toAmino(_: QueryInflationRequest): QueryInflationRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryInflationRequestAminoMsg): QueryInflationRequest {
+    return QueryInflationRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryInflationRequest): QueryInflationRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryInflationRequest",
+      value: QueryInflationRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryInflationRequestProtoMsg): QueryInflationRequest {
+    return QueryInflationRequest.decode(message.value);
+  },
+  toProto(message: QueryInflationRequest): Uint8Array {
+    return QueryInflationRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryInflationRequest): QueryInflationRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest",
+      value: QueryInflationRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryInflationRequest.typeUrl, QueryInflationRequest);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryInflationRequest.aminoType, QueryInflationRequest.typeUrl);
+function createBaseQueryInflationResponse(): QueryInflationResponse {
+  return {
+    inflation: new Uint8Array()
+  };
+}
+export const QueryInflationResponse = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse",
+  aminoType: "cosmos-sdk/QueryInflationResponse",
+  is(o: any): o is QueryInflationResponse {
+    return o && (o.$typeUrl === QueryInflationResponse.typeUrl || o.inflation instanceof Uint8Array || typeof o.inflation === "string");
+  },
+  isAmino(o: any): o is QueryInflationResponseAmino {
+    return o && (o.$typeUrl === QueryInflationResponse.typeUrl || o.inflation instanceof Uint8Array || typeof o.inflation === "string");
+  },
+  encode(message: QueryInflationResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.inflation.length !== 0) {
+      writer.uint32(10).bytes(message.inflation);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryInflationResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryInflationResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.inflation = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryInflationResponse>): QueryInflationResponse {
+    const message = createBaseQueryInflationResponse();
+    message.inflation = object.inflation ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: QueryInflationResponseAmino): QueryInflationResponse {
+    const message = createBaseQueryInflationResponse();
+    if (object.inflation !== undefined && object.inflation !== null) {
+      message.inflation = bytesFromBase64(object.inflation);
+    }
+    return message;
+  },
+  toAmino(message: QueryInflationResponse): QueryInflationResponseAmino {
+    const obj: any = {};
+    obj.inflation = message.inflation ? base64FromBytes(message.inflation) : "";
+    return obj;
+  },
+  fromAminoMsg(object: QueryInflationResponseAminoMsg): QueryInflationResponse {
+    return QueryInflationResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryInflationResponse): QueryInflationResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryInflationResponse",
+      value: QueryInflationResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryInflationResponseProtoMsg): QueryInflationResponse {
+    return QueryInflationResponse.decode(message.value);
+  },
+  toProto(message: QueryInflationResponse): Uint8Array {
+    return QueryInflationResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryInflationResponse): QueryInflationResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse",
+      value: QueryInflationResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryInflationResponse.typeUrl, QueryInflationResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryInflationResponse.aminoType, QueryInflationResponse.typeUrl);
+function createBaseQueryAnnualProvisionsRequest(): QueryAnnualProvisionsRequest {
+  return {};
+}
+export const QueryAnnualProvisionsRequest = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest",
+  aminoType: "cosmos-sdk/QueryAnnualProvisionsRequest",
+  is(o: any): o is QueryAnnualProvisionsRequest {
+    return o && o.$typeUrl === QueryAnnualProvisionsRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryAnnualProvisionsRequestAmino {
+    return o && o.$typeUrl === QueryAnnualProvisionsRequest.typeUrl;
+  },
+  encode(_: QueryAnnualProvisionsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAnnualProvisionsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAnnualProvisionsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<QueryAnnualProvisionsRequest>): QueryAnnualProvisionsRequest {
+    const message = createBaseQueryAnnualProvisionsRequest();
+    return message;
+  },
+  fromAmino(_: QueryAnnualProvisionsRequestAmino): QueryAnnualProvisionsRequest {
+    const message = createBaseQueryAnnualProvisionsRequest();
+    return message;
+  },
+  toAmino(_: QueryAnnualProvisionsRequest): QueryAnnualProvisionsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryAnnualProvisionsRequestAminoMsg): QueryAnnualProvisionsRequest {
+    return QueryAnnualProvisionsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAnnualProvisionsRequest): QueryAnnualProvisionsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAnnualProvisionsRequest",
+      value: QueryAnnualProvisionsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAnnualProvisionsRequestProtoMsg): QueryAnnualProvisionsRequest {
+    return QueryAnnualProvisionsRequest.decode(message.value);
+  },
+  toProto(message: QueryAnnualProvisionsRequest): Uint8Array {
+    return QueryAnnualProvisionsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAnnualProvisionsRequest): QueryAnnualProvisionsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest",
+      value: QueryAnnualProvisionsRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryAnnualProvisionsRequest.typeUrl, QueryAnnualProvisionsRequest);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryAnnualProvisionsRequest.aminoType, QueryAnnualProvisionsRequest.typeUrl);
+function createBaseQueryAnnualProvisionsResponse(): QueryAnnualProvisionsResponse {
+  return {
+    annualProvisions: new Uint8Array()
+  };
+}
+export const QueryAnnualProvisionsResponse = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
+  aminoType: "cosmos-sdk/QueryAnnualProvisionsResponse",
+  is(o: any): o is QueryAnnualProvisionsResponse {
+    return o && (o.$typeUrl === QueryAnnualProvisionsResponse.typeUrl || o.annualProvisions instanceof Uint8Array || typeof o.annualProvisions === "string");
+  },
+  isAmino(o: any): o is QueryAnnualProvisionsResponseAmino {
+    return o && (o.$typeUrl === QueryAnnualProvisionsResponse.typeUrl || o.annual_provisions instanceof Uint8Array || typeof o.annual_provisions === "string");
+  },
+  encode(message: QueryAnnualProvisionsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.annualProvisions.length !== 0) {
+      writer.uint32(10).bytes(message.annualProvisions);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAnnualProvisionsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAnnualProvisionsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.annualProvisions = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryAnnualProvisionsResponse>): QueryAnnualProvisionsResponse {
+    const message = createBaseQueryAnnualProvisionsResponse();
+    message.annualProvisions = object.annualProvisions ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: QueryAnnualProvisionsResponseAmino): QueryAnnualProvisionsResponse {
+    const message = createBaseQueryAnnualProvisionsResponse();
+    if (object.annual_provisions !== undefined && object.annual_provisions !== null) {
+      message.annualProvisions = bytesFromBase64(object.annual_provisions);
+    }
+    return message;
+  },
+  toAmino(message: QueryAnnualProvisionsResponse): QueryAnnualProvisionsResponseAmino {
+    const obj: any = {};
+    obj.annual_provisions = message.annualProvisions ? base64FromBytes(message.annualProvisions) : "";
+    return obj;
+  },
+  fromAminoMsg(object: QueryAnnualProvisionsResponseAminoMsg): QueryAnnualProvisionsResponse {
+    return QueryAnnualProvisionsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAnnualProvisionsResponse): QueryAnnualProvisionsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAnnualProvisionsResponse",
+      value: QueryAnnualProvisionsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAnnualProvisionsResponseProtoMsg): QueryAnnualProvisionsResponse {
+    return QueryAnnualProvisionsResponse.decode(message.value);
+  },
+  toProto(message: QueryAnnualProvisionsResponse): Uint8Array {
+    return QueryAnnualProvisionsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAnnualProvisionsResponse): QueryAnnualProvisionsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
+      value: QueryAnnualProvisionsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryAnnualProvisionsResponse.typeUrl, QueryAnnualProvisionsResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryAnnualProvisionsResponse.aminoType, QueryAnnualProvisionsResponse.typeUrl);

package/src/cosmos/mint/v1beta1/tx.amino.ts

@@ -0,0 +1,8 @@
+import { MsgUpdateParams } from "./tx";
+export const AminoConverter = {
+  "/cosmos.mint.v1beta1.MsgUpdateParams": {
+    aminoType: "cosmos-sdk/x/mint/MsgUpdateParams",
+    toAmino: MsgUpdateParams.toAmino,
+    fromAmino: MsgUpdateParams.fromAmino
+  }
+};

package/src/cosmos/mint/v1beta1/tx.registry.ts

@@ -0,0 +1,3 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgUpdateParams } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.mint.v1beta1.MsgUpdateParams", MsgUpdateParams]];

package/src/cosmos/mint/v1beta1/tx.rpc.func.ts

@@ -0,0 +1,9 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgUpdateParams } from "./tx";
+export const createUpdateParams = (clientResolver?: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
+  typeUrl: MsgUpdateParams.typeUrl,
+  encoders: toEncoders(MsgUpdateParams),
+  converters: toConverters(MsgUpdateParams)
+});

package/src/cosmos/mint/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,31 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
+/** Msg defines the x/mint Msg service. */
+export interface Msg {
+  /**
+   * UpdateParams defines a governance operation for updating the x/mint module
+   * parameters. The authority is defaults to the x/gov module account.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* UpdateParams defines a governance operation for updating the x/mint module
+   parameters. The authority is defaults to the x/gov module account.
+  
+   Since: cosmos-sdk 0.47 */
+  updateParams = async (request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> => {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("cosmos.mint.v1beta1.Msg", "UpdateParams", data);
+    return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createClientImpl = (rpc: TxRpc) => {
+  return new MsgClientImpl(rpc);
+};