@xpla/xpla-react 1.7.0 → 1.8.0-rc.1

package/esm/xpla/burn/v1beta1/query.js

@@ -0,0 +1,327 @@
+import { BurnProposal } from "./burn";
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseQueryOngoingProposalsRequest() {
+    return {};
+}
+/**
+ * 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 const QueryOngoingProposalsRequest = {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalsRequest",
+    is(o) {
+        return o && o.$typeUrl === QueryOngoingProposalsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === QueryOngoingProposalsRequest.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOngoingProposalsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryOngoingProposalsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryOngoingProposalsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOngoingProposalsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOngoingProposalsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOngoingProposalsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalsRequest",
+            value: QueryOngoingProposalsRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryOngoingProposalsResponse() {
+    return {
+        proposals: []
+    };
+}
+/**
+ * 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 const QueryOngoingProposalsResponse = {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalsResponse",
+    is(o) {
+        return o && (o.$typeUrl === QueryOngoingProposalsResponse.typeUrl || Array.isArray(o.proposals) && (!o.proposals.length || BurnProposal.is(o.proposals[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === QueryOngoingProposalsResponse.typeUrl || Array.isArray(o.proposals) && (!o.proposals.length || BurnProposal.isAmino(o.proposals[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.proposals) {
+            BurnProposal.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOngoingProposalsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.proposals.push(BurnProposal.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOngoingProposalsResponse();
+        message.proposals = object.proposals?.map(e => BurnProposal.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOngoingProposalsResponse();
+        message.proposals = object.proposals?.map(e => BurnProposal.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.proposals) {
+            obj.proposals = message.proposals.map(e => e ? BurnProposal.toAmino(e) : undefined);
+        }
+        else {
+            obj.proposals = message.proposals;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOngoingProposalsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOngoingProposalsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOngoingProposalsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalsResponse",
+            value: QueryOngoingProposalsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOngoingProposalsResponse.typeUrl)) {
+            return;
+        }
+        BurnProposal.registerTypeUrl();
+    }
+};
+function createBaseQueryOngoingProposalRequest() {
+    return {
+        proposalId: BigInt(0)
+    };
+}
+/**
+ * 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 const QueryOngoingProposalRequest = {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalRequest",
+    is(o) {
+        return o && (o.$typeUrl === QueryOngoingProposalRequest.typeUrl || typeof o.proposalId === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === QueryOngoingProposalRequest.typeUrl || typeof o.proposal_id === "bigint");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.proposalId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOngoingProposalRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.proposalId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOngoingProposalRequest();
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOngoingProposalRequest();
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOngoingProposalRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOngoingProposalRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOngoingProposalRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalRequest",
+            value: QueryOngoingProposalRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryOngoingProposalResponse() {
+    return {
+        proposer: "",
+        amount: []
+    };
+}
+/**
+ * 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 const QueryOngoingProposalResponse = {
+    typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalResponse",
+    is(o) {
+        return o && (o.$typeUrl === QueryOngoingProposalResponse.typeUrl || typeof o.proposer === "string" && Array.isArray(o.amount) && (!o.amount.length || Coin.is(o.amount[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === QueryOngoingProposalResponse.typeUrl || typeof o.proposer === "string" && Array.isArray(o.amount) && (!o.amount.length || Coin.isAmino(o.amount[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.proposer !== "") {
+            writer.uint32(10).string(message.proposer);
+        }
+        for (const v of message.amount) {
+            Coin.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOngoingProposalResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.proposer = reader.string();
+                    break;
+                case 2:
+                    message.amount.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOngoingProposalResponse();
+        message.proposer = object.proposer ?? "";
+        message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOngoingProposalResponse();
+        if (object.proposer !== undefined && object.proposer !== null) {
+            message.proposer = object.proposer;
+        }
+        message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.proposer = message.proposer === "" ? undefined : message.proposer;
+        if (message.amount) {
+            obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.amount = message.amount;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOngoingProposalResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOngoingProposalResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOngoingProposalResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.QueryOngoingProposalResponse",
+            value: QueryOngoingProposalResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOngoingProposalResponse.typeUrl)) {
+            return;
+        }
+        Coin.registerTypeUrl();
+    }
+};

package/esm/xpla/burn/v1beta1/query.rpc.func.js

@@ -0,0 +1,28 @@
+import { buildQuery } from "../../../helper-func-types";
+import { QueryOngoingProposalsRequest, QueryOngoingProposalsResponse, QueryOngoingProposalRequest, QueryOngoingProposalResponse } from "./query";
+/**
+ * Query all ongoing burn proposals
+ * @name getOngoingProposals
+ * @package xpla.burn.v1beta1
+ * @see proto service: xpla.burn.v1beta1.OngoingProposals
+ */
+export const getOngoingProposals = buildQuery({
+    encode: QueryOngoingProposalsRequest.encode,
+    decode: QueryOngoingProposalsResponse.decode,
+    service: "xpla.burn.v1beta1.Query",
+    method: "OngoingProposals",
+    deps: [QueryOngoingProposalsRequest, QueryOngoingProposalsResponse]
+});
+/**
+ * Query a specific ongoing burn proposal by ID
+ * @name getOngoingProposal
+ * @package xpla.burn.v1beta1
+ * @see proto service: xpla.burn.v1beta1.OngoingProposal
+ */
+export const getOngoingProposal = buildQuery({
+    encode: QueryOngoingProposalRequest.encode,
+    decode: QueryOngoingProposalResponse.decode,
+    service: "xpla.burn.v1beta1.Query",
+    method: "OngoingProposal",
+    deps: [QueryOngoingProposalRequest, QueryOngoingProposalResponse]
+});

