@xpla/xplajs 1.7.0 → 1.8.0-rc.1

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

@@ -0,0 +1,22 @@
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Query all ongoing burn proposals */
+    ongoingProposals = async (_params = {}) => {
+        const endpoint = `xpla/burn/v1beta1/ongoing_proposals`;
+        return await this.req.get(endpoint);
+    };
+    /* Query a specific ongoing burn proposal by ID */
+    ongoingProposal = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.proposalId !== "undefined") {
+            options.params.proposal_id = params.proposalId;
+        }
+        const endpoint = `xpla/burn/v1beta1/ongoing_proposal`;
+        return await this.req.get(endpoint, options);
+    };
+}

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

@@ -0,0 +1,33 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryOngoingProposalsRequest, QueryOngoingProposalsResponse, QueryOngoingProposalRequest, QueryOngoingProposalResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Query all ongoing burn proposals */
+    ongoingProposals = async (request = {}) => {
+        const data = QueryOngoingProposalsRequest.encode(request).finish();
+        const promise = this.rpc.request("xpla.burn.v1beta1.Query", "OngoingProposals", data);
+        return promise.then(data => QueryOngoingProposalsResponse.decode(new BinaryReader(data)));
+    };
+    /* Query a specific ongoing burn proposal by ID */
+    ongoingProposal = async (request) => {
+        const data = QueryOngoingProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("xpla.burn.v1beta1.Query", "OngoingProposal", data);
+        return promise.then(data => QueryOngoingProposalResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        ongoingProposals(request) {
+            return queryService.ongoingProposals(request);
+        },
+        ongoingProposal(request) {
+            return queryService.ongoingProposal(request);
+        }
+    };
+};

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/tx.amino.js

@@ -0,0 +1,8 @@
+import { MsgBurn } from "./tx";
+export const AminoConverter = {
+    "/xpla.burn.v1beta1.MsgBurn": {
+        aminoType: "xpladev/MsgBurn",
+        toAmino: MsgBurn.toAmino,
+        fromAmino: MsgBurn.fromAmino
+    }
+};

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.msg.js

@@ -0,0 +1,17 @@
+import { BinaryReader } from "../../../binary";
+import { MsgBurn, MsgBurnResponse } from "./tx";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Burn defines a method for burning coins from an account. */
+    burn = async (request) => {
+        const data = MsgBurn.encode(request).finish();
+        const promise = this.rpc.request("xpla.burn.v1beta1.Msg", "Burn", data);
+        return promise.then(data => MsgBurnResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};

package/esm/xpla/lcd.js

@@ -47,6 +47,18 @@ export const createLCDClient = async ({ restEndpoint }) => {
                     requestClient
                 })
             },
