@xpla/xplajs 1.7.0 → 1.8.0-rc.1

package/xpla/bundle.d.ts

@@ -0,0 +1,22 @@
+export * from "./burn/v1beta1/burn";
+export { GenesisState as XplaBurnV1beta1GenesisState, GenesisStateProtoMsg as XplaBurnV1beta1GenesisStateProtoMsg, GenesisStateAmino as XplaBurnV1beta1GenesisStateAmino, GenesisStateAminoMsg as XplaBurnV1beta1GenesisStateAminoMsg } from "./burn/v1beta1/genesis";
+export * from "./burn/v1beta1/query";
+export * from "./burn/v1beta1/tx";
+export { GenesisState as XplaRewardV1beta1GenesisState, GenesisStateProtoMsg as XplaRewardV1beta1GenesisStateProtoMsg, GenesisStateAmino as XplaRewardV1beta1GenesisStateAmino, GenesisStateAminoMsg as XplaRewardV1beta1GenesisStateAminoMsg } from "./reward/v1beta1/genesis";
+export { QueryParamsRequest as XplaRewardV1beta1QueryParamsRequest, QueryParamsRequestProtoMsg as XplaRewardV1beta1QueryParamsRequestProtoMsg, QueryParamsRequestAmino as XplaRewardV1beta1QueryParamsRequestAmino, QueryParamsRequestAminoMsg as XplaRewardV1beta1QueryParamsRequestAminoMsg, QueryParamsResponse as XplaRewardV1beta1QueryParamsResponse, QueryParamsResponseProtoMsg as XplaRewardV1beta1QueryParamsResponseProtoMsg, QueryParamsResponseAmino as XplaRewardV1beta1QueryParamsResponseAmino, QueryParamsResponseAminoMsg as XplaRewardV1beta1QueryParamsResponseAminoMsg, QueryPoolRequest as XplaRewardV1beta1QueryPoolRequest, QueryPoolRequestProtoMsg as XplaRewardV1beta1QueryPoolRequestProtoMsg, QueryPoolRequestAmino as XplaRewardV1beta1QueryPoolRequestAmino, QueryPoolRequestAminoMsg as XplaRewardV1beta1QueryPoolRequestAminoMsg, QueryPoolResponse as XplaRewardV1beta1QueryPoolResponse, QueryPoolResponseProtoMsg as XplaRewardV1beta1QueryPoolResponseProtoMsg, QueryPoolResponseAmino as XplaRewardV1beta1QueryPoolResponseAmino, QueryPoolResponseAminoMsg as XplaRewardV1beta1QueryPoolResponseAminoMsg } from "./reward/v1beta1/query";
+export { Params as XplaRewardV1beta1Params, ParamsProtoMsg as XplaRewardV1beta1ParamsProtoMsg, ParamsAmino as XplaRewardV1beta1ParamsAmino, ParamsAminoMsg as XplaRewardV1beta1ParamsAminoMsg } from "./reward/v1beta1/reward";
+export { MsgFundRewardPool, MsgFundRewardPoolProtoMsg, MsgFundRewardPoolAmino, MsgFundRewardPoolAminoMsg, MsgFundRewardPoolResponse, MsgFundRewardPoolResponseProtoMsg, MsgFundRewardPoolResponseAmino, MsgFundRewardPoolResponseAminoMsg, MsgUpdateParams as XplaRewardV1beta1MsgUpdateParams, MsgUpdateParamsProtoMsg as XplaRewardV1beta1MsgUpdateParamsProtoMsg, MsgUpdateParamsAmino as XplaRewardV1beta1MsgUpdateParamsAmino, MsgUpdateParamsAminoMsg as XplaRewardV1beta1MsgUpdateParamsAminoMsg, MsgUpdateParamsResponse as XplaRewardV1beta1MsgUpdateParamsResponse, MsgUpdateParamsResponseProtoMsg as XplaRewardV1beta1MsgUpdateParamsResponseProtoMsg, MsgUpdateParamsResponseAmino as XplaRewardV1beta1MsgUpdateParamsResponseAmino, MsgUpdateParamsResponseAminoMsg as XplaRewardV1beta1MsgUpdateParamsResponseAminoMsg } from "./reward/v1beta1/tx";
+export { GenesisState as XplaVolunteerV1beta1GenesisState, GenesisStateProtoMsg as XplaVolunteerV1beta1GenesisStateProtoMsg, GenesisStateAmino as XplaVolunteerV1beta1GenesisStateAmino, GenesisStateAminoMsg as XplaVolunteerV1beta1GenesisStateAminoMsg } from "./volunteer/v1beta1/genesis";
+export * from "./volunteer/v1beta1/proposal";
+export * from "./volunteer/v1beta1/query";
+export * from "./volunteer/v1beta1/tx";
+export * from "./volunteer/v1beta1/volunteervalidator";
+export { registry as XplaBurnV1beta1Registry, MessageComposer as XplaBurnV1beta1MessageComposer } from "./burn/v1beta1/tx.registry";
+export { registry as XplaRewardV1beta1Registry, MessageComposer as XplaRewardV1beta1MessageComposer } from "./reward/v1beta1/tx.registry";
+export { registry as XplaVolunteerV1beta1Registry, MessageComposer as XplaVolunteerV1beta1MessageComposer } from "./volunteer/v1beta1/tx.registry";
+export * from "./burn/v1beta1/query.rpc.func";
+export { getParams as getParamsXplaRewardV1beta1, getPool as getPoolXplaRewardV1beta1 } from "./reward/v1beta1/query.rpc.func";
+export * from "./volunteer/v1beta1/query.rpc.func";
+export * from "./burn/v1beta1/tx.rpc.func";
+export { fundRewardPool, updateParams as updateParamsXplaRewardV1beta1 } from "./reward/v1beta1/tx.rpc.func";
+export * from "./volunteer/v1beta1/tx.rpc.func";

package/xpla/bundle.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateParamsXplaRewardV1beta1 = exports.fundRewardPool = exports.getPoolXplaRewardV1beta1 = exports.getParamsXplaRewardV1beta1 = exports.XplaVolunteerV1beta1MessageComposer = exports.XplaVolunteerV1beta1Registry = exports.XplaRewardV1beta1MessageComposer = exports.XplaRewardV1beta1Registry = exports.XplaBurnV1beta1MessageComposer = exports.XplaBurnV1beta1Registry = exports.XplaVolunteerV1beta1GenesisState = exports.XplaRewardV1beta1MsgUpdateParamsResponse = exports.XplaRewardV1beta1MsgUpdateParams = exports.MsgFundRewardPoolResponse = exports.MsgFundRewardPool = exports.XplaRewardV1beta1Params = exports.XplaRewardV1beta1QueryPoolResponse = exports.XplaRewardV1beta1QueryPoolRequest = exports.XplaRewardV1beta1QueryParamsResponse = exports.XplaRewardV1beta1QueryParamsRequest = exports.XplaRewardV1beta1GenesisState = exports.XplaBurnV1beta1GenesisState = void 0;
+__exportStar(require("./burn/v1beta1/burn"), exports);
+var genesis_1 = require("./burn/v1beta1/genesis");
+Object.defineProperty(exports, "XplaBurnV1beta1GenesisState", { enumerable: true, get: function () { return genesis_1.GenesisState; } });
+__exportStar(require("./burn/v1beta1/query"), exports);
+__exportStar(require("./burn/v1beta1/tx"), exports);
+var genesis_2 = require("./reward/v1beta1/genesis");
+Object.defineProperty(exports, "XplaRewardV1beta1GenesisState", { enumerable: true, get: function () { return genesis_2.GenesisState; } });
+var query_1 = require("./reward/v1beta1/query");
+Object.defineProperty(exports, "XplaRewardV1beta1QueryParamsRequest", { enumerable: true, get: function () { return query_1.QueryParamsRequest; } });
+Object.defineProperty(exports, "XplaRewardV1beta1QueryParamsResponse", { enumerable: true, get: function () { return query_1.QueryParamsResponse; } });
+Object.defineProperty(exports, "XplaRewardV1beta1QueryPoolRequest", { enumerable: true, get: function () { return query_1.QueryPoolRequest; } });
+Object.defineProperty(exports, "XplaRewardV1beta1QueryPoolResponse", { enumerable: true, get: function () { return query_1.QueryPoolResponse; } });
+var reward_1 = require("./reward/v1beta1/reward");
+Object.defineProperty(exports, "XplaRewardV1beta1Params", { enumerable: true, get: function () { return reward_1.Params; } });
+var tx_1 = require("./reward/v1beta1/tx");
+Object.defineProperty(exports, "MsgFundRewardPool", { enumerable: true, get: function () { return tx_1.MsgFundRewardPool; } });
+Object.defineProperty(exports, "MsgFundRewardPoolResponse", { enumerable: true, get: function () { return tx_1.MsgFundRewardPoolResponse; } });
+Object.defineProperty(exports, "XplaRewardV1beta1MsgUpdateParams", { enumerable: true, get: function () { return tx_1.MsgUpdateParams; } });
+Object.defineProperty(exports, "XplaRewardV1beta1MsgUpdateParamsResponse", { enumerable: true, get: function () { return tx_1.MsgUpdateParamsResponse; } });
+var genesis_3 = require("./volunteer/v1beta1/genesis");
+Object.defineProperty(exports, "XplaVolunteerV1beta1GenesisState", { enumerable: true, get: function () { return genesis_3.GenesisState; } });
+__exportStar(require("./volunteer/v1beta1/proposal"), exports);
+__exportStar(require("./volunteer/v1beta1/query"), exports);
+__exportStar(require("./volunteer/v1beta1/tx"), exports);
+__exportStar(require("./volunteer/v1beta1/volunteervalidator"), exports);
+var tx_registry_1 = require("./burn/v1beta1/tx.registry");
+Object.defineProperty(exports, "XplaBurnV1beta1Registry", { enumerable: true, get: function () { return tx_registry_1.registry; } });
+Object.defineProperty(exports, "XplaBurnV1beta1MessageComposer", { enumerable: true, get: function () { return tx_registry_1.MessageComposer; } });
+var tx_registry_2 = require("./reward/v1beta1/tx.registry");
+Object.defineProperty(exports, "XplaRewardV1beta1Registry", { enumerable: true, get: function () { return tx_registry_2.registry; } });
+Object.defineProperty(exports, "XplaRewardV1beta1MessageComposer", { enumerable: true, get: function () { return tx_registry_2.MessageComposer; } });
+var tx_registry_3 = require("./volunteer/v1beta1/tx.registry");
+Object.defineProperty(exports, "XplaVolunteerV1beta1Registry", { enumerable: true, get: function () { return tx_registry_3.registry; } });
+Object.defineProperty(exports, "XplaVolunteerV1beta1MessageComposer", { enumerable: true, get: function () { return tx_registry_3.MessageComposer; } });
+__exportStar(require("./burn/v1beta1/query.rpc.func"), exports);
+var query_rpc_func_1 = require("./reward/v1beta1/query.rpc.func");
+Object.defineProperty(exports, "getParamsXplaRewardV1beta1", { enumerable: true, get: function () { return query_rpc_func_1.getParams; } });
+Object.defineProperty(exports, "getPoolXplaRewardV1beta1", { enumerable: true, get: function () { return query_rpc_func_1.getPool; } });
+__exportStar(require("./volunteer/v1beta1/query.rpc.func"), exports);
+__exportStar(require("./burn/v1beta1/tx.rpc.func"), exports);
+var tx_rpc_func_1 = require("./reward/v1beta1/tx.rpc.func");
+Object.defineProperty(exports, "fundRewardPool", { enumerable: true, get: function () { return tx_rpc_func_1.fundRewardPool; } });
+Object.defineProperty(exports, "updateParamsXplaRewardV1beta1", { enumerable: true, get: function () { return tx_rpc_func_1.updateParams; } });
+__exportStar(require("./volunteer/v1beta1/tx.rpc.func"), exports);