package/esm/xpla/burn/v1beta1/query.rpc.react.js

@@ -0,0 +1,22 @@
+import { buildUseQuery } from "../../../react-query";
+import { getOngoingProposals, getOngoingProposal } from "./query.rpc.func";
+/**
+ * Query all ongoing burn proposals
+ * @name useGetOngoingProposals
+ * @package xpla.burn.v1beta1
+ * @see proto service: xpla.burn.v1beta1.OngoingProposals
+ */
+export const useGetOngoingProposals = buildUseQuery({
+    builderQueryFn: getOngoingProposals,
+    queryKeyPrefix: "OngoingProposalsQuery"
+});
+/**
+ * Query a specific ongoing burn proposal by ID
+ * @name useGetOngoingProposal
+ * @package xpla.burn.v1beta1
+ * @see proto service: xpla.burn.v1beta1.OngoingProposal
+ */
+export const useGetOngoingProposal = buildUseQuery({
+    builderQueryFn: getOngoingProposal,
+    queryKeyPrefix: "OngoingProposalQuery"
+});

package/esm/xpla/burn/v1beta1/tx.js

@@ -0,0 +1,169 @@
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseMsgBurn() {
+    return {
+        authority: "",
+        amount: []
+    };
+}
+/**
+ * MsgBurn represents a message to burn coins from an account.
+ * @name MsgBurn
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.MsgBurn
+ */
+export const MsgBurn = {
+    typeUrl: "/xpla.burn.v1beta1.MsgBurn",
+    aminoType: "xpladev/MsgBurn",
+    is(o) {
+        return o && (o.$typeUrl === MsgBurn.typeUrl || typeof o.authority === "string" && Array.isArray(o.amount) && (!o.amount.length || Coin.is(o.amount[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgBurn.typeUrl || typeof o.authority === "string" && Array.isArray(o.amount) && (!o.amount.length || Coin.isAmino(o.amount[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        for (const v of message.amount) {
+            Coin.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgBurn();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.amount.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBurn();
+        message.authority = object.authority ?? "";
+        message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBurn();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        if (message.amount) {
+            obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.amount = message.amount;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurn.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "xpladev/MsgBurn",
+            value: MsgBurn.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgBurn.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurn.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.MsgBurn",
+            value: MsgBurn.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgBurn.typeUrl)) {
+            return;
+        }
+        Coin.registerTypeUrl();
+    }
+};
+function createBaseMsgBurnResponse() {
+    return {};
+}
+/**
+ * MsgBurnResponse defines the Msg/Burn response type.
+ * @name MsgBurnResponse
+ * @package xpla.burn.v1beta1
+ * @see proto type: xpla.burn.v1beta1.MsgBurnResponse
+ */
+export const MsgBurnResponse = {
+    typeUrl: "/xpla.burn.v1beta1.MsgBurnResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgBurnResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgBurnResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgBurnResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgBurnResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgBurnResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurnResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgBurnResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurnResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.burn.v1beta1.MsgBurnResponse",
+            value: MsgBurnResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/esm/xpla/burn/v1beta1/tx.registry.js

@@ -0,0 +1,28 @@
+import { MsgBurn } from "./tx";
+export const registry = [["/xpla.burn.v1beta1.MsgBurn", MsgBurn]];
+export const MessageComposer = {
+    encoded: {
+        burn(value) {
+            return {
+                typeUrl: "/xpla.burn.v1beta1.MsgBurn",
+                value: MsgBurn.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        burn(value) {
+            return {
+                typeUrl: "/xpla.burn.v1beta1.MsgBurn",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        burn(value) {
+            return {
+                typeUrl: "/xpla.burn.v1beta1.MsgBurn",
+                value: MsgBurn.fromPartial(value)
+            };
+        }
+    }
+};

package/esm/xpla/burn/v1beta1/tx.rpc.func.js

@@ -0,0 +1,11 @@
+import { buildTx } from "../../../helper-func-types";
+import { MsgBurn } from "./tx";
+/**
+ * Burn defines a method for burning coins from an account.
+ * @name burn
+ * @package xpla.burn.v1beta1
+ * @see proto service: xpla.burn.v1beta1.Burn
+ */
+export const burn = buildTx({
+    msg: MsgBurn
+});

package/esm/xpla/burn/v1beta1/tx.rpc.react.js

@@ -0,0 +1,11 @@
+import { buildUseMutation } from "../../../react-query";
+import { burn } from "./tx.rpc.func";
+/**
+ * Burn defines a method for burning coins from an account.
+ * @name useBurn
+ * @package xpla.burn.v1beta1
+ * @see proto service: xpla.burn.v1beta1.Burn
+ */
+export const useBurn = buildUseMutation({
+    builderMutationFn: burn
+});

package/esm/xpla/reward/v1beta1/genesis.js

@@ -1,10 +1,17 @@
 import { Params } from "./reward";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         params: Params.fromPartial({})
     };
 }
+/**
+ * GenesisState defines the reward module's genesis state.
+ * @name GenesisState
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.GenesisState
+ */
 export const GenesisState = {
     typeUrl: "/xpla.reward.v1beta1.GenesisState",
     is(o) {
@@ -69,6 +76,9 @@ export const GenesisState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GenesisState.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };