@xpla/xpla-react 1.7.0-beta.0

package/src/cosmos/mint/module/v1/module.ts

@@ -0,0 +1,113 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** Module is the config object of the mint module. */
+export interface Module {
+  feeCollectorName: string;
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.mint.module.v1.Module";
+  value: Uint8Array;
+}
+/** Module is the config object of the mint module. */
+export interface ModuleAmino {
+  fee_collector_name: string;
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+function createBaseModule(): Module {
+  return {
+    feeCollectorName: "",
+    authority: ""
+  };
+}
+export const Module = {
+  typeUrl: "/cosmos.mint.module.v1.Module",
+  aminoType: "cosmos-sdk/Module",
+  is(o: any): o is Module {
+    return o && (o.$typeUrl === Module.typeUrl || typeof o.feeCollectorName === "string" && typeof o.authority === "string");
+  },
+  isAmino(o: any): o is ModuleAmino {
+    return o && (o.$typeUrl === Module.typeUrl || typeof o.fee_collector_name === "string" && typeof o.authority === "string");
+  },
+  encode(message: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.feeCollectorName !== "") {
+      writer.uint32(10).string(message.feeCollectorName);
+    }
+    if (message.authority !== "") {
+      writer.uint32(18).string(message.authority);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Module {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.feeCollectorName = reader.string();
+          break;
+        case 2:
+          message.authority = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.feeCollectorName = object.feeCollectorName ?? "";
+    message.authority = object.authority ?? "";
+    return message;
+  },
+  fromAmino(object: ModuleAmino): Module {
+    const message = createBaseModule();
+    if (object.fee_collector_name !== undefined && object.fee_collector_name !== null) {
+      message.feeCollectorName = object.fee_collector_name;
+    }
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    return message;
+  },
+  toAmino(message: Module): ModuleAmino {
+    const obj: any = {};
+    obj.fee_collector_name = message.feeCollectorName === "" ? undefined : message.feeCollectorName;
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAminoMsg): Module {
+    return Module.fromAmino(object.value);
+  },
+  toAminoMsg(message: Module): ModuleAminoMsg {
+    return {
+      type: "cosmos-sdk/Module",
+      value: Module.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleProtoMsg): Module {
+    return Module.decode(message.value);
+  },
+  toProto(message: Module): Uint8Array {
+    return Module.encode(message).finish();
+  },
+  toProtoMsg(message: Module): ModuleProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Module.typeUrl, Module);
+GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

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

@@ -0,0 +1,116 @@
+import { Minter, MinterAmino, Params, ParamsAmino } from "./mint";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** GenesisState defines the mint module's genesis state. */
+export interface GenesisState {
+  /** minter is a space for holding current inflation information. */
+  minter: Minter;
+  /** params defines all the parameters of the module. */
+  params: Params;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the mint module's genesis state. */
+export interface GenesisStateAmino {
+  /** minter is a space for holding current inflation information. */
+  minter: MinterAmino;
+  /** params defines all the parameters of the module. */
+  params: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    minter: Minter.fromPartial({}),
+    params: Params.fromPartial({})
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.mint.v1beta1.GenesisState",
+  aminoType: "cosmos-sdk/GenesisState",
+  is(o: any): o is GenesisState {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Minter.is(o.minter) && Params.is(o.params));
+  },
+  isAmino(o: any): o is GenesisStateAmino {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Minter.isAmino(o.minter) && Params.isAmino(o.params));
+  },
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.minter !== undefined) {
+      Minter.encode(message.minter, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  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.minter = Minter.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.minter = object.minter !== undefined && object.minter !== null ? Minter.fromPartial(object.minter) : undefined;
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.minter !== undefined && object.minter !== null) {
+      message.minter = Minter.fromAmino(object.minter);
+    }
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.minter = message.minter ? Minter.toAmino(message.minter) : Minter.toAmino(Minter.fromPartial({}));
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    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.mint.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
+GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);

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

@@ -0,0 +1,291 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** Minter represents the minting state. */
+export interface Minter {
+  /** current annual inflation rate */
+  inflation: string;
+  /** current annual expected provisions */
+  annualProvisions: string;
+}
+export interface MinterProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.Minter";
+  value: Uint8Array;
+}
+/** Minter represents the minting state. */
+export interface MinterAmino {
+  /** current annual inflation rate */
+  inflation: string;
+  /** current annual expected provisions */
+  annual_provisions: string;
+}
+export interface MinterAminoMsg {
+  type: "cosmos-sdk/Minter";
+  value: MinterAmino;
+}
+/** Params defines the parameters for the x/mint module. */
+export interface Params {
+  /** type of coin to mint */
+  mintDenom: string;
+  /** maximum annual change in inflation rate */
+  inflationRateChange: string;
+  /** maximum inflation rate */
+  inflationMax: string;
+  /** minimum inflation rate */
+  inflationMin: string;
+  /** goal of percent bonded atoms */
+  goalBonded: string;
+  /** expected blocks per year */
+  blocksPerYear: bigint;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.Params";
+  value: Uint8Array;
+}
+/** Params defines the parameters for the x/mint module. */
+export interface ParamsAmino {
+  /** type of coin to mint */
+  mint_denom: string;
+  /** maximum annual change in inflation rate */
+  inflation_rate_change: string;
+  /** maximum inflation rate */
+  inflation_max: string;
+  /** minimum inflation rate */
+  inflation_min: string;
+  /** goal of percent bonded atoms */
+  goal_bonded: string;
+  /** expected blocks per year */
+  blocks_per_year: string;
+}
+export interface ParamsAminoMsg {
+  type: "cosmos-sdk/x/mint/Params";
+  value: ParamsAmino;
+}
+function createBaseMinter(): Minter {
+  return {
+    inflation: "",
+    annualProvisions: ""
+  };
+}
+export const Minter = {
+  typeUrl: "/cosmos.mint.v1beta1.Minter",
+  aminoType: "cosmos-sdk/Minter",
+  is(o: any): o is Minter {
+    return o && (o.$typeUrl === Minter.typeUrl || typeof o.inflation === "string" && typeof o.annualProvisions === "string");
+  },
+  isAmino(o: any): o is MinterAmino {
+    return o && (o.$typeUrl === Minter.typeUrl || typeof o.inflation === "string" && typeof o.annual_provisions === "string");
+  },
+  encode(message: Minter, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.inflation !== "") {
+      writer.uint32(10).string(message.inflation);
+    }
+    if (message.annualProvisions !== "") {
+      writer.uint32(18).string(message.annualProvisions);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Minter {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMinter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.inflation = reader.string();
+          break;
+        case 2:
+          message.annualProvisions = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Minter>): Minter {
+    const message = createBaseMinter();
+    message.inflation = object.inflation ?? "";
+    message.annualProvisions = object.annualProvisions ?? "";
+    return message;
+  },
+  fromAmino(object: MinterAmino): Minter {
+    const message = createBaseMinter();
+    if (object.inflation !== undefined && object.inflation !== null) {
+      message.inflation = object.inflation;
+    }
+    if (object.annual_provisions !== undefined && object.annual_provisions !== null) {
+      message.annualProvisions = object.annual_provisions;
+    }
+    return message;
+  },
+  toAmino(message: Minter): MinterAmino {
+    const obj: any = {};
+    obj.inflation = message.inflation === "" ? undefined : message.inflation;
+    obj.annual_provisions = message.annualProvisions === "" ? undefined : message.annualProvisions;
+    return obj;
+  },
+  fromAminoMsg(object: MinterAminoMsg): Minter {
+    return Minter.fromAmino(object.value);
+  },
+  toAminoMsg(message: Minter): MinterAminoMsg {
+    return {
+      type: "cosmos-sdk/Minter",
+      value: Minter.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MinterProtoMsg): Minter {
+    return Minter.decode(message.value);
+  },
+  toProto(message: Minter): Uint8Array {
+    return Minter.encode(message).finish();
+  },
+  toProtoMsg(message: Minter): MinterProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.Minter",
+      value: Minter.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Minter.typeUrl, Minter);
+GlobalDecoderRegistry.registerAminoProtoMapping(Minter.aminoType, Minter.typeUrl);
+function createBaseParams(): Params {
+  return {
+    mintDenom: "",
+    inflationRateChange: "",
+    inflationMax: "",
+    inflationMin: "",
+    goalBonded: "",
+    blocksPerYear: BigInt(0)
+  };
+}
+export const Params = {
+  typeUrl: "/cosmos.mint.v1beta1.Params",
+  aminoType: "cosmos-sdk/x/mint/Params",
+  is(o: any): o is Params {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.mintDenom === "string" && typeof o.inflationRateChange === "string" && typeof o.inflationMax === "string" && typeof o.inflationMin === "string" && typeof o.goalBonded === "string" && typeof o.blocksPerYear === "bigint");
+  },
+  isAmino(o: any): o is ParamsAmino {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.mint_denom === "string" && typeof o.inflation_rate_change === "string" && typeof o.inflation_max === "string" && typeof o.inflation_min === "string" && typeof o.goal_bonded === "string" && typeof o.blocks_per_year === "bigint");
+  },
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.mintDenom !== "") {
+      writer.uint32(10).string(message.mintDenom);
+    }
+    if (message.inflationRateChange !== "") {
+      writer.uint32(18).string(message.inflationRateChange);
+    }
+    if (message.inflationMax !== "") {
+      writer.uint32(26).string(message.inflationMax);
+    }
+    if (message.inflationMin !== "") {
+      writer.uint32(34).string(message.inflationMin);
+    }
+    if (message.goalBonded !== "") {
+      writer.uint32(42).string(message.goalBonded);
+    }
+    if (message.blocksPerYear !== BigInt(0)) {
+      writer.uint32(48).uint64(message.blocksPerYear);
+    }
+    return writer;
+  },
+  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.mintDenom = reader.string();
+          break;
+        case 2:
+          message.inflationRateChange = reader.string();
+          break;
+        case 3:
+          message.inflationMax = reader.string();
+          break;
+        case 4:
+          message.inflationMin = reader.string();
+          break;
+        case 5:
+          message.goalBonded = reader.string();
+          break;
+        case 6:
+          message.blocksPerYear = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.mintDenom = object.mintDenom ?? "";
+    message.inflationRateChange = object.inflationRateChange ?? "";
+    message.inflationMax = object.inflationMax ?? "";
+    message.inflationMin = object.inflationMin ?? "";
+    message.goalBonded = object.goalBonded ?? "";
+    message.blocksPerYear = object.blocksPerYear !== undefined && object.blocksPerYear !== null ? BigInt(object.blocksPerYear.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    if (object.mint_denom !== undefined && object.mint_denom !== null) {
+      message.mintDenom = object.mint_denom;
+    }
+    if (object.inflation_rate_change !== undefined && object.inflation_rate_change !== null) {
+      message.inflationRateChange = object.inflation_rate_change;
+    }
+    if (object.inflation_max !== undefined && object.inflation_max !== null) {
+      message.inflationMax = object.inflation_max;
+    }
+    if (object.inflation_min !== undefined && object.inflation_min !== null) {
+      message.inflationMin = object.inflation_min;
+    }
+    if (object.goal_bonded !== undefined && object.goal_bonded !== null) {
+      message.goalBonded = object.goal_bonded;
+    }
+    if (object.blocks_per_year !== undefined && object.blocks_per_year !== null) {
+      message.blocksPerYear = BigInt(object.blocks_per_year);
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    obj.mint_denom = message.mintDenom === "" ? undefined : message.mintDenom;
+    obj.inflation_rate_change = message.inflationRateChange ?? "";
+    obj.inflation_max = message.inflationMax ?? "";
+    obj.inflation_min = message.inflationMin ?? "";
+    obj.goal_bonded = message.goalBonded ?? "";
+    obj.blocks_per_year = message.blocksPerYear !== BigInt(0) ? message.blocksPerYear?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "cosmos-sdk/x/mint/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: "/cosmos.mint.v1beta1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Params.typeUrl, Params);
+GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

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

@@ -0,0 +1,36 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { buildUseQuery } from "../../../react-query";
+import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
+export const createGetParams = (clientResolver?: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+  encode: QueryParamsRequest.encode,
+  decode: QueryParamsResponse.decode,
+  service: "cosmos.mint.v1beta1.Query",
+  method: "Params",
+  clientResolver
+});
+export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
+  builderQueryFn: createGetParams,
+  queryKeyPrefix: "ParamsQuery"
+});
+export const createGetInflation = (clientResolver?: RpcResolver) => buildQuery<QueryInflationRequest, QueryInflationResponse>({
+  encode: QueryInflationRequest.encode,
+  decode: QueryInflationResponse.decode,
+  service: "cosmos.mint.v1beta1.Query",
+  method: "Inflation",
+  clientResolver
+});
+export const useGetInflation = buildUseQuery<QueryInflationRequest, QueryInflationResponse>({
+  builderQueryFn: createGetInflation,
+  queryKeyPrefix: "InflationQuery"
+});
+export const createGetAnnualProvisions = (clientResolver?: RpcResolver) => buildQuery<QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse>({
+  encode: QueryAnnualProvisionsRequest.encode,
+  decode: QueryAnnualProvisionsResponse.decode,
+  service: "cosmos.mint.v1beta1.Query",
+  method: "AnnualProvisions",
+  clientResolver
+});
+export const useGetAnnualProvisions = buildUseQuery<QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse>({
+  builderQueryFn: createGetAnnualProvisions,
+  queryKeyPrefix: "AnnualProvisionsQuery"
+});