@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.31

package/esm/akash/oracle/v2/service.rpc.msg.js

@@ -0,0 +1,26 @@
+import { BinaryReader } from "../../../binary";
+import { MsgAddPriceEntry, MsgAddPriceEntryResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./msgs";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* AddPriceEntry adds a new price entry for a denomination from an authorized source */
+    addPriceEntry = async (request) => {
+        const data = MsgAddPriceEntry.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v2.Msg", "AddPriceEntry", data);
+        return promise.then(data => MsgAddPriceEntryResponse.decode(new BinaryReader(data)));
+    };
+    /* UpdateParams defines a governance operation for updating the x/oracle module
+     parameters. The authority is hard-coded to the x/gov module account.
+    
+     Since: akash v2.0.0 */
+    updateParams = async (request) => {
+        const data = MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v2.Msg", "UpdateParams", data);
+        return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};

package/esm/akash/rpc.query.js

@@ -7,35 +7,45 @@ export const createRPCQueryClient = async ({ rpcEndpoint }) => {
     return {
         akash: {
             audit: {
-                v1: (await import("./audit/v1/query.rpc.Query")).createRpcQueryExtension(client),
-                v1beta3: (await import("./audit/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+                v1: (await import("./audit/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },
             bme: {
                 v1: (await import("./bme/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },
             cert: {
-                v1: (await import("./cert/v1/query.rpc.Query")).createRpcQueryExtension(client),
-                v1beta3: (await import("./cert/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+                v1: (await import("./cert/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },
             deployment: {
-                v1beta3: (await import("./deployment/v1beta3/query.rpc.Query")).createRpcQueryExtension(client),
-                v1beta4: (await import("./deployment/v1beta4/query.rpc.Query")).createRpcQueryExtension(client)
+                v1beta4: (await import("./deployment/v1beta4/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta5: (await import("./deployment/v1beta5/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            downtimedetector: {
+                v1beta1: (await import("./downtimedetector/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            epochs: {
+                v1beta1: (await import("./epochs/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
             },
             escrow: {
                 v1: (await import("./escrow/v1/query.rpc.Query")).createRpcQueryExtension(client),
                 v1beta3: (await import("./escrow/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
             },
             market: {
-                v1beta4: (await import("./market/v1beta4/query.rpc.Query")).createRpcQueryExtension(client),
-                v1beta5: (await import("./market/v1beta5/query.rpc.Query")).createRpcQueryExtension(client)
+                v1beta5: (await import("./market/v1beta5/query.rpc.Query")).createRpcQueryExtension(client),
+                v2beta1: (await import("./market/v2beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            oracle: {
+                v1: (await import("./oracle/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v2: (await import("./oracle/v2/query.rpc.Query")).createRpcQueryExtension(client)
             },
             provider: {
-                v1beta3: (await import("./provider/v1beta3/query.rpc.Query")).createRpcQueryExtension(client),
                 v1beta4: (await import("./provider/v1beta4/query.rpc.Query")).createRpcQueryExtension(client)
             },
             take: {
                 v1: (await import("./take/v1/query.rpc.Query")).createRpcQueryExtension(client),
                 v1beta3: (await import("./take/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            wasm: {
+                v1: (await import("./wasm/v1/query.rpc.Query")).createRpcQueryExtension(client)
             }
         },
         cosmos: {

package/esm/akash/rpc.tx.js

@@ -1,30 +1,37 @@
 export const createRPCMsgClient = async ({ rpc }) => ({
     akash: {
         audit: {
-            v1: new (await import("./audit/v1/service.rpc.msg")).MsgClientImpl(rpc),
-            v1beta3: new (await import("./audit/v1beta3/audit.rpc.msg")).MsgClientImpl(rpc)
+            v1: new (await import("./audit/v1/service.rpc.msg")).MsgClientImpl(rpc)
         },
         bme: {
             v1: new (await import("./bme/v1/service.rpc.msg")).MsgClientImpl(rpc)
         },
         cert: {
-            v1: new (await import("./cert/v1/service.rpc.msg")).MsgClientImpl(rpc),
-            v1beta3: new (await import("./cert/v1beta3/cert.rpc.msg")).MsgClientImpl(rpc)
+            v1: new (await import("./cert/v1/service.rpc.msg")).MsgClientImpl(rpc)
         },
         deployment: {
-            v1beta3: new (await import("./deployment/v1beta3/service.rpc.msg")).MsgClientImpl(rpc),
-            v1beta4: new (await import("./deployment/v1beta4/service.rpc.msg")).MsgClientImpl(rpc)
+            v1beta4: new (await import("./deployment/v1beta4/service.rpc.msg")).MsgClientImpl(rpc),
+            v1beta5: new (await import("./deployment/v1beta5/service.rpc.msg")).MsgClientImpl(rpc)
+        },
+        escrow: {
+            v1: new (await import("./escrow/v1/service.rpc.msg")).MsgClientImpl(rpc)
         },
         market: {
-            v1beta4: new (await import("./market/v1beta4/service.rpc.msg")).MsgClientImpl(rpc),
-            v1beta5: new (await import("./market/v1beta5/service.rpc.msg")).MsgClientImpl(rpc)
+            v1beta5: new (await import("./market/v1beta5/service.rpc.msg")).MsgClientImpl(rpc),
+            v2beta1: new (await import("./market/v2beta1/service.rpc.msg")).MsgClientImpl(rpc)
+        },
+        oracle: {
+            v1: new (await import("./oracle/v1/service.rpc.msg")).MsgClientImpl(rpc),
+            v2: new (await import("./oracle/v2/service.rpc.msg")).MsgClientImpl(rpc)
         },
         provider: {
-            v1beta3: new (await import("./provider/v1beta3/provider.rpc.msg")).MsgClientImpl(rpc),
             v1beta4: new (await import("./provider/v1beta4/service.rpc.msg")).MsgClientImpl(rpc)
         },
         take: {
             v1: new (await import("./take/v1/service.rpc.msg")).MsgClientImpl(rpc)
+        },
+        wasm: {
+            v1: new (await import("./wasm/v1/service.rpc.msg")).MsgClientImpl(rpc)
         }
     },
     cosmos: {

package/esm/akash/take/v1/query.lcd.js

@@ -3,7 +3,7 @@ export class LCDQueryClient {
     constructor({ requestClient }) {
         this.req = requestClient;
     }
-    /* Params returns the total set of minting parameters. */
+    /* Params returns the total set of take parameters. */
     params = async (_params = {}) => {
         const endpoint = `akash/take/v1/params`;
         return await this.req.get(endpoint);

package/esm/akash/take/v1/query.rpc.Query.js

@@ -6,7 +6,7 @@ export class QueryClientImpl {
     constructor(rpc) {
         this.rpc = rpc;
     }
-    /* Params returns the total set of minting parameters. */
+    /* Params returns the total set of take parameters. */
     params = async (request = {}) => {
         const data = QueryParamsRequest.encode(request).finish();
         const promise = this.rpc.request("akash.take.v1.Query", "Params", data);

package/esm/akash/wasm/v1/event.js

@@ -0,0 +1,96 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseEventMsgBlocked() {
+    return {
+        contractAddress: "",
+        msgType: "",
+        reason: ""
+    };
+}
+/**
+ * EventMsgBlocked is triggered when smart contract does not
+ * pass message filter
+ * @name EventMsgBlocked
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.EventMsgBlocked
+ */
+export const EventMsgBlocked = {
+    typeUrl: "/akash.wasm.v1.EventMsgBlocked",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.contractAddress !== "") {
+            writer.uint32(10).string(message.contractAddress);
+        }
+        if (message.msgType !== "") {
+            writer.uint32(18).string(message.msgType);
+        }
+        if (message.reason !== "") {
+            writer.uint32(26).string(message.reason);
+        }
+        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 = createBaseEventMsgBlocked();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contractAddress = reader.string();
+                    break;
+                case 2:
+                    message.msgType = reader.string();
+                    break;
+                case 3:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventMsgBlocked();
+        message.contractAddress = object.contractAddress ?? "";
+        message.msgType = object.msgType ?? "";
+        message.reason = object.reason ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventMsgBlocked();
+        if (object.contract_address !== undefined && object.contract_address !== null) {
+            message.contractAddress = object.contract_address;
+        }
+        if (object.msg_type !== undefined && object.msg_type !== null) {
+            message.msgType = object.msg_type;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract_address = message.contractAddress ?? "";
+        obj.msg_type = message.msgType ?? "";
+        obj.reason = message.reason ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return EventMsgBlocked.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EventMsgBlocked.decode(message.value);
+    },
+    toProto(message) {
+        return EventMsgBlocked.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.EventMsgBlocked",
+            value: EventMsgBlocked.encode(message).finish()
+        };
+    }
+};

package/esm/akash/wasm/v1/genesis.js

@@ -0,0 +1,72 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * GenesisState stores slice of genesis wasm parameters.
+ * @name GenesisState
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/akash.wasm.v1.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, 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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};

package/esm/akash/wasm/v1/params.js

@@ -0,0 +1,74 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseParams() {
+    return {
+        blockedAddresses: []
+    };
+}
+/**
+ * Params defines the parameters for the x/wasm package.
+ * @name Params
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.Params
+ */
+export const Params = {
+    typeUrl: "/akash.wasm.v1.Params",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.blockedAddresses) {
+            writer.uint32(10).string(v);
+        }
+        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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.blockedAddresses.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.blockedAddresses = object.blockedAddresses?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        message.blockedAddresses = object.blocked_addresses?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.blockedAddresses) {
+            obj.blocked_addresses = message.blockedAddresses.map(e => e);
+        }
+        else {
+            obj.blocked_addresses = message.blockedAddresses;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Params.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Params.decode(message.value);
+    },
+    toProto(message) {
+        return Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.Params",
+            value: Params.encode(message).finish()
+        };
+    }
+};

package/esm/akash/wasm/v1/paramsmsg.js

@@ -0,0 +1,145 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ *
+ * Since: akash v1.0.0
+ * @name MsgUpdateParams
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/akash.wasm.v1.MsgUpdateParams",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, 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 = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ *
+ * Since: akash v1.0.0
+ * @name MsgUpdateParamsResponse
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/akash.wasm.v1.MsgUpdateParamsResponse",
+    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 = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};

package/esm/akash/wasm/v1/query.js

@@ -0,0 +1,128 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/akash.wasm.v1.QueryParamsRequest",
+    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 = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.wasm.v1
+ * @see proto type: akash.wasm.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/akash.wasm.v1.QueryParamsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, 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 = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.wasm.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    }
+};

package/esm/akash/wasm/v1/query.lcd.js

@@ -0,0 +1,11 @@
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Params returns the total set of wasm parameters. */
+    params = async (_params = {}) => {
+        const endpoint = `akash/wasm/v1/params`;
+        return await this.req.get(endpoint);
+    };
+}