package/xpla/burn/v1beta1/burn.d.ts

@@ -0,0 +1,54 @@
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * BurnProposal defines a ongoingburn proposal
+ * @name BurnProposal
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.BurnProposal
+ */
+export interface BurnProposal {
+    proposalId: bigint;
+    proposer: string;
+    amount: Coin[];
+}
+export interface BurnProposalProtoMsg {
+    typeUrl: "/xpla.burn.v1beta1.BurnProposal";
+    value: Uint8Array;
+}
+/**
+ * BurnProposal defines a ongoingburn proposal
+ * @name BurnProposalAmino
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.BurnProposal
+ */
+export interface BurnProposalAmino {
+    proposal_id: string;
+    proposer: string;
+    amount: CoinAmino[];
+}
+export interface BurnProposalAminoMsg {
+    type: "/xpla.burn.v1beta1.BurnProposal";
+    value: BurnProposalAmino;
+}
+/**
+ * BurnProposal defines a ongoingburn proposal
+ * @name BurnProposal
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.BurnProposal
+ */
+export declare const BurnProposal: {
+    typeUrl: string;
+    is(o: any): o is BurnProposal;
+    isAmino(o: any): o is BurnProposalAmino;
+    encode(message: BurnProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BurnProposal;
+    fromPartial(object: DeepPartial<BurnProposal>): BurnProposal;
+    fromAmino(object: BurnProposalAmino): BurnProposal;
+    toAmino(message: BurnProposal): BurnProposalAmino;
+    fromAminoMsg(object: BurnProposalAminoMsg): BurnProposal;
+    fromProtoMsg(message: BurnProposalProtoMsg): BurnProposal;
+    toProto(message: BurnProposal): Uint8Array;
+    toProtoMsg(message: BurnProposal): BurnProposalProtoMsg;
+    registerTypeUrl(): void;
+};

package/xpla/burn/v1beta1/burn.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BurnProposal = void 0;
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseBurnProposal() {
+    return {
+        proposalId: BigInt(0),
+        proposer: "",
+        amount: []
+    };
+}
+/**
+ * BurnProposal defines a ongoingburn proposal
+ * @name BurnProposal
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.BurnProposal
+ */
+exports.BurnProposal = {
+    typeUrl: "/xpla.burn.v1beta1.BurnProposal",
+    is(o) {
+        return o && (o.$typeUrl === exports.BurnProposal.typeUrl || typeof o.proposalId === "bigint" && typeof o.proposer === "string" && Array.isArray(o.amount) && (!o.amount.length || coin_1.Coin.is(o.amount[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.BurnProposal.typeUrl || typeof o.proposal_id === "bigint" && typeof o.proposer === "string" && Array.isArray(o.amount) && (!o.amount.length || coin_1.Coin.isAmino(o.amount[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.proposalId);
+        }
+        if (message.proposer !== "") {
+            writer.uint32(18).string(message.proposer);
+        }
+        for (const v of message.amount) {
+            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBurnProposal();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.proposalId = reader.uint64();
+                    break;
+                case 2:
+                    message.proposer = reader.string();
+                    break;
+                case 3:
+                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBurnProposal();
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        message.proposer = object.proposer ?? "";
+        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBurnProposal();
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        if (object.proposer !== undefined && object.proposer !== null) {
+            message.proposer = object.proposer;
+        }
+        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        obj.proposer = message.proposer === "" ? undefined : message.proposer;
+        if (message.amount) {
+            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.amount = message.amount;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.BurnProposal.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.BurnProposal.decode(message.value);
+    },
+    toProto(message) {
+        return exports.BurnProposal.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.BurnProposal",
+            value: exports.BurnProposal.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.BurnProposal.typeUrl)) {
+            return;
+        }
+        coin_1.Coin.registerTypeUrl();
+    }
+};

package/{cosmos/crisis → xpla/burn}/v1beta1/genesis.d.ts

@@ -1,33 +1,46 @@
-import { Coin, CoinAmino } from "../../base/v1beta1/coin";
+import { BurnProposal, BurnProposalAmino } from "./burn";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
-/** GenesisState defines the crisis module's genesis state. */
+/**
+ * GenesisState defines the bank module's genesis state.
+ * @name GenesisState
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.GenesisState
+ */
 export interface GenesisState {
     /**
-     * constant_fee is the fee used to verify the invariant in the crisis
-     * module.
+     * ongoing_burn_proposals defines the ongoing burn proposals at genesis
      */
-    constantFee: Coin;
+    ongoingBurnProposals: BurnProposal[];
 }
 export interface GenesisStateProtoMsg {
-    typeUrl: "/cosmos.crisis.v1beta1.GenesisState";
+    typeUrl: "/xpla.burn.v1beta1.GenesisState";
     value: Uint8Array;
 }
-/** GenesisState defines the crisis module's genesis state. */
+/**
+ * GenesisState defines the bank module's genesis state.
+ * @name GenesisStateAmino
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.GenesisState
+ */
 export interface GenesisStateAmino {
     /**
-     * constant_fee is the fee used to verify the invariant in the crisis
-     * module.
+     * ongoing_burn_proposals defines the ongoing burn proposals at genesis
      */
-    constant_fee: CoinAmino;
+    ongoing_burn_proposals: BurnProposalAmino[];
 }
 export interface GenesisStateAminoMsg {
-    type: "cosmos-sdk/GenesisState";
+    type: "/xpla.burn.v1beta1.GenesisState";
     value: GenesisStateAmino;
 }
+/**
+ * GenesisState defines the bank module's genesis state.
+ * @name GenesisState
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.GenesisState
+ */
 export declare const GenesisState: {
     typeUrl: string;
-    aminoType: string;
     is(o: any): o is GenesisState;
     isAmino(o: any): o is GenesisStateAmino;
     encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
@@ -36,8 +49,8 @@ export declare const GenesisState: {
     fromAmino(object: GenesisStateAmino): GenesisState;
     toAmino(message: GenesisState): GenesisStateAmino;
     fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
-    toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
     fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
     toProto(message: GenesisState): Uint8Array;
     toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+    registerTypeUrl(): void;
 };

package/{cosmos/genutil → xpla/burn}/v1beta1/genesis.js

@@ -1,26 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenesisState = void 0;
+const burn_1 = require("./burn");
 const binary_1 = require("../../../binary");
-const helpers_1 = require("../../../helpers");
 const registry_1 = require("../../../registry");
 function createBaseGenesisState() {
     return {
-        genTxs: []
+        ongoingBurnProposals: []
     };
 }
+/**
+ * GenesisState defines the bank module's genesis state.
+ * @name GenesisState
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.GenesisState
+ */
 exports.GenesisState = {
-    typeUrl: "/cosmos.genutil.v1beta1.GenesisState",
-    aminoType: "cosmos-sdk/GenesisState",
+    typeUrl: "/xpla.burn.v1beta1.GenesisState",
     is(o) {
-        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.genTxs) && (!o.genTxs.length || o.genTxs[0] instanceof Uint8Array || typeof o.genTxs[0] === "string"));
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.ongoingBurnProposals) && (!o.ongoingBurnProposals.length || burn_1.BurnProposal.is(o.ongoingBurnProposals[0])));
     },
     isAmino(o) {
-        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.gen_txs) && (!o.gen_txs.length || o.gen_txs[0] instanceof Uint8Array || typeof o.gen_txs[0] === "string"));
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.ongoing_burn_proposals) && (!o.ongoing_burn_proposals.length || burn_1.BurnProposal.isAmino(o.ongoing_burn_proposals[0])));
     },
     encode(message, writer = binary_1.BinaryWriter.create()) {
-        for (const v of message.genTxs) {
-            writer.uint32(10).bytes(v);
+        for (const v of message.ongoingBurnProposals) {
+            burn_1.BurnProposal.encode(v, writer.uint32(10).fork()).ldelim();
         }
         return writer;
     },
@@ -32,7 +37,7 @@ exports.GenesisState = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.genTxs.push(reader.bytes());
+                    message.ongoingBurnProposals.push(burn_1.BurnProposal.decode(reader, reader.uint32()));
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -43,33 +48,27 @@ exports.GenesisState = {
     },
     fromPartial(object) {
         const message = createBaseGenesisState();
-        message.genTxs = object.genTxs?.map(e => e) || [];
+        message.ongoingBurnProposals = object.ongoingBurnProposals?.map(e => burn_1.BurnProposal.fromPartial(e)) || [];
         return message;
     },
     fromAmino(object) {
         const message = createBaseGenesisState();
-        message.genTxs = object.gen_txs?.map(e => (0, helpers_1.bytesFromBase64)(e)) || [];
+        message.ongoingBurnProposals = object.ongoing_burn_proposals?.map(e => burn_1.BurnProposal.fromAmino(e)) || [];
         return message;
     },
     toAmino(message) {
         const obj = {};
-        if (message.genTxs) {
-            obj.gen_txs = message.genTxs.map(e => (0, helpers_1.base64FromBytes)(e));
+        if (message.ongoingBurnProposals) {
+            obj.ongoing_burn_proposals = message.ongoingBurnProposals.map(e => e ? burn_1.BurnProposal.toAmino(e) : undefined);
         }
         else {
-            obj.gen_txs = message.genTxs;
+            obj.ongoing_burn_proposals = message.ongoingBurnProposals;
         }
         return obj;
     },
     fromAminoMsg(object) {
         return exports.GenesisState.fromAmino(object.value);
     },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/GenesisState",
-            value: exports.GenesisState.toAmino(message)
-        };
-    },
     fromProtoMsg(message) {
         return exports.GenesisState.decode(message.value);
     },
@@ -78,10 +77,14 @@ exports.GenesisState = {
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/cosmos.genutil.v1beta1.GenesisState",
+            typeUrl: "/xpla.burn.v1beta1.GenesisState",
             value: exports.GenesisState.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.GenesisState.typeUrl)) {
+            return;
+        }
+        burn_1.BurnProposal.registerTypeUrl();
     }
 };
-registry_1.GlobalDecoderRegistry.register(exports.GenesisState.typeUrl, exports.GenesisState);
-registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.GenesisState.aminoType, exports.GenesisState.typeUrl);

package/xpla/burn/v1beta1/query.d.ts

@@ -0,0 +1,204 @@
+import { BurnProposal, BurnProposalAmino } from "./burn";
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * QueryOngoingProposalsRequest is the request type for the
+ * Query/OngoingProposals RPC method.
+ * @name QueryOngoingProposalsRequest
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalsRequest
+ */
+export interface QueryOngoingProposalsRequest {
+}
+export interface QueryOngoingProposalsRequestProtoMsg {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryOngoingProposalsRequest is the request type for the
+ * Query/OngoingProposals RPC method.
+ * @name QueryOngoingProposalsRequestAmino
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalsRequest
+ */
+export interface QueryOngoingProposalsRequestAmino {
+}
+export interface QueryOngoingProposalsRequestAminoMsg {
+    type: "/xpla.burn.v1beta1.QueryOngoingProposalsRequest";
+    value: QueryOngoingProposalsRequestAmino;
+}
+/**
+ * QueryOngoingProposalsResponse is the response type for the
+ * Query/OngoingProposals RPC method.
+ * @name QueryOngoingProposalsResponse
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalsResponse
+ */
+export interface QueryOngoingProposalsResponse {
+    proposals: BurnProposal[];
+}
+export interface QueryOngoingProposalsResponseProtoMsg {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryOngoingProposalsResponse is the response type for the
+ * Query/OngoingProposals RPC method.
+ * @name QueryOngoingProposalsResponseAmino
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalsResponse
+ */
+export interface QueryOngoingProposalsResponseAmino {
+    proposals: BurnProposalAmino[];
+}
+export interface QueryOngoingProposalsResponseAminoMsg {
+    type: "/xpla.burn.v1beta1.QueryOngoingProposalsResponse";
+    value: QueryOngoingProposalsResponseAmino;
+}
+/**
+ * QueryOngoingProposalRequest is the request type for the Query/OngoingProposal
+ * RPC method.
+ * @name QueryOngoingProposalRequest
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalRequest
+ */
+export interface QueryOngoingProposalRequest {
+    proposalId: bigint;
+}
+export interface QueryOngoingProposalRequestProtoMsg {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryOngoingProposalRequest is the request type for the Query/OngoingProposal
+ * RPC method.
+ * @name QueryOngoingProposalRequestAmino
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalRequest
+ */
+export interface QueryOngoingProposalRequestAmino {
+    proposal_id: string;
+}
+export interface QueryOngoingProposalRequestAminoMsg {
+    type: "/xpla.burn.v1beta1.QueryOngoingProposalRequest";
+    value: QueryOngoingProposalRequestAmino;
+}
+/**
+ * QueryOngoingProposalResponse is the response type for the
+ * Query/OngoingProposal RPC method.
+ * @name QueryOngoingProposalResponse
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalResponse
+ */
+export interface QueryOngoingProposalResponse {
+    proposer: string;
+    amount: Coin[];
+}
+export interface QueryOngoingProposalResponseProtoMsg {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryOngoingProposalResponse is the response type for the
+ * Query/OngoingProposal RPC method.
+ * @name QueryOngoingProposalResponseAmino
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalResponse
+ */
+export interface QueryOngoingProposalResponseAmino {
+    proposer: string;
+    amount: CoinAmino[];
+}
+export interface QueryOngoingProposalResponseAminoMsg {
+    type: "/xpla.burn.v1beta1.QueryOngoingProposalResponse";
+    value: QueryOngoingProposalResponseAmino;
+}
+/**
+ * QueryOngoingProposalsRequest is the request type for the
+ * Query/OngoingProposals RPC method.
+ * @name QueryOngoingProposalsRequest
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalsRequest
+ */
+export declare const QueryOngoingProposalsRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryOngoingProposalsRequest;
+    isAmino(o: any): o is QueryOngoingProposalsRequestAmino;
+    encode(_: QueryOngoingProposalsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryOngoingProposalsRequest;
+    fromPartial(_: DeepPartial<QueryOngoingProposalsRequest>): QueryOngoingProposalsRequest;
+    fromAmino(_: QueryOngoingProposalsRequestAmino): QueryOngoingProposalsRequest;
+    toAmino(_: QueryOngoingProposalsRequest): QueryOngoingProposalsRequestAmino;
+    fromAminoMsg(object: QueryOngoingProposalsRequestAminoMsg): QueryOngoingProposalsRequest;
+    fromProtoMsg(message: QueryOngoingProposalsRequestProtoMsg): QueryOngoingProposalsRequest;
+    toProto(message: QueryOngoingProposalsRequest): Uint8Array;
+    toProtoMsg(message: QueryOngoingProposalsRequest): QueryOngoingProposalsRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryOngoingProposalsResponse is the response type for the
+ * Query/OngoingProposals RPC method.
+ * @name QueryOngoingProposalsResponse
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalsResponse
+ */
+export declare const QueryOngoingProposalsResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryOngoingProposalsResponse;
+    isAmino(o: any): o is QueryOngoingProposalsResponseAmino;
+    encode(message: QueryOngoingProposalsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryOngoingProposalsResponse;
+    fromPartial(object: DeepPartial<QueryOngoingProposalsResponse>): QueryOngoingProposalsResponse;
+    fromAmino(object: QueryOngoingProposalsResponseAmino): QueryOngoingProposalsResponse;
+    toAmino(message: QueryOngoingProposalsResponse): QueryOngoingProposalsResponseAmino;
+    fromAminoMsg(object: QueryOngoingProposalsResponseAminoMsg): QueryOngoingProposalsResponse;
+    fromProtoMsg(message: QueryOngoingProposalsResponseProtoMsg): QueryOngoingProposalsResponse;
+    toProto(message: QueryOngoingProposalsResponse): Uint8Array;
+    toProtoMsg(message: QueryOngoingProposalsResponse): QueryOngoingProposalsResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryOngoingProposalRequest is the request type for the Query/OngoingProposal
+ * RPC method.
+ * @name QueryOngoingProposalRequest
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalRequest
+ */
+export declare const QueryOngoingProposalRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryOngoingProposalRequest;
+    isAmino(o: any): o is QueryOngoingProposalRequestAmino;
+    encode(message: QueryOngoingProposalRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryOngoingProposalRequest;
+    fromPartial(object: DeepPartial<QueryOngoingProposalRequest>): QueryOngoingProposalRequest;
+    fromAmino(object: QueryOngoingProposalRequestAmino): QueryOngoingProposalRequest;
+    toAmino(message: QueryOngoingProposalRequest): QueryOngoingProposalRequestAmino;
+    fromAminoMsg(object: QueryOngoingProposalRequestAminoMsg): QueryOngoingProposalRequest;
+    fromProtoMsg(message: QueryOngoingProposalRequestProtoMsg): QueryOngoingProposalRequest;
+    toProto(message: QueryOngoingProposalRequest): Uint8Array;
+    toProtoMsg(message: QueryOngoingProposalRequest): QueryOngoingProposalRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryOngoingProposalResponse is the response type for the
+ * Query/OngoingProposal RPC method.
+ * @name QueryOngoingProposalResponse
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.QueryOngoingProposalResponse
+ */
+export declare const QueryOngoingProposalResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryOngoingProposalResponse;
+    isAmino(o: any): o is QueryOngoingProposalResponseAmino;
+    encode(message: QueryOngoingProposalResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryOngoingProposalResponse;
+    fromPartial(object: DeepPartial<QueryOngoingProposalResponse>): QueryOngoingProposalResponse;
+    fromAmino(object: QueryOngoingProposalResponseAmino): QueryOngoingProposalResponse;
+    toAmino(message: QueryOngoingProposalResponse): QueryOngoingProposalResponseAmino;
+    fromAminoMsg(object: QueryOngoingProposalResponseAminoMsg): QueryOngoingProposalResponse;
+    fromProtoMsg(message: QueryOngoingProposalResponseProtoMsg): QueryOngoingProposalResponse;
+    toProto(message: QueryOngoingProposalResponse): Uint8Array;
+    toProtoMsg(message: QueryOngoingProposalResponse): QueryOngoingProposalResponseProtoMsg;
+    registerTypeUrl(): void;
+};