+            evm: {
+                feemarket: {
+                    v1: new (await import("../cosmos/evm/feemarket/v1/query.lcd")).LCDQueryClient({
+                        requestClient
+                    })
+                },
+                vm: {
+                    v1: new (await import("../cosmos/evm/vm/v1/query.lcd")).LCDQueryClient({
+                        requestClient
+                    })
+                }
+            },
             feegrant: {
                 v1beta1: new (await import("../cosmos/feegrant/v1beta1/query.lcd")).LCDQueryClient({
                     requestClient
@@ -65,11 +77,6 @@ export const createLCDClient = async ({ restEndpoint }) => {
                     requestClient
                 })
             },
-            params: {
-                v1beta1: new (await import("../cosmos/params/v1beta1/query.lcd")).LCDQueryClient({
-                    requestClient
-                })
-            },
             slashing: {
                 v1beta1: new (await import("../cosmos/slashing/v1beta1/query.lcd")).LCDQueryClient({
                     requestClient
@@ -98,31 +105,9 @@ export const createLCDClient = async ({ restEndpoint }) => {
                 })
             }
         },
-        ethermint: {
-            evm: {
-                v1: new (await import("../ethermint/evm/v1/query.lcd")).LCDQueryClient({
-                    requestClient
-                })
-            },
-            feemarket: {
-                v1: new (await import("../ethermint/feemarket/v1/query.lcd")).LCDQueryClient({
-                    requestClient
-                })
-            }
-        },
         ibc: {
             applications: {
-                fee: {
-                    v1: new (await import("../ibc/applications/fee/v1/query.lcd")).LCDQueryClient({
-                        requestClient
-                    })
-                },
                 interchain_accounts: {
-                    controller: {
-                        v1: new (await import("../ibc/applications/interchain_accounts/controller/v1/query.lcd")).LCDQueryClient({
-                            requestClient
-                        })
-                    },
                     host: {
                         v1: new (await import("../ibc/applications/interchain_accounts/host/v1/query.lcd")).LCDQueryClient({
                             requestClient
@@ -139,11 +124,17 @@ export const createLCDClient = async ({ restEndpoint }) => {
                 channel: {
                     v1: new (await import("../ibc/core/channel/v1/query.lcd")).LCDQueryClient({
                         requestClient
+                    }),
+                    v2: new (await import("../ibc/core/channel/v2/query.lcd")).LCDQueryClient({
+                        requestClient
                     })
                 },
                 client: {
                     v1: new (await import("../ibc/core/client/v1/query.lcd")).LCDQueryClient({
                         requestClient
+                    }),
+                    v2: new (await import("../ibc/core/client/v2/query.lcd")).LCDQueryClient({
+                        requestClient
                     })
                 },
                 connection: {
@@ -151,16 +142,14 @@ export const createLCDClient = async ({ restEndpoint }) => {
                         requestClient
                     })
                 }
-            },
-            lightclients: {
-                wasm: {
-                    v1: new (await import("../ibc/lightclients/wasm/v1/query.lcd")).LCDQueryClient({
-                        requestClient
-                    })
-                }
             }
         },
         xpla: {
+            burn: {
+                v1beta1: new (await import("./burn/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
             reward: {
                 v1beta1: new (await import("./reward/v1beta1/query.lcd")).LCDQueryClient({
                     requestClient

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();
     }
 };

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

@@ -1,9 +1,16 @@
 import { Params } from "./reward";
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryParamsRequest() {
     return {};
 }
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.QueryParamsRequest
+ */
 export const QueryParamsRequest = {
     typeUrl: "/xpla.reward.v1beta1.QueryParamsRequest",
     is(o) {
@@ -63,6 +70,12 @@ function createBaseQueryParamsResponse() {
         params: Params.fromPartial({})
     };
 }
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.QueryParamsResponse
+ */
 export const QueryParamsResponse = {
     typeUrl: "/xpla.reward.v1beta1.QueryParamsResponse",
     is(o) {
@@ -127,12 +140,22 @@ export const QueryParamsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryParamsResponse.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };
 function createBaseQueryPoolRequest() {
     return {};
 }
+/**
+ * QueryPoolRequest is the request type for the Query/Pool RPC
+ * method.
+ * @name QueryPoolRequest
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.QueryPoolRequest
+ */
 export const QueryPoolRequest = {
     typeUrl: "/xpla.reward.v1beta1.QueryPoolRequest",
     is(o) {
@@ -192,6 +215,13 @@ function createBaseQueryPoolResponse() {
         pool: []
     };
 }
+/**
+ * QueryPoolResponse is the response type for the Query/Pool
+ * RPC method.
+ * @name QueryPoolResponse
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.QueryPoolResponse
+ */
 export const QueryPoolResponse = {
     typeUrl: "/xpla.reward.v1beta1.QueryPoolResponse",
     is(o) {
@@ -259,6 +289,9 @@ export const QueryPoolResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryPoolResponse.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };

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

@@ -1,18 +1,28 @@
 import { buildQuery } from "../../../helper-func-types";
 import { QueryParamsRequest, QueryParamsResponse, QueryPoolRequest, QueryPoolResponse } from "./query";
-export const createGetParams = (clientResolver) => buildQuery({
+/**
+ * Params queries params of the reward module.
+ * @name getParams
+ * @package xpla.reward.v1beta1
+ * @see proto service: xpla.reward.v1beta1.Params
+ */
+export const getParams = buildQuery({
     encode: QueryParamsRequest.encode,
     decode: QueryParamsResponse.decode,
     service: "xpla.reward.v1beta1.Query",
     method: "Params",
-    clientResolver,
     deps: [QueryParamsRequest, QueryParamsResponse]
 });
-export const createGetPool = (clientResolver) => buildQuery({
+/**
+ * Pool queries the reward module pool coins.
+ * @name getPool
+ * @package xpla.reward.v1beta1
+ * @see proto service: xpla.reward.v1beta1.Pool
+ */
+export const getPool = buildQuery({
     encode: QueryPoolRequest.encode,
     decode: QueryPoolResponse.decode,
     service: "xpla.reward.v1beta1.Query",
     method: "Pool",
-    clientResolver,
     deps: [QueryPoolRequest, QueryPoolResponse]
 });

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

@@ -9,6 +9,12 @@ function createBaseParams() {
         rewardDistributeAccount: ""
     };
 }
+/**
+ * Params defines the set of params for the reward module.
+ * @name Params
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.Params
+ */
 export const Params = {
     typeUrl: "/xpla.reward.v1beta1.Params",
     aminoType: "xpladev/x/reward/Params",

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

@@ -1,12 +1,20 @@
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { Params } from "./reward";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgFundRewardPool() {
     return {
         amount: [],
         depositor: ""
     };
 }
+/**
+ * MsgFundRewardPool allows an account to directly
+ * fund the reward pool.
+ * @name MsgFundRewardPool
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.MsgFundRewardPool
+ */
 export const MsgFundRewardPool = {
     typeUrl: "/xpla.reward.v1beta1.MsgFundRewardPool",
     aminoType: "xpladev/MsgFundRewardPool",
@@ -92,12 +100,21 @@ export const MsgFundRewardPool = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgFundRewardPool.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };
 function createBaseMsgFundRewardPoolResponse() {
     return {};
 }
+/**
+ * MsgFundRewardPoolResponse defines the Msg/FundRewardPool response type.
+ * @name MsgFundRewardPoolResponse
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.MsgFundRewardPoolResponse
+ */
 export const MsgFundRewardPoolResponse = {
     typeUrl: "/xpla.reward.v1beta1.MsgFundRewardPoolResponse",
     is(o) {
@@ -158,6 +175,13 @@ function createBaseMsgUpdateParams() {
         params: Params.fromPartial({})
     };
 }
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type for reward parameters.
+ * Since: cosmos-sdk 0.47
+ * @name MsgUpdateParams
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.MsgUpdateParams
+ */
 export const MsgUpdateParams = {
     typeUrl: "/xpla.reward.v1beta1.MsgUpdateParams",
     aminoType: "xpladev/x/reward/MsgUpdateParams",
@@ -240,12 +264,23 @@ export const MsgUpdateParams = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };
 function createBaseMsgUpdateParamsResponse() {
     return {};
 }
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * Since: cosmos-sdk 0.47
+ * @name MsgUpdateParamsResponse
+ * @package xpla.reward.v1beta1
+ * @see proto type: xpla.reward.v1beta1.MsgUpdateParamsResponse
+ */
 export const MsgUpdateParamsResponse = {
     typeUrl: "/xpla.reward.v1beta1.MsgUpdateParamsResponse",
     is(o